netbox_openapi/apis/
circuits_api.rs

1/*
2 * NetBox REST API
3 *
4 * No description provided (generated by Openapi Generator https://github.com/openapitools/openapi-generator)
5 *
6 * The version of the OpenAPI document: 4.5.9-Docker-4.0.2 (4.5)
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 [`circuits_circuit_group_assignments_bulk_destroy`]
17#[derive(Debug, Clone, Serialize, Deserialize)]
18#[serde(untagged)]
19pub enum CircuitsCircuitGroupAssignmentsBulkDestroyError {
20    UnknownValue(serde_json::Value),
21}
22
23/// struct for typed errors of method [`circuits_circuit_group_assignments_bulk_partial_update`]
24#[derive(Debug, Clone, Serialize, Deserialize)]
25#[serde(untagged)]
26pub enum CircuitsCircuitGroupAssignmentsBulkPartialUpdateError {
27    UnknownValue(serde_json::Value),
28}
29
30/// struct for typed errors of method [`circuits_circuit_group_assignments_bulk_update`]
31#[derive(Debug, Clone, Serialize, Deserialize)]
32#[serde(untagged)]
33pub enum CircuitsCircuitGroupAssignmentsBulkUpdateError {
34    UnknownValue(serde_json::Value),
35}
36
37/// struct for typed errors of method [`circuits_circuit_group_assignments_create`]
38#[derive(Debug, Clone, Serialize, Deserialize)]
39#[serde(untagged)]
40pub enum CircuitsCircuitGroupAssignmentsCreateError {
41    UnknownValue(serde_json::Value),
42}
43
44/// struct for typed errors of method [`circuits_circuit_group_assignments_destroy`]
45#[derive(Debug, Clone, Serialize, Deserialize)]
46#[serde(untagged)]
47pub enum CircuitsCircuitGroupAssignmentsDestroyError {
48    UnknownValue(serde_json::Value),
49}
50
51/// struct for typed errors of method [`circuits_circuit_group_assignments_list`]
52#[derive(Debug, Clone, Serialize, Deserialize)]
53#[serde(untagged)]
54pub enum CircuitsCircuitGroupAssignmentsListError {
55    UnknownValue(serde_json::Value),
56}
57
58/// struct for typed errors of method [`circuits_circuit_group_assignments_partial_update`]
59#[derive(Debug, Clone, Serialize, Deserialize)]
60#[serde(untagged)]
61pub enum CircuitsCircuitGroupAssignmentsPartialUpdateError {
62    UnknownValue(serde_json::Value),
63}
64
65/// struct for typed errors of method [`circuits_circuit_group_assignments_retrieve`]
66#[derive(Debug, Clone, Serialize, Deserialize)]
67#[serde(untagged)]
68pub enum CircuitsCircuitGroupAssignmentsRetrieveError {
69    UnknownValue(serde_json::Value),
70}
71
72/// struct for typed errors of method [`circuits_circuit_group_assignments_update`]
73#[derive(Debug, Clone, Serialize, Deserialize)]
74#[serde(untagged)]
75pub enum CircuitsCircuitGroupAssignmentsUpdateError {
76    UnknownValue(serde_json::Value),
77}
78
79/// struct for typed errors of method [`circuits_circuit_groups_bulk_destroy`]
80#[derive(Debug, Clone, Serialize, Deserialize)]
81#[serde(untagged)]
82pub enum CircuitsCircuitGroupsBulkDestroyError {
83    UnknownValue(serde_json::Value),
84}
85
86/// struct for typed errors of method [`circuits_circuit_groups_bulk_partial_update`]
87#[derive(Debug, Clone, Serialize, Deserialize)]
88#[serde(untagged)]
89pub enum CircuitsCircuitGroupsBulkPartialUpdateError {
90    UnknownValue(serde_json::Value),
91}
92
93/// struct for typed errors of method [`circuits_circuit_groups_bulk_update`]
94#[derive(Debug, Clone, Serialize, Deserialize)]
95#[serde(untagged)]
96pub enum CircuitsCircuitGroupsBulkUpdateError {
97    UnknownValue(serde_json::Value),
98}
99
100/// struct for typed errors of method [`circuits_circuit_groups_create`]
101#[derive(Debug, Clone, Serialize, Deserialize)]
102#[serde(untagged)]
103pub enum CircuitsCircuitGroupsCreateError {
104    UnknownValue(serde_json::Value),
105}
106
107/// struct for typed errors of method [`circuits_circuit_groups_destroy`]
108#[derive(Debug, Clone, Serialize, Deserialize)]
109#[serde(untagged)]
110pub enum CircuitsCircuitGroupsDestroyError {
111    UnknownValue(serde_json::Value),
112}
113
114/// struct for typed errors of method [`circuits_circuit_groups_list`]
115#[derive(Debug, Clone, Serialize, Deserialize)]
116#[serde(untagged)]
117pub enum CircuitsCircuitGroupsListError {
118    UnknownValue(serde_json::Value),
119}
120
121/// struct for typed errors of method [`circuits_circuit_groups_partial_update`]
122#[derive(Debug, Clone, Serialize, Deserialize)]
123#[serde(untagged)]
124pub enum CircuitsCircuitGroupsPartialUpdateError {
125    UnknownValue(serde_json::Value),
126}
127
128/// struct for typed errors of method [`circuits_circuit_groups_retrieve`]
129#[derive(Debug, Clone, Serialize, Deserialize)]
130#[serde(untagged)]
131pub enum CircuitsCircuitGroupsRetrieveError {
132    UnknownValue(serde_json::Value),
133}
134
135/// struct for typed errors of method [`circuits_circuit_groups_update`]
136#[derive(Debug, Clone, Serialize, Deserialize)]
137#[serde(untagged)]
138pub enum CircuitsCircuitGroupsUpdateError {
139    UnknownValue(serde_json::Value),
140}
141
142/// struct for typed errors of method [`circuits_circuit_terminations_bulk_destroy`]
143#[derive(Debug, Clone, Serialize, Deserialize)]
144#[serde(untagged)]
145pub enum CircuitsCircuitTerminationsBulkDestroyError {
146    UnknownValue(serde_json::Value),
147}
148
149/// struct for typed errors of method [`circuits_circuit_terminations_bulk_partial_update`]
150#[derive(Debug, Clone, Serialize, Deserialize)]
151#[serde(untagged)]
152pub enum CircuitsCircuitTerminationsBulkPartialUpdateError {
153    UnknownValue(serde_json::Value),
154}
155
156/// struct for typed errors of method [`circuits_circuit_terminations_bulk_update`]
157#[derive(Debug, Clone, Serialize, Deserialize)]
158#[serde(untagged)]
159pub enum CircuitsCircuitTerminationsBulkUpdateError {
160    UnknownValue(serde_json::Value),
161}
162
163/// struct for typed errors of method [`circuits_circuit_terminations_create`]
164#[derive(Debug, Clone, Serialize, Deserialize)]
165#[serde(untagged)]
166pub enum CircuitsCircuitTerminationsCreateError {
167    UnknownValue(serde_json::Value),
168}
169
170/// struct for typed errors of method [`circuits_circuit_terminations_destroy`]
171#[derive(Debug, Clone, Serialize, Deserialize)]
172#[serde(untagged)]
173pub enum CircuitsCircuitTerminationsDestroyError {
174    UnknownValue(serde_json::Value),
175}
176
177/// struct for typed errors of method [`circuits_circuit_terminations_list`]
178#[derive(Debug, Clone, Serialize, Deserialize)]
179#[serde(untagged)]
180pub enum CircuitsCircuitTerminationsListError {
181    UnknownValue(serde_json::Value),
182}
183
184/// struct for typed errors of method [`circuits_circuit_terminations_partial_update`]
185#[derive(Debug, Clone, Serialize, Deserialize)]
186#[serde(untagged)]
187pub enum CircuitsCircuitTerminationsPartialUpdateError {
188    UnknownValue(serde_json::Value),
189}
190
191/// struct for typed errors of method [`circuits_circuit_terminations_paths_retrieve`]
192#[derive(Debug, Clone, Serialize, Deserialize)]
193#[serde(untagged)]
194pub enum CircuitsCircuitTerminationsPathsRetrieveError {
195    UnknownValue(serde_json::Value),
196}
197
198/// struct for typed errors of method [`circuits_circuit_terminations_retrieve`]
199#[derive(Debug, Clone, Serialize, Deserialize)]
200#[serde(untagged)]
201pub enum CircuitsCircuitTerminationsRetrieveError {
202    UnknownValue(serde_json::Value),
203}
204
205/// struct for typed errors of method [`circuits_circuit_terminations_update`]
206#[derive(Debug, Clone, Serialize, Deserialize)]
207#[serde(untagged)]
208pub enum CircuitsCircuitTerminationsUpdateError {
209    UnknownValue(serde_json::Value),
210}
211
212/// struct for typed errors of method [`circuits_circuit_types_bulk_destroy`]
213#[derive(Debug, Clone, Serialize, Deserialize)]
214#[serde(untagged)]
215pub enum CircuitsCircuitTypesBulkDestroyError {
216    UnknownValue(serde_json::Value),
217}
218
219/// struct for typed errors of method [`circuits_circuit_types_bulk_partial_update`]
220#[derive(Debug, Clone, Serialize, Deserialize)]
221#[serde(untagged)]
222pub enum CircuitsCircuitTypesBulkPartialUpdateError {
223    UnknownValue(serde_json::Value),
224}
225
226/// struct for typed errors of method [`circuits_circuit_types_bulk_update`]
227#[derive(Debug, Clone, Serialize, Deserialize)]
228#[serde(untagged)]
229pub enum CircuitsCircuitTypesBulkUpdateError {
230    UnknownValue(serde_json::Value),
231}
232
233/// struct for typed errors of method [`circuits_circuit_types_create`]
234#[derive(Debug, Clone, Serialize, Deserialize)]
235#[serde(untagged)]
236pub enum CircuitsCircuitTypesCreateError {
237    UnknownValue(serde_json::Value),
238}
239
240/// struct for typed errors of method [`circuits_circuit_types_destroy`]
241#[derive(Debug, Clone, Serialize, Deserialize)]
242#[serde(untagged)]
243pub enum CircuitsCircuitTypesDestroyError {
244    UnknownValue(serde_json::Value),
245}
246
247/// struct for typed errors of method [`circuits_circuit_types_list`]
248#[derive(Debug, Clone, Serialize, Deserialize)]
249#[serde(untagged)]
250pub enum CircuitsCircuitTypesListError {
251    UnknownValue(serde_json::Value),
252}
253
254/// struct for typed errors of method [`circuits_circuit_types_partial_update`]
255#[derive(Debug, Clone, Serialize, Deserialize)]
256#[serde(untagged)]
257pub enum CircuitsCircuitTypesPartialUpdateError {
258    UnknownValue(serde_json::Value),
259}
260
261/// struct for typed errors of method [`circuits_circuit_types_retrieve`]
262#[derive(Debug, Clone, Serialize, Deserialize)]
263#[serde(untagged)]
264pub enum CircuitsCircuitTypesRetrieveError {
265    UnknownValue(serde_json::Value),
266}
267
268/// struct for typed errors of method [`circuits_circuit_types_update`]
269#[derive(Debug, Clone, Serialize, Deserialize)]
270#[serde(untagged)]
271pub enum CircuitsCircuitTypesUpdateError {
272    UnknownValue(serde_json::Value),
273}
274
275/// struct for typed errors of method [`circuits_circuits_bulk_destroy`]
276#[derive(Debug, Clone, Serialize, Deserialize)]
277#[serde(untagged)]
278pub enum CircuitsCircuitsBulkDestroyError {
279    UnknownValue(serde_json::Value),
280}
281
282/// struct for typed errors of method [`circuits_circuits_bulk_partial_update`]
283#[derive(Debug, Clone, Serialize, Deserialize)]
284#[serde(untagged)]
285pub enum CircuitsCircuitsBulkPartialUpdateError {
286    UnknownValue(serde_json::Value),
287}
288
289/// struct for typed errors of method [`circuits_circuits_bulk_update`]
290#[derive(Debug, Clone, Serialize, Deserialize)]
291#[serde(untagged)]
292pub enum CircuitsCircuitsBulkUpdateError {
293    UnknownValue(serde_json::Value),
294}
295
296/// struct for typed errors of method [`circuits_circuits_create`]
297#[derive(Debug, Clone, Serialize, Deserialize)]
298#[serde(untagged)]
299pub enum CircuitsCircuitsCreateError {
300    UnknownValue(serde_json::Value),
301}
302
303/// struct for typed errors of method [`circuits_circuits_destroy`]
304#[derive(Debug, Clone, Serialize, Deserialize)]
305#[serde(untagged)]
306pub enum CircuitsCircuitsDestroyError {
307    UnknownValue(serde_json::Value),
308}
309
310/// struct for typed errors of method [`circuits_circuits_list`]
311#[derive(Debug, Clone, Serialize, Deserialize)]
312#[serde(untagged)]
313pub enum CircuitsCircuitsListError {
314    UnknownValue(serde_json::Value),
315}
316
317/// struct for typed errors of method [`circuits_circuits_partial_update`]
318#[derive(Debug, Clone, Serialize, Deserialize)]
319#[serde(untagged)]
320pub enum CircuitsCircuitsPartialUpdateError {
321    UnknownValue(serde_json::Value),
322}
323
324/// struct for typed errors of method [`circuits_circuits_retrieve`]
325#[derive(Debug, Clone, Serialize, Deserialize)]
326#[serde(untagged)]
327pub enum CircuitsCircuitsRetrieveError {
328    UnknownValue(serde_json::Value),
329}
330
331/// struct for typed errors of method [`circuits_circuits_update`]
332#[derive(Debug, Clone, Serialize, Deserialize)]
333#[serde(untagged)]
334pub enum CircuitsCircuitsUpdateError {
335    UnknownValue(serde_json::Value),
336}
337
338/// struct for typed errors of method [`circuits_provider_accounts_bulk_destroy`]
339#[derive(Debug, Clone, Serialize, Deserialize)]
340#[serde(untagged)]
341pub enum CircuitsProviderAccountsBulkDestroyError {
342    UnknownValue(serde_json::Value),
343}
344
345/// struct for typed errors of method [`circuits_provider_accounts_bulk_partial_update`]
346#[derive(Debug, Clone, Serialize, Deserialize)]
347#[serde(untagged)]
348pub enum CircuitsProviderAccountsBulkPartialUpdateError {
349    UnknownValue(serde_json::Value),
350}
351
352/// struct for typed errors of method [`circuits_provider_accounts_bulk_update`]
353#[derive(Debug, Clone, Serialize, Deserialize)]
354#[serde(untagged)]
355pub enum CircuitsProviderAccountsBulkUpdateError {
356    UnknownValue(serde_json::Value),
357}
358
359/// struct for typed errors of method [`circuits_provider_accounts_create`]
360#[derive(Debug, Clone, Serialize, Deserialize)]
361#[serde(untagged)]
362pub enum CircuitsProviderAccountsCreateError {
363    UnknownValue(serde_json::Value),
364}
365
366/// struct for typed errors of method [`circuits_provider_accounts_destroy`]
367#[derive(Debug, Clone, Serialize, Deserialize)]
368#[serde(untagged)]
369pub enum CircuitsProviderAccountsDestroyError {
370    UnknownValue(serde_json::Value),
371}
372
373/// struct for typed errors of method [`circuits_provider_accounts_list`]
374#[derive(Debug, Clone, Serialize, Deserialize)]
375#[serde(untagged)]
376pub enum CircuitsProviderAccountsListError {
377    UnknownValue(serde_json::Value),
378}
379
380/// struct for typed errors of method [`circuits_provider_accounts_partial_update`]
381#[derive(Debug, Clone, Serialize, Deserialize)]
382#[serde(untagged)]
383pub enum CircuitsProviderAccountsPartialUpdateError {
384    UnknownValue(serde_json::Value),
385}
386
387/// struct for typed errors of method [`circuits_provider_accounts_retrieve`]
388#[derive(Debug, Clone, Serialize, Deserialize)]
389#[serde(untagged)]
390pub enum CircuitsProviderAccountsRetrieveError {
391    UnknownValue(serde_json::Value),
392}
393
394/// struct for typed errors of method [`circuits_provider_accounts_update`]
395#[derive(Debug, Clone, Serialize, Deserialize)]
396#[serde(untagged)]
397pub enum CircuitsProviderAccountsUpdateError {
398    UnknownValue(serde_json::Value),
399}
400
401/// struct for typed errors of method [`circuits_provider_networks_bulk_destroy`]
402#[derive(Debug, Clone, Serialize, Deserialize)]
403#[serde(untagged)]
404pub enum CircuitsProviderNetworksBulkDestroyError {
405    UnknownValue(serde_json::Value),
406}
407
408/// struct for typed errors of method [`circuits_provider_networks_bulk_partial_update`]
409#[derive(Debug, Clone, Serialize, Deserialize)]
410#[serde(untagged)]
411pub enum CircuitsProviderNetworksBulkPartialUpdateError {
412    UnknownValue(serde_json::Value),
413}
414
415/// struct for typed errors of method [`circuits_provider_networks_bulk_update`]
416#[derive(Debug, Clone, Serialize, Deserialize)]
417#[serde(untagged)]
418pub enum CircuitsProviderNetworksBulkUpdateError {
419    UnknownValue(serde_json::Value),
420}
421
422/// struct for typed errors of method [`circuits_provider_networks_create`]
423#[derive(Debug, Clone, Serialize, Deserialize)]
424#[serde(untagged)]
425pub enum CircuitsProviderNetworksCreateError {
426    UnknownValue(serde_json::Value),
427}
428
429/// struct for typed errors of method [`circuits_provider_networks_destroy`]
430#[derive(Debug, Clone, Serialize, Deserialize)]
431#[serde(untagged)]
432pub enum CircuitsProviderNetworksDestroyError {
433    UnknownValue(serde_json::Value),
434}
435
436/// struct for typed errors of method [`circuits_provider_networks_list`]
437#[derive(Debug, Clone, Serialize, Deserialize)]
438#[serde(untagged)]
439pub enum CircuitsProviderNetworksListError {
440    UnknownValue(serde_json::Value),
441}
442
443/// struct for typed errors of method [`circuits_provider_networks_partial_update`]
444#[derive(Debug, Clone, Serialize, Deserialize)]
445#[serde(untagged)]
446pub enum CircuitsProviderNetworksPartialUpdateError {
447    UnknownValue(serde_json::Value),
448}
449
450/// struct for typed errors of method [`circuits_provider_networks_retrieve`]
451#[derive(Debug, Clone, Serialize, Deserialize)]
452#[serde(untagged)]
453pub enum CircuitsProviderNetworksRetrieveError {
454    UnknownValue(serde_json::Value),
455}
456
457/// struct for typed errors of method [`circuits_provider_networks_update`]
458#[derive(Debug, Clone, Serialize, Deserialize)]
459#[serde(untagged)]
460pub enum CircuitsProviderNetworksUpdateError {
461    UnknownValue(serde_json::Value),
462}
463
464/// struct for typed errors of method [`circuits_providers_bulk_destroy`]
465#[derive(Debug, Clone, Serialize, Deserialize)]
466#[serde(untagged)]
467pub enum CircuitsProvidersBulkDestroyError {
468    UnknownValue(serde_json::Value),
469}
470
471/// struct for typed errors of method [`circuits_providers_bulk_partial_update`]
472#[derive(Debug, Clone, Serialize, Deserialize)]
473#[serde(untagged)]
474pub enum CircuitsProvidersBulkPartialUpdateError {
475    UnknownValue(serde_json::Value),
476}
477
478/// struct for typed errors of method [`circuits_providers_bulk_update`]
479#[derive(Debug, Clone, Serialize, Deserialize)]
480#[serde(untagged)]
481pub enum CircuitsProvidersBulkUpdateError {
482    UnknownValue(serde_json::Value),
483}
484
485/// struct for typed errors of method [`circuits_providers_create`]
486#[derive(Debug, Clone, Serialize, Deserialize)]
487#[serde(untagged)]
488pub enum CircuitsProvidersCreateError {
489    UnknownValue(serde_json::Value),
490}
491
492/// struct for typed errors of method [`circuits_providers_destroy`]
493#[derive(Debug, Clone, Serialize, Deserialize)]
494#[serde(untagged)]
495pub enum CircuitsProvidersDestroyError {
496    UnknownValue(serde_json::Value),
497}
498
499/// struct for typed errors of method [`circuits_providers_list`]
500#[derive(Debug, Clone, Serialize, Deserialize)]
501#[serde(untagged)]
502pub enum CircuitsProvidersListError {
503    UnknownValue(serde_json::Value),
504}
505
506/// struct for typed errors of method [`circuits_providers_partial_update`]
507#[derive(Debug, Clone, Serialize, Deserialize)]
508#[serde(untagged)]
509pub enum CircuitsProvidersPartialUpdateError {
510    UnknownValue(serde_json::Value),
511}
512
513/// struct for typed errors of method [`circuits_providers_retrieve`]
514#[derive(Debug, Clone, Serialize, Deserialize)]
515#[serde(untagged)]
516pub enum CircuitsProvidersRetrieveError {
517    UnknownValue(serde_json::Value),
518}
519
520/// struct for typed errors of method [`circuits_providers_update`]
521#[derive(Debug, Clone, Serialize, Deserialize)]
522#[serde(untagged)]
523pub enum CircuitsProvidersUpdateError {
524    UnknownValue(serde_json::Value),
525}
526
527/// struct for typed errors of method [`circuits_virtual_circuit_terminations_bulk_destroy`]
528#[derive(Debug, Clone, Serialize, Deserialize)]
529#[serde(untagged)]
530pub enum CircuitsVirtualCircuitTerminationsBulkDestroyError {
531    UnknownValue(serde_json::Value),
532}
533
534/// struct for typed errors of method [`circuits_virtual_circuit_terminations_bulk_partial_update`]
535#[derive(Debug, Clone, Serialize, Deserialize)]
536#[serde(untagged)]
537pub enum CircuitsVirtualCircuitTerminationsBulkPartialUpdateError {
538    UnknownValue(serde_json::Value),
539}
540
541/// struct for typed errors of method [`circuits_virtual_circuit_terminations_bulk_update`]
542#[derive(Debug, Clone, Serialize, Deserialize)]
543#[serde(untagged)]
544pub enum CircuitsVirtualCircuitTerminationsBulkUpdateError {
545    UnknownValue(serde_json::Value),
546}
547
548/// struct for typed errors of method [`circuits_virtual_circuit_terminations_create`]
549#[derive(Debug, Clone, Serialize, Deserialize)]
550#[serde(untagged)]
551pub enum CircuitsVirtualCircuitTerminationsCreateError {
552    UnknownValue(serde_json::Value),
553}
554
555/// struct for typed errors of method [`circuits_virtual_circuit_terminations_destroy`]
556#[derive(Debug, Clone, Serialize, Deserialize)]
557#[serde(untagged)]
558pub enum CircuitsVirtualCircuitTerminationsDestroyError {
559    UnknownValue(serde_json::Value),
560}
561
562/// struct for typed errors of method [`circuits_virtual_circuit_terminations_list`]
563#[derive(Debug, Clone, Serialize, Deserialize)]
564#[serde(untagged)]
565pub enum CircuitsVirtualCircuitTerminationsListError {
566    UnknownValue(serde_json::Value),
567}
568
569/// struct for typed errors of method [`circuits_virtual_circuit_terminations_partial_update`]
570#[derive(Debug, Clone, Serialize, Deserialize)]
571#[serde(untagged)]
572pub enum CircuitsVirtualCircuitTerminationsPartialUpdateError {
573    UnknownValue(serde_json::Value),
574}
575
576/// struct for typed errors of method [`circuits_virtual_circuit_terminations_paths_retrieve`]
577#[derive(Debug, Clone, Serialize, Deserialize)]
578#[serde(untagged)]
579pub enum CircuitsVirtualCircuitTerminationsPathsRetrieveError {
580    UnknownValue(serde_json::Value),
581}
582
583/// struct for typed errors of method [`circuits_virtual_circuit_terminations_retrieve`]
584#[derive(Debug, Clone, Serialize, Deserialize)]
585#[serde(untagged)]
586pub enum CircuitsVirtualCircuitTerminationsRetrieveError {
587    UnknownValue(serde_json::Value),
588}
589
590/// struct for typed errors of method [`circuits_virtual_circuit_terminations_update`]
591#[derive(Debug, Clone, Serialize, Deserialize)]
592#[serde(untagged)]
593pub enum CircuitsVirtualCircuitTerminationsUpdateError {
594    UnknownValue(serde_json::Value),
595}
596
597/// struct for typed errors of method [`circuits_virtual_circuit_types_bulk_destroy`]
598#[derive(Debug, Clone, Serialize, Deserialize)]
599#[serde(untagged)]
600pub enum CircuitsVirtualCircuitTypesBulkDestroyError {
601    UnknownValue(serde_json::Value),
602}
603
604/// struct for typed errors of method [`circuits_virtual_circuit_types_bulk_partial_update`]
605#[derive(Debug, Clone, Serialize, Deserialize)]
606#[serde(untagged)]
607pub enum CircuitsVirtualCircuitTypesBulkPartialUpdateError {
608    UnknownValue(serde_json::Value),
609}
610
611/// struct for typed errors of method [`circuits_virtual_circuit_types_bulk_update`]
612#[derive(Debug, Clone, Serialize, Deserialize)]
613#[serde(untagged)]
614pub enum CircuitsVirtualCircuitTypesBulkUpdateError {
615    UnknownValue(serde_json::Value),
616}
617
618/// struct for typed errors of method [`circuits_virtual_circuit_types_create`]
619#[derive(Debug, Clone, Serialize, Deserialize)]
620#[serde(untagged)]
621pub enum CircuitsVirtualCircuitTypesCreateError {
622    UnknownValue(serde_json::Value),
623}
624
625/// struct for typed errors of method [`circuits_virtual_circuit_types_destroy`]
626#[derive(Debug, Clone, Serialize, Deserialize)]
627#[serde(untagged)]
628pub enum CircuitsVirtualCircuitTypesDestroyError {
629    UnknownValue(serde_json::Value),
630}
631
632/// struct for typed errors of method [`circuits_virtual_circuit_types_list`]
633#[derive(Debug, Clone, Serialize, Deserialize)]
634#[serde(untagged)]
635pub enum CircuitsVirtualCircuitTypesListError {
636    UnknownValue(serde_json::Value),
637}
638
639/// struct for typed errors of method [`circuits_virtual_circuit_types_partial_update`]
640#[derive(Debug, Clone, Serialize, Deserialize)]
641#[serde(untagged)]
642pub enum CircuitsVirtualCircuitTypesPartialUpdateError {
643    UnknownValue(serde_json::Value),
644}
645
646/// struct for typed errors of method [`circuits_virtual_circuit_types_retrieve`]
647#[derive(Debug, Clone, Serialize, Deserialize)]
648#[serde(untagged)]
649pub enum CircuitsVirtualCircuitTypesRetrieveError {
650    UnknownValue(serde_json::Value),
651}
652
653/// struct for typed errors of method [`circuits_virtual_circuit_types_update`]
654#[derive(Debug, Clone, Serialize, Deserialize)]
655#[serde(untagged)]
656pub enum CircuitsVirtualCircuitTypesUpdateError {
657    UnknownValue(serde_json::Value),
658}
659
660/// struct for typed errors of method [`circuits_virtual_circuits_bulk_destroy`]
661#[derive(Debug, Clone, Serialize, Deserialize)]
662#[serde(untagged)]
663pub enum CircuitsVirtualCircuitsBulkDestroyError {
664    UnknownValue(serde_json::Value),
665}
666
667/// struct for typed errors of method [`circuits_virtual_circuits_bulk_partial_update`]
668#[derive(Debug, Clone, Serialize, Deserialize)]
669#[serde(untagged)]
670pub enum CircuitsVirtualCircuitsBulkPartialUpdateError {
671    UnknownValue(serde_json::Value),
672}
673
674/// struct for typed errors of method [`circuits_virtual_circuits_bulk_update`]
675#[derive(Debug, Clone, Serialize, Deserialize)]
676#[serde(untagged)]
677pub enum CircuitsVirtualCircuitsBulkUpdateError {
678    UnknownValue(serde_json::Value),
679}
680
681/// struct for typed errors of method [`circuits_virtual_circuits_create`]
682#[derive(Debug, Clone, Serialize, Deserialize)]
683#[serde(untagged)]
684pub enum CircuitsVirtualCircuitsCreateError {
685    UnknownValue(serde_json::Value),
686}
687
688/// struct for typed errors of method [`circuits_virtual_circuits_destroy`]
689#[derive(Debug, Clone, Serialize, Deserialize)]
690#[serde(untagged)]
691pub enum CircuitsVirtualCircuitsDestroyError {
692    UnknownValue(serde_json::Value),
693}
694
695/// struct for typed errors of method [`circuits_virtual_circuits_list`]
696#[derive(Debug, Clone, Serialize, Deserialize)]
697#[serde(untagged)]
698pub enum CircuitsVirtualCircuitsListError {
699    UnknownValue(serde_json::Value),
700}
701
702/// struct for typed errors of method [`circuits_virtual_circuits_partial_update`]
703#[derive(Debug, Clone, Serialize, Deserialize)]
704#[serde(untagged)]
705pub enum CircuitsVirtualCircuitsPartialUpdateError {
706    UnknownValue(serde_json::Value),
707}
708
709/// struct for typed errors of method [`circuits_virtual_circuits_retrieve`]
710#[derive(Debug, Clone, Serialize, Deserialize)]
711#[serde(untagged)]
712pub enum CircuitsVirtualCircuitsRetrieveError {
713    UnknownValue(serde_json::Value),
714}
715
716/// struct for typed errors of method [`circuits_virtual_circuits_update`]
717#[derive(Debug, Clone, Serialize, Deserialize)]
718#[serde(untagged)]
719pub enum CircuitsVirtualCircuitsUpdateError {
720    UnknownValue(serde_json::Value),
721}
722
723/// Delete a list of Circuit group assignment objects.
724pub async fn circuits_circuit_group_assignments_bulk_destroy(
725    configuration: &configuration::Configuration,
726    circuit_group_assignment_request: Vec<crate::models::CircuitGroupAssignmentRequest>,
727) -> Result<(), Error<CircuitsCircuitGroupAssignmentsBulkDestroyError>> {
728    let local_var_configuration = configuration;
729
730    let local_var_client = &local_var_configuration.client;
731
732    let local_var_uri_str = format!(
733        "{}/api/circuits/circuit-group-assignments/",
734        local_var_configuration.base_path
735    );
736    let mut local_var_req_builder =
737        local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());
738
739    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
740        local_var_req_builder =
741            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
742    }
743    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
744        let local_var_key = local_var_apikey.key.clone();
745        let local_var_value = match local_var_apikey.prefix {
746            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
747            None => local_var_key,
748        };
749        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
750    };
751    local_var_req_builder = local_var_req_builder.json(&circuit_group_assignment_request);
752
753    let local_var_req = local_var_req_builder.build()?;
754    let local_var_resp = local_var_client.execute(local_var_req).await?;
755
756    let local_var_status = local_var_resp.status();
757    let local_var_content = local_var_resp.text().await?;
758
759    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
760        Ok(())
761    } else {
762        let local_var_entity: Option<CircuitsCircuitGroupAssignmentsBulkDestroyError> =
763            serde_json::from_str(&local_var_content).ok();
764        let local_var_error = ResponseContent {
765            status: local_var_status,
766            content: local_var_content,
767            entity: local_var_entity,
768        };
769        Err(Error::ResponseError(local_var_error))
770    }
771}
772
773/// Patch a list of Circuit group assignment objects.
774pub async fn circuits_circuit_group_assignments_bulk_partial_update(
775    configuration: &configuration::Configuration,
776    circuit_group_assignment_request: Vec<crate::models::CircuitGroupAssignmentRequest>,
777) -> Result<
778    Vec<crate::models::CircuitGroupAssignment>,
779    Error<CircuitsCircuitGroupAssignmentsBulkPartialUpdateError>,
780> {
781    let local_var_configuration = configuration;
782
783    let local_var_client = &local_var_configuration.client;
784
785    let local_var_uri_str = format!(
786        "{}/api/circuits/circuit-group-assignments/",
787        local_var_configuration.base_path
788    );
789    let mut local_var_req_builder =
790        local_var_client.request(reqwest::Method::PATCH, local_var_uri_str.as_str());
791
792    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
793        local_var_req_builder =
794            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
795    }
796    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
797        let local_var_key = local_var_apikey.key.clone();
798        let local_var_value = match local_var_apikey.prefix {
799            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
800            None => local_var_key,
801        };
802        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
803    };
804    local_var_req_builder = local_var_req_builder.json(&circuit_group_assignment_request);
805
806    let local_var_req = local_var_req_builder.build()?;
807    let local_var_resp = local_var_client.execute(local_var_req).await?;
808
809    let local_var_status = local_var_resp.status();
810    let local_var_content = local_var_resp.text().await?;
811
812    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
813        serde_json::from_str(&local_var_content).map_err(Error::from)
814    } else {
815        let local_var_entity: Option<CircuitsCircuitGroupAssignmentsBulkPartialUpdateError> =
816            serde_json::from_str(&local_var_content).ok();
817        let local_var_error = ResponseContent {
818            status: local_var_status,
819            content: local_var_content,
820            entity: local_var_entity,
821        };
822        Err(Error::ResponseError(local_var_error))
823    }
824}
825
826/// Put a list of Circuit group assignment objects.
827pub async fn circuits_circuit_group_assignments_bulk_update(
828    configuration: &configuration::Configuration,
829    circuit_group_assignment_request: Vec<crate::models::CircuitGroupAssignmentRequest>,
830) -> Result<
831    Vec<crate::models::CircuitGroupAssignment>,
832    Error<CircuitsCircuitGroupAssignmentsBulkUpdateError>,
833> {
834    let local_var_configuration = configuration;
835
836    let local_var_client = &local_var_configuration.client;
837
838    let local_var_uri_str = format!(
839        "{}/api/circuits/circuit-group-assignments/",
840        local_var_configuration.base_path
841    );
842    let mut local_var_req_builder =
843        local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());
844
845    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
846        local_var_req_builder =
847            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
848    }
849    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
850        let local_var_key = local_var_apikey.key.clone();
851        let local_var_value = match local_var_apikey.prefix {
852            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
853            None => local_var_key,
854        };
855        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
856    };
857    local_var_req_builder = local_var_req_builder.json(&circuit_group_assignment_request);
858
859    let local_var_req = local_var_req_builder.build()?;
860    let local_var_resp = local_var_client.execute(local_var_req).await?;
861
862    let local_var_status = local_var_resp.status();
863    let local_var_content = local_var_resp.text().await?;
864
865    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
866        serde_json::from_str(&local_var_content).map_err(Error::from)
867    } else {
868        let local_var_entity: Option<CircuitsCircuitGroupAssignmentsBulkUpdateError> =
869            serde_json::from_str(&local_var_content).ok();
870        let local_var_error = ResponseContent {
871            status: local_var_status,
872            content: local_var_content,
873            entity: local_var_entity,
874        };
875        Err(Error::ResponseError(local_var_error))
876    }
877}
878
879/// Post a list of Circuit group assignment objects.
880pub async fn circuits_circuit_group_assignments_create(
881    configuration: &configuration::Configuration,
882    circuits_circuit_group_assignments_create_request: crate::models::CircuitsCircuitGroupAssignmentsCreateRequest,
883) -> Result<crate::models::CircuitGroupAssignment, Error<CircuitsCircuitGroupAssignmentsCreateError>>
884{
885    let local_var_configuration = configuration;
886
887    let local_var_client = &local_var_configuration.client;
888
889    let local_var_uri_str = format!(
890        "{}/api/circuits/circuit-group-assignments/",
891        local_var_configuration.base_path
892    );
893    let mut local_var_req_builder =
894        local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
895
896    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
897        local_var_req_builder =
898            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
899    }
900    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
901        let local_var_key = local_var_apikey.key.clone();
902        let local_var_value = match local_var_apikey.prefix {
903            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
904            None => local_var_key,
905        };
906        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
907    };
908    local_var_req_builder =
909        local_var_req_builder.json(&circuits_circuit_group_assignments_create_request);
910
911    let local_var_req = local_var_req_builder.build()?;
912    let local_var_resp = local_var_client.execute(local_var_req).await?;
913
914    let local_var_status = local_var_resp.status();
915    let local_var_content = local_var_resp.text().await?;
916
917    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
918        serde_json::from_str(&local_var_content).map_err(Error::from)
919    } else {
920        let local_var_entity: Option<CircuitsCircuitGroupAssignmentsCreateError> =
921            serde_json::from_str(&local_var_content).ok();
922        let local_var_error = ResponseContent {
923            status: local_var_status,
924            content: local_var_content,
925            entity: local_var_entity,
926        };
927        Err(Error::ResponseError(local_var_error))
928    }
929}
930
931/// Delete a Circuit group assignment object.
932pub async fn circuits_circuit_group_assignments_destroy(
933    configuration: &configuration::Configuration,
934    id: i32,
935) -> Result<(), Error<CircuitsCircuitGroupAssignmentsDestroyError>> {
936    let local_var_configuration = configuration;
937
938    let local_var_client = &local_var_configuration.client;
939
940    let local_var_uri_str = format!(
941        "{}/api/circuits/circuit-group-assignments/{id}/",
942        local_var_configuration.base_path,
943        id = id
944    );
945    let mut local_var_req_builder =
946        local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());
947
948    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
949        local_var_req_builder =
950            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
951    }
952    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
953        let local_var_key = local_var_apikey.key.clone();
954        let local_var_value = match local_var_apikey.prefix {
955            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
956            None => local_var_key,
957        };
958        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
959    };
960
961    let local_var_req = local_var_req_builder.build()?;
962    let local_var_resp = local_var_client.execute(local_var_req).await?;
963
964    let local_var_status = local_var_resp.status();
965    let local_var_content = local_var_resp.text().await?;
966
967    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
968        Ok(())
969    } else {
970        let local_var_entity: Option<CircuitsCircuitGroupAssignmentsDestroyError> =
971            serde_json::from_str(&local_var_content).ok();
972        let local_var_error = ResponseContent {
973            status: local_var_status,
974            content: local_var_content,
975            entity: local_var_entity,
976        };
977        Err(Error::ResponseError(local_var_error))
978    }
979}
980
981/// Get a list of Circuit group assignment objects.
982pub async fn circuits_circuit_group_assignments_list(
983    configuration: &configuration::Configuration,
984    circuit: Option<Vec<String>>,
985    circuit_id: Option<Vec<i32>>,
986    created: Option<Vec<String>>,
987    created__empty: Option<Vec<String>>,
988    created__gt: Option<Vec<String>>,
989    created__gte: Option<Vec<String>>,
990    created__lt: Option<Vec<String>>,
991    created__lte: Option<Vec<String>>,
992    created__n: Option<Vec<String>>,
993    created_by_request: Option<&str>,
994    group: Option<Vec<String>>,
995    group__n: Option<Vec<String>>,
996    group_id: Option<Vec<i32>>,
997    group_id__n: Option<Vec<i32>>,
998    id: Option<Vec<i32>>,
999    id__empty: Option<bool>,
1000    id__gt: Option<Vec<i32>>,
1001    id__gte: Option<Vec<i32>>,
1002    id__lt: Option<Vec<i32>>,
1003    id__lte: Option<Vec<i32>>,
1004    id__n: Option<Vec<i32>>,
1005    last_updated: Option<Vec<String>>,
1006    last_updated__empty: Option<Vec<String>>,
1007    last_updated__gt: Option<Vec<String>>,
1008    last_updated__gte: Option<Vec<String>>,
1009    last_updated__lt: Option<Vec<String>>,
1010    last_updated__lte: Option<Vec<String>>,
1011    last_updated__n: Option<Vec<String>>,
1012    limit: Option<i32>,
1013    member_id: Option<Vec<i32>>,
1014    member_id__empty: Option<bool>,
1015    member_id__gt: Option<Vec<i32>>,
1016    member_id__gte: Option<Vec<i32>>,
1017    member_id__lt: Option<Vec<i32>>,
1018    member_id__lte: Option<Vec<i32>>,
1019    member_id__n: Option<Vec<i32>>,
1020    member_type: Option<Vec<String>>,
1021    member_type__n: Option<Vec<String>>,
1022    modified_by_request: Option<&str>,
1023    offset: Option<i32>,
1024    ordering: Option<&str>,
1025    priority: Option<&str>,
1026    priority__empty: Option<bool>,
1027    priority__ic: Option<Vec<String>>,
1028    priority__ie: Option<Vec<String>>,
1029    priority__iew: Option<Vec<String>>,
1030    priority__iregex: Option<Vec<String>>,
1031    priority__isw: Option<Vec<String>>,
1032    priority__n: Option<&str>,
1033    priority__nic: Option<Vec<String>>,
1034    priority__nie: Option<Vec<String>>,
1035    priority__niew: Option<Vec<String>>,
1036    priority__nisw: Option<Vec<String>>,
1037    priority__regex: Option<Vec<String>>,
1038    provider: Option<Vec<String>>,
1039    provider_id: Option<Vec<i32>>,
1040    q: Option<&str>,
1041    tag: Option<Vec<String>>,
1042    tag__n: Option<Vec<String>>,
1043    tag_id: Option<Vec<i32>>,
1044    tag_id__n: Option<Vec<i32>>,
1045    updated_by_request: Option<&str>,
1046    virtual_circuit: Option<Vec<String>>,
1047    virtual_circuit_id: Option<Vec<i32>>,
1048) -> Result<
1049    crate::models::PaginatedCircuitGroupAssignmentList,
1050    Error<CircuitsCircuitGroupAssignmentsListError>,
1051> {
1052    let local_var_configuration = configuration;
1053
1054    let local_var_client = &local_var_configuration.client;
1055
1056    let local_var_uri_str = format!(
1057        "{}/api/circuits/circuit-group-assignments/",
1058        local_var_configuration.base_path
1059    );
1060    let mut local_var_req_builder =
1061        local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
1062
1063    if let Some(ref local_var_str) = circuit {
1064        local_var_req_builder = match "multi" {
1065            "multi" => local_var_req_builder.query(
1066                &local_var_str
1067                    .into_iter()
1068                    .map(|p| ("circuit".to_owned(), p.to_string()))
1069                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1070            ),
1071            _ => local_var_req_builder.query(&[(
1072                "circuit",
1073                &local_var_str
1074                    .into_iter()
1075                    .map(|p| p.to_string())
1076                    .collect::<Vec<String>>()
1077                    .join(",")
1078                    .to_string(),
1079            )]),
1080        };
1081    }
1082    if let Some(ref local_var_str) = circuit_id {
1083        local_var_req_builder = match "multi" {
1084            "multi" => local_var_req_builder.query(
1085                &local_var_str
1086                    .into_iter()
1087                    .map(|p| ("circuit_id".to_owned(), p.to_string()))
1088                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1089            ),
1090            _ => local_var_req_builder.query(&[(
1091                "circuit_id",
1092                &local_var_str
1093                    .into_iter()
1094                    .map(|p| p.to_string())
1095                    .collect::<Vec<String>>()
1096                    .join(",")
1097                    .to_string(),
1098            )]),
1099        };
1100    }
1101    if let Some(ref local_var_str) = created {
1102        local_var_req_builder = match "multi" {
1103            "multi" => local_var_req_builder.query(
1104                &local_var_str
1105                    .into_iter()
1106                    .map(|p| ("created".to_owned(), p.to_string()))
1107                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1108            ),
1109            _ => local_var_req_builder.query(&[(
1110                "created",
1111                &local_var_str
1112                    .into_iter()
1113                    .map(|p| p.to_string())
1114                    .collect::<Vec<String>>()
1115                    .join(",")
1116                    .to_string(),
1117            )]),
1118        };
1119    }
1120    if let Some(ref local_var_str) = created__empty {
1121        local_var_req_builder = match "multi" {
1122            "multi" => local_var_req_builder.query(
1123                &local_var_str
1124                    .into_iter()
1125                    .map(|p| ("created__empty".to_owned(), p.to_string()))
1126                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1127            ),
1128            _ => local_var_req_builder.query(&[(
1129                "created__empty",
1130                &local_var_str
1131                    .into_iter()
1132                    .map(|p| p.to_string())
1133                    .collect::<Vec<String>>()
1134                    .join(",")
1135                    .to_string(),
1136            )]),
1137        };
1138    }
1139    if let Some(ref local_var_str) = created__gt {
1140        local_var_req_builder = match "multi" {
1141            "multi" => local_var_req_builder.query(
1142                &local_var_str
1143                    .into_iter()
1144                    .map(|p| ("created__gt".to_owned(), p.to_string()))
1145                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1146            ),
1147            _ => local_var_req_builder.query(&[(
1148                "created__gt",
1149                &local_var_str
1150                    .into_iter()
1151                    .map(|p| p.to_string())
1152                    .collect::<Vec<String>>()
1153                    .join(",")
1154                    .to_string(),
1155            )]),
1156        };
1157    }
1158    if let Some(ref local_var_str) = created__gte {
1159        local_var_req_builder = match "multi" {
1160            "multi" => local_var_req_builder.query(
1161                &local_var_str
1162                    .into_iter()
1163                    .map(|p| ("created__gte".to_owned(), p.to_string()))
1164                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1165            ),
1166            _ => local_var_req_builder.query(&[(
1167                "created__gte",
1168                &local_var_str
1169                    .into_iter()
1170                    .map(|p| p.to_string())
1171                    .collect::<Vec<String>>()
1172                    .join(",")
1173                    .to_string(),
1174            )]),
1175        };
1176    }
1177    if let Some(ref local_var_str) = created__lt {
1178        local_var_req_builder = match "multi" {
1179            "multi" => local_var_req_builder.query(
1180                &local_var_str
1181                    .into_iter()
1182                    .map(|p| ("created__lt".to_owned(), p.to_string()))
1183                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1184            ),
1185            _ => local_var_req_builder.query(&[(
1186                "created__lt",
1187                &local_var_str
1188                    .into_iter()
1189                    .map(|p| p.to_string())
1190                    .collect::<Vec<String>>()
1191                    .join(",")
1192                    .to_string(),
1193            )]),
1194        };
1195    }
1196    if let Some(ref local_var_str) = created__lte {
1197        local_var_req_builder = match "multi" {
1198            "multi" => local_var_req_builder.query(
1199                &local_var_str
1200                    .into_iter()
1201                    .map(|p| ("created__lte".to_owned(), p.to_string()))
1202                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1203            ),
1204            _ => local_var_req_builder.query(&[(
1205                "created__lte",
1206                &local_var_str
1207                    .into_iter()
1208                    .map(|p| p.to_string())
1209                    .collect::<Vec<String>>()
1210                    .join(",")
1211                    .to_string(),
1212            )]),
1213        };
1214    }
1215    if let Some(ref local_var_str) = created__n {
1216        local_var_req_builder = match "multi" {
1217            "multi" => local_var_req_builder.query(
1218                &local_var_str
1219                    .into_iter()
1220                    .map(|p| ("created__n".to_owned(), p.to_string()))
1221                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1222            ),
1223            _ => local_var_req_builder.query(&[(
1224                "created__n",
1225                &local_var_str
1226                    .into_iter()
1227                    .map(|p| p.to_string())
1228                    .collect::<Vec<String>>()
1229                    .join(",")
1230                    .to_string(),
1231            )]),
1232        };
1233    }
1234    if let Some(ref local_var_str) = created_by_request {
1235        local_var_req_builder =
1236            local_var_req_builder.query(&[("created_by_request", &local_var_str.to_string())]);
1237    }
1238    if let Some(ref local_var_str) = group {
1239        local_var_req_builder = match "multi" {
1240            "multi" => local_var_req_builder.query(
1241                &local_var_str
1242                    .into_iter()
1243                    .map(|p| ("group".to_owned(), p.to_string()))
1244                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1245            ),
1246            _ => local_var_req_builder.query(&[(
1247                "group",
1248                &local_var_str
1249                    .into_iter()
1250                    .map(|p| p.to_string())
1251                    .collect::<Vec<String>>()
1252                    .join(",")
1253                    .to_string(),
1254            )]),
1255        };
1256    }
1257    if let Some(ref local_var_str) = group__n {
1258        local_var_req_builder = match "multi" {
1259            "multi" => local_var_req_builder.query(
1260                &local_var_str
1261                    .into_iter()
1262                    .map(|p| ("group__n".to_owned(), p.to_string()))
1263                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1264            ),
1265            _ => local_var_req_builder.query(&[(
1266                "group__n",
1267                &local_var_str
1268                    .into_iter()
1269                    .map(|p| p.to_string())
1270                    .collect::<Vec<String>>()
1271                    .join(",")
1272                    .to_string(),
1273            )]),
1274        };
1275    }
1276    if let Some(ref local_var_str) = group_id {
1277        local_var_req_builder = match "multi" {
1278            "multi" => local_var_req_builder.query(
1279                &local_var_str
1280                    .into_iter()
1281                    .map(|p| ("group_id".to_owned(), p.to_string()))
1282                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1283            ),
1284            _ => local_var_req_builder.query(&[(
1285                "group_id",
1286                &local_var_str
1287                    .into_iter()
1288                    .map(|p| p.to_string())
1289                    .collect::<Vec<String>>()
1290                    .join(",")
1291                    .to_string(),
1292            )]),
1293        };
1294    }
1295    if let Some(ref local_var_str) = group_id__n {
1296        local_var_req_builder = match "multi" {
1297            "multi" => local_var_req_builder.query(
1298                &local_var_str
1299                    .into_iter()
1300                    .map(|p| ("group_id__n".to_owned(), p.to_string()))
1301                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1302            ),
1303            _ => local_var_req_builder.query(&[(
1304                "group_id__n",
1305                &local_var_str
1306                    .into_iter()
1307                    .map(|p| p.to_string())
1308                    .collect::<Vec<String>>()
1309                    .join(",")
1310                    .to_string(),
1311            )]),
1312        };
1313    }
1314    if let Some(ref local_var_str) = id {
1315        local_var_req_builder = match "multi" {
1316            "multi" => local_var_req_builder.query(
1317                &local_var_str
1318                    .into_iter()
1319                    .map(|p| ("id".to_owned(), p.to_string()))
1320                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1321            ),
1322            _ => local_var_req_builder.query(&[(
1323                "id",
1324                &local_var_str
1325                    .into_iter()
1326                    .map(|p| p.to_string())
1327                    .collect::<Vec<String>>()
1328                    .join(",")
1329                    .to_string(),
1330            )]),
1331        };
1332    }
1333    if let Some(ref local_var_str) = id__empty {
1334        local_var_req_builder =
1335            local_var_req_builder.query(&[("id__empty", &local_var_str.to_string())]);
1336    }
1337    if let Some(ref local_var_str) = id__gt {
1338        local_var_req_builder = match "multi" {
1339            "multi" => local_var_req_builder.query(
1340                &local_var_str
1341                    .into_iter()
1342                    .map(|p| ("id__gt".to_owned(), p.to_string()))
1343                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1344            ),
1345            _ => local_var_req_builder.query(&[(
1346                "id__gt",
1347                &local_var_str
1348                    .into_iter()
1349                    .map(|p| p.to_string())
1350                    .collect::<Vec<String>>()
1351                    .join(",")
1352                    .to_string(),
1353            )]),
1354        };
1355    }
1356    if let Some(ref local_var_str) = id__gte {
1357        local_var_req_builder = match "multi" {
1358            "multi" => local_var_req_builder.query(
1359                &local_var_str
1360                    .into_iter()
1361                    .map(|p| ("id__gte".to_owned(), p.to_string()))
1362                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1363            ),
1364            _ => local_var_req_builder.query(&[(
1365                "id__gte",
1366                &local_var_str
1367                    .into_iter()
1368                    .map(|p| p.to_string())
1369                    .collect::<Vec<String>>()
1370                    .join(",")
1371                    .to_string(),
1372            )]),
1373        };
1374    }
1375    if let Some(ref local_var_str) = id__lt {
1376        local_var_req_builder = match "multi" {
1377            "multi" => local_var_req_builder.query(
1378                &local_var_str
1379                    .into_iter()
1380                    .map(|p| ("id__lt".to_owned(), p.to_string()))
1381                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1382            ),
1383            _ => local_var_req_builder.query(&[(
1384                "id__lt",
1385                &local_var_str
1386                    .into_iter()
1387                    .map(|p| p.to_string())
1388                    .collect::<Vec<String>>()
1389                    .join(",")
1390                    .to_string(),
1391            )]),
1392        };
1393    }
1394    if let Some(ref local_var_str) = id__lte {
1395        local_var_req_builder = match "multi" {
1396            "multi" => local_var_req_builder.query(
1397                &local_var_str
1398                    .into_iter()
1399                    .map(|p| ("id__lte".to_owned(), p.to_string()))
1400                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1401            ),
1402            _ => local_var_req_builder.query(&[(
1403                "id__lte",
1404                &local_var_str
1405                    .into_iter()
1406                    .map(|p| p.to_string())
1407                    .collect::<Vec<String>>()
1408                    .join(",")
1409                    .to_string(),
1410            )]),
1411        };
1412    }
1413    if let Some(ref local_var_str) = id__n {
1414        local_var_req_builder = match "multi" {
1415            "multi" => local_var_req_builder.query(
1416                &local_var_str
1417                    .into_iter()
1418                    .map(|p| ("id__n".to_owned(), p.to_string()))
1419                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1420            ),
1421            _ => local_var_req_builder.query(&[(
1422                "id__n",
1423                &local_var_str
1424                    .into_iter()
1425                    .map(|p| p.to_string())
1426                    .collect::<Vec<String>>()
1427                    .join(",")
1428                    .to_string(),
1429            )]),
1430        };
1431    }
1432    if let Some(ref local_var_str) = last_updated {
1433        local_var_req_builder = match "multi" {
1434            "multi" => local_var_req_builder.query(
1435                &local_var_str
1436                    .into_iter()
1437                    .map(|p| ("last_updated".to_owned(), p.to_string()))
1438                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1439            ),
1440            _ => local_var_req_builder.query(&[(
1441                "last_updated",
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) = last_updated__empty {
1452        local_var_req_builder = match "multi" {
1453            "multi" => local_var_req_builder.query(
1454                &local_var_str
1455                    .into_iter()
1456                    .map(|p| ("last_updated__empty".to_owned(), p.to_string()))
1457                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1458            ),
1459            _ => local_var_req_builder.query(&[(
1460                "last_updated__empty",
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) = last_updated__gt {
1471        local_var_req_builder = match "multi" {
1472            "multi" => local_var_req_builder.query(
1473                &local_var_str
1474                    .into_iter()
1475                    .map(|p| ("last_updated__gt".to_owned(), p.to_string()))
1476                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1477            ),
1478            _ => local_var_req_builder.query(&[(
1479                "last_updated__gt",
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) = last_updated__gte {
1490        local_var_req_builder = match "multi" {
1491            "multi" => local_var_req_builder.query(
1492                &local_var_str
1493                    .into_iter()
1494                    .map(|p| ("last_updated__gte".to_owned(), p.to_string()))
1495                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1496            ),
1497            _ => local_var_req_builder.query(&[(
1498                "last_updated__gte",
1499                &local_var_str
1500                    .into_iter()
1501                    .map(|p| p.to_string())
1502                    .collect::<Vec<String>>()
1503                    .join(",")
1504                    .to_string(),
1505            )]),
1506        };
1507    }
1508    if let Some(ref local_var_str) = last_updated__lt {
1509        local_var_req_builder = match "multi" {
1510            "multi" => local_var_req_builder.query(
1511                &local_var_str
1512                    .into_iter()
1513                    .map(|p| ("last_updated__lt".to_owned(), p.to_string()))
1514                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1515            ),
1516            _ => local_var_req_builder.query(&[(
1517                "last_updated__lt",
1518                &local_var_str
1519                    .into_iter()
1520                    .map(|p| p.to_string())
1521                    .collect::<Vec<String>>()
1522                    .join(",")
1523                    .to_string(),
1524            )]),
1525        };
1526    }
1527    if let Some(ref local_var_str) = last_updated__lte {
1528        local_var_req_builder = match "multi" {
1529            "multi" => local_var_req_builder.query(
1530                &local_var_str
1531                    .into_iter()
1532                    .map(|p| ("last_updated__lte".to_owned(), p.to_string()))
1533                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1534            ),
1535            _ => local_var_req_builder.query(&[(
1536                "last_updated__lte",
1537                &local_var_str
1538                    .into_iter()
1539                    .map(|p| p.to_string())
1540                    .collect::<Vec<String>>()
1541                    .join(",")
1542                    .to_string(),
1543            )]),
1544        };
1545    }
1546    if let Some(ref local_var_str) = last_updated__n {
1547        local_var_req_builder = match "multi" {
1548            "multi" => local_var_req_builder.query(
1549                &local_var_str
1550                    .into_iter()
1551                    .map(|p| ("last_updated__n".to_owned(), p.to_string()))
1552                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1553            ),
1554            _ => local_var_req_builder.query(&[(
1555                "last_updated__n",
1556                &local_var_str
1557                    .into_iter()
1558                    .map(|p| p.to_string())
1559                    .collect::<Vec<String>>()
1560                    .join(",")
1561                    .to_string(),
1562            )]),
1563        };
1564    }
1565    if let Some(ref local_var_str) = limit {
1566        local_var_req_builder =
1567            local_var_req_builder.query(&[("limit", &local_var_str.to_string())]);
1568    }
1569    if let Some(ref local_var_str) = member_id {
1570        local_var_req_builder = match "multi" {
1571            "multi" => local_var_req_builder.query(
1572                &local_var_str
1573                    .into_iter()
1574                    .map(|p| ("member_id".to_owned(), p.to_string()))
1575                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1576            ),
1577            _ => local_var_req_builder.query(&[(
1578                "member_id",
1579                &local_var_str
1580                    .into_iter()
1581                    .map(|p| p.to_string())
1582                    .collect::<Vec<String>>()
1583                    .join(",")
1584                    .to_string(),
1585            )]),
1586        };
1587    }
1588    if let Some(ref local_var_str) = member_id__empty {
1589        local_var_req_builder =
1590            local_var_req_builder.query(&[("member_id__empty", &local_var_str.to_string())]);
1591    }
1592    if let Some(ref local_var_str) = member_id__gt {
1593        local_var_req_builder = match "multi" {
1594            "multi" => local_var_req_builder.query(
1595                &local_var_str
1596                    .into_iter()
1597                    .map(|p| ("member_id__gt".to_owned(), p.to_string()))
1598                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1599            ),
1600            _ => local_var_req_builder.query(&[(
1601                "member_id__gt",
1602                &local_var_str
1603                    .into_iter()
1604                    .map(|p| p.to_string())
1605                    .collect::<Vec<String>>()
1606                    .join(",")
1607                    .to_string(),
1608            )]),
1609        };
1610    }
1611    if let Some(ref local_var_str) = member_id__gte {
1612        local_var_req_builder = match "multi" {
1613            "multi" => local_var_req_builder.query(
1614                &local_var_str
1615                    .into_iter()
1616                    .map(|p| ("member_id__gte".to_owned(), p.to_string()))
1617                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1618            ),
1619            _ => local_var_req_builder.query(&[(
1620                "member_id__gte",
1621                &local_var_str
1622                    .into_iter()
1623                    .map(|p| p.to_string())
1624                    .collect::<Vec<String>>()
1625                    .join(",")
1626                    .to_string(),
1627            )]),
1628        };
1629    }
1630    if let Some(ref local_var_str) = member_id__lt {
1631        local_var_req_builder = match "multi" {
1632            "multi" => local_var_req_builder.query(
1633                &local_var_str
1634                    .into_iter()
1635                    .map(|p| ("member_id__lt".to_owned(), p.to_string()))
1636                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1637            ),
1638            _ => local_var_req_builder.query(&[(
1639                "member_id__lt",
1640                &local_var_str
1641                    .into_iter()
1642                    .map(|p| p.to_string())
1643                    .collect::<Vec<String>>()
1644                    .join(",")
1645                    .to_string(),
1646            )]),
1647        };
1648    }
1649    if let Some(ref local_var_str) = member_id__lte {
1650        local_var_req_builder = match "multi" {
1651            "multi" => local_var_req_builder.query(
1652                &local_var_str
1653                    .into_iter()
1654                    .map(|p| ("member_id__lte".to_owned(), p.to_string()))
1655                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1656            ),
1657            _ => local_var_req_builder.query(&[(
1658                "member_id__lte",
1659                &local_var_str
1660                    .into_iter()
1661                    .map(|p| p.to_string())
1662                    .collect::<Vec<String>>()
1663                    .join(",")
1664                    .to_string(),
1665            )]),
1666        };
1667    }
1668    if let Some(ref local_var_str) = member_id__n {
1669        local_var_req_builder = match "multi" {
1670            "multi" => local_var_req_builder.query(
1671                &local_var_str
1672                    .into_iter()
1673                    .map(|p| ("member_id__n".to_owned(), p.to_string()))
1674                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1675            ),
1676            _ => local_var_req_builder.query(&[(
1677                "member_id__n",
1678                &local_var_str
1679                    .into_iter()
1680                    .map(|p| p.to_string())
1681                    .collect::<Vec<String>>()
1682                    .join(",")
1683                    .to_string(),
1684            )]),
1685        };
1686    }
1687    if let Some(ref local_var_str) = member_type {
1688        local_var_req_builder = match "multi" {
1689            "multi" => local_var_req_builder.query(
1690                &local_var_str
1691                    .into_iter()
1692                    .map(|p| ("member_type".to_owned(), p.to_string()))
1693                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1694            ),
1695            _ => local_var_req_builder.query(&[(
1696                "member_type",
1697                &local_var_str
1698                    .into_iter()
1699                    .map(|p| p.to_string())
1700                    .collect::<Vec<String>>()
1701                    .join(",")
1702                    .to_string(),
1703            )]),
1704        };
1705    }
1706    if let Some(ref local_var_str) = member_type__n {
1707        local_var_req_builder = match "multi" {
1708            "multi" => local_var_req_builder.query(
1709                &local_var_str
1710                    .into_iter()
1711                    .map(|p| ("member_type__n".to_owned(), p.to_string()))
1712                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1713            ),
1714            _ => local_var_req_builder.query(&[(
1715                "member_type__n",
1716                &local_var_str
1717                    .into_iter()
1718                    .map(|p| p.to_string())
1719                    .collect::<Vec<String>>()
1720                    .join(",")
1721                    .to_string(),
1722            )]),
1723        };
1724    }
1725    if let Some(ref local_var_str) = modified_by_request {
1726        local_var_req_builder =
1727            local_var_req_builder.query(&[("modified_by_request", &local_var_str.to_string())]);
1728    }
1729    if let Some(ref local_var_str) = offset {
1730        local_var_req_builder =
1731            local_var_req_builder.query(&[("offset", &local_var_str.to_string())]);
1732    }
1733    if let Some(ref local_var_str) = ordering {
1734        local_var_req_builder =
1735            local_var_req_builder.query(&[("ordering", &local_var_str.to_string())]);
1736    }
1737    if let Some(ref local_var_str) = priority {
1738        local_var_req_builder =
1739            local_var_req_builder.query(&[("priority", &local_var_str.to_string())]);
1740    }
1741    if let Some(ref local_var_str) = priority__empty {
1742        local_var_req_builder =
1743            local_var_req_builder.query(&[("priority__empty", &local_var_str.to_string())]);
1744    }
1745    if let Some(ref local_var_str) = priority__ic {
1746        local_var_req_builder = match "multi" {
1747            "multi" => local_var_req_builder.query(
1748                &local_var_str
1749                    .into_iter()
1750                    .map(|p| ("priority__ic".to_owned(), p.to_string()))
1751                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1752            ),
1753            _ => local_var_req_builder.query(&[(
1754                "priority__ic",
1755                &local_var_str
1756                    .into_iter()
1757                    .map(|p| p.to_string())
1758                    .collect::<Vec<String>>()
1759                    .join(",")
1760                    .to_string(),
1761            )]),
1762        };
1763    }
1764    if let Some(ref local_var_str) = priority__ie {
1765        local_var_req_builder = match "multi" {
1766            "multi" => local_var_req_builder.query(
1767                &local_var_str
1768                    .into_iter()
1769                    .map(|p| ("priority__ie".to_owned(), p.to_string()))
1770                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1771            ),
1772            _ => local_var_req_builder.query(&[(
1773                "priority__ie",
1774                &local_var_str
1775                    .into_iter()
1776                    .map(|p| p.to_string())
1777                    .collect::<Vec<String>>()
1778                    .join(",")
1779                    .to_string(),
1780            )]),
1781        };
1782    }
1783    if let Some(ref local_var_str) = priority__iew {
1784        local_var_req_builder = match "multi" {
1785            "multi" => local_var_req_builder.query(
1786                &local_var_str
1787                    .into_iter()
1788                    .map(|p| ("priority__iew".to_owned(), p.to_string()))
1789                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1790            ),
1791            _ => local_var_req_builder.query(&[(
1792                "priority__iew",
1793                &local_var_str
1794                    .into_iter()
1795                    .map(|p| p.to_string())
1796                    .collect::<Vec<String>>()
1797                    .join(",")
1798                    .to_string(),
1799            )]),
1800        };
1801    }
1802    if let Some(ref local_var_str) = priority__iregex {
1803        local_var_req_builder = match "multi" {
1804            "multi" => local_var_req_builder.query(
1805                &local_var_str
1806                    .into_iter()
1807                    .map(|p| ("priority__iregex".to_owned(), p.to_string()))
1808                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1809            ),
1810            _ => local_var_req_builder.query(&[(
1811                "priority__iregex",
1812                &local_var_str
1813                    .into_iter()
1814                    .map(|p| p.to_string())
1815                    .collect::<Vec<String>>()
1816                    .join(",")
1817                    .to_string(),
1818            )]),
1819        };
1820    }
1821    if let Some(ref local_var_str) = priority__isw {
1822        local_var_req_builder = match "multi" {
1823            "multi" => local_var_req_builder.query(
1824                &local_var_str
1825                    .into_iter()
1826                    .map(|p| ("priority__isw".to_owned(), p.to_string()))
1827                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1828            ),
1829            _ => local_var_req_builder.query(&[(
1830                "priority__isw",
1831                &local_var_str
1832                    .into_iter()
1833                    .map(|p| p.to_string())
1834                    .collect::<Vec<String>>()
1835                    .join(",")
1836                    .to_string(),
1837            )]),
1838        };
1839    }
1840    if let Some(ref local_var_str) = priority__n {
1841        local_var_req_builder =
1842            local_var_req_builder.query(&[("priority__n", &local_var_str.to_string())]);
1843    }
1844    if let Some(ref local_var_str) = priority__nic {
1845        local_var_req_builder = match "multi" {
1846            "multi" => local_var_req_builder.query(
1847                &local_var_str
1848                    .into_iter()
1849                    .map(|p| ("priority__nic".to_owned(), p.to_string()))
1850                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1851            ),
1852            _ => local_var_req_builder.query(&[(
1853                "priority__nic",
1854                &local_var_str
1855                    .into_iter()
1856                    .map(|p| p.to_string())
1857                    .collect::<Vec<String>>()
1858                    .join(",")
1859                    .to_string(),
1860            )]),
1861        };
1862    }
1863    if let Some(ref local_var_str) = priority__nie {
1864        local_var_req_builder = match "multi" {
1865            "multi" => local_var_req_builder.query(
1866                &local_var_str
1867                    .into_iter()
1868                    .map(|p| ("priority__nie".to_owned(), p.to_string()))
1869                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1870            ),
1871            _ => local_var_req_builder.query(&[(
1872                "priority__nie",
1873                &local_var_str
1874                    .into_iter()
1875                    .map(|p| p.to_string())
1876                    .collect::<Vec<String>>()
1877                    .join(",")
1878                    .to_string(),
1879            )]),
1880        };
1881    }
1882    if let Some(ref local_var_str) = priority__niew {
1883        local_var_req_builder = match "multi" {
1884            "multi" => local_var_req_builder.query(
1885                &local_var_str
1886                    .into_iter()
1887                    .map(|p| ("priority__niew".to_owned(), p.to_string()))
1888                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1889            ),
1890            _ => local_var_req_builder.query(&[(
1891                "priority__niew",
1892                &local_var_str
1893                    .into_iter()
1894                    .map(|p| p.to_string())
1895                    .collect::<Vec<String>>()
1896                    .join(",")
1897                    .to_string(),
1898            )]),
1899        };
1900    }
1901    if let Some(ref local_var_str) = priority__nisw {
1902        local_var_req_builder = match "multi" {
1903            "multi" => local_var_req_builder.query(
1904                &local_var_str
1905                    .into_iter()
1906                    .map(|p| ("priority__nisw".to_owned(), p.to_string()))
1907                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1908            ),
1909            _ => local_var_req_builder.query(&[(
1910                "priority__nisw",
1911                &local_var_str
1912                    .into_iter()
1913                    .map(|p| p.to_string())
1914                    .collect::<Vec<String>>()
1915                    .join(",")
1916                    .to_string(),
1917            )]),
1918        };
1919    }
1920    if let Some(ref local_var_str) = priority__regex {
1921        local_var_req_builder = match "multi" {
1922            "multi" => local_var_req_builder.query(
1923                &local_var_str
1924                    .into_iter()
1925                    .map(|p| ("priority__regex".to_owned(), p.to_string()))
1926                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1927            ),
1928            _ => local_var_req_builder.query(&[(
1929                "priority__regex",
1930                &local_var_str
1931                    .into_iter()
1932                    .map(|p| p.to_string())
1933                    .collect::<Vec<String>>()
1934                    .join(",")
1935                    .to_string(),
1936            )]),
1937        };
1938    }
1939    if let Some(ref local_var_str) = provider {
1940        local_var_req_builder = match "multi" {
1941            "multi" => local_var_req_builder.query(
1942                &local_var_str
1943                    .into_iter()
1944                    .map(|p| ("provider".to_owned(), p.to_string()))
1945                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1946            ),
1947            _ => local_var_req_builder.query(&[(
1948                "provider",
1949                &local_var_str
1950                    .into_iter()
1951                    .map(|p| p.to_string())
1952                    .collect::<Vec<String>>()
1953                    .join(",")
1954                    .to_string(),
1955            )]),
1956        };
1957    }
1958    if let Some(ref local_var_str) = provider_id {
1959        local_var_req_builder = match "multi" {
1960            "multi" => local_var_req_builder.query(
1961                &local_var_str
1962                    .into_iter()
1963                    .map(|p| ("provider_id".to_owned(), p.to_string()))
1964                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1965            ),
1966            _ => local_var_req_builder.query(&[(
1967                "provider_id",
1968                &local_var_str
1969                    .into_iter()
1970                    .map(|p| p.to_string())
1971                    .collect::<Vec<String>>()
1972                    .join(",")
1973                    .to_string(),
1974            )]),
1975        };
1976    }
1977    if let Some(ref local_var_str) = q {
1978        local_var_req_builder = local_var_req_builder.query(&[("q", &local_var_str.to_string())]);
1979    }
1980    if let Some(ref local_var_str) = tag {
1981        local_var_req_builder = match "multi" {
1982            "multi" => local_var_req_builder.query(
1983                &local_var_str
1984                    .into_iter()
1985                    .map(|p| ("tag".to_owned(), p.to_string()))
1986                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1987            ),
1988            _ => local_var_req_builder.query(&[(
1989                "tag",
1990                &local_var_str
1991                    .into_iter()
1992                    .map(|p| p.to_string())
1993                    .collect::<Vec<String>>()
1994                    .join(",")
1995                    .to_string(),
1996            )]),
1997        };
1998    }
1999    if let Some(ref local_var_str) = tag__n {
2000        local_var_req_builder = match "multi" {
2001            "multi" => local_var_req_builder.query(
2002                &local_var_str
2003                    .into_iter()
2004                    .map(|p| ("tag__n".to_owned(), p.to_string()))
2005                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2006            ),
2007            _ => local_var_req_builder.query(&[(
2008                "tag__n",
2009                &local_var_str
2010                    .into_iter()
2011                    .map(|p| p.to_string())
2012                    .collect::<Vec<String>>()
2013                    .join(",")
2014                    .to_string(),
2015            )]),
2016        };
2017    }
2018    if let Some(ref local_var_str) = tag_id {
2019        local_var_req_builder = match "multi" {
2020            "multi" => local_var_req_builder.query(
2021                &local_var_str
2022                    .into_iter()
2023                    .map(|p| ("tag_id".to_owned(), p.to_string()))
2024                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2025            ),
2026            _ => local_var_req_builder.query(&[(
2027                "tag_id",
2028                &local_var_str
2029                    .into_iter()
2030                    .map(|p| p.to_string())
2031                    .collect::<Vec<String>>()
2032                    .join(",")
2033                    .to_string(),
2034            )]),
2035        };
2036    }
2037    if let Some(ref local_var_str) = tag_id__n {
2038        local_var_req_builder = match "multi" {
2039            "multi" => local_var_req_builder.query(
2040                &local_var_str
2041                    .into_iter()
2042                    .map(|p| ("tag_id__n".to_owned(), p.to_string()))
2043                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2044            ),
2045            _ => local_var_req_builder.query(&[(
2046                "tag_id__n",
2047                &local_var_str
2048                    .into_iter()
2049                    .map(|p| p.to_string())
2050                    .collect::<Vec<String>>()
2051                    .join(",")
2052                    .to_string(),
2053            )]),
2054        };
2055    }
2056    if let Some(ref local_var_str) = updated_by_request {
2057        local_var_req_builder =
2058            local_var_req_builder.query(&[("updated_by_request", &local_var_str.to_string())]);
2059    }
2060    if let Some(ref local_var_str) = virtual_circuit {
2061        local_var_req_builder = match "multi" {
2062            "multi" => local_var_req_builder.query(
2063                &local_var_str
2064                    .into_iter()
2065                    .map(|p| ("virtual_circuit".to_owned(), p.to_string()))
2066                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2067            ),
2068            _ => local_var_req_builder.query(&[(
2069                "virtual_circuit",
2070                &local_var_str
2071                    .into_iter()
2072                    .map(|p| p.to_string())
2073                    .collect::<Vec<String>>()
2074                    .join(",")
2075                    .to_string(),
2076            )]),
2077        };
2078    }
2079    if let Some(ref local_var_str) = virtual_circuit_id {
2080        local_var_req_builder = match "multi" {
2081            "multi" => local_var_req_builder.query(
2082                &local_var_str
2083                    .into_iter()
2084                    .map(|p| ("virtual_circuit_id".to_owned(), p.to_string()))
2085                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2086            ),
2087            _ => local_var_req_builder.query(&[(
2088                "virtual_circuit_id",
2089                &local_var_str
2090                    .into_iter()
2091                    .map(|p| p.to_string())
2092                    .collect::<Vec<String>>()
2093                    .join(",")
2094                    .to_string(),
2095            )]),
2096        };
2097    }
2098    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
2099        local_var_req_builder =
2100            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
2101    }
2102    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
2103        let local_var_key = local_var_apikey.key.clone();
2104        let local_var_value = match local_var_apikey.prefix {
2105            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
2106            None => local_var_key,
2107        };
2108        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
2109    };
2110
2111    let local_var_req = local_var_req_builder.build()?;
2112    let local_var_resp = local_var_client.execute(local_var_req).await?;
2113
2114    let local_var_status = local_var_resp.status();
2115    let local_var_content = local_var_resp.text().await?;
2116
2117    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
2118        serde_json::from_str(&local_var_content).map_err(Error::from)
2119    } else {
2120        let local_var_entity: Option<CircuitsCircuitGroupAssignmentsListError> =
2121            serde_json::from_str(&local_var_content).ok();
2122        let local_var_error = ResponseContent {
2123            status: local_var_status,
2124            content: local_var_content,
2125            entity: local_var_entity,
2126        };
2127        Err(Error::ResponseError(local_var_error))
2128    }
2129}
2130
2131/// Patch a Circuit group assignment object.
2132pub async fn circuits_circuit_group_assignments_partial_update(
2133    configuration: &configuration::Configuration,
2134    id: i32,
2135    patched_writable_circuit_group_assignment_request: Option<
2136        crate::models::PatchedWritableCircuitGroupAssignmentRequest,
2137    >,
2138) -> Result<
2139    crate::models::CircuitGroupAssignment,
2140    Error<CircuitsCircuitGroupAssignmentsPartialUpdateError>,
2141> {
2142    let local_var_configuration = configuration;
2143
2144    let local_var_client = &local_var_configuration.client;
2145
2146    let local_var_uri_str = format!(
2147        "{}/api/circuits/circuit-group-assignments/{id}/",
2148        local_var_configuration.base_path,
2149        id = id
2150    );
2151    let mut local_var_req_builder =
2152        local_var_client.request(reqwest::Method::PATCH, local_var_uri_str.as_str());
2153
2154    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
2155        local_var_req_builder =
2156            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
2157    }
2158    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
2159        let local_var_key = local_var_apikey.key.clone();
2160        let local_var_value = match local_var_apikey.prefix {
2161            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
2162            None => local_var_key,
2163        };
2164        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
2165    };
2166    local_var_req_builder =
2167        local_var_req_builder.json(&patched_writable_circuit_group_assignment_request);
2168
2169    let local_var_req = local_var_req_builder.build()?;
2170    let local_var_resp = local_var_client.execute(local_var_req).await?;
2171
2172    let local_var_status = local_var_resp.status();
2173    let local_var_content = local_var_resp.text().await?;
2174
2175    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
2176        serde_json::from_str(&local_var_content).map_err(Error::from)
2177    } else {
2178        let local_var_entity: Option<CircuitsCircuitGroupAssignmentsPartialUpdateError> =
2179            serde_json::from_str(&local_var_content).ok();
2180        let local_var_error = ResponseContent {
2181            status: local_var_status,
2182            content: local_var_content,
2183            entity: local_var_entity,
2184        };
2185        Err(Error::ResponseError(local_var_error))
2186    }
2187}
2188
2189/// Get a Circuit group assignment object.
2190pub async fn circuits_circuit_group_assignments_retrieve(
2191    configuration: &configuration::Configuration,
2192    id: i32,
2193) -> Result<
2194    crate::models::CircuitGroupAssignment,
2195    Error<CircuitsCircuitGroupAssignmentsRetrieveError>,
2196> {
2197    let local_var_configuration = configuration;
2198
2199    let local_var_client = &local_var_configuration.client;
2200
2201    let local_var_uri_str = format!(
2202        "{}/api/circuits/circuit-group-assignments/{id}/",
2203        local_var_configuration.base_path,
2204        id = id
2205    );
2206    let mut local_var_req_builder =
2207        local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
2208
2209    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
2210        local_var_req_builder =
2211            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
2212    }
2213    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
2214        let local_var_key = local_var_apikey.key.clone();
2215        let local_var_value = match local_var_apikey.prefix {
2216            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
2217            None => local_var_key,
2218        };
2219        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
2220    };
2221
2222    let local_var_req = local_var_req_builder.build()?;
2223    let local_var_resp = local_var_client.execute(local_var_req).await?;
2224
2225    let local_var_status = local_var_resp.status();
2226    let local_var_content = local_var_resp.text().await?;
2227
2228    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
2229        serde_json::from_str(&local_var_content).map_err(Error::from)
2230    } else {
2231        let local_var_entity: Option<CircuitsCircuitGroupAssignmentsRetrieveError> =
2232            serde_json::from_str(&local_var_content).ok();
2233        let local_var_error = ResponseContent {
2234            status: local_var_status,
2235            content: local_var_content,
2236            entity: local_var_entity,
2237        };
2238        Err(Error::ResponseError(local_var_error))
2239    }
2240}
2241
2242/// Put a Circuit group assignment object.
2243pub async fn circuits_circuit_group_assignments_update(
2244    configuration: &configuration::Configuration,
2245    id: i32,
2246    writable_circuit_group_assignment_request: crate::models::WritableCircuitGroupAssignmentRequest,
2247) -> Result<crate::models::CircuitGroupAssignment, Error<CircuitsCircuitGroupAssignmentsUpdateError>>
2248{
2249    let local_var_configuration = configuration;
2250
2251    let local_var_client = &local_var_configuration.client;
2252
2253    let local_var_uri_str = format!(
2254        "{}/api/circuits/circuit-group-assignments/{id}/",
2255        local_var_configuration.base_path,
2256        id = id
2257    );
2258    let mut local_var_req_builder =
2259        local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());
2260
2261    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
2262        local_var_req_builder =
2263            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
2264    }
2265    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
2266        let local_var_key = local_var_apikey.key.clone();
2267        let local_var_value = match local_var_apikey.prefix {
2268            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
2269            None => local_var_key,
2270        };
2271        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
2272    };
2273    local_var_req_builder = local_var_req_builder.json(&writable_circuit_group_assignment_request);
2274
2275    let local_var_req = local_var_req_builder.build()?;
2276    let local_var_resp = local_var_client.execute(local_var_req).await?;
2277
2278    let local_var_status = local_var_resp.status();
2279    let local_var_content = local_var_resp.text().await?;
2280
2281    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
2282        serde_json::from_str(&local_var_content).map_err(Error::from)
2283    } else {
2284        let local_var_entity: Option<CircuitsCircuitGroupAssignmentsUpdateError> =
2285            serde_json::from_str(&local_var_content).ok();
2286        let local_var_error = ResponseContent {
2287            status: local_var_status,
2288            content: local_var_content,
2289            entity: local_var_entity,
2290        };
2291        Err(Error::ResponseError(local_var_error))
2292    }
2293}
2294
2295/// Delete a list of circuit group objects.
2296pub async fn circuits_circuit_groups_bulk_destroy(
2297    configuration: &configuration::Configuration,
2298    circuit_group_request: Vec<crate::models::CircuitGroupRequest>,
2299) -> Result<(), Error<CircuitsCircuitGroupsBulkDestroyError>> {
2300    let local_var_configuration = configuration;
2301
2302    let local_var_client = &local_var_configuration.client;
2303
2304    let local_var_uri_str = format!(
2305        "{}/api/circuits/circuit-groups/",
2306        local_var_configuration.base_path
2307    );
2308    let mut local_var_req_builder =
2309        local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());
2310
2311    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
2312        local_var_req_builder =
2313            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
2314    }
2315    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
2316        let local_var_key = local_var_apikey.key.clone();
2317        let local_var_value = match local_var_apikey.prefix {
2318            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
2319            None => local_var_key,
2320        };
2321        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
2322    };
2323    local_var_req_builder = local_var_req_builder.json(&circuit_group_request);
2324
2325    let local_var_req = local_var_req_builder.build()?;
2326    let local_var_resp = local_var_client.execute(local_var_req).await?;
2327
2328    let local_var_status = local_var_resp.status();
2329    let local_var_content = local_var_resp.text().await?;
2330
2331    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
2332        Ok(())
2333    } else {
2334        let local_var_entity: Option<CircuitsCircuitGroupsBulkDestroyError> =
2335            serde_json::from_str(&local_var_content).ok();
2336        let local_var_error = ResponseContent {
2337            status: local_var_status,
2338            content: local_var_content,
2339            entity: local_var_entity,
2340        };
2341        Err(Error::ResponseError(local_var_error))
2342    }
2343}
2344
2345/// Patch a list of circuit group objects.
2346pub async fn circuits_circuit_groups_bulk_partial_update(
2347    configuration: &configuration::Configuration,
2348    circuit_group_request: Vec<crate::models::CircuitGroupRequest>,
2349) -> Result<Vec<crate::models::CircuitGroup>, Error<CircuitsCircuitGroupsBulkPartialUpdateError>> {
2350    let local_var_configuration = configuration;
2351
2352    let local_var_client = &local_var_configuration.client;
2353
2354    let local_var_uri_str = format!(
2355        "{}/api/circuits/circuit-groups/",
2356        local_var_configuration.base_path
2357    );
2358    let mut local_var_req_builder =
2359        local_var_client.request(reqwest::Method::PATCH, local_var_uri_str.as_str());
2360
2361    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
2362        local_var_req_builder =
2363            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
2364    }
2365    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
2366        let local_var_key = local_var_apikey.key.clone();
2367        let local_var_value = match local_var_apikey.prefix {
2368            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
2369            None => local_var_key,
2370        };
2371        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
2372    };
2373    local_var_req_builder = local_var_req_builder.json(&circuit_group_request);
2374
2375    let local_var_req = local_var_req_builder.build()?;
2376    let local_var_resp = local_var_client.execute(local_var_req).await?;
2377
2378    let local_var_status = local_var_resp.status();
2379    let local_var_content = local_var_resp.text().await?;
2380
2381    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
2382        serde_json::from_str(&local_var_content).map_err(Error::from)
2383    } else {
2384        let local_var_entity: Option<CircuitsCircuitGroupsBulkPartialUpdateError> =
2385            serde_json::from_str(&local_var_content).ok();
2386        let local_var_error = ResponseContent {
2387            status: local_var_status,
2388            content: local_var_content,
2389            entity: local_var_entity,
2390        };
2391        Err(Error::ResponseError(local_var_error))
2392    }
2393}
2394
2395/// Put a list of circuit group objects.
2396pub async fn circuits_circuit_groups_bulk_update(
2397    configuration: &configuration::Configuration,
2398    circuit_group_request: Vec<crate::models::CircuitGroupRequest>,
2399) -> Result<Vec<crate::models::CircuitGroup>, Error<CircuitsCircuitGroupsBulkUpdateError>> {
2400    let local_var_configuration = configuration;
2401
2402    let local_var_client = &local_var_configuration.client;
2403
2404    let local_var_uri_str = format!(
2405        "{}/api/circuits/circuit-groups/",
2406        local_var_configuration.base_path
2407    );
2408    let mut local_var_req_builder =
2409        local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());
2410
2411    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
2412        local_var_req_builder =
2413            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
2414    }
2415    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
2416        let local_var_key = local_var_apikey.key.clone();
2417        let local_var_value = match local_var_apikey.prefix {
2418            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
2419            None => local_var_key,
2420        };
2421        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
2422    };
2423    local_var_req_builder = local_var_req_builder.json(&circuit_group_request);
2424
2425    let local_var_req = local_var_req_builder.build()?;
2426    let local_var_resp = local_var_client.execute(local_var_req).await?;
2427
2428    let local_var_status = local_var_resp.status();
2429    let local_var_content = local_var_resp.text().await?;
2430
2431    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
2432        serde_json::from_str(&local_var_content).map_err(Error::from)
2433    } else {
2434        let local_var_entity: Option<CircuitsCircuitGroupsBulkUpdateError> =
2435            serde_json::from_str(&local_var_content).ok();
2436        let local_var_error = ResponseContent {
2437            status: local_var_status,
2438            content: local_var_content,
2439            entity: local_var_entity,
2440        };
2441        Err(Error::ResponseError(local_var_error))
2442    }
2443}
2444
2445/// Post a list of circuit group objects.
2446pub async fn circuits_circuit_groups_create(
2447    configuration: &configuration::Configuration,
2448    circuits_circuit_groups_create_request: crate::models::CircuitsCircuitGroupsCreateRequest,
2449) -> Result<crate::models::CircuitGroup, Error<CircuitsCircuitGroupsCreateError>> {
2450    let local_var_configuration = configuration;
2451
2452    let local_var_client = &local_var_configuration.client;
2453
2454    let local_var_uri_str = format!(
2455        "{}/api/circuits/circuit-groups/",
2456        local_var_configuration.base_path
2457    );
2458    let mut local_var_req_builder =
2459        local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
2460
2461    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
2462        local_var_req_builder =
2463            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
2464    }
2465    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
2466        let local_var_key = local_var_apikey.key.clone();
2467        let local_var_value = match local_var_apikey.prefix {
2468            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
2469            None => local_var_key,
2470        };
2471        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
2472    };
2473    local_var_req_builder = local_var_req_builder.json(&circuits_circuit_groups_create_request);
2474
2475    let local_var_req = local_var_req_builder.build()?;
2476    let local_var_resp = local_var_client.execute(local_var_req).await?;
2477
2478    let local_var_status = local_var_resp.status();
2479    let local_var_content = local_var_resp.text().await?;
2480
2481    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
2482        serde_json::from_str(&local_var_content).map_err(Error::from)
2483    } else {
2484        let local_var_entity: Option<CircuitsCircuitGroupsCreateError> =
2485            serde_json::from_str(&local_var_content).ok();
2486        let local_var_error = ResponseContent {
2487            status: local_var_status,
2488            content: local_var_content,
2489            entity: local_var_entity,
2490        };
2491        Err(Error::ResponseError(local_var_error))
2492    }
2493}
2494
2495/// Delete a circuit group object.
2496pub async fn circuits_circuit_groups_destroy(
2497    configuration: &configuration::Configuration,
2498    id: i32,
2499) -> Result<(), Error<CircuitsCircuitGroupsDestroyError>> {
2500    let local_var_configuration = configuration;
2501
2502    let local_var_client = &local_var_configuration.client;
2503
2504    let local_var_uri_str = format!(
2505        "{}/api/circuits/circuit-groups/{id}/",
2506        local_var_configuration.base_path,
2507        id = id
2508    );
2509    let mut local_var_req_builder =
2510        local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());
2511
2512    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
2513        local_var_req_builder =
2514            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
2515    }
2516    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
2517        let local_var_key = local_var_apikey.key.clone();
2518        let local_var_value = match local_var_apikey.prefix {
2519            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
2520            None => local_var_key,
2521        };
2522        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
2523    };
2524
2525    let local_var_req = local_var_req_builder.build()?;
2526    let local_var_resp = local_var_client.execute(local_var_req).await?;
2527
2528    let local_var_status = local_var_resp.status();
2529    let local_var_content = local_var_resp.text().await?;
2530
2531    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
2532        Ok(())
2533    } else {
2534        let local_var_entity: Option<CircuitsCircuitGroupsDestroyError> =
2535            serde_json::from_str(&local_var_content).ok();
2536        let local_var_error = ResponseContent {
2537            status: local_var_status,
2538            content: local_var_content,
2539            entity: local_var_entity,
2540        };
2541        Err(Error::ResponseError(local_var_error))
2542    }
2543}
2544
2545/// Get a list of circuit group objects.
2546pub async fn circuits_circuit_groups_list(
2547    configuration: &configuration::Configuration,
2548    created: Option<Vec<String>>,
2549    created__empty: Option<Vec<String>>,
2550    created__gt: Option<Vec<String>>,
2551    created__gte: Option<Vec<String>>,
2552    created__lt: Option<Vec<String>>,
2553    created__lte: Option<Vec<String>>,
2554    created__n: Option<Vec<String>>,
2555    created_by_request: Option<&str>,
2556    description: Option<Vec<String>>,
2557    description__empty: Option<bool>,
2558    description__ic: Option<Vec<String>>,
2559    description__ie: Option<Vec<String>>,
2560    description__iew: Option<Vec<String>>,
2561    description__iregex: Option<Vec<String>>,
2562    description__isw: Option<Vec<String>>,
2563    description__n: Option<Vec<String>>,
2564    description__nic: Option<Vec<String>>,
2565    description__nie: Option<Vec<String>>,
2566    description__niew: Option<Vec<String>>,
2567    description__nisw: Option<Vec<String>>,
2568    description__regex: Option<Vec<String>>,
2569    id: Option<Vec<i32>>,
2570    id__empty: Option<bool>,
2571    id__gt: Option<Vec<i32>>,
2572    id__gte: Option<Vec<i32>>,
2573    id__lt: Option<Vec<i32>>,
2574    id__lte: Option<Vec<i32>>,
2575    id__n: Option<Vec<i32>>,
2576    last_updated: Option<Vec<String>>,
2577    last_updated__empty: Option<Vec<String>>,
2578    last_updated__gt: Option<Vec<String>>,
2579    last_updated__gte: Option<Vec<String>>,
2580    last_updated__lt: Option<Vec<String>>,
2581    last_updated__lte: Option<Vec<String>>,
2582    last_updated__n: Option<Vec<String>>,
2583    limit: Option<i32>,
2584    modified_by_request: Option<&str>,
2585    name: Option<Vec<String>>,
2586    name__empty: Option<bool>,
2587    name__ic: Option<Vec<String>>,
2588    name__ie: Option<Vec<String>>,
2589    name__iew: Option<Vec<String>>,
2590    name__iregex: Option<Vec<String>>,
2591    name__isw: Option<Vec<String>>,
2592    name__n: Option<Vec<String>>,
2593    name__nic: Option<Vec<String>>,
2594    name__nie: Option<Vec<String>>,
2595    name__niew: Option<Vec<String>>,
2596    name__nisw: Option<Vec<String>>,
2597    name__regex: Option<Vec<String>>,
2598    offset: Option<i32>,
2599    ordering: Option<&str>,
2600    owner: Option<Vec<String>>,
2601    owner__n: Option<Vec<String>>,
2602    owner_group: Option<Vec<String>>,
2603    owner_group__n: Option<Vec<String>>,
2604    owner_group_id: Option<Vec<i32>>,
2605    owner_group_id__n: Option<Vec<i32>>,
2606    owner_id: Option<Vec<i32>>,
2607    owner_id__n: Option<Vec<i32>>,
2608    q: Option<&str>,
2609    slug: Option<Vec<String>>,
2610    slug__empty: Option<bool>,
2611    slug__ic: Option<Vec<String>>,
2612    slug__ie: Option<Vec<String>>,
2613    slug__iew: Option<Vec<String>>,
2614    slug__iregex: Option<Vec<String>>,
2615    slug__isw: Option<Vec<String>>,
2616    slug__n: Option<Vec<String>>,
2617    slug__nic: Option<Vec<String>>,
2618    slug__nie: Option<Vec<String>>,
2619    slug__niew: Option<Vec<String>>,
2620    slug__nisw: Option<Vec<String>>,
2621    slug__regex: Option<Vec<String>>,
2622    tag: Option<Vec<String>>,
2623    tag__n: Option<Vec<String>>,
2624    tag_id: Option<Vec<i32>>,
2625    tag_id__n: Option<Vec<i32>>,
2626    tenant: Option<Vec<String>>,
2627    tenant__n: Option<Vec<String>>,
2628    tenant_group: Option<Vec<String>>,
2629    tenant_group__n: Option<Vec<String>>,
2630    tenant_group_id: Option<Vec<String>>,
2631    tenant_group_id__n: Option<Vec<String>>,
2632    tenant_id: Option<Vec<i32>>,
2633    tenant_id__n: Option<Vec<i32>>,
2634    updated_by_request: Option<&str>,
2635) -> Result<crate::models::PaginatedCircuitGroupList, Error<CircuitsCircuitGroupsListError>> {
2636    let local_var_configuration = configuration;
2637
2638    let local_var_client = &local_var_configuration.client;
2639
2640    let local_var_uri_str = format!(
2641        "{}/api/circuits/circuit-groups/",
2642        local_var_configuration.base_path
2643    );
2644    let mut local_var_req_builder =
2645        local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
2646
2647    if let Some(ref local_var_str) = created {
2648        local_var_req_builder = match "multi" {
2649            "multi" => local_var_req_builder.query(
2650                &local_var_str
2651                    .into_iter()
2652                    .map(|p| ("created".to_owned(), p.to_string()))
2653                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2654            ),
2655            _ => local_var_req_builder.query(&[(
2656                "created",
2657                &local_var_str
2658                    .into_iter()
2659                    .map(|p| p.to_string())
2660                    .collect::<Vec<String>>()
2661                    .join(",")
2662                    .to_string(),
2663            )]),
2664        };
2665    }
2666    if let Some(ref local_var_str) = created__empty {
2667        local_var_req_builder = match "multi" {
2668            "multi" => local_var_req_builder.query(
2669                &local_var_str
2670                    .into_iter()
2671                    .map(|p| ("created__empty".to_owned(), p.to_string()))
2672                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2673            ),
2674            _ => local_var_req_builder.query(&[(
2675                "created__empty",
2676                &local_var_str
2677                    .into_iter()
2678                    .map(|p| p.to_string())
2679                    .collect::<Vec<String>>()
2680                    .join(",")
2681                    .to_string(),
2682            )]),
2683        };
2684    }
2685    if let Some(ref local_var_str) = created__gt {
2686        local_var_req_builder = match "multi" {
2687            "multi" => local_var_req_builder.query(
2688                &local_var_str
2689                    .into_iter()
2690                    .map(|p| ("created__gt".to_owned(), p.to_string()))
2691                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2692            ),
2693            _ => local_var_req_builder.query(&[(
2694                "created__gt",
2695                &local_var_str
2696                    .into_iter()
2697                    .map(|p| p.to_string())
2698                    .collect::<Vec<String>>()
2699                    .join(",")
2700                    .to_string(),
2701            )]),
2702        };
2703    }
2704    if let Some(ref local_var_str) = created__gte {
2705        local_var_req_builder = match "multi" {
2706            "multi" => local_var_req_builder.query(
2707                &local_var_str
2708                    .into_iter()
2709                    .map(|p| ("created__gte".to_owned(), p.to_string()))
2710                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2711            ),
2712            _ => local_var_req_builder.query(&[(
2713                "created__gte",
2714                &local_var_str
2715                    .into_iter()
2716                    .map(|p| p.to_string())
2717                    .collect::<Vec<String>>()
2718                    .join(",")
2719                    .to_string(),
2720            )]),
2721        };
2722    }
2723    if let Some(ref local_var_str) = created__lt {
2724        local_var_req_builder = match "multi" {
2725            "multi" => local_var_req_builder.query(
2726                &local_var_str
2727                    .into_iter()
2728                    .map(|p| ("created__lt".to_owned(), p.to_string()))
2729                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2730            ),
2731            _ => local_var_req_builder.query(&[(
2732                "created__lt",
2733                &local_var_str
2734                    .into_iter()
2735                    .map(|p| p.to_string())
2736                    .collect::<Vec<String>>()
2737                    .join(",")
2738                    .to_string(),
2739            )]),
2740        };
2741    }
2742    if let Some(ref local_var_str) = created__lte {
2743        local_var_req_builder = match "multi" {
2744            "multi" => local_var_req_builder.query(
2745                &local_var_str
2746                    .into_iter()
2747                    .map(|p| ("created__lte".to_owned(), p.to_string()))
2748                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2749            ),
2750            _ => local_var_req_builder.query(&[(
2751                "created__lte",
2752                &local_var_str
2753                    .into_iter()
2754                    .map(|p| p.to_string())
2755                    .collect::<Vec<String>>()
2756                    .join(",")
2757                    .to_string(),
2758            )]),
2759        };
2760    }
2761    if let Some(ref local_var_str) = created__n {
2762        local_var_req_builder = match "multi" {
2763            "multi" => local_var_req_builder.query(
2764                &local_var_str
2765                    .into_iter()
2766                    .map(|p| ("created__n".to_owned(), p.to_string()))
2767                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2768            ),
2769            _ => local_var_req_builder.query(&[(
2770                "created__n",
2771                &local_var_str
2772                    .into_iter()
2773                    .map(|p| p.to_string())
2774                    .collect::<Vec<String>>()
2775                    .join(",")
2776                    .to_string(),
2777            )]),
2778        };
2779    }
2780    if let Some(ref local_var_str) = created_by_request {
2781        local_var_req_builder =
2782            local_var_req_builder.query(&[("created_by_request", &local_var_str.to_string())]);
2783    }
2784    if let Some(ref local_var_str) = description {
2785        local_var_req_builder = match "multi" {
2786            "multi" => local_var_req_builder.query(
2787                &local_var_str
2788                    .into_iter()
2789                    .map(|p| ("description".to_owned(), p.to_string()))
2790                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2791            ),
2792            _ => local_var_req_builder.query(&[(
2793                "description",
2794                &local_var_str
2795                    .into_iter()
2796                    .map(|p| p.to_string())
2797                    .collect::<Vec<String>>()
2798                    .join(",")
2799                    .to_string(),
2800            )]),
2801        };
2802    }
2803    if let Some(ref local_var_str) = description__empty {
2804        local_var_req_builder =
2805            local_var_req_builder.query(&[("description__empty", &local_var_str.to_string())]);
2806    }
2807    if let Some(ref local_var_str) = description__ic {
2808        local_var_req_builder = match "multi" {
2809            "multi" => local_var_req_builder.query(
2810                &local_var_str
2811                    .into_iter()
2812                    .map(|p| ("description__ic".to_owned(), p.to_string()))
2813                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2814            ),
2815            _ => local_var_req_builder.query(&[(
2816                "description__ic",
2817                &local_var_str
2818                    .into_iter()
2819                    .map(|p| p.to_string())
2820                    .collect::<Vec<String>>()
2821                    .join(",")
2822                    .to_string(),
2823            )]),
2824        };
2825    }
2826    if let Some(ref local_var_str) = description__ie {
2827        local_var_req_builder = match "multi" {
2828            "multi" => local_var_req_builder.query(
2829                &local_var_str
2830                    .into_iter()
2831                    .map(|p| ("description__ie".to_owned(), p.to_string()))
2832                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2833            ),
2834            _ => local_var_req_builder.query(&[(
2835                "description__ie",
2836                &local_var_str
2837                    .into_iter()
2838                    .map(|p| p.to_string())
2839                    .collect::<Vec<String>>()
2840                    .join(",")
2841                    .to_string(),
2842            )]),
2843        };
2844    }
2845    if let Some(ref local_var_str) = description__iew {
2846        local_var_req_builder = match "multi" {
2847            "multi" => local_var_req_builder.query(
2848                &local_var_str
2849                    .into_iter()
2850                    .map(|p| ("description__iew".to_owned(), p.to_string()))
2851                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2852            ),
2853            _ => local_var_req_builder.query(&[(
2854                "description__iew",
2855                &local_var_str
2856                    .into_iter()
2857                    .map(|p| p.to_string())
2858                    .collect::<Vec<String>>()
2859                    .join(",")
2860                    .to_string(),
2861            )]),
2862        };
2863    }
2864    if let Some(ref local_var_str) = description__iregex {
2865        local_var_req_builder = match "multi" {
2866            "multi" => local_var_req_builder.query(
2867                &local_var_str
2868                    .into_iter()
2869                    .map(|p| ("description__iregex".to_owned(), p.to_string()))
2870                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2871            ),
2872            _ => local_var_req_builder.query(&[(
2873                "description__iregex",
2874                &local_var_str
2875                    .into_iter()
2876                    .map(|p| p.to_string())
2877                    .collect::<Vec<String>>()
2878                    .join(",")
2879                    .to_string(),
2880            )]),
2881        };
2882    }
2883    if let Some(ref local_var_str) = description__isw {
2884        local_var_req_builder = match "multi" {
2885            "multi" => local_var_req_builder.query(
2886                &local_var_str
2887                    .into_iter()
2888                    .map(|p| ("description__isw".to_owned(), p.to_string()))
2889                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2890            ),
2891            _ => local_var_req_builder.query(&[(
2892                "description__isw",
2893                &local_var_str
2894                    .into_iter()
2895                    .map(|p| p.to_string())
2896                    .collect::<Vec<String>>()
2897                    .join(",")
2898                    .to_string(),
2899            )]),
2900        };
2901    }
2902    if let Some(ref local_var_str) = description__n {
2903        local_var_req_builder = match "multi" {
2904            "multi" => local_var_req_builder.query(
2905                &local_var_str
2906                    .into_iter()
2907                    .map(|p| ("description__n".to_owned(), p.to_string()))
2908                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2909            ),
2910            _ => local_var_req_builder.query(&[(
2911                "description__n",
2912                &local_var_str
2913                    .into_iter()
2914                    .map(|p| p.to_string())
2915                    .collect::<Vec<String>>()
2916                    .join(",")
2917                    .to_string(),
2918            )]),
2919        };
2920    }
2921    if let Some(ref local_var_str) = description__nic {
2922        local_var_req_builder = match "multi" {
2923            "multi" => local_var_req_builder.query(
2924                &local_var_str
2925                    .into_iter()
2926                    .map(|p| ("description__nic".to_owned(), p.to_string()))
2927                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2928            ),
2929            _ => local_var_req_builder.query(&[(
2930                "description__nic",
2931                &local_var_str
2932                    .into_iter()
2933                    .map(|p| p.to_string())
2934                    .collect::<Vec<String>>()
2935                    .join(",")
2936                    .to_string(),
2937            )]),
2938        };
2939    }
2940    if let Some(ref local_var_str) = description__nie {
2941        local_var_req_builder = match "multi" {
2942            "multi" => local_var_req_builder.query(
2943                &local_var_str
2944                    .into_iter()
2945                    .map(|p| ("description__nie".to_owned(), p.to_string()))
2946                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2947            ),
2948            _ => local_var_req_builder.query(&[(
2949                "description__nie",
2950                &local_var_str
2951                    .into_iter()
2952                    .map(|p| p.to_string())
2953                    .collect::<Vec<String>>()
2954                    .join(",")
2955                    .to_string(),
2956            )]),
2957        };
2958    }
2959    if let Some(ref local_var_str) = description__niew {
2960        local_var_req_builder = match "multi" {
2961            "multi" => local_var_req_builder.query(
2962                &local_var_str
2963                    .into_iter()
2964                    .map(|p| ("description__niew".to_owned(), p.to_string()))
2965                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2966            ),
2967            _ => local_var_req_builder.query(&[(
2968                "description__niew",
2969                &local_var_str
2970                    .into_iter()
2971                    .map(|p| p.to_string())
2972                    .collect::<Vec<String>>()
2973                    .join(",")
2974                    .to_string(),
2975            )]),
2976        };
2977    }
2978    if let Some(ref local_var_str) = description__nisw {
2979        local_var_req_builder = match "multi" {
2980            "multi" => local_var_req_builder.query(
2981                &local_var_str
2982                    .into_iter()
2983                    .map(|p| ("description__nisw".to_owned(), p.to_string()))
2984                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2985            ),
2986            _ => local_var_req_builder.query(&[(
2987                "description__nisw",
2988                &local_var_str
2989                    .into_iter()
2990                    .map(|p| p.to_string())
2991                    .collect::<Vec<String>>()
2992                    .join(",")
2993                    .to_string(),
2994            )]),
2995        };
2996    }
2997    if let Some(ref local_var_str) = description__regex {
2998        local_var_req_builder = match "multi" {
2999            "multi" => local_var_req_builder.query(
3000                &local_var_str
3001                    .into_iter()
3002                    .map(|p| ("description__regex".to_owned(), p.to_string()))
3003                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3004            ),
3005            _ => local_var_req_builder.query(&[(
3006                "description__regex",
3007                &local_var_str
3008                    .into_iter()
3009                    .map(|p| p.to_string())
3010                    .collect::<Vec<String>>()
3011                    .join(",")
3012                    .to_string(),
3013            )]),
3014        };
3015    }
3016    if let Some(ref local_var_str) = id {
3017        local_var_req_builder = match "multi" {
3018            "multi" => local_var_req_builder.query(
3019                &local_var_str
3020                    .into_iter()
3021                    .map(|p| ("id".to_owned(), p.to_string()))
3022                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3023            ),
3024            _ => local_var_req_builder.query(&[(
3025                "id",
3026                &local_var_str
3027                    .into_iter()
3028                    .map(|p| p.to_string())
3029                    .collect::<Vec<String>>()
3030                    .join(",")
3031                    .to_string(),
3032            )]),
3033        };
3034    }
3035    if let Some(ref local_var_str) = id__empty {
3036        local_var_req_builder =
3037            local_var_req_builder.query(&[("id__empty", &local_var_str.to_string())]);
3038    }
3039    if let Some(ref local_var_str) = id__gt {
3040        local_var_req_builder = match "multi" {
3041            "multi" => local_var_req_builder.query(
3042                &local_var_str
3043                    .into_iter()
3044                    .map(|p| ("id__gt".to_owned(), p.to_string()))
3045                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3046            ),
3047            _ => local_var_req_builder.query(&[(
3048                "id__gt",
3049                &local_var_str
3050                    .into_iter()
3051                    .map(|p| p.to_string())
3052                    .collect::<Vec<String>>()
3053                    .join(",")
3054                    .to_string(),
3055            )]),
3056        };
3057    }
3058    if let Some(ref local_var_str) = id__gte {
3059        local_var_req_builder = match "multi" {
3060            "multi" => local_var_req_builder.query(
3061                &local_var_str
3062                    .into_iter()
3063                    .map(|p| ("id__gte".to_owned(), p.to_string()))
3064                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3065            ),
3066            _ => local_var_req_builder.query(&[(
3067                "id__gte",
3068                &local_var_str
3069                    .into_iter()
3070                    .map(|p| p.to_string())
3071                    .collect::<Vec<String>>()
3072                    .join(",")
3073                    .to_string(),
3074            )]),
3075        };
3076    }
3077    if let Some(ref local_var_str) = id__lt {
3078        local_var_req_builder = match "multi" {
3079            "multi" => local_var_req_builder.query(
3080                &local_var_str
3081                    .into_iter()
3082                    .map(|p| ("id__lt".to_owned(), p.to_string()))
3083                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3084            ),
3085            _ => local_var_req_builder.query(&[(
3086                "id__lt",
3087                &local_var_str
3088                    .into_iter()
3089                    .map(|p| p.to_string())
3090                    .collect::<Vec<String>>()
3091                    .join(",")
3092                    .to_string(),
3093            )]),
3094        };
3095    }
3096    if let Some(ref local_var_str) = id__lte {
3097        local_var_req_builder = match "multi" {
3098            "multi" => local_var_req_builder.query(
3099                &local_var_str
3100                    .into_iter()
3101                    .map(|p| ("id__lte".to_owned(), p.to_string()))
3102                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3103            ),
3104            _ => local_var_req_builder.query(&[(
3105                "id__lte",
3106                &local_var_str
3107                    .into_iter()
3108                    .map(|p| p.to_string())
3109                    .collect::<Vec<String>>()
3110                    .join(",")
3111                    .to_string(),
3112            )]),
3113        };
3114    }
3115    if let Some(ref local_var_str) = id__n {
3116        local_var_req_builder = match "multi" {
3117            "multi" => local_var_req_builder.query(
3118                &local_var_str
3119                    .into_iter()
3120                    .map(|p| ("id__n".to_owned(), p.to_string()))
3121                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3122            ),
3123            _ => local_var_req_builder.query(&[(
3124                "id__n",
3125                &local_var_str
3126                    .into_iter()
3127                    .map(|p| p.to_string())
3128                    .collect::<Vec<String>>()
3129                    .join(",")
3130                    .to_string(),
3131            )]),
3132        };
3133    }
3134    if let Some(ref local_var_str) = last_updated {
3135        local_var_req_builder = match "multi" {
3136            "multi" => local_var_req_builder.query(
3137                &local_var_str
3138                    .into_iter()
3139                    .map(|p| ("last_updated".to_owned(), p.to_string()))
3140                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3141            ),
3142            _ => local_var_req_builder.query(&[(
3143                "last_updated",
3144                &local_var_str
3145                    .into_iter()
3146                    .map(|p| p.to_string())
3147                    .collect::<Vec<String>>()
3148                    .join(",")
3149                    .to_string(),
3150            )]),
3151        };
3152    }
3153    if let Some(ref local_var_str) = last_updated__empty {
3154        local_var_req_builder = match "multi" {
3155            "multi" => local_var_req_builder.query(
3156                &local_var_str
3157                    .into_iter()
3158                    .map(|p| ("last_updated__empty".to_owned(), p.to_string()))
3159                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3160            ),
3161            _ => local_var_req_builder.query(&[(
3162                "last_updated__empty",
3163                &local_var_str
3164                    .into_iter()
3165                    .map(|p| p.to_string())
3166                    .collect::<Vec<String>>()
3167                    .join(",")
3168                    .to_string(),
3169            )]),
3170        };
3171    }
3172    if let Some(ref local_var_str) = last_updated__gt {
3173        local_var_req_builder = match "multi" {
3174            "multi" => local_var_req_builder.query(
3175                &local_var_str
3176                    .into_iter()
3177                    .map(|p| ("last_updated__gt".to_owned(), p.to_string()))
3178                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3179            ),
3180            _ => local_var_req_builder.query(&[(
3181                "last_updated__gt",
3182                &local_var_str
3183                    .into_iter()
3184                    .map(|p| p.to_string())
3185                    .collect::<Vec<String>>()
3186                    .join(",")
3187                    .to_string(),
3188            )]),
3189        };
3190    }
3191    if let Some(ref local_var_str) = last_updated__gte {
3192        local_var_req_builder = match "multi" {
3193            "multi" => local_var_req_builder.query(
3194                &local_var_str
3195                    .into_iter()
3196                    .map(|p| ("last_updated__gte".to_owned(), p.to_string()))
3197                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3198            ),
3199            _ => local_var_req_builder.query(&[(
3200                "last_updated__gte",
3201                &local_var_str
3202                    .into_iter()
3203                    .map(|p| p.to_string())
3204                    .collect::<Vec<String>>()
3205                    .join(",")
3206                    .to_string(),
3207            )]),
3208        };
3209    }
3210    if let Some(ref local_var_str) = last_updated__lt {
3211        local_var_req_builder = match "multi" {
3212            "multi" => local_var_req_builder.query(
3213                &local_var_str
3214                    .into_iter()
3215                    .map(|p| ("last_updated__lt".to_owned(), p.to_string()))
3216                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3217            ),
3218            _ => local_var_req_builder.query(&[(
3219                "last_updated__lt",
3220                &local_var_str
3221                    .into_iter()
3222                    .map(|p| p.to_string())
3223                    .collect::<Vec<String>>()
3224                    .join(",")
3225                    .to_string(),
3226            )]),
3227        };
3228    }
3229    if let Some(ref local_var_str) = last_updated__lte {
3230        local_var_req_builder = match "multi" {
3231            "multi" => local_var_req_builder.query(
3232                &local_var_str
3233                    .into_iter()
3234                    .map(|p| ("last_updated__lte".to_owned(), p.to_string()))
3235                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3236            ),
3237            _ => local_var_req_builder.query(&[(
3238                "last_updated__lte",
3239                &local_var_str
3240                    .into_iter()
3241                    .map(|p| p.to_string())
3242                    .collect::<Vec<String>>()
3243                    .join(",")
3244                    .to_string(),
3245            )]),
3246        };
3247    }
3248    if let Some(ref local_var_str) = last_updated__n {
3249        local_var_req_builder = match "multi" {
3250            "multi" => local_var_req_builder.query(
3251                &local_var_str
3252                    .into_iter()
3253                    .map(|p| ("last_updated__n".to_owned(), p.to_string()))
3254                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3255            ),
3256            _ => local_var_req_builder.query(&[(
3257                "last_updated__n",
3258                &local_var_str
3259                    .into_iter()
3260                    .map(|p| p.to_string())
3261                    .collect::<Vec<String>>()
3262                    .join(",")
3263                    .to_string(),
3264            )]),
3265        };
3266    }
3267    if let Some(ref local_var_str) = limit {
3268        local_var_req_builder =
3269            local_var_req_builder.query(&[("limit", &local_var_str.to_string())]);
3270    }
3271    if let Some(ref local_var_str) = modified_by_request {
3272        local_var_req_builder =
3273            local_var_req_builder.query(&[("modified_by_request", &local_var_str.to_string())]);
3274    }
3275    if let Some(ref local_var_str) = name {
3276        local_var_req_builder = match "multi" {
3277            "multi" => local_var_req_builder.query(
3278                &local_var_str
3279                    .into_iter()
3280                    .map(|p| ("name".to_owned(), p.to_string()))
3281                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3282            ),
3283            _ => local_var_req_builder.query(&[(
3284                "name",
3285                &local_var_str
3286                    .into_iter()
3287                    .map(|p| p.to_string())
3288                    .collect::<Vec<String>>()
3289                    .join(",")
3290                    .to_string(),
3291            )]),
3292        };
3293    }
3294    if let Some(ref local_var_str) = name__empty {
3295        local_var_req_builder =
3296            local_var_req_builder.query(&[("name__empty", &local_var_str.to_string())]);
3297    }
3298    if let Some(ref local_var_str) = name__ic {
3299        local_var_req_builder = match "multi" {
3300            "multi" => local_var_req_builder.query(
3301                &local_var_str
3302                    .into_iter()
3303                    .map(|p| ("name__ic".to_owned(), p.to_string()))
3304                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3305            ),
3306            _ => local_var_req_builder.query(&[(
3307                "name__ic",
3308                &local_var_str
3309                    .into_iter()
3310                    .map(|p| p.to_string())
3311                    .collect::<Vec<String>>()
3312                    .join(",")
3313                    .to_string(),
3314            )]),
3315        };
3316    }
3317    if let Some(ref local_var_str) = name__ie {
3318        local_var_req_builder = match "multi" {
3319            "multi" => local_var_req_builder.query(
3320                &local_var_str
3321                    .into_iter()
3322                    .map(|p| ("name__ie".to_owned(), p.to_string()))
3323                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3324            ),
3325            _ => local_var_req_builder.query(&[(
3326                "name__ie",
3327                &local_var_str
3328                    .into_iter()
3329                    .map(|p| p.to_string())
3330                    .collect::<Vec<String>>()
3331                    .join(",")
3332                    .to_string(),
3333            )]),
3334        };
3335    }
3336    if let Some(ref local_var_str) = name__iew {
3337        local_var_req_builder = match "multi" {
3338            "multi" => local_var_req_builder.query(
3339                &local_var_str
3340                    .into_iter()
3341                    .map(|p| ("name__iew".to_owned(), p.to_string()))
3342                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3343            ),
3344            _ => local_var_req_builder.query(&[(
3345                "name__iew",
3346                &local_var_str
3347                    .into_iter()
3348                    .map(|p| p.to_string())
3349                    .collect::<Vec<String>>()
3350                    .join(",")
3351                    .to_string(),
3352            )]),
3353        };
3354    }
3355    if let Some(ref local_var_str) = name__iregex {
3356        local_var_req_builder = match "multi" {
3357            "multi" => local_var_req_builder.query(
3358                &local_var_str
3359                    .into_iter()
3360                    .map(|p| ("name__iregex".to_owned(), p.to_string()))
3361                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3362            ),
3363            _ => local_var_req_builder.query(&[(
3364                "name__iregex",
3365                &local_var_str
3366                    .into_iter()
3367                    .map(|p| p.to_string())
3368                    .collect::<Vec<String>>()
3369                    .join(",")
3370                    .to_string(),
3371            )]),
3372        };
3373    }
3374    if let Some(ref local_var_str) = name__isw {
3375        local_var_req_builder = match "multi" {
3376            "multi" => local_var_req_builder.query(
3377                &local_var_str
3378                    .into_iter()
3379                    .map(|p| ("name__isw".to_owned(), p.to_string()))
3380                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3381            ),
3382            _ => local_var_req_builder.query(&[(
3383                "name__isw",
3384                &local_var_str
3385                    .into_iter()
3386                    .map(|p| p.to_string())
3387                    .collect::<Vec<String>>()
3388                    .join(",")
3389                    .to_string(),
3390            )]),
3391        };
3392    }
3393    if let Some(ref local_var_str) = name__n {
3394        local_var_req_builder = match "multi" {
3395            "multi" => local_var_req_builder.query(
3396                &local_var_str
3397                    .into_iter()
3398                    .map(|p| ("name__n".to_owned(), p.to_string()))
3399                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3400            ),
3401            _ => local_var_req_builder.query(&[(
3402                "name__n",
3403                &local_var_str
3404                    .into_iter()
3405                    .map(|p| p.to_string())
3406                    .collect::<Vec<String>>()
3407                    .join(",")
3408                    .to_string(),
3409            )]),
3410        };
3411    }
3412    if let Some(ref local_var_str) = name__nic {
3413        local_var_req_builder = match "multi" {
3414            "multi" => local_var_req_builder.query(
3415                &local_var_str
3416                    .into_iter()
3417                    .map(|p| ("name__nic".to_owned(), p.to_string()))
3418                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3419            ),
3420            _ => local_var_req_builder.query(&[(
3421                "name__nic",
3422                &local_var_str
3423                    .into_iter()
3424                    .map(|p| p.to_string())
3425                    .collect::<Vec<String>>()
3426                    .join(",")
3427                    .to_string(),
3428            )]),
3429        };
3430    }
3431    if let Some(ref local_var_str) = name__nie {
3432        local_var_req_builder = match "multi" {
3433            "multi" => local_var_req_builder.query(
3434                &local_var_str
3435                    .into_iter()
3436                    .map(|p| ("name__nie".to_owned(), p.to_string()))
3437                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3438            ),
3439            _ => local_var_req_builder.query(&[(
3440                "name__nie",
3441                &local_var_str
3442                    .into_iter()
3443                    .map(|p| p.to_string())
3444                    .collect::<Vec<String>>()
3445                    .join(",")
3446                    .to_string(),
3447            )]),
3448        };
3449    }
3450    if let Some(ref local_var_str) = name__niew {
3451        local_var_req_builder = match "multi" {
3452            "multi" => local_var_req_builder.query(
3453                &local_var_str
3454                    .into_iter()
3455                    .map(|p| ("name__niew".to_owned(), p.to_string()))
3456                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3457            ),
3458            _ => local_var_req_builder.query(&[(
3459                "name__niew",
3460                &local_var_str
3461                    .into_iter()
3462                    .map(|p| p.to_string())
3463                    .collect::<Vec<String>>()
3464                    .join(",")
3465                    .to_string(),
3466            )]),
3467        };
3468    }
3469    if let Some(ref local_var_str) = name__nisw {
3470        local_var_req_builder = match "multi" {
3471            "multi" => local_var_req_builder.query(
3472                &local_var_str
3473                    .into_iter()
3474                    .map(|p| ("name__nisw".to_owned(), p.to_string()))
3475                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3476            ),
3477            _ => local_var_req_builder.query(&[(
3478                "name__nisw",
3479                &local_var_str
3480                    .into_iter()
3481                    .map(|p| p.to_string())
3482                    .collect::<Vec<String>>()
3483                    .join(",")
3484                    .to_string(),
3485            )]),
3486        };
3487    }
3488    if let Some(ref local_var_str) = name__regex {
3489        local_var_req_builder = match "multi" {
3490            "multi" => local_var_req_builder.query(
3491                &local_var_str
3492                    .into_iter()
3493                    .map(|p| ("name__regex".to_owned(), p.to_string()))
3494                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3495            ),
3496            _ => local_var_req_builder.query(&[(
3497                "name__regex",
3498                &local_var_str
3499                    .into_iter()
3500                    .map(|p| p.to_string())
3501                    .collect::<Vec<String>>()
3502                    .join(",")
3503                    .to_string(),
3504            )]),
3505        };
3506    }
3507    if let Some(ref local_var_str) = offset {
3508        local_var_req_builder =
3509            local_var_req_builder.query(&[("offset", &local_var_str.to_string())]);
3510    }
3511    if let Some(ref local_var_str) = ordering {
3512        local_var_req_builder =
3513            local_var_req_builder.query(&[("ordering", &local_var_str.to_string())]);
3514    }
3515    if let Some(ref local_var_str) = owner {
3516        local_var_req_builder = match "multi" {
3517            "multi" => local_var_req_builder.query(
3518                &local_var_str
3519                    .into_iter()
3520                    .map(|p| ("owner".to_owned(), p.to_string()))
3521                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3522            ),
3523            _ => local_var_req_builder.query(&[(
3524                "owner",
3525                &local_var_str
3526                    .into_iter()
3527                    .map(|p| p.to_string())
3528                    .collect::<Vec<String>>()
3529                    .join(",")
3530                    .to_string(),
3531            )]),
3532        };
3533    }
3534    if let Some(ref local_var_str) = owner__n {
3535        local_var_req_builder = match "multi" {
3536            "multi" => local_var_req_builder.query(
3537                &local_var_str
3538                    .into_iter()
3539                    .map(|p| ("owner__n".to_owned(), p.to_string()))
3540                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3541            ),
3542            _ => local_var_req_builder.query(&[(
3543                "owner__n",
3544                &local_var_str
3545                    .into_iter()
3546                    .map(|p| p.to_string())
3547                    .collect::<Vec<String>>()
3548                    .join(",")
3549                    .to_string(),
3550            )]),
3551        };
3552    }
3553    if let Some(ref local_var_str) = owner_group {
3554        local_var_req_builder = match "multi" {
3555            "multi" => local_var_req_builder.query(
3556                &local_var_str
3557                    .into_iter()
3558                    .map(|p| ("owner_group".to_owned(), p.to_string()))
3559                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3560            ),
3561            _ => local_var_req_builder.query(&[(
3562                "owner_group",
3563                &local_var_str
3564                    .into_iter()
3565                    .map(|p| p.to_string())
3566                    .collect::<Vec<String>>()
3567                    .join(",")
3568                    .to_string(),
3569            )]),
3570        };
3571    }
3572    if let Some(ref local_var_str) = owner_group__n {
3573        local_var_req_builder = match "multi" {
3574            "multi" => local_var_req_builder.query(
3575                &local_var_str
3576                    .into_iter()
3577                    .map(|p| ("owner_group__n".to_owned(), p.to_string()))
3578                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3579            ),
3580            _ => local_var_req_builder.query(&[(
3581                "owner_group__n",
3582                &local_var_str
3583                    .into_iter()
3584                    .map(|p| p.to_string())
3585                    .collect::<Vec<String>>()
3586                    .join(",")
3587                    .to_string(),
3588            )]),
3589        };
3590    }
3591    if let Some(ref local_var_str) = owner_group_id {
3592        local_var_req_builder = match "multi" {
3593            "multi" => local_var_req_builder.query(
3594                &local_var_str
3595                    .into_iter()
3596                    .map(|p| ("owner_group_id".to_owned(), p.to_string()))
3597                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3598            ),
3599            _ => local_var_req_builder.query(&[(
3600                "owner_group_id",
3601                &local_var_str
3602                    .into_iter()
3603                    .map(|p| p.to_string())
3604                    .collect::<Vec<String>>()
3605                    .join(",")
3606                    .to_string(),
3607            )]),
3608        };
3609    }
3610    if let Some(ref local_var_str) = owner_group_id__n {
3611        local_var_req_builder = match "multi" {
3612            "multi" => local_var_req_builder.query(
3613                &local_var_str
3614                    .into_iter()
3615                    .map(|p| ("owner_group_id__n".to_owned(), p.to_string()))
3616                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3617            ),
3618            _ => local_var_req_builder.query(&[(
3619                "owner_group_id__n",
3620                &local_var_str
3621                    .into_iter()
3622                    .map(|p| p.to_string())
3623                    .collect::<Vec<String>>()
3624                    .join(",")
3625                    .to_string(),
3626            )]),
3627        };
3628    }
3629    if let Some(ref local_var_str) = owner_id {
3630        local_var_req_builder = match "multi" {
3631            "multi" => local_var_req_builder.query(
3632                &local_var_str
3633                    .into_iter()
3634                    .map(|p| ("owner_id".to_owned(), p.to_string()))
3635                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3636            ),
3637            _ => local_var_req_builder.query(&[(
3638                "owner_id",
3639                &local_var_str
3640                    .into_iter()
3641                    .map(|p| p.to_string())
3642                    .collect::<Vec<String>>()
3643                    .join(",")
3644                    .to_string(),
3645            )]),
3646        };
3647    }
3648    if let Some(ref local_var_str) = owner_id__n {
3649        local_var_req_builder = match "multi" {
3650            "multi" => local_var_req_builder.query(
3651                &local_var_str
3652                    .into_iter()
3653                    .map(|p| ("owner_id__n".to_owned(), p.to_string()))
3654                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3655            ),
3656            _ => local_var_req_builder.query(&[(
3657                "owner_id__n",
3658                &local_var_str
3659                    .into_iter()
3660                    .map(|p| p.to_string())
3661                    .collect::<Vec<String>>()
3662                    .join(",")
3663                    .to_string(),
3664            )]),
3665        };
3666    }
3667    if let Some(ref local_var_str) = q {
3668        local_var_req_builder = local_var_req_builder.query(&[("q", &local_var_str.to_string())]);
3669    }
3670    if let Some(ref local_var_str) = slug {
3671        local_var_req_builder = match "multi" {
3672            "multi" => local_var_req_builder.query(
3673                &local_var_str
3674                    .into_iter()
3675                    .map(|p| ("slug".to_owned(), p.to_string()))
3676                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3677            ),
3678            _ => local_var_req_builder.query(&[(
3679                "slug",
3680                &local_var_str
3681                    .into_iter()
3682                    .map(|p| p.to_string())
3683                    .collect::<Vec<String>>()
3684                    .join(",")
3685                    .to_string(),
3686            )]),
3687        };
3688    }
3689    if let Some(ref local_var_str) = slug__empty {
3690        local_var_req_builder =
3691            local_var_req_builder.query(&[("slug__empty", &local_var_str.to_string())]);
3692    }
3693    if let Some(ref local_var_str) = slug__ic {
3694        local_var_req_builder = match "multi" {
3695            "multi" => local_var_req_builder.query(
3696                &local_var_str
3697                    .into_iter()
3698                    .map(|p| ("slug__ic".to_owned(), p.to_string()))
3699                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3700            ),
3701            _ => local_var_req_builder.query(&[(
3702                "slug__ic",
3703                &local_var_str
3704                    .into_iter()
3705                    .map(|p| p.to_string())
3706                    .collect::<Vec<String>>()
3707                    .join(",")
3708                    .to_string(),
3709            )]),
3710        };
3711    }
3712    if let Some(ref local_var_str) = slug__ie {
3713        local_var_req_builder = match "multi" {
3714            "multi" => local_var_req_builder.query(
3715                &local_var_str
3716                    .into_iter()
3717                    .map(|p| ("slug__ie".to_owned(), p.to_string()))
3718                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3719            ),
3720            _ => local_var_req_builder.query(&[(
3721                "slug__ie",
3722                &local_var_str
3723                    .into_iter()
3724                    .map(|p| p.to_string())
3725                    .collect::<Vec<String>>()
3726                    .join(",")
3727                    .to_string(),
3728            )]),
3729        };
3730    }
3731    if let Some(ref local_var_str) = slug__iew {
3732        local_var_req_builder = match "multi" {
3733            "multi" => local_var_req_builder.query(
3734                &local_var_str
3735                    .into_iter()
3736                    .map(|p| ("slug__iew".to_owned(), p.to_string()))
3737                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3738            ),
3739            _ => local_var_req_builder.query(&[(
3740                "slug__iew",
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) = slug__iregex {
3751        local_var_req_builder = match "multi" {
3752            "multi" => local_var_req_builder.query(
3753                &local_var_str
3754                    .into_iter()
3755                    .map(|p| ("slug__iregex".to_owned(), p.to_string()))
3756                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3757            ),
3758            _ => local_var_req_builder.query(&[(
3759                "slug__iregex",
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) = slug__isw {
3770        local_var_req_builder = match "multi" {
3771            "multi" => local_var_req_builder.query(
3772                &local_var_str
3773                    .into_iter()
3774                    .map(|p| ("slug__isw".to_owned(), p.to_string()))
3775                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3776            ),
3777            _ => local_var_req_builder.query(&[(
3778                "slug__isw",
3779                &local_var_str
3780                    .into_iter()
3781                    .map(|p| p.to_string())
3782                    .collect::<Vec<String>>()
3783                    .join(",")
3784                    .to_string(),
3785            )]),
3786        };
3787    }
3788    if let Some(ref local_var_str) = slug__n {
3789        local_var_req_builder = match "multi" {
3790            "multi" => local_var_req_builder.query(
3791                &local_var_str
3792                    .into_iter()
3793                    .map(|p| ("slug__n".to_owned(), p.to_string()))
3794                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3795            ),
3796            _ => local_var_req_builder.query(&[(
3797                "slug__n",
3798                &local_var_str
3799                    .into_iter()
3800                    .map(|p| p.to_string())
3801                    .collect::<Vec<String>>()
3802                    .join(",")
3803                    .to_string(),
3804            )]),
3805        };
3806    }
3807    if let Some(ref local_var_str) = slug__nic {
3808        local_var_req_builder = match "multi" {
3809            "multi" => local_var_req_builder.query(
3810                &local_var_str
3811                    .into_iter()
3812                    .map(|p| ("slug__nic".to_owned(), p.to_string()))
3813                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3814            ),
3815            _ => local_var_req_builder.query(&[(
3816                "slug__nic",
3817                &local_var_str
3818                    .into_iter()
3819                    .map(|p| p.to_string())
3820                    .collect::<Vec<String>>()
3821                    .join(",")
3822                    .to_string(),
3823            )]),
3824        };
3825    }
3826    if let Some(ref local_var_str) = slug__nie {
3827        local_var_req_builder = match "multi" {
3828            "multi" => local_var_req_builder.query(
3829                &local_var_str
3830                    .into_iter()
3831                    .map(|p| ("slug__nie".to_owned(), p.to_string()))
3832                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3833            ),
3834            _ => local_var_req_builder.query(&[(
3835                "slug__nie",
3836                &local_var_str
3837                    .into_iter()
3838                    .map(|p| p.to_string())
3839                    .collect::<Vec<String>>()
3840                    .join(",")
3841                    .to_string(),
3842            )]),
3843        };
3844    }
3845    if let Some(ref local_var_str) = slug__niew {
3846        local_var_req_builder = match "multi" {
3847            "multi" => local_var_req_builder.query(
3848                &local_var_str
3849                    .into_iter()
3850                    .map(|p| ("slug__niew".to_owned(), p.to_string()))
3851                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3852            ),
3853            _ => local_var_req_builder.query(&[(
3854                "slug__niew",
3855                &local_var_str
3856                    .into_iter()
3857                    .map(|p| p.to_string())
3858                    .collect::<Vec<String>>()
3859                    .join(",")
3860                    .to_string(),
3861            )]),
3862        };
3863    }
3864    if let Some(ref local_var_str) = slug__nisw {
3865        local_var_req_builder = match "multi" {
3866            "multi" => local_var_req_builder.query(
3867                &local_var_str
3868                    .into_iter()
3869                    .map(|p| ("slug__nisw".to_owned(), p.to_string()))
3870                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3871            ),
3872            _ => local_var_req_builder.query(&[(
3873                "slug__nisw",
3874                &local_var_str
3875                    .into_iter()
3876                    .map(|p| p.to_string())
3877                    .collect::<Vec<String>>()
3878                    .join(",")
3879                    .to_string(),
3880            )]),
3881        };
3882    }
3883    if let Some(ref local_var_str) = slug__regex {
3884        local_var_req_builder = match "multi" {
3885            "multi" => local_var_req_builder.query(
3886                &local_var_str
3887                    .into_iter()
3888                    .map(|p| ("slug__regex".to_owned(), p.to_string()))
3889                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3890            ),
3891            _ => local_var_req_builder.query(&[(
3892                "slug__regex",
3893                &local_var_str
3894                    .into_iter()
3895                    .map(|p| p.to_string())
3896                    .collect::<Vec<String>>()
3897                    .join(",")
3898                    .to_string(),
3899            )]),
3900        };
3901    }
3902    if let Some(ref local_var_str) = tag {
3903        local_var_req_builder = match "multi" {
3904            "multi" => local_var_req_builder.query(
3905                &local_var_str
3906                    .into_iter()
3907                    .map(|p| ("tag".to_owned(), p.to_string()))
3908                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3909            ),
3910            _ => local_var_req_builder.query(&[(
3911                "tag",
3912                &local_var_str
3913                    .into_iter()
3914                    .map(|p| p.to_string())
3915                    .collect::<Vec<String>>()
3916                    .join(",")
3917                    .to_string(),
3918            )]),
3919        };
3920    }
3921    if let Some(ref local_var_str) = tag__n {
3922        local_var_req_builder = match "multi" {
3923            "multi" => local_var_req_builder.query(
3924                &local_var_str
3925                    .into_iter()
3926                    .map(|p| ("tag__n".to_owned(), p.to_string()))
3927                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3928            ),
3929            _ => local_var_req_builder.query(&[(
3930                "tag__n",
3931                &local_var_str
3932                    .into_iter()
3933                    .map(|p| p.to_string())
3934                    .collect::<Vec<String>>()
3935                    .join(",")
3936                    .to_string(),
3937            )]),
3938        };
3939    }
3940    if let Some(ref local_var_str) = tag_id {
3941        local_var_req_builder = match "multi" {
3942            "multi" => local_var_req_builder.query(
3943                &local_var_str
3944                    .into_iter()
3945                    .map(|p| ("tag_id".to_owned(), p.to_string()))
3946                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3947            ),
3948            _ => local_var_req_builder.query(&[(
3949                "tag_id",
3950                &local_var_str
3951                    .into_iter()
3952                    .map(|p| p.to_string())
3953                    .collect::<Vec<String>>()
3954                    .join(",")
3955                    .to_string(),
3956            )]),
3957        };
3958    }
3959    if let Some(ref local_var_str) = tag_id__n {
3960        local_var_req_builder = match "multi" {
3961            "multi" => local_var_req_builder.query(
3962                &local_var_str
3963                    .into_iter()
3964                    .map(|p| ("tag_id__n".to_owned(), p.to_string()))
3965                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3966            ),
3967            _ => local_var_req_builder.query(&[(
3968                "tag_id__n",
3969                &local_var_str
3970                    .into_iter()
3971                    .map(|p| p.to_string())
3972                    .collect::<Vec<String>>()
3973                    .join(",")
3974                    .to_string(),
3975            )]),
3976        };
3977    }
3978    if let Some(ref local_var_str) = tenant {
3979        local_var_req_builder = match "multi" {
3980            "multi" => local_var_req_builder.query(
3981                &local_var_str
3982                    .into_iter()
3983                    .map(|p| ("tenant".to_owned(), p.to_string()))
3984                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3985            ),
3986            _ => local_var_req_builder.query(&[(
3987                "tenant",
3988                &local_var_str
3989                    .into_iter()
3990                    .map(|p| p.to_string())
3991                    .collect::<Vec<String>>()
3992                    .join(",")
3993                    .to_string(),
3994            )]),
3995        };
3996    }
3997    if let Some(ref local_var_str) = tenant__n {
3998        local_var_req_builder = match "multi" {
3999            "multi" => local_var_req_builder.query(
4000                &local_var_str
4001                    .into_iter()
4002                    .map(|p| ("tenant__n".to_owned(), p.to_string()))
4003                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4004            ),
4005            _ => local_var_req_builder.query(&[(
4006                "tenant__n",
4007                &local_var_str
4008                    .into_iter()
4009                    .map(|p| p.to_string())
4010                    .collect::<Vec<String>>()
4011                    .join(",")
4012                    .to_string(),
4013            )]),
4014        };
4015    }
4016    if let Some(ref local_var_str) = tenant_group {
4017        local_var_req_builder = match "multi" {
4018            "multi" => local_var_req_builder.query(
4019                &local_var_str
4020                    .into_iter()
4021                    .map(|p| ("tenant_group".to_owned(), p.to_string()))
4022                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4023            ),
4024            _ => local_var_req_builder.query(&[(
4025                "tenant_group",
4026                &local_var_str
4027                    .into_iter()
4028                    .map(|p| p.to_string())
4029                    .collect::<Vec<String>>()
4030                    .join(",")
4031                    .to_string(),
4032            )]),
4033        };
4034    }
4035    if let Some(ref local_var_str) = tenant_group__n {
4036        local_var_req_builder = match "multi" {
4037            "multi" => local_var_req_builder.query(
4038                &local_var_str
4039                    .into_iter()
4040                    .map(|p| ("tenant_group__n".to_owned(), p.to_string()))
4041                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4042            ),
4043            _ => local_var_req_builder.query(&[(
4044                "tenant_group__n",
4045                &local_var_str
4046                    .into_iter()
4047                    .map(|p| p.to_string())
4048                    .collect::<Vec<String>>()
4049                    .join(",")
4050                    .to_string(),
4051            )]),
4052        };
4053    }
4054    if let Some(ref local_var_str) = tenant_group_id {
4055        local_var_req_builder = match "multi" {
4056            "multi" => local_var_req_builder.query(
4057                &local_var_str
4058                    .into_iter()
4059                    .map(|p| ("tenant_group_id".to_owned(), p.to_string()))
4060                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4061            ),
4062            _ => local_var_req_builder.query(&[(
4063                "tenant_group_id",
4064                &local_var_str
4065                    .into_iter()
4066                    .map(|p| p.to_string())
4067                    .collect::<Vec<String>>()
4068                    .join(",")
4069                    .to_string(),
4070            )]),
4071        };
4072    }
4073    if let Some(ref local_var_str) = tenant_group_id__n {
4074        local_var_req_builder = match "multi" {
4075            "multi" => local_var_req_builder.query(
4076                &local_var_str
4077                    .into_iter()
4078                    .map(|p| ("tenant_group_id__n".to_owned(), p.to_string()))
4079                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4080            ),
4081            _ => local_var_req_builder.query(&[(
4082                "tenant_group_id__n",
4083                &local_var_str
4084                    .into_iter()
4085                    .map(|p| p.to_string())
4086                    .collect::<Vec<String>>()
4087                    .join(",")
4088                    .to_string(),
4089            )]),
4090        };
4091    }
4092    if let Some(ref local_var_str) = tenant_id {
4093        local_var_req_builder = match "multi" {
4094            "multi" => local_var_req_builder.query(
4095                &local_var_str
4096                    .into_iter()
4097                    .map(|p| ("tenant_id".to_owned(), p.to_string()))
4098                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4099            ),
4100            _ => local_var_req_builder.query(&[(
4101                "tenant_id",
4102                &local_var_str
4103                    .into_iter()
4104                    .map(|p| p.to_string())
4105                    .collect::<Vec<String>>()
4106                    .join(",")
4107                    .to_string(),
4108            )]),
4109        };
4110    }
4111    if let Some(ref local_var_str) = tenant_id__n {
4112        local_var_req_builder = match "multi" {
4113            "multi" => local_var_req_builder.query(
4114                &local_var_str
4115                    .into_iter()
4116                    .map(|p| ("tenant_id__n".to_owned(), p.to_string()))
4117                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4118            ),
4119            _ => local_var_req_builder.query(&[(
4120                "tenant_id__n",
4121                &local_var_str
4122                    .into_iter()
4123                    .map(|p| p.to_string())
4124                    .collect::<Vec<String>>()
4125                    .join(",")
4126                    .to_string(),
4127            )]),
4128        };
4129    }
4130    if let Some(ref local_var_str) = updated_by_request {
4131        local_var_req_builder =
4132            local_var_req_builder.query(&[("updated_by_request", &local_var_str.to_string())]);
4133    }
4134    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
4135        local_var_req_builder =
4136            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
4137    }
4138    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
4139        let local_var_key = local_var_apikey.key.clone();
4140        let local_var_value = match local_var_apikey.prefix {
4141            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
4142            None => local_var_key,
4143        };
4144        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
4145    };
4146
4147    let local_var_req = local_var_req_builder.build()?;
4148    let local_var_resp = local_var_client.execute(local_var_req).await?;
4149
4150    let local_var_status = local_var_resp.status();
4151    let local_var_content = local_var_resp.text().await?;
4152
4153    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
4154        serde_json::from_str(&local_var_content).map_err(Error::from)
4155    } else {
4156        let local_var_entity: Option<CircuitsCircuitGroupsListError> =
4157            serde_json::from_str(&local_var_content).ok();
4158        let local_var_error = ResponseContent {
4159            status: local_var_status,
4160            content: local_var_content,
4161            entity: local_var_entity,
4162        };
4163        Err(Error::ResponseError(local_var_error))
4164    }
4165}
4166
4167/// Patch a circuit group object.
4168pub async fn circuits_circuit_groups_partial_update(
4169    configuration: &configuration::Configuration,
4170    id: i32,
4171    patched_circuit_group_request: Option<crate::models::PatchedCircuitGroupRequest>,
4172) -> Result<crate::models::CircuitGroup, Error<CircuitsCircuitGroupsPartialUpdateError>> {
4173    let local_var_configuration = configuration;
4174
4175    let local_var_client = &local_var_configuration.client;
4176
4177    let local_var_uri_str = format!(
4178        "{}/api/circuits/circuit-groups/{id}/",
4179        local_var_configuration.base_path,
4180        id = id
4181    );
4182    let mut local_var_req_builder =
4183        local_var_client.request(reqwest::Method::PATCH, local_var_uri_str.as_str());
4184
4185    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
4186        local_var_req_builder =
4187            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
4188    }
4189    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
4190        let local_var_key = local_var_apikey.key.clone();
4191        let local_var_value = match local_var_apikey.prefix {
4192            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
4193            None => local_var_key,
4194        };
4195        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
4196    };
4197    local_var_req_builder = local_var_req_builder.json(&patched_circuit_group_request);
4198
4199    let local_var_req = local_var_req_builder.build()?;
4200    let local_var_resp = local_var_client.execute(local_var_req).await?;
4201
4202    let local_var_status = local_var_resp.status();
4203    let local_var_content = local_var_resp.text().await?;
4204
4205    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
4206        serde_json::from_str(&local_var_content).map_err(Error::from)
4207    } else {
4208        let local_var_entity: Option<CircuitsCircuitGroupsPartialUpdateError> =
4209            serde_json::from_str(&local_var_content).ok();
4210        let local_var_error = ResponseContent {
4211            status: local_var_status,
4212            content: local_var_content,
4213            entity: local_var_entity,
4214        };
4215        Err(Error::ResponseError(local_var_error))
4216    }
4217}
4218
4219/// Get a circuit group object.
4220pub async fn circuits_circuit_groups_retrieve(
4221    configuration: &configuration::Configuration,
4222    id: i32,
4223) -> Result<crate::models::CircuitGroup, Error<CircuitsCircuitGroupsRetrieveError>> {
4224    let local_var_configuration = configuration;
4225
4226    let local_var_client = &local_var_configuration.client;
4227
4228    let local_var_uri_str = format!(
4229        "{}/api/circuits/circuit-groups/{id}/",
4230        local_var_configuration.base_path,
4231        id = id
4232    );
4233    let mut local_var_req_builder =
4234        local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
4235
4236    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
4237        local_var_req_builder =
4238            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
4239    }
4240    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
4241        let local_var_key = local_var_apikey.key.clone();
4242        let local_var_value = match local_var_apikey.prefix {
4243            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
4244            None => local_var_key,
4245        };
4246        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
4247    };
4248
4249    let local_var_req = local_var_req_builder.build()?;
4250    let local_var_resp = local_var_client.execute(local_var_req).await?;
4251
4252    let local_var_status = local_var_resp.status();
4253    let local_var_content = local_var_resp.text().await?;
4254
4255    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
4256        serde_json::from_str(&local_var_content).map_err(Error::from)
4257    } else {
4258        let local_var_entity: Option<CircuitsCircuitGroupsRetrieveError> =
4259            serde_json::from_str(&local_var_content).ok();
4260        let local_var_error = ResponseContent {
4261            status: local_var_status,
4262            content: local_var_content,
4263            entity: local_var_entity,
4264        };
4265        Err(Error::ResponseError(local_var_error))
4266    }
4267}
4268
4269/// Put a circuit group object.
4270pub async fn circuits_circuit_groups_update(
4271    configuration: &configuration::Configuration,
4272    id: i32,
4273    circuit_group_request: crate::models::CircuitGroupRequest,
4274) -> Result<crate::models::CircuitGroup, Error<CircuitsCircuitGroupsUpdateError>> {
4275    let local_var_configuration = configuration;
4276
4277    let local_var_client = &local_var_configuration.client;
4278
4279    let local_var_uri_str = format!(
4280        "{}/api/circuits/circuit-groups/{id}/",
4281        local_var_configuration.base_path,
4282        id = id
4283    );
4284    let mut local_var_req_builder =
4285        local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());
4286
4287    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
4288        local_var_req_builder =
4289            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
4290    }
4291    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
4292        let local_var_key = local_var_apikey.key.clone();
4293        let local_var_value = match local_var_apikey.prefix {
4294            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
4295            None => local_var_key,
4296        };
4297        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
4298    };
4299    local_var_req_builder = local_var_req_builder.json(&circuit_group_request);
4300
4301    let local_var_req = local_var_req_builder.build()?;
4302    let local_var_resp = local_var_client.execute(local_var_req).await?;
4303
4304    let local_var_status = local_var_resp.status();
4305    let local_var_content = local_var_resp.text().await?;
4306
4307    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
4308        serde_json::from_str(&local_var_content).map_err(Error::from)
4309    } else {
4310        let local_var_entity: Option<CircuitsCircuitGroupsUpdateError> =
4311            serde_json::from_str(&local_var_content).ok();
4312        let local_var_error = ResponseContent {
4313            status: local_var_status,
4314            content: local_var_content,
4315            entity: local_var_entity,
4316        };
4317        Err(Error::ResponseError(local_var_error))
4318    }
4319}
4320
4321/// Delete a list of circuit termination objects.
4322pub async fn circuits_circuit_terminations_bulk_destroy(
4323    configuration: &configuration::Configuration,
4324    circuit_termination_request: Vec<crate::models::CircuitTerminationRequest>,
4325) -> Result<(), Error<CircuitsCircuitTerminationsBulkDestroyError>> {
4326    let local_var_configuration = configuration;
4327
4328    let local_var_client = &local_var_configuration.client;
4329
4330    let local_var_uri_str = format!(
4331        "{}/api/circuits/circuit-terminations/",
4332        local_var_configuration.base_path
4333    );
4334    let mut local_var_req_builder =
4335        local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());
4336
4337    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
4338        local_var_req_builder =
4339            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
4340    }
4341    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
4342        let local_var_key = local_var_apikey.key.clone();
4343        let local_var_value = match local_var_apikey.prefix {
4344            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
4345            None => local_var_key,
4346        };
4347        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
4348    };
4349    local_var_req_builder = local_var_req_builder.json(&circuit_termination_request);
4350
4351    let local_var_req = local_var_req_builder.build()?;
4352    let local_var_resp = local_var_client.execute(local_var_req).await?;
4353
4354    let local_var_status = local_var_resp.status();
4355    let local_var_content = local_var_resp.text().await?;
4356
4357    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
4358        Ok(())
4359    } else {
4360        let local_var_entity: Option<CircuitsCircuitTerminationsBulkDestroyError> =
4361            serde_json::from_str(&local_var_content).ok();
4362        let local_var_error = ResponseContent {
4363            status: local_var_status,
4364            content: local_var_content,
4365            entity: local_var_entity,
4366        };
4367        Err(Error::ResponseError(local_var_error))
4368    }
4369}
4370
4371/// Patch a list of circuit termination objects.
4372pub async fn circuits_circuit_terminations_bulk_partial_update(
4373    configuration: &configuration::Configuration,
4374    circuit_termination_request: Vec<crate::models::CircuitTerminationRequest>,
4375) -> Result<
4376    Vec<crate::models::CircuitTermination>,
4377    Error<CircuitsCircuitTerminationsBulkPartialUpdateError>,
4378> {
4379    let local_var_configuration = configuration;
4380
4381    let local_var_client = &local_var_configuration.client;
4382
4383    let local_var_uri_str = format!(
4384        "{}/api/circuits/circuit-terminations/",
4385        local_var_configuration.base_path
4386    );
4387    let mut local_var_req_builder =
4388        local_var_client.request(reqwest::Method::PATCH, local_var_uri_str.as_str());
4389
4390    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
4391        local_var_req_builder =
4392            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
4393    }
4394    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
4395        let local_var_key = local_var_apikey.key.clone();
4396        let local_var_value = match local_var_apikey.prefix {
4397            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
4398            None => local_var_key,
4399        };
4400        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
4401    };
4402    local_var_req_builder = local_var_req_builder.json(&circuit_termination_request);
4403
4404    let local_var_req = local_var_req_builder.build()?;
4405    let local_var_resp = local_var_client.execute(local_var_req).await?;
4406
4407    let local_var_status = local_var_resp.status();
4408    let local_var_content = local_var_resp.text().await?;
4409
4410    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
4411        serde_json::from_str(&local_var_content).map_err(Error::from)
4412    } else {
4413        let local_var_entity: Option<CircuitsCircuitTerminationsBulkPartialUpdateError> =
4414            serde_json::from_str(&local_var_content).ok();
4415        let local_var_error = ResponseContent {
4416            status: local_var_status,
4417            content: local_var_content,
4418            entity: local_var_entity,
4419        };
4420        Err(Error::ResponseError(local_var_error))
4421    }
4422}
4423
4424/// Put a list of circuit termination objects.
4425pub async fn circuits_circuit_terminations_bulk_update(
4426    configuration: &configuration::Configuration,
4427    circuit_termination_request: Vec<crate::models::CircuitTerminationRequest>,
4428) -> Result<Vec<crate::models::CircuitTermination>, Error<CircuitsCircuitTerminationsBulkUpdateError>>
4429{
4430    let local_var_configuration = configuration;
4431
4432    let local_var_client = &local_var_configuration.client;
4433
4434    let local_var_uri_str = format!(
4435        "{}/api/circuits/circuit-terminations/",
4436        local_var_configuration.base_path
4437    );
4438    let mut local_var_req_builder =
4439        local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());
4440
4441    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
4442        local_var_req_builder =
4443            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
4444    }
4445    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
4446        let local_var_key = local_var_apikey.key.clone();
4447        let local_var_value = match local_var_apikey.prefix {
4448            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
4449            None => local_var_key,
4450        };
4451        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
4452    };
4453    local_var_req_builder = local_var_req_builder.json(&circuit_termination_request);
4454
4455    let local_var_req = local_var_req_builder.build()?;
4456    let local_var_resp = local_var_client.execute(local_var_req).await?;
4457
4458    let local_var_status = local_var_resp.status();
4459    let local_var_content = local_var_resp.text().await?;
4460
4461    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
4462        serde_json::from_str(&local_var_content).map_err(Error::from)
4463    } else {
4464        let local_var_entity: Option<CircuitsCircuitTerminationsBulkUpdateError> =
4465            serde_json::from_str(&local_var_content).ok();
4466        let local_var_error = ResponseContent {
4467            status: local_var_status,
4468            content: local_var_content,
4469            entity: local_var_entity,
4470        };
4471        Err(Error::ResponseError(local_var_error))
4472    }
4473}
4474
4475/// Post a list of circuit termination objects.
4476pub async fn circuits_circuit_terminations_create(
4477    configuration: &configuration::Configuration,
4478    circuits_circuit_terminations_create_request: crate::models::CircuitsCircuitTerminationsCreateRequest,
4479) -> Result<crate::models::CircuitTermination, Error<CircuitsCircuitTerminationsCreateError>> {
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        "{}/api/circuits/circuit-terminations/",
4486        local_var_configuration.base_path
4487    );
4488    let mut local_var_req_builder =
4489        local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
4490
4491    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
4492        local_var_req_builder =
4493            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
4494    }
4495    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
4496        let local_var_key = local_var_apikey.key.clone();
4497        let local_var_value = match local_var_apikey.prefix {
4498            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
4499            None => local_var_key,
4500        };
4501        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
4502    };
4503    local_var_req_builder =
4504        local_var_req_builder.json(&circuits_circuit_terminations_create_request);
4505
4506    let local_var_req = local_var_req_builder.build()?;
4507    let local_var_resp = local_var_client.execute(local_var_req).await?;
4508
4509    let local_var_status = local_var_resp.status();
4510    let local_var_content = local_var_resp.text().await?;
4511
4512    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
4513        serde_json::from_str(&local_var_content).map_err(Error::from)
4514    } else {
4515        let local_var_entity: Option<CircuitsCircuitTerminationsCreateError> =
4516            serde_json::from_str(&local_var_content).ok();
4517        let local_var_error = ResponseContent {
4518            status: local_var_status,
4519            content: local_var_content,
4520            entity: local_var_entity,
4521        };
4522        Err(Error::ResponseError(local_var_error))
4523    }
4524}
4525
4526/// Delete a circuit termination object.
4527pub async fn circuits_circuit_terminations_destroy(
4528    configuration: &configuration::Configuration,
4529    id: i32,
4530) -> Result<(), Error<CircuitsCircuitTerminationsDestroyError>> {
4531    let local_var_configuration = configuration;
4532
4533    let local_var_client = &local_var_configuration.client;
4534
4535    let local_var_uri_str = format!(
4536        "{}/api/circuits/circuit-terminations/{id}/",
4537        local_var_configuration.base_path,
4538        id = id
4539    );
4540    let mut local_var_req_builder =
4541        local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());
4542
4543    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
4544        local_var_req_builder =
4545            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
4546    }
4547    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
4548        let local_var_key = local_var_apikey.key.clone();
4549        let local_var_value = match local_var_apikey.prefix {
4550            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
4551            None => local_var_key,
4552        };
4553        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
4554    };
4555
4556    let local_var_req = local_var_req_builder.build()?;
4557    let local_var_resp = local_var_client.execute(local_var_req).await?;
4558
4559    let local_var_status = local_var_resp.status();
4560    let local_var_content = local_var_resp.text().await?;
4561
4562    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
4563        Ok(())
4564    } else {
4565        let local_var_entity: Option<CircuitsCircuitTerminationsDestroyError> =
4566            serde_json::from_str(&local_var_content).ok();
4567        let local_var_error = ResponseContent {
4568            status: local_var_status,
4569            content: local_var_content,
4570            entity: local_var_entity,
4571        };
4572        Err(Error::ResponseError(local_var_error))
4573    }
4574}
4575
4576/// Get a list of circuit termination objects.
4577pub async fn circuits_circuit_terminations_list(
4578    configuration: &configuration::Configuration,
4579    cable_connector: Option<Vec<i32>>,
4580    cable_connector__empty: Option<bool>,
4581    cable_connector__gt: Option<Vec<i32>>,
4582    cable_connector__gte: Option<Vec<i32>>,
4583    cable_connector__lt: Option<Vec<i32>>,
4584    cable_connector__lte: Option<Vec<i32>>,
4585    cable_connector__n: Option<Vec<i32>>,
4586    cable_end: Option<&str>,
4587    cable_end__empty: Option<bool>,
4588    cable_end__ic: Option<Vec<String>>,
4589    cable_end__ie: Option<Vec<String>>,
4590    cable_end__iew: Option<Vec<String>>,
4591    cable_end__iregex: Option<Vec<String>>,
4592    cable_end__isw: Option<Vec<String>>,
4593    cable_end__n: Option<&str>,
4594    cable_end__nic: Option<Vec<String>>,
4595    cable_end__nie: Option<Vec<String>>,
4596    cable_end__niew: Option<Vec<String>>,
4597    cable_end__nisw: Option<Vec<String>>,
4598    cable_end__regex: Option<Vec<String>>,
4599    cable_id: Option<Vec<i32>>,
4600    cable_id__n: Option<Vec<i32>>,
4601    cabled: Option<bool>,
4602    circuit_id: Option<Vec<i32>>,
4603    circuit_id__n: Option<Vec<i32>>,
4604    created: Option<Vec<String>>,
4605    created__empty: Option<Vec<String>>,
4606    created__gt: Option<Vec<String>>,
4607    created__gte: Option<Vec<String>>,
4608    created__lt: Option<Vec<String>>,
4609    created__lte: Option<Vec<String>>,
4610    created__n: Option<Vec<String>>,
4611    created_by_request: Option<&str>,
4612    description: Option<Vec<String>>,
4613    description__empty: Option<bool>,
4614    description__ic: Option<Vec<String>>,
4615    description__ie: Option<Vec<String>>,
4616    description__iew: Option<Vec<String>>,
4617    description__iregex: Option<Vec<String>>,
4618    description__isw: Option<Vec<String>>,
4619    description__n: Option<Vec<String>>,
4620    description__nic: Option<Vec<String>>,
4621    description__nie: Option<Vec<String>>,
4622    description__niew: Option<Vec<String>>,
4623    description__nisw: Option<Vec<String>>,
4624    description__regex: Option<Vec<String>>,
4625    id: Option<Vec<i32>>,
4626    id__empty: Option<bool>,
4627    id__gt: Option<Vec<i32>>,
4628    id__gte: Option<Vec<i32>>,
4629    id__lt: Option<Vec<i32>>,
4630    id__lte: Option<Vec<i32>>,
4631    id__n: Option<Vec<i32>>,
4632    last_updated: Option<Vec<String>>,
4633    last_updated__empty: Option<Vec<String>>,
4634    last_updated__gt: Option<Vec<String>>,
4635    last_updated__gte: Option<Vec<String>>,
4636    last_updated__lt: Option<Vec<String>>,
4637    last_updated__lte: Option<Vec<String>>,
4638    last_updated__n: Option<Vec<String>>,
4639    limit: Option<i32>,
4640    location: Option<Vec<String>>,
4641    location__n: Option<Vec<String>>,
4642    location_id: Option<Vec<String>>,
4643    location_id__n: Option<Vec<String>>,
4644    mark_connected: Option<bool>,
4645    modified_by_request: Option<&str>,
4646    occupied: Option<bool>,
4647    offset: Option<i32>,
4648    ordering: Option<&str>,
4649    port_speed: Option<Vec<i32>>,
4650    port_speed__empty: Option<bool>,
4651    port_speed__gt: Option<Vec<i32>>,
4652    port_speed__gte: Option<Vec<i32>>,
4653    port_speed__lt: Option<Vec<i32>>,
4654    port_speed__lte: Option<Vec<i32>>,
4655    port_speed__n: Option<Vec<i32>>,
4656    pp_info: Option<Vec<String>>,
4657    pp_info__empty: Option<bool>,
4658    pp_info__ic: Option<Vec<String>>,
4659    pp_info__ie: Option<Vec<String>>,
4660    pp_info__iew: Option<Vec<String>>,
4661    pp_info__iregex: Option<Vec<String>>,
4662    pp_info__isw: Option<Vec<String>>,
4663    pp_info__n: Option<Vec<String>>,
4664    pp_info__nic: Option<Vec<String>>,
4665    pp_info__nie: Option<Vec<String>>,
4666    pp_info__niew: Option<Vec<String>>,
4667    pp_info__nisw: Option<Vec<String>>,
4668    pp_info__regex: Option<Vec<String>>,
4669    provider: Option<Vec<String>>,
4670    provider__n: Option<Vec<String>>,
4671    provider_id: Option<Vec<i32>>,
4672    provider_id__n: Option<Vec<i32>>,
4673    provider_network_id: Option<Vec<i32>>,
4674    provider_network_id__n: Option<Vec<i32>>,
4675    q: Option<&str>,
4676    region: Option<Vec<String>>,
4677    region__n: Option<Vec<String>>,
4678    region_id: Option<Vec<String>>,
4679    region_id__n: Option<Vec<String>>,
4680    site: Option<Vec<String>>,
4681    site__n: Option<Vec<String>>,
4682    site_group: Option<Vec<String>>,
4683    site_group__n: Option<Vec<String>>,
4684    site_group_id: Option<Vec<String>>,
4685    site_group_id__n: Option<Vec<String>>,
4686    site_id: Option<Vec<i32>>,
4687    site_id__n: Option<Vec<i32>>,
4688    tag: Option<Vec<String>>,
4689    tag__n: Option<Vec<String>>,
4690    tag_id: Option<Vec<i32>>,
4691    tag_id__n: Option<Vec<i32>>,
4692    term_side: Option<&str>,
4693    term_side__empty: Option<bool>,
4694    term_side__ic: Option<Vec<String>>,
4695    term_side__ie: Option<Vec<String>>,
4696    term_side__iew: Option<Vec<String>>,
4697    term_side__iregex: Option<Vec<String>>,
4698    term_side__isw: Option<Vec<String>>,
4699    term_side__n: Option<&str>,
4700    term_side__nic: Option<Vec<String>>,
4701    term_side__nie: Option<Vec<String>>,
4702    term_side__niew: Option<Vec<String>>,
4703    term_side__nisw: Option<Vec<String>>,
4704    term_side__regex: Option<Vec<String>>,
4705    termination_id: Option<Vec<i32>>,
4706    termination_id__empty: Option<bool>,
4707    termination_id__gt: Option<Vec<i32>>,
4708    termination_id__gte: Option<Vec<i32>>,
4709    termination_id__lt: Option<Vec<i32>>,
4710    termination_id__lte: Option<Vec<i32>>,
4711    termination_id__n: Option<Vec<i32>>,
4712    termination_type: Option<Vec<String>>,
4713    termination_type__n: Option<Vec<String>>,
4714    updated_by_request: Option<&str>,
4715    upstream_speed: Option<Vec<i32>>,
4716    upstream_speed__empty: Option<bool>,
4717    upstream_speed__gt: Option<Vec<i32>>,
4718    upstream_speed__gte: Option<Vec<i32>>,
4719    upstream_speed__lt: Option<Vec<i32>>,
4720    upstream_speed__lte: Option<Vec<i32>>,
4721    upstream_speed__n: Option<Vec<i32>>,
4722    xconnect_id: Option<Vec<String>>,
4723    xconnect_id__empty: Option<bool>,
4724    xconnect_id__ic: Option<Vec<String>>,
4725    xconnect_id__ie: Option<Vec<String>>,
4726    xconnect_id__iew: Option<Vec<String>>,
4727    xconnect_id__iregex: Option<Vec<String>>,
4728    xconnect_id__isw: Option<Vec<String>>,
4729    xconnect_id__n: Option<Vec<String>>,
4730    xconnect_id__nic: Option<Vec<String>>,
4731    xconnect_id__nie: Option<Vec<String>>,
4732    xconnect_id__niew: Option<Vec<String>>,
4733    xconnect_id__nisw: Option<Vec<String>>,
4734    xconnect_id__regex: Option<Vec<String>>,
4735) -> Result<
4736    crate::models::PaginatedCircuitTerminationList,
4737    Error<CircuitsCircuitTerminationsListError>,
4738> {
4739    let local_var_configuration = configuration;
4740
4741    let local_var_client = &local_var_configuration.client;
4742
4743    let local_var_uri_str = format!(
4744        "{}/api/circuits/circuit-terminations/",
4745        local_var_configuration.base_path
4746    );
4747    let mut local_var_req_builder =
4748        local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
4749
4750    if let Some(ref local_var_str) = cable_connector {
4751        local_var_req_builder = match "multi" {
4752            "multi" => local_var_req_builder.query(
4753                &local_var_str
4754                    .into_iter()
4755                    .map(|p| ("cable_connector".to_owned(), p.to_string()))
4756                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4757            ),
4758            _ => local_var_req_builder.query(&[(
4759                "cable_connector",
4760                &local_var_str
4761                    .into_iter()
4762                    .map(|p| p.to_string())
4763                    .collect::<Vec<String>>()
4764                    .join(",")
4765                    .to_string(),
4766            )]),
4767        };
4768    }
4769    if let Some(ref local_var_str) = cable_connector__empty {
4770        local_var_req_builder =
4771            local_var_req_builder.query(&[("cable_connector__empty", &local_var_str.to_string())]);
4772    }
4773    if let Some(ref local_var_str) = cable_connector__gt {
4774        local_var_req_builder = match "multi" {
4775            "multi" => local_var_req_builder.query(
4776                &local_var_str
4777                    .into_iter()
4778                    .map(|p| ("cable_connector__gt".to_owned(), p.to_string()))
4779                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4780            ),
4781            _ => local_var_req_builder.query(&[(
4782                "cable_connector__gt",
4783                &local_var_str
4784                    .into_iter()
4785                    .map(|p| p.to_string())
4786                    .collect::<Vec<String>>()
4787                    .join(",")
4788                    .to_string(),
4789            )]),
4790        };
4791    }
4792    if let Some(ref local_var_str) = cable_connector__gte {
4793        local_var_req_builder = match "multi" {
4794            "multi" => local_var_req_builder.query(
4795                &local_var_str
4796                    .into_iter()
4797                    .map(|p| ("cable_connector__gte".to_owned(), p.to_string()))
4798                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4799            ),
4800            _ => local_var_req_builder.query(&[(
4801                "cable_connector__gte",
4802                &local_var_str
4803                    .into_iter()
4804                    .map(|p| p.to_string())
4805                    .collect::<Vec<String>>()
4806                    .join(",")
4807                    .to_string(),
4808            )]),
4809        };
4810    }
4811    if let Some(ref local_var_str) = cable_connector__lt {
4812        local_var_req_builder = match "multi" {
4813            "multi" => local_var_req_builder.query(
4814                &local_var_str
4815                    .into_iter()
4816                    .map(|p| ("cable_connector__lt".to_owned(), p.to_string()))
4817                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4818            ),
4819            _ => local_var_req_builder.query(&[(
4820                "cable_connector__lt",
4821                &local_var_str
4822                    .into_iter()
4823                    .map(|p| p.to_string())
4824                    .collect::<Vec<String>>()
4825                    .join(",")
4826                    .to_string(),
4827            )]),
4828        };
4829    }
4830    if let Some(ref local_var_str) = cable_connector__lte {
4831        local_var_req_builder = match "multi" {
4832            "multi" => local_var_req_builder.query(
4833                &local_var_str
4834                    .into_iter()
4835                    .map(|p| ("cable_connector__lte".to_owned(), p.to_string()))
4836                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4837            ),
4838            _ => local_var_req_builder.query(&[(
4839                "cable_connector__lte",
4840                &local_var_str
4841                    .into_iter()
4842                    .map(|p| p.to_string())
4843                    .collect::<Vec<String>>()
4844                    .join(",")
4845                    .to_string(),
4846            )]),
4847        };
4848    }
4849    if let Some(ref local_var_str) = cable_connector__n {
4850        local_var_req_builder = match "multi" {
4851            "multi" => local_var_req_builder.query(
4852                &local_var_str
4853                    .into_iter()
4854                    .map(|p| ("cable_connector__n".to_owned(), p.to_string()))
4855                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4856            ),
4857            _ => local_var_req_builder.query(&[(
4858                "cable_connector__n",
4859                &local_var_str
4860                    .into_iter()
4861                    .map(|p| p.to_string())
4862                    .collect::<Vec<String>>()
4863                    .join(",")
4864                    .to_string(),
4865            )]),
4866        };
4867    }
4868    if let Some(ref local_var_str) = cable_end {
4869        local_var_req_builder =
4870            local_var_req_builder.query(&[("cable_end", &local_var_str.to_string())]);
4871    }
4872    if let Some(ref local_var_str) = cable_end__empty {
4873        local_var_req_builder =
4874            local_var_req_builder.query(&[("cable_end__empty", &local_var_str.to_string())]);
4875    }
4876    if let Some(ref local_var_str) = cable_end__ic {
4877        local_var_req_builder = match "multi" {
4878            "multi" => local_var_req_builder.query(
4879                &local_var_str
4880                    .into_iter()
4881                    .map(|p| ("cable_end__ic".to_owned(), p.to_string()))
4882                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4883            ),
4884            _ => local_var_req_builder.query(&[(
4885                "cable_end__ic",
4886                &local_var_str
4887                    .into_iter()
4888                    .map(|p| p.to_string())
4889                    .collect::<Vec<String>>()
4890                    .join(",")
4891                    .to_string(),
4892            )]),
4893        };
4894    }
4895    if let Some(ref local_var_str) = cable_end__ie {
4896        local_var_req_builder = match "multi" {
4897            "multi" => local_var_req_builder.query(
4898                &local_var_str
4899                    .into_iter()
4900                    .map(|p| ("cable_end__ie".to_owned(), p.to_string()))
4901                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4902            ),
4903            _ => local_var_req_builder.query(&[(
4904                "cable_end__ie",
4905                &local_var_str
4906                    .into_iter()
4907                    .map(|p| p.to_string())
4908                    .collect::<Vec<String>>()
4909                    .join(",")
4910                    .to_string(),
4911            )]),
4912        };
4913    }
4914    if let Some(ref local_var_str) = cable_end__iew {
4915        local_var_req_builder = match "multi" {
4916            "multi" => local_var_req_builder.query(
4917                &local_var_str
4918                    .into_iter()
4919                    .map(|p| ("cable_end__iew".to_owned(), p.to_string()))
4920                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4921            ),
4922            _ => local_var_req_builder.query(&[(
4923                "cable_end__iew",
4924                &local_var_str
4925                    .into_iter()
4926                    .map(|p| p.to_string())
4927                    .collect::<Vec<String>>()
4928                    .join(",")
4929                    .to_string(),
4930            )]),
4931        };
4932    }
4933    if let Some(ref local_var_str) = cable_end__iregex {
4934        local_var_req_builder = match "multi" {
4935            "multi" => local_var_req_builder.query(
4936                &local_var_str
4937                    .into_iter()
4938                    .map(|p| ("cable_end__iregex".to_owned(), p.to_string()))
4939                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4940            ),
4941            _ => local_var_req_builder.query(&[(
4942                "cable_end__iregex",
4943                &local_var_str
4944                    .into_iter()
4945                    .map(|p| p.to_string())
4946                    .collect::<Vec<String>>()
4947                    .join(",")
4948                    .to_string(),
4949            )]),
4950        };
4951    }
4952    if let Some(ref local_var_str) = cable_end__isw {
4953        local_var_req_builder = match "multi" {
4954            "multi" => local_var_req_builder.query(
4955                &local_var_str
4956                    .into_iter()
4957                    .map(|p| ("cable_end__isw".to_owned(), p.to_string()))
4958                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4959            ),
4960            _ => local_var_req_builder.query(&[(
4961                "cable_end__isw",
4962                &local_var_str
4963                    .into_iter()
4964                    .map(|p| p.to_string())
4965                    .collect::<Vec<String>>()
4966                    .join(",")
4967                    .to_string(),
4968            )]),
4969        };
4970    }
4971    if let Some(ref local_var_str) = cable_end__n {
4972        local_var_req_builder =
4973            local_var_req_builder.query(&[("cable_end__n", &local_var_str.to_string())]);
4974    }
4975    if let Some(ref local_var_str) = cable_end__nic {
4976        local_var_req_builder = match "multi" {
4977            "multi" => local_var_req_builder.query(
4978                &local_var_str
4979                    .into_iter()
4980                    .map(|p| ("cable_end__nic".to_owned(), p.to_string()))
4981                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4982            ),
4983            _ => local_var_req_builder.query(&[(
4984                "cable_end__nic",
4985                &local_var_str
4986                    .into_iter()
4987                    .map(|p| p.to_string())
4988                    .collect::<Vec<String>>()
4989                    .join(",")
4990                    .to_string(),
4991            )]),
4992        };
4993    }
4994    if let Some(ref local_var_str) = cable_end__nie {
4995        local_var_req_builder = match "multi" {
4996            "multi" => local_var_req_builder.query(
4997                &local_var_str
4998                    .into_iter()
4999                    .map(|p| ("cable_end__nie".to_owned(), p.to_string()))
5000                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5001            ),
5002            _ => local_var_req_builder.query(&[(
5003                "cable_end__nie",
5004                &local_var_str
5005                    .into_iter()
5006                    .map(|p| p.to_string())
5007                    .collect::<Vec<String>>()
5008                    .join(",")
5009                    .to_string(),
5010            )]),
5011        };
5012    }
5013    if let Some(ref local_var_str) = cable_end__niew {
5014        local_var_req_builder = match "multi" {
5015            "multi" => local_var_req_builder.query(
5016                &local_var_str
5017                    .into_iter()
5018                    .map(|p| ("cable_end__niew".to_owned(), p.to_string()))
5019                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5020            ),
5021            _ => local_var_req_builder.query(&[(
5022                "cable_end__niew",
5023                &local_var_str
5024                    .into_iter()
5025                    .map(|p| p.to_string())
5026                    .collect::<Vec<String>>()
5027                    .join(",")
5028                    .to_string(),
5029            )]),
5030        };
5031    }
5032    if let Some(ref local_var_str) = cable_end__nisw {
5033        local_var_req_builder = match "multi" {
5034            "multi" => local_var_req_builder.query(
5035                &local_var_str
5036                    .into_iter()
5037                    .map(|p| ("cable_end__nisw".to_owned(), p.to_string()))
5038                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5039            ),
5040            _ => local_var_req_builder.query(&[(
5041                "cable_end__nisw",
5042                &local_var_str
5043                    .into_iter()
5044                    .map(|p| p.to_string())
5045                    .collect::<Vec<String>>()
5046                    .join(",")
5047                    .to_string(),
5048            )]),
5049        };
5050    }
5051    if let Some(ref local_var_str) = cable_end__regex {
5052        local_var_req_builder = match "multi" {
5053            "multi" => local_var_req_builder.query(
5054                &local_var_str
5055                    .into_iter()
5056                    .map(|p| ("cable_end__regex".to_owned(), p.to_string()))
5057                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5058            ),
5059            _ => local_var_req_builder.query(&[(
5060                "cable_end__regex",
5061                &local_var_str
5062                    .into_iter()
5063                    .map(|p| p.to_string())
5064                    .collect::<Vec<String>>()
5065                    .join(",")
5066                    .to_string(),
5067            )]),
5068        };
5069    }
5070    if let Some(ref local_var_str) = cable_id {
5071        local_var_req_builder = match "multi" {
5072            "multi" => local_var_req_builder.query(
5073                &local_var_str
5074                    .into_iter()
5075                    .map(|p| ("cable_id".to_owned(), p.to_string()))
5076                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5077            ),
5078            _ => local_var_req_builder.query(&[(
5079                "cable_id",
5080                &local_var_str
5081                    .into_iter()
5082                    .map(|p| p.to_string())
5083                    .collect::<Vec<String>>()
5084                    .join(",")
5085                    .to_string(),
5086            )]),
5087        };
5088    }
5089    if let Some(ref local_var_str) = cable_id__n {
5090        local_var_req_builder = match "multi" {
5091            "multi" => local_var_req_builder.query(
5092                &local_var_str
5093                    .into_iter()
5094                    .map(|p| ("cable_id__n".to_owned(), p.to_string()))
5095                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5096            ),
5097            _ => local_var_req_builder.query(&[(
5098                "cable_id__n",
5099                &local_var_str
5100                    .into_iter()
5101                    .map(|p| p.to_string())
5102                    .collect::<Vec<String>>()
5103                    .join(",")
5104                    .to_string(),
5105            )]),
5106        };
5107    }
5108    if let Some(ref local_var_str) = cabled {
5109        local_var_req_builder =
5110            local_var_req_builder.query(&[("cabled", &local_var_str.to_string())]);
5111    }
5112    if let Some(ref local_var_str) = circuit_id {
5113        local_var_req_builder = match "multi" {
5114            "multi" => local_var_req_builder.query(
5115                &local_var_str
5116                    .into_iter()
5117                    .map(|p| ("circuit_id".to_owned(), p.to_string()))
5118                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5119            ),
5120            _ => local_var_req_builder.query(&[(
5121                "circuit_id",
5122                &local_var_str
5123                    .into_iter()
5124                    .map(|p| p.to_string())
5125                    .collect::<Vec<String>>()
5126                    .join(",")
5127                    .to_string(),
5128            )]),
5129        };
5130    }
5131    if let Some(ref local_var_str) = circuit_id__n {
5132        local_var_req_builder = match "multi" {
5133            "multi" => local_var_req_builder.query(
5134                &local_var_str
5135                    .into_iter()
5136                    .map(|p| ("circuit_id__n".to_owned(), p.to_string()))
5137                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5138            ),
5139            _ => local_var_req_builder.query(&[(
5140                "circuit_id__n",
5141                &local_var_str
5142                    .into_iter()
5143                    .map(|p| p.to_string())
5144                    .collect::<Vec<String>>()
5145                    .join(",")
5146                    .to_string(),
5147            )]),
5148        };
5149    }
5150    if let Some(ref local_var_str) = created {
5151        local_var_req_builder = match "multi" {
5152            "multi" => local_var_req_builder.query(
5153                &local_var_str
5154                    .into_iter()
5155                    .map(|p| ("created".to_owned(), p.to_string()))
5156                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5157            ),
5158            _ => local_var_req_builder.query(&[(
5159                "created",
5160                &local_var_str
5161                    .into_iter()
5162                    .map(|p| p.to_string())
5163                    .collect::<Vec<String>>()
5164                    .join(",")
5165                    .to_string(),
5166            )]),
5167        };
5168    }
5169    if let Some(ref local_var_str) = created__empty {
5170        local_var_req_builder = match "multi" {
5171            "multi" => local_var_req_builder.query(
5172                &local_var_str
5173                    .into_iter()
5174                    .map(|p| ("created__empty".to_owned(), p.to_string()))
5175                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5176            ),
5177            _ => local_var_req_builder.query(&[(
5178                "created__empty",
5179                &local_var_str
5180                    .into_iter()
5181                    .map(|p| p.to_string())
5182                    .collect::<Vec<String>>()
5183                    .join(",")
5184                    .to_string(),
5185            )]),
5186        };
5187    }
5188    if let Some(ref local_var_str) = created__gt {
5189        local_var_req_builder = match "multi" {
5190            "multi" => local_var_req_builder.query(
5191                &local_var_str
5192                    .into_iter()
5193                    .map(|p| ("created__gt".to_owned(), p.to_string()))
5194                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5195            ),
5196            _ => local_var_req_builder.query(&[(
5197                "created__gt",
5198                &local_var_str
5199                    .into_iter()
5200                    .map(|p| p.to_string())
5201                    .collect::<Vec<String>>()
5202                    .join(",")
5203                    .to_string(),
5204            )]),
5205        };
5206    }
5207    if let Some(ref local_var_str) = created__gte {
5208        local_var_req_builder = match "multi" {
5209            "multi" => local_var_req_builder.query(
5210                &local_var_str
5211                    .into_iter()
5212                    .map(|p| ("created__gte".to_owned(), p.to_string()))
5213                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5214            ),
5215            _ => local_var_req_builder.query(&[(
5216                "created__gte",
5217                &local_var_str
5218                    .into_iter()
5219                    .map(|p| p.to_string())
5220                    .collect::<Vec<String>>()
5221                    .join(",")
5222                    .to_string(),
5223            )]),
5224        };
5225    }
5226    if let Some(ref local_var_str) = created__lt {
5227        local_var_req_builder = match "multi" {
5228            "multi" => local_var_req_builder.query(
5229                &local_var_str
5230                    .into_iter()
5231                    .map(|p| ("created__lt".to_owned(), p.to_string()))
5232                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5233            ),
5234            _ => local_var_req_builder.query(&[(
5235                "created__lt",
5236                &local_var_str
5237                    .into_iter()
5238                    .map(|p| p.to_string())
5239                    .collect::<Vec<String>>()
5240                    .join(",")
5241                    .to_string(),
5242            )]),
5243        };
5244    }
5245    if let Some(ref local_var_str) = created__lte {
5246        local_var_req_builder = match "multi" {
5247            "multi" => local_var_req_builder.query(
5248                &local_var_str
5249                    .into_iter()
5250                    .map(|p| ("created__lte".to_owned(), p.to_string()))
5251                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5252            ),
5253            _ => local_var_req_builder.query(&[(
5254                "created__lte",
5255                &local_var_str
5256                    .into_iter()
5257                    .map(|p| p.to_string())
5258                    .collect::<Vec<String>>()
5259                    .join(",")
5260                    .to_string(),
5261            )]),
5262        };
5263    }
5264    if let Some(ref local_var_str) = created__n {
5265        local_var_req_builder = match "multi" {
5266            "multi" => local_var_req_builder.query(
5267                &local_var_str
5268                    .into_iter()
5269                    .map(|p| ("created__n".to_owned(), p.to_string()))
5270                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5271            ),
5272            _ => local_var_req_builder.query(&[(
5273                "created__n",
5274                &local_var_str
5275                    .into_iter()
5276                    .map(|p| p.to_string())
5277                    .collect::<Vec<String>>()
5278                    .join(",")
5279                    .to_string(),
5280            )]),
5281        };
5282    }
5283    if let Some(ref local_var_str) = created_by_request {
5284        local_var_req_builder =
5285            local_var_req_builder.query(&[("created_by_request", &local_var_str.to_string())]);
5286    }
5287    if let Some(ref local_var_str) = description {
5288        local_var_req_builder = match "multi" {
5289            "multi" => local_var_req_builder.query(
5290                &local_var_str
5291                    .into_iter()
5292                    .map(|p| ("description".to_owned(), p.to_string()))
5293                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5294            ),
5295            _ => local_var_req_builder.query(&[(
5296                "description",
5297                &local_var_str
5298                    .into_iter()
5299                    .map(|p| p.to_string())
5300                    .collect::<Vec<String>>()
5301                    .join(",")
5302                    .to_string(),
5303            )]),
5304        };
5305    }
5306    if let Some(ref local_var_str) = description__empty {
5307        local_var_req_builder =
5308            local_var_req_builder.query(&[("description__empty", &local_var_str.to_string())]);
5309    }
5310    if let Some(ref local_var_str) = description__ic {
5311        local_var_req_builder = match "multi" {
5312            "multi" => local_var_req_builder.query(
5313                &local_var_str
5314                    .into_iter()
5315                    .map(|p| ("description__ic".to_owned(), p.to_string()))
5316                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5317            ),
5318            _ => local_var_req_builder.query(&[(
5319                "description__ic",
5320                &local_var_str
5321                    .into_iter()
5322                    .map(|p| p.to_string())
5323                    .collect::<Vec<String>>()
5324                    .join(",")
5325                    .to_string(),
5326            )]),
5327        };
5328    }
5329    if let Some(ref local_var_str) = description__ie {
5330        local_var_req_builder = match "multi" {
5331            "multi" => local_var_req_builder.query(
5332                &local_var_str
5333                    .into_iter()
5334                    .map(|p| ("description__ie".to_owned(), p.to_string()))
5335                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5336            ),
5337            _ => local_var_req_builder.query(&[(
5338                "description__ie",
5339                &local_var_str
5340                    .into_iter()
5341                    .map(|p| p.to_string())
5342                    .collect::<Vec<String>>()
5343                    .join(",")
5344                    .to_string(),
5345            )]),
5346        };
5347    }
5348    if let Some(ref local_var_str) = description__iew {
5349        local_var_req_builder = match "multi" {
5350            "multi" => local_var_req_builder.query(
5351                &local_var_str
5352                    .into_iter()
5353                    .map(|p| ("description__iew".to_owned(), p.to_string()))
5354                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5355            ),
5356            _ => local_var_req_builder.query(&[(
5357                "description__iew",
5358                &local_var_str
5359                    .into_iter()
5360                    .map(|p| p.to_string())
5361                    .collect::<Vec<String>>()
5362                    .join(",")
5363                    .to_string(),
5364            )]),
5365        };
5366    }
5367    if let Some(ref local_var_str) = description__iregex {
5368        local_var_req_builder = match "multi" {
5369            "multi" => local_var_req_builder.query(
5370                &local_var_str
5371                    .into_iter()
5372                    .map(|p| ("description__iregex".to_owned(), p.to_string()))
5373                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5374            ),
5375            _ => local_var_req_builder.query(&[(
5376                "description__iregex",
5377                &local_var_str
5378                    .into_iter()
5379                    .map(|p| p.to_string())
5380                    .collect::<Vec<String>>()
5381                    .join(",")
5382                    .to_string(),
5383            )]),
5384        };
5385    }
5386    if let Some(ref local_var_str) = description__isw {
5387        local_var_req_builder = match "multi" {
5388            "multi" => local_var_req_builder.query(
5389                &local_var_str
5390                    .into_iter()
5391                    .map(|p| ("description__isw".to_owned(), p.to_string()))
5392                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5393            ),
5394            _ => local_var_req_builder.query(&[(
5395                "description__isw",
5396                &local_var_str
5397                    .into_iter()
5398                    .map(|p| p.to_string())
5399                    .collect::<Vec<String>>()
5400                    .join(",")
5401                    .to_string(),
5402            )]),
5403        };
5404    }
5405    if let Some(ref local_var_str) = description__n {
5406        local_var_req_builder = match "multi" {
5407            "multi" => local_var_req_builder.query(
5408                &local_var_str
5409                    .into_iter()
5410                    .map(|p| ("description__n".to_owned(), p.to_string()))
5411                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5412            ),
5413            _ => local_var_req_builder.query(&[(
5414                "description__n",
5415                &local_var_str
5416                    .into_iter()
5417                    .map(|p| p.to_string())
5418                    .collect::<Vec<String>>()
5419                    .join(",")
5420                    .to_string(),
5421            )]),
5422        };
5423    }
5424    if let Some(ref local_var_str) = description__nic {
5425        local_var_req_builder = match "multi" {
5426            "multi" => local_var_req_builder.query(
5427                &local_var_str
5428                    .into_iter()
5429                    .map(|p| ("description__nic".to_owned(), p.to_string()))
5430                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5431            ),
5432            _ => local_var_req_builder.query(&[(
5433                "description__nic",
5434                &local_var_str
5435                    .into_iter()
5436                    .map(|p| p.to_string())
5437                    .collect::<Vec<String>>()
5438                    .join(",")
5439                    .to_string(),
5440            )]),
5441        };
5442    }
5443    if let Some(ref local_var_str) = description__nie {
5444        local_var_req_builder = match "multi" {
5445            "multi" => local_var_req_builder.query(
5446                &local_var_str
5447                    .into_iter()
5448                    .map(|p| ("description__nie".to_owned(), p.to_string()))
5449                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5450            ),
5451            _ => local_var_req_builder.query(&[(
5452                "description__nie",
5453                &local_var_str
5454                    .into_iter()
5455                    .map(|p| p.to_string())
5456                    .collect::<Vec<String>>()
5457                    .join(",")
5458                    .to_string(),
5459            )]),
5460        };
5461    }
5462    if let Some(ref local_var_str) = description__niew {
5463        local_var_req_builder = match "multi" {
5464            "multi" => local_var_req_builder.query(
5465                &local_var_str
5466                    .into_iter()
5467                    .map(|p| ("description__niew".to_owned(), p.to_string()))
5468                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5469            ),
5470            _ => local_var_req_builder.query(&[(
5471                "description__niew",
5472                &local_var_str
5473                    .into_iter()
5474                    .map(|p| p.to_string())
5475                    .collect::<Vec<String>>()
5476                    .join(",")
5477                    .to_string(),
5478            )]),
5479        };
5480    }
5481    if let Some(ref local_var_str) = description__nisw {
5482        local_var_req_builder = match "multi" {
5483            "multi" => local_var_req_builder.query(
5484                &local_var_str
5485                    .into_iter()
5486                    .map(|p| ("description__nisw".to_owned(), p.to_string()))
5487                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5488            ),
5489            _ => local_var_req_builder.query(&[(
5490                "description__nisw",
5491                &local_var_str
5492                    .into_iter()
5493                    .map(|p| p.to_string())
5494                    .collect::<Vec<String>>()
5495                    .join(",")
5496                    .to_string(),
5497            )]),
5498        };
5499    }
5500    if let Some(ref local_var_str) = description__regex {
5501        local_var_req_builder = match "multi" {
5502            "multi" => local_var_req_builder.query(
5503                &local_var_str
5504                    .into_iter()
5505                    .map(|p| ("description__regex".to_owned(), p.to_string()))
5506                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5507            ),
5508            _ => local_var_req_builder.query(&[(
5509                "description__regex",
5510                &local_var_str
5511                    .into_iter()
5512                    .map(|p| p.to_string())
5513                    .collect::<Vec<String>>()
5514                    .join(",")
5515                    .to_string(),
5516            )]),
5517        };
5518    }
5519    if let Some(ref local_var_str) = id {
5520        local_var_req_builder = match "multi" {
5521            "multi" => local_var_req_builder.query(
5522                &local_var_str
5523                    .into_iter()
5524                    .map(|p| ("id".to_owned(), p.to_string()))
5525                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5526            ),
5527            _ => local_var_req_builder.query(&[(
5528                "id",
5529                &local_var_str
5530                    .into_iter()
5531                    .map(|p| p.to_string())
5532                    .collect::<Vec<String>>()
5533                    .join(",")
5534                    .to_string(),
5535            )]),
5536        };
5537    }
5538    if let Some(ref local_var_str) = id__empty {
5539        local_var_req_builder =
5540            local_var_req_builder.query(&[("id__empty", &local_var_str.to_string())]);
5541    }
5542    if let Some(ref local_var_str) = id__gt {
5543        local_var_req_builder = match "multi" {
5544            "multi" => local_var_req_builder.query(
5545                &local_var_str
5546                    .into_iter()
5547                    .map(|p| ("id__gt".to_owned(), p.to_string()))
5548                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5549            ),
5550            _ => local_var_req_builder.query(&[(
5551                "id__gt",
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) = id__gte {
5562        local_var_req_builder = match "multi" {
5563            "multi" => local_var_req_builder.query(
5564                &local_var_str
5565                    .into_iter()
5566                    .map(|p| ("id__gte".to_owned(), p.to_string()))
5567                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5568            ),
5569            _ => local_var_req_builder.query(&[(
5570                "id__gte",
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) = id__lt {
5581        local_var_req_builder = match "multi" {
5582            "multi" => local_var_req_builder.query(
5583                &local_var_str
5584                    .into_iter()
5585                    .map(|p| ("id__lt".to_owned(), p.to_string()))
5586                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5587            ),
5588            _ => local_var_req_builder.query(&[(
5589                "id__lt",
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) = id__lte {
5600        local_var_req_builder = match "multi" {
5601            "multi" => local_var_req_builder.query(
5602                &local_var_str
5603                    .into_iter()
5604                    .map(|p| ("id__lte".to_owned(), p.to_string()))
5605                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5606            ),
5607            _ => local_var_req_builder.query(&[(
5608                "id__lte",
5609                &local_var_str
5610                    .into_iter()
5611                    .map(|p| p.to_string())
5612                    .collect::<Vec<String>>()
5613                    .join(",")
5614                    .to_string(),
5615            )]),
5616        };
5617    }
5618    if let Some(ref local_var_str) = id__n {
5619        local_var_req_builder = match "multi" {
5620            "multi" => local_var_req_builder.query(
5621                &local_var_str
5622                    .into_iter()
5623                    .map(|p| ("id__n".to_owned(), p.to_string()))
5624                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5625            ),
5626            _ => local_var_req_builder.query(&[(
5627                "id__n",
5628                &local_var_str
5629                    .into_iter()
5630                    .map(|p| p.to_string())
5631                    .collect::<Vec<String>>()
5632                    .join(",")
5633                    .to_string(),
5634            )]),
5635        };
5636    }
5637    if let Some(ref local_var_str) = last_updated {
5638        local_var_req_builder = match "multi" {
5639            "multi" => local_var_req_builder.query(
5640                &local_var_str
5641                    .into_iter()
5642                    .map(|p| ("last_updated".to_owned(), p.to_string()))
5643                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5644            ),
5645            _ => local_var_req_builder.query(&[(
5646                "last_updated",
5647                &local_var_str
5648                    .into_iter()
5649                    .map(|p| p.to_string())
5650                    .collect::<Vec<String>>()
5651                    .join(",")
5652                    .to_string(),
5653            )]),
5654        };
5655    }
5656    if let Some(ref local_var_str) = last_updated__empty {
5657        local_var_req_builder = match "multi" {
5658            "multi" => local_var_req_builder.query(
5659                &local_var_str
5660                    .into_iter()
5661                    .map(|p| ("last_updated__empty".to_owned(), p.to_string()))
5662                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5663            ),
5664            _ => local_var_req_builder.query(&[(
5665                "last_updated__empty",
5666                &local_var_str
5667                    .into_iter()
5668                    .map(|p| p.to_string())
5669                    .collect::<Vec<String>>()
5670                    .join(",")
5671                    .to_string(),
5672            )]),
5673        };
5674    }
5675    if let Some(ref local_var_str) = last_updated__gt {
5676        local_var_req_builder = match "multi" {
5677            "multi" => local_var_req_builder.query(
5678                &local_var_str
5679                    .into_iter()
5680                    .map(|p| ("last_updated__gt".to_owned(), p.to_string()))
5681                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5682            ),
5683            _ => local_var_req_builder.query(&[(
5684                "last_updated__gt",
5685                &local_var_str
5686                    .into_iter()
5687                    .map(|p| p.to_string())
5688                    .collect::<Vec<String>>()
5689                    .join(",")
5690                    .to_string(),
5691            )]),
5692        };
5693    }
5694    if let Some(ref local_var_str) = last_updated__gte {
5695        local_var_req_builder = match "multi" {
5696            "multi" => local_var_req_builder.query(
5697                &local_var_str
5698                    .into_iter()
5699                    .map(|p| ("last_updated__gte".to_owned(), p.to_string()))
5700                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5701            ),
5702            _ => local_var_req_builder.query(&[(
5703                "last_updated__gte",
5704                &local_var_str
5705                    .into_iter()
5706                    .map(|p| p.to_string())
5707                    .collect::<Vec<String>>()
5708                    .join(",")
5709                    .to_string(),
5710            )]),
5711        };
5712    }
5713    if let Some(ref local_var_str) = last_updated__lt {
5714        local_var_req_builder = match "multi" {
5715            "multi" => local_var_req_builder.query(
5716                &local_var_str
5717                    .into_iter()
5718                    .map(|p| ("last_updated__lt".to_owned(), p.to_string()))
5719                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5720            ),
5721            _ => local_var_req_builder.query(&[(
5722                "last_updated__lt",
5723                &local_var_str
5724                    .into_iter()
5725                    .map(|p| p.to_string())
5726                    .collect::<Vec<String>>()
5727                    .join(",")
5728                    .to_string(),
5729            )]),
5730        };
5731    }
5732    if let Some(ref local_var_str) = last_updated__lte {
5733        local_var_req_builder = match "multi" {
5734            "multi" => local_var_req_builder.query(
5735                &local_var_str
5736                    .into_iter()
5737                    .map(|p| ("last_updated__lte".to_owned(), p.to_string()))
5738                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5739            ),
5740            _ => local_var_req_builder.query(&[(
5741                "last_updated__lte",
5742                &local_var_str
5743                    .into_iter()
5744                    .map(|p| p.to_string())
5745                    .collect::<Vec<String>>()
5746                    .join(",")
5747                    .to_string(),
5748            )]),
5749        };
5750    }
5751    if let Some(ref local_var_str) = last_updated__n {
5752        local_var_req_builder = match "multi" {
5753            "multi" => local_var_req_builder.query(
5754                &local_var_str
5755                    .into_iter()
5756                    .map(|p| ("last_updated__n".to_owned(), p.to_string()))
5757                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5758            ),
5759            _ => local_var_req_builder.query(&[(
5760                "last_updated__n",
5761                &local_var_str
5762                    .into_iter()
5763                    .map(|p| p.to_string())
5764                    .collect::<Vec<String>>()
5765                    .join(",")
5766                    .to_string(),
5767            )]),
5768        };
5769    }
5770    if let Some(ref local_var_str) = limit {
5771        local_var_req_builder =
5772            local_var_req_builder.query(&[("limit", &local_var_str.to_string())]);
5773    }
5774    if let Some(ref local_var_str) = location {
5775        local_var_req_builder = match "multi" {
5776            "multi" => local_var_req_builder.query(
5777                &local_var_str
5778                    .into_iter()
5779                    .map(|p| ("location".to_owned(), p.to_string()))
5780                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5781            ),
5782            _ => local_var_req_builder.query(&[(
5783                "location",
5784                &local_var_str
5785                    .into_iter()
5786                    .map(|p| p.to_string())
5787                    .collect::<Vec<String>>()
5788                    .join(",")
5789                    .to_string(),
5790            )]),
5791        };
5792    }
5793    if let Some(ref local_var_str) = location__n {
5794        local_var_req_builder = match "multi" {
5795            "multi" => local_var_req_builder.query(
5796                &local_var_str
5797                    .into_iter()
5798                    .map(|p| ("location__n".to_owned(), p.to_string()))
5799                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5800            ),
5801            _ => local_var_req_builder.query(&[(
5802                "location__n",
5803                &local_var_str
5804                    .into_iter()
5805                    .map(|p| p.to_string())
5806                    .collect::<Vec<String>>()
5807                    .join(",")
5808                    .to_string(),
5809            )]),
5810        };
5811    }
5812    if let Some(ref local_var_str) = location_id {
5813        local_var_req_builder = match "multi" {
5814            "multi" => local_var_req_builder.query(
5815                &local_var_str
5816                    .into_iter()
5817                    .map(|p| ("location_id".to_owned(), p.to_string()))
5818                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5819            ),
5820            _ => local_var_req_builder.query(&[(
5821                "location_id",
5822                &local_var_str
5823                    .into_iter()
5824                    .map(|p| p.to_string())
5825                    .collect::<Vec<String>>()
5826                    .join(",")
5827                    .to_string(),
5828            )]),
5829        };
5830    }
5831    if let Some(ref local_var_str) = location_id__n {
5832        local_var_req_builder = match "multi" {
5833            "multi" => local_var_req_builder.query(
5834                &local_var_str
5835                    .into_iter()
5836                    .map(|p| ("location_id__n".to_owned(), p.to_string()))
5837                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5838            ),
5839            _ => local_var_req_builder.query(&[(
5840                "location_id__n",
5841                &local_var_str
5842                    .into_iter()
5843                    .map(|p| p.to_string())
5844                    .collect::<Vec<String>>()
5845                    .join(",")
5846                    .to_string(),
5847            )]),
5848        };
5849    }
5850    if let Some(ref local_var_str) = mark_connected {
5851        local_var_req_builder =
5852            local_var_req_builder.query(&[("mark_connected", &local_var_str.to_string())]);
5853    }
5854    if let Some(ref local_var_str) = modified_by_request {
5855        local_var_req_builder =
5856            local_var_req_builder.query(&[("modified_by_request", &local_var_str.to_string())]);
5857    }
5858    if let Some(ref local_var_str) = occupied {
5859        local_var_req_builder =
5860            local_var_req_builder.query(&[("occupied", &local_var_str.to_string())]);
5861    }
5862    if let Some(ref local_var_str) = offset {
5863        local_var_req_builder =
5864            local_var_req_builder.query(&[("offset", &local_var_str.to_string())]);
5865    }
5866    if let Some(ref local_var_str) = ordering {
5867        local_var_req_builder =
5868            local_var_req_builder.query(&[("ordering", &local_var_str.to_string())]);
5869    }
5870    if let Some(ref local_var_str) = port_speed {
5871        local_var_req_builder = match "multi" {
5872            "multi" => local_var_req_builder.query(
5873                &local_var_str
5874                    .into_iter()
5875                    .map(|p| ("port_speed".to_owned(), p.to_string()))
5876                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5877            ),
5878            _ => local_var_req_builder.query(&[(
5879                "port_speed",
5880                &local_var_str
5881                    .into_iter()
5882                    .map(|p| p.to_string())
5883                    .collect::<Vec<String>>()
5884                    .join(",")
5885                    .to_string(),
5886            )]),
5887        };
5888    }
5889    if let Some(ref local_var_str) = port_speed__empty {
5890        local_var_req_builder =
5891            local_var_req_builder.query(&[("port_speed__empty", &local_var_str.to_string())]);
5892    }
5893    if let Some(ref local_var_str) = port_speed__gt {
5894        local_var_req_builder = match "multi" {
5895            "multi" => local_var_req_builder.query(
5896                &local_var_str
5897                    .into_iter()
5898                    .map(|p| ("port_speed__gt".to_owned(), p.to_string()))
5899                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5900            ),
5901            _ => local_var_req_builder.query(&[(
5902                "port_speed__gt",
5903                &local_var_str
5904                    .into_iter()
5905                    .map(|p| p.to_string())
5906                    .collect::<Vec<String>>()
5907                    .join(",")
5908                    .to_string(),
5909            )]),
5910        };
5911    }
5912    if let Some(ref local_var_str) = port_speed__gte {
5913        local_var_req_builder = match "multi" {
5914            "multi" => local_var_req_builder.query(
5915                &local_var_str
5916                    .into_iter()
5917                    .map(|p| ("port_speed__gte".to_owned(), p.to_string()))
5918                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5919            ),
5920            _ => local_var_req_builder.query(&[(
5921                "port_speed__gte",
5922                &local_var_str
5923                    .into_iter()
5924                    .map(|p| p.to_string())
5925                    .collect::<Vec<String>>()
5926                    .join(",")
5927                    .to_string(),
5928            )]),
5929        };
5930    }
5931    if let Some(ref local_var_str) = port_speed__lt {
5932        local_var_req_builder = match "multi" {
5933            "multi" => local_var_req_builder.query(
5934                &local_var_str
5935                    .into_iter()
5936                    .map(|p| ("port_speed__lt".to_owned(), p.to_string()))
5937                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5938            ),
5939            _ => local_var_req_builder.query(&[(
5940                "port_speed__lt",
5941                &local_var_str
5942                    .into_iter()
5943                    .map(|p| p.to_string())
5944                    .collect::<Vec<String>>()
5945                    .join(",")
5946                    .to_string(),
5947            )]),
5948        };
5949    }
5950    if let Some(ref local_var_str) = port_speed__lte {
5951        local_var_req_builder = match "multi" {
5952            "multi" => local_var_req_builder.query(
5953                &local_var_str
5954                    .into_iter()
5955                    .map(|p| ("port_speed__lte".to_owned(), p.to_string()))
5956                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5957            ),
5958            _ => local_var_req_builder.query(&[(
5959                "port_speed__lte",
5960                &local_var_str
5961                    .into_iter()
5962                    .map(|p| p.to_string())
5963                    .collect::<Vec<String>>()
5964                    .join(",")
5965                    .to_string(),
5966            )]),
5967        };
5968    }
5969    if let Some(ref local_var_str) = port_speed__n {
5970        local_var_req_builder = match "multi" {
5971            "multi" => local_var_req_builder.query(
5972                &local_var_str
5973                    .into_iter()
5974                    .map(|p| ("port_speed__n".to_owned(), p.to_string()))
5975                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5976            ),
5977            _ => local_var_req_builder.query(&[(
5978                "port_speed__n",
5979                &local_var_str
5980                    .into_iter()
5981                    .map(|p| p.to_string())
5982                    .collect::<Vec<String>>()
5983                    .join(",")
5984                    .to_string(),
5985            )]),
5986        };
5987    }
5988    if let Some(ref local_var_str) = pp_info {
5989        local_var_req_builder = match "multi" {
5990            "multi" => local_var_req_builder.query(
5991                &local_var_str
5992                    .into_iter()
5993                    .map(|p| ("pp_info".to_owned(), p.to_string()))
5994                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5995            ),
5996            _ => local_var_req_builder.query(&[(
5997                "pp_info",
5998                &local_var_str
5999                    .into_iter()
6000                    .map(|p| p.to_string())
6001                    .collect::<Vec<String>>()
6002                    .join(",")
6003                    .to_string(),
6004            )]),
6005        };
6006    }
6007    if let Some(ref local_var_str) = pp_info__empty {
6008        local_var_req_builder =
6009            local_var_req_builder.query(&[("pp_info__empty", &local_var_str.to_string())]);
6010    }
6011    if let Some(ref local_var_str) = pp_info__ic {
6012        local_var_req_builder = match "multi" {
6013            "multi" => local_var_req_builder.query(
6014                &local_var_str
6015                    .into_iter()
6016                    .map(|p| ("pp_info__ic".to_owned(), p.to_string()))
6017                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6018            ),
6019            _ => local_var_req_builder.query(&[(
6020                "pp_info__ic",
6021                &local_var_str
6022                    .into_iter()
6023                    .map(|p| p.to_string())
6024                    .collect::<Vec<String>>()
6025                    .join(",")
6026                    .to_string(),
6027            )]),
6028        };
6029    }
6030    if let Some(ref local_var_str) = pp_info__ie {
6031        local_var_req_builder = match "multi" {
6032            "multi" => local_var_req_builder.query(
6033                &local_var_str
6034                    .into_iter()
6035                    .map(|p| ("pp_info__ie".to_owned(), p.to_string()))
6036                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6037            ),
6038            _ => local_var_req_builder.query(&[(
6039                "pp_info__ie",
6040                &local_var_str
6041                    .into_iter()
6042                    .map(|p| p.to_string())
6043                    .collect::<Vec<String>>()
6044                    .join(",")
6045                    .to_string(),
6046            )]),
6047        };
6048    }
6049    if let Some(ref local_var_str) = pp_info__iew {
6050        local_var_req_builder = match "multi" {
6051            "multi" => local_var_req_builder.query(
6052                &local_var_str
6053                    .into_iter()
6054                    .map(|p| ("pp_info__iew".to_owned(), p.to_string()))
6055                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6056            ),
6057            _ => local_var_req_builder.query(&[(
6058                "pp_info__iew",
6059                &local_var_str
6060                    .into_iter()
6061                    .map(|p| p.to_string())
6062                    .collect::<Vec<String>>()
6063                    .join(",")
6064                    .to_string(),
6065            )]),
6066        };
6067    }
6068    if let Some(ref local_var_str) = pp_info__iregex {
6069        local_var_req_builder = match "multi" {
6070            "multi" => local_var_req_builder.query(
6071                &local_var_str
6072                    .into_iter()
6073                    .map(|p| ("pp_info__iregex".to_owned(), p.to_string()))
6074                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6075            ),
6076            _ => local_var_req_builder.query(&[(
6077                "pp_info__iregex",
6078                &local_var_str
6079                    .into_iter()
6080                    .map(|p| p.to_string())
6081                    .collect::<Vec<String>>()
6082                    .join(",")
6083                    .to_string(),
6084            )]),
6085        };
6086    }
6087    if let Some(ref local_var_str) = pp_info__isw {
6088        local_var_req_builder = match "multi" {
6089            "multi" => local_var_req_builder.query(
6090                &local_var_str
6091                    .into_iter()
6092                    .map(|p| ("pp_info__isw".to_owned(), p.to_string()))
6093                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6094            ),
6095            _ => local_var_req_builder.query(&[(
6096                "pp_info__isw",
6097                &local_var_str
6098                    .into_iter()
6099                    .map(|p| p.to_string())
6100                    .collect::<Vec<String>>()
6101                    .join(",")
6102                    .to_string(),
6103            )]),
6104        };
6105    }
6106    if let Some(ref local_var_str) = pp_info__n {
6107        local_var_req_builder = match "multi" {
6108            "multi" => local_var_req_builder.query(
6109                &local_var_str
6110                    .into_iter()
6111                    .map(|p| ("pp_info__n".to_owned(), p.to_string()))
6112                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6113            ),
6114            _ => local_var_req_builder.query(&[(
6115                "pp_info__n",
6116                &local_var_str
6117                    .into_iter()
6118                    .map(|p| p.to_string())
6119                    .collect::<Vec<String>>()
6120                    .join(",")
6121                    .to_string(),
6122            )]),
6123        };
6124    }
6125    if let Some(ref local_var_str) = pp_info__nic {
6126        local_var_req_builder = match "multi" {
6127            "multi" => local_var_req_builder.query(
6128                &local_var_str
6129                    .into_iter()
6130                    .map(|p| ("pp_info__nic".to_owned(), p.to_string()))
6131                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6132            ),
6133            _ => local_var_req_builder.query(&[(
6134                "pp_info__nic",
6135                &local_var_str
6136                    .into_iter()
6137                    .map(|p| p.to_string())
6138                    .collect::<Vec<String>>()
6139                    .join(",")
6140                    .to_string(),
6141            )]),
6142        };
6143    }
6144    if let Some(ref local_var_str) = pp_info__nie {
6145        local_var_req_builder = match "multi" {
6146            "multi" => local_var_req_builder.query(
6147                &local_var_str
6148                    .into_iter()
6149                    .map(|p| ("pp_info__nie".to_owned(), p.to_string()))
6150                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6151            ),
6152            _ => local_var_req_builder.query(&[(
6153                "pp_info__nie",
6154                &local_var_str
6155                    .into_iter()
6156                    .map(|p| p.to_string())
6157                    .collect::<Vec<String>>()
6158                    .join(",")
6159                    .to_string(),
6160            )]),
6161        };
6162    }
6163    if let Some(ref local_var_str) = pp_info__niew {
6164        local_var_req_builder = match "multi" {
6165            "multi" => local_var_req_builder.query(
6166                &local_var_str
6167                    .into_iter()
6168                    .map(|p| ("pp_info__niew".to_owned(), p.to_string()))
6169                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6170            ),
6171            _ => local_var_req_builder.query(&[(
6172                "pp_info__niew",
6173                &local_var_str
6174                    .into_iter()
6175                    .map(|p| p.to_string())
6176                    .collect::<Vec<String>>()
6177                    .join(",")
6178                    .to_string(),
6179            )]),
6180        };
6181    }
6182    if let Some(ref local_var_str) = pp_info__nisw {
6183        local_var_req_builder = match "multi" {
6184            "multi" => local_var_req_builder.query(
6185                &local_var_str
6186                    .into_iter()
6187                    .map(|p| ("pp_info__nisw".to_owned(), p.to_string()))
6188                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6189            ),
6190            _ => local_var_req_builder.query(&[(
6191                "pp_info__nisw",
6192                &local_var_str
6193                    .into_iter()
6194                    .map(|p| p.to_string())
6195                    .collect::<Vec<String>>()
6196                    .join(",")
6197                    .to_string(),
6198            )]),
6199        };
6200    }
6201    if let Some(ref local_var_str) = pp_info__regex {
6202        local_var_req_builder = match "multi" {
6203            "multi" => local_var_req_builder.query(
6204                &local_var_str
6205                    .into_iter()
6206                    .map(|p| ("pp_info__regex".to_owned(), p.to_string()))
6207                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6208            ),
6209            _ => local_var_req_builder.query(&[(
6210                "pp_info__regex",
6211                &local_var_str
6212                    .into_iter()
6213                    .map(|p| p.to_string())
6214                    .collect::<Vec<String>>()
6215                    .join(",")
6216                    .to_string(),
6217            )]),
6218        };
6219    }
6220    if let Some(ref local_var_str) = provider {
6221        local_var_req_builder = match "multi" {
6222            "multi" => local_var_req_builder.query(
6223                &local_var_str
6224                    .into_iter()
6225                    .map(|p| ("provider".to_owned(), p.to_string()))
6226                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6227            ),
6228            _ => local_var_req_builder.query(&[(
6229                "provider",
6230                &local_var_str
6231                    .into_iter()
6232                    .map(|p| p.to_string())
6233                    .collect::<Vec<String>>()
6234                    .join(",")
6235                    .to_string(),
6236            )]),
6237        };
6238    }
6239    if let Some(ref local_var_str) = provider__n {
6240        local_var_req_builder = match "multi" {
6241            "multi" => local_var_req_builder.query(
6242                &local_var_str
6243                    .into_iter()
6244                    .map(|p| ("provider__n".to_owned(), p.to_string()))
6245                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6246            ),
6247            _ => local_var_req_builder.query(&[(
6248                "provider__n",
6249                &local_var_str
6250                    .into_iter()
6251                    .map(|p| p.to_string())
6252                    .collect::<Vec<String>>()
6253                    .join(",")
6254                    .to_string(),
6255            )]),
6256        };
6257    }
6258    if let Some(ref local_var_str) = provider_id {
6259        local_var_req_builder = match "multi" {
6260            "multi" => local_var_req_builder.query(
6261                &local_var_str
6262                    .into_iter()
6263                    .map(|p| ("provider_id".to_owned(), p.to_string()))
6264                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6265            ),
6266            _ => local_var_req_builder.query(&[(
6267                "provider_id",
6268                &local_var_str
6269                    .into_iter()
6270                    .map(|p| p.to_string())
6271                    .collect::<Vec<String>>()
6272                    .join(",")
6273                    .to_string(),
6274            )]),
6275        };
6276    }
6277    if let Some(ref local_var_str) = provider_id__n {
6278        local_var_req_builder = match "multi" {
6279            "multi" => local_var_req_builder.query(
6280                &local_var_str
6281                    .into_iter()
6282                    .map(|p| ("provider_id__n".to_owned(), p.to_string()))
6283                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6284            ),
6285            _ => local_var_req_builder.query(&[(
6286                "provider_id__n",
6287                &local_var_str
6288                    .into_iter()
6289                    .map(|p| p.to_string())
6290                    .collect::<Vec<String>>()
6291                    .join(",")
6292                    .to_string(),
6293            )]),
6294        };
6295    }
6296    if let Some(ref local_var_str) = provider_network_id {
6297        local_var_req_builder = match "multi" {
6298            "multi" => local_var_req_builder.query(
6299                &local_var_str
6300                    .into_iter()
6301                    .map(|p| ("provider_network_id".to_owned(), p.to_string()))
6302                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6303            ),
6304            _ => local_var_req_builder.query(&[(
6305                "provider_network_id",
6306                &local_var_str
6307                    .into_iter()
6308                    .map(|p| p.to_string())
6309                    .collect::<Vec<String>>()
6310                    .join(",")
6311                    .to_string(),
6312            )]),
6313        };
6314    }
6315    if let Some(ref local_var_str) = provider_network_id__n {
6316        local_var_req_builder = match "multi" {
6317            "multi" => local_var_req_builder.query(
6318                &local_var_str
6319                    .into_iter()
6320                    .map(|p| ("provider_network_id__n".to_owned(), p.to_string()))
6321                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6322            ),
6323            _ => local_var_req_builder.query(&[(
6324                "provider_network_id__n",
6325                &local_var_str
6326                    .into_iter()
6327                    .map(|p| p.to_string())
6328                    .collect::<Vec<String>>()
6329                    .join(",")
6330                    .to_string(),
6331            )]),
6332        };
6333    }
6334    if let Some(ref local_var_str) = q {
6335        local_var_req_builder = local_var_req_builder.query(&[("q", &local_var_str.to_string())]);
6336    }
6337    if let Some(ref local_var_str) = region {
6338        local_var_req_builder = match "multi" {
6339            "multi" => local_var_req_builder.query(
6340                &local_var_str
6341                    .into_iter()
6342                    .map(|p| ("region".to_owned(), p.to_string()))
6343                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6344            ),
6345            _ => local_var_req_builder.query(&[(
6346                "region",
6347                &local_var_str
6348                    .into_iter()
6349                    .map(|p| p.to_string())
6350                    .collect::<Vec<String>>()
6351                    .join(",")
6352                    .to_string(),
6353            )]),
6354        };
6355    }
6356    if let Some(ref local_var_str) = region__n {
6357        local_var_req_builder = match "multi" {
6358            "multi" => local_var_req_builder.query(
6359                &local_var_str
6360                    .into_iter()
6361                    .map(|p| ("region__n".to_owned(), p.to_string()))
6362                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6363            ),
6364            _ => local_var_req_builder.query(&[(
6365                "region__n",
6366                &local_var_str
6367                    .into_iter()
6368                    .map(|p| p.to_string())
6369                    .collect::<Vec<String>>()
6370                    .join(",")
6371                    .to_string(),
6372            )]),
6373        };
6374    }
6375    if let Some(ref local_var_str) = region_id {
6376        local_var_req_builder = match "multi" {
6377            "multi" => local_var_req_builder.query(
6378                &local_var_str
6379                    .into_iter()
6380                    .map(|p| ("region_id".to_owned(), p.to_string()))
6381                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6382            ),
6383            _ => local_var_req_builder.query(&[(
6384                "region_id",
6385                &local_var_str
6386                    .into_iter()
6387                    .map(|p| p.to_string())
6388                    .collect::<Vec<String>>()
6389                    .join(",")
6390                    .to_string(),
6391            )]),
6392        };
6393    }
6394    if let Some(ref local_var_str) = region_id__n {
6395        local_var_req_builder = match "multi" {
6396            "multi" => local_var_req_builder.query(
6397                &local_var_str
6398                    .into_iter()
6399                    .map(|p| ("region_id__n".to_owned(), p.to_string()))
6400                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6401            ),
6402            _ => local_var_req_builder.query(&[(
6403                "region_id__n",
6404                &local_var_str
6405                    .into_iter()
6406                    .map(|p| p.to_string())
6407                    .collect::<Vec<String>>()
6408                    .join(",")
6409                    .to_string(),
6410            )]),
6411        };
6412    }
6413    if let Some(ref local_var_str) = site {
6414        local_var_req_builder = match "multi" {
6415            "multi" => local_var_req_builder.query(
6416                &local_var_str
6417                    .into_iter()
6418                    .map(|p| ("site".to_owned(), p.to_string()))
6419                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6420            ),
6421            _ => local_var_req_builder.query(&[(
6422                "site",
6423                &local_var_str
6424                    .into_iter()
6425                    .map(|p| p.to_string())
6426                    .collect::<Vec<String>>()
6427                    .join(",")
6428                    .to_string(),
6429            )]),
6430        };
6431    }
6432    if let Some(ref local_var_str) = site__n {
6433        local_var_req_builder = match "multi" {
6434            "multi" => local_var_req_builder.query(
6435                &local_var_str
6436                    .into_iter()
6437                    .map(|p| ("site__n".to_owned(), p.to_string()))
6438                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6439            ),
6440            _ => local_var_req_builder.query(&[(
6441                "site__n",
6442                &local_var_str
6443                    .into_iter()
6444                    .map(|p| p.to_string())
6445                    .collect::<Vec<String>>()
6446                    .join(",")
6447                    .to_string(),
6448            )]),
6449        };
6450    }
6451    if let Some(ref local_var_str) = site_group {
6452        local_var_req_builder = match "multi" {
6453            "multi" => local_var_req_builder.query(
6454                &local_var_str
6455                    .into_iter()
6456                    .map(|p| ("site_group".to_owned(), p.to_string()))
6457                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6458            ),
6459            _ => local_var_req_builder.query(&[(
6460                "site_group",
6461                &local_var_str
6462                    .into_iter()
6463                    .map(|p| p.to_string())
6464                    .collect::<Vec<String>>()
6465                    .join(",")
6466                    .to_string(),
6467            )]),
6468        };
6469    }
6470    if let Some(ref local_var_str) = site_group__n {
6471        local_var_req_builder = match "multi" {
6472            "multi" => local_var_req_builder.query(
6473                &local_var_str
6474                    .into_iter()
6475                    .map(|p| ("site_group__n".to_owned(), p.to_string()))
6476                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6477            ),
6478            _ => local_var_req_builder.query(&[(
6479                "site_group__n",
6480                &local_var_str
6481                    .into_iter()
6482                    .map(|p| p.to_string())
6483                    .collect::<Vec<String>>()
6484                    .join(",")
6485                    .to_string(),
6486            )]),
6487        };
6488    }
6489    if let Some(ref local_var_str) = site_group_id {
6490        local_var_req_builder = match "multi" {
6491            "multi" => local_var_req_builder.query(
6492                &local_var_str
6493                    .into_iter()
6494                    .map(|p| ("site_group_id".to_owned(), p.to_string()))
6495                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6496            ),
6497            _ => local_var_req_builder.query(&[(
6498                "site_group_id",
6499                &local_var_str
6500                    .into_iter()
6501                    .map(|p| p.to_string())
6502                    .collect::<Vec<String>>()
6503                    .join(",")
6504                    .to_string(),
6505            )]),
6506        };
6507    }
6508    if let Some(ref local_var_str) = site_group_id__n {
6509        local_var_req_builder = match "multi" {
6510            "multi" => local_var_req_builder.query(
6511                &local_var_str
6512                    .into_iter()
6513                    .map(|p| ("site_group_id__n".to_owned(), p.to_string()))
6514                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6515            ),
6516            _ => local_var_req_builder.query(&[(
6517                "site_group_id__n",
6518                &local_var_str
6519                    .into_iter()
6520                    .map(|p| p.to_string())
6521                    .collect::<Vec<String>>()
6522                    .join(",")
6523                    .to_string(),
6524            )]),
6525        };
6526    }
6527    if let Some(ref local_var_str) = site_id {
6528        local_var_req_builder = match "multi" {
6529            "multi" => local_var_req_builder.query(
6530                &local_var_str
6531                    .into_iter()
6532                    .map(|p| ("site_id".to_owned(), p.to_string()))
6533                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6534            ),
6535            _ => local_var_req_builder.query(&[(
6536                "site_id",
6537                &local_var_str
6538                    .into_iter()
6539                    .map(|p| p.to_string())
6540                    .collect::<Vec<String>>()
6541                    .join(",")
6542                    .to_string(),
6543            )]),
6544        };
6545    }
6546    if let Some(ref local_var_str) = site_id__n {
6547        local_var_req_builder = match "multi" {
6548            "multi" => local_var_req_builder.query(
6549                &local_var_str
6550                    .into_iter()
6551                    .map(|p| ("site_id__n".to_owned(), p.to_string()))
6552                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6553            ),
6554            _ => local_var_req_builder.query(&[(
6555                "site_id__n",
6556                &local_var_str
6557                    .into_iter()
6558                    .map(|p| p.to_string())
6559                    .collect::<Vec<String>>()
6560                    .join(",")
6561                    .to_string(),
6562            )]),
6563        };
6564    }
6565    if let Some(ref local_var_str) = tag {
6566        local_var_req_builder = match "multi" {
6567            "multi" => local_var_req_builder.query(
6568                &local_var_str
6569                    .into_iter()
6570                    .map(|p| ("tag".to_owned(), p.to_string()))
6571                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6572            ),
6573            _ => local_var_req_builder.query(&[(
6574                "tag",
6575                &local_var_str
6576                    .into_iter()
6577                    .map(|p| p.to_string())
6578                    .collect::<Vec<String>>()
6579                    .join(",")
6580                    .to_string(),
6581            )]),
6582        };
6583    }
6584    if let Some(ref local_var_str) = tag__n {
6585        local_var_req_builder = match "multi" {
6586            "multi" => local_var_req_builder.query(
6587                &local_var_str
6588                    .into_iter()
6589                    .map(|p| ("tag__n".to_owned(), p.to_string()))
6590                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6591            ),
6592            _ => local_var_req_builder.query(&[(
6593                "tag__n",
6594                &local_var_str
6595                    .into_iter()
6596                    .map(|p| p.to_string())
6597                    .collect::<Vec<String>>()
6598                    .join(",")
6599                    .to_string(),
6600            )]),
6601        };
6602    }
6603    if let Some(ref local_var_str) = tag_id {
6604        local_var_req_builder = match "multi" {
6605            "multi" => local_var_req_builder.query(
6606                &local_var_str
6607                    .into_iter()
6608                    .map(|p| ("tag_id".to_owned(), p.to_string()))
6609                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6610            ),
6611            _ => local_var_req_builder.query(&[(
6612                "tag_id",
6613                &local_var_str
6614                    .into_iter()
6615                    .map(|p| p.to_string())
6616                    .collect::<Vec<String>>()
6617                    .join(",")
6618                    .to_string(),
6619            )]),
6620        };
6621    }
6622    if let Some(ref local_var_str) = tag_id__n {
6623        local_var_req_builder = match "multi" {
6624            "multi" => local_var_req_builder.query(
6625                &local_var_str
6626                    .into_iter()
6627                    .map(|p| ("tag_id__n".to_owned(), p.to_string()))
6628                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6629            ),
6630            _ => local_var_req_builder.query(&[(
6631                "tag_id__n",
6632                &local_var_str
6633                    .into_iter()
6634                    .map(|p| p.to_string())
6635                    .collect::<Vec<String>>()
6636                    .join(",")
6637                    .to_string(),
6638            )]),
6639        };
6640    }
6641    if let Some(ref local_var_str) = term_side {
6642        local_var_req_builder =
6643            local_var_req_builder.query(&[("term_side", &local_var_str.to_string())]);
6644    }
6645    if let Some(ref local_var_str) = term_side__empty {
6646        local_var_req_builder =
6647            local_var_req_builder.query(&[("term_side__empty", &local_var_str.to_string())]);
6648    }
6649    if let Some(ref local_var_str) = term_side__ic {
6650        local_var_req_builder = match "multi" {
6651            "multi" => local_var_req_builder.query(
6652                &local_var_str
6653                    .into_iter()
6654                    .map(|p| ("term_side__ic".to_owned(), p.to_string()))
6655                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6656            ),
6657            _ => local_var_req_builder.query(&[(
6658                "term_side__ic",
6659                &local_var_str
6660                    .into_iter()
6661                    .map(|p| p.to_string())
6662                    .collect::<Vec<String>>()
6663                    .join(",")
6664                    .to_string(),
6665            )]),
6666        };
6667    }
6668    if let Some(ref local_var_str) = term_side__ie {
6669        local_var_req_builder = match "multi" {
6670            "multi" => local_var_req_builder.query(
6671                &local_var_str
6672                    .into_iter()
6673                    .map(|p| ("term_side__ie".to_owned(), p.to_string()))
6674                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6675            ),
6676            _ => local_var_req_builder.query(&[(
6677                "term_side__ie",
6678                &local_var_str
6679                    .into_iter()
6680                    .map(|p| p.to_string())
6681                    .collect::<Vec<String>>()
6682                    .join(",")
6683                    .to_string(),
6684            )]),
6685        };
6686    }
6687    if let Some(ref local_var_str) = term_side__iew {
6688        local_var_req_builder = match "multi" {
6689            "multi" => local_var_req_builder.query(
6690                &local_var_str
6691                    .into_iter()
6692                    .map(|p| ("term_side__iew".to_owned(), p.to_string()))
6693                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6694            ),
6695            _ => local_var_req_builder.query(&[(
6696                "term_side__iew",
6697                &local_var_str
6698                    .into_iter()
6699                    .map(|p| p.to_string())
6700                    .collect::<Vec<String>>()
6701                    .join(",")
6702                    .to_string(),
6703            )]),
6704        };
6705    }
6706    if let Some(ref local_var_str) = term_side__iregex {
6707        local_var_req_builder = match "multi" {
6708            "multi" => local_var_req_builder.query(
6709                &local_var_str
6710                    .into_iter()
6711                    .map(|p| ("term_side__iregex".to_owned(), p.to_string()))
6712                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6713            ),
6714            _ => local_var_req_builder.query(&[(
6715                "term_side__iregex",
6716                &local_var_str
6717                    .into_iter()
6718                    .map(|p| p.to_string())
6719                    .collect::<Vec<String>>()
6720                    .join(",")
6721                    .to_string(),
6722            )]),
6723        };
6724    }
6725    if let Some(ref local_var_str) = term_side__isw {
6726        local_var_req_builder = match "multi" {
6727            "multi" => local_var_req_builder.query(
6728                &local_var_str
6729                    .into_iter()
6730                    .map(|p| ("term_side__isw".to_owned(), p.to_string()))
6731                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6732            ),
6733            _ => local_var_req_builder.query(&[(
6734                "term_side__isw",
6735                &local_var_str
6736                    .into_iter()
6737                    .map(|p| p.to_string())
6738                    .collect::<Vec<String>>()
6739                    .join(",")
6740                    .to_string(),
6741            )]),
6742        };
6743    }
6744    if let Some(ref local_var_str) = term_side__n {
6745        local_var_req_builder =
6746            local_var_req_builder.query(&[("term_side__n", &local_var_str.to_string())]);
6747    }
6748    if let Some(ref local_var_str) = term_side__nic {
6749        local_var_req_builder = match "multi" {
6750            "multi" => local_var_req_builder.query(
6751                &local_var_str
6752                    .into_iter()
6753                    .map(|p| ("term_side__nic".to_owned(), p.to_string()))
6754                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6755            ),
6756            _ => local_var_req_builder.query(&[(
6757                "term_side__nic",
6758                &local_var_str
6759                    .into_iter()
6760                    .map(|p| p.to_string())
6761                    .collect::<Vec<String>>()
6762                    .join(",")
6763                    .to_string(),
6764            )]),
6765        };
6766    }
6767    if let Some(ref local_var_str) = term_side__nie {
6768        local_var_req_builder = match "multi" {
6769            "multi" => local_var_req_builder.query(
6770                &local_var_str
6771                    .into_iter()
6772                    .map(|p| ("term_side__nie".to_owned(), p.to_string()))
6773                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6774            ),
6775            _ => local_var_req_builder.query(&[(
6776                "term_side__nie",
6777                &local_var_str
6778                    .into_iter()
6779                    .map(|p| p.to_string())
6780                    .collect::<Vec<String>>()
6781                    .join(",")
6782                    .to_string(),
6783            )]),
6784        };
6785    }
6786    if let Some(ref local_var_str) = term_side__niew {
6787        local_var_req_builder = match "multi" {
6788            "multi" => local_var_req_builder.query(
6789                &local_var_str
6790                    .into_iter()
6791                    .map(|p| ("term_side__niew".to_owned(), p.to_string()))
6792                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6793            ),
6794            _ => local_var_req_builder.query(&[(
6795                "term_side__niew",
6796                &local_var_str
6797                    .into_iter()
6798                    .map(|p| p.to_string())
6799                    .collect::<Vec<String>>()
6800                    .join(",")
6801                    .to_string(),
6802            )]),
6803        };
6804    }
6805    if let Some(ref local_var_str) = term_side__nisw {
6806        local_var_req_builder = match "multi" {
6807            "multi" => local_var_req_builder.query(
6808                &local_var_str
6809                    .into_iter()
6810                    .map(|p| ("term_side__nisw".to_owned(), p.to_string()))
6811                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6812            ),
6813            _ => local_var_req_builder.query(&[(
6814                "term_side__nisw",
6815                &local_var_str
6816                    .into_iter()
6817                    .map(|p| p.to_string())
6818                    .collect::<Vec<String>>()
6819                    .join(",")
6820                    .to_string(),
6821            )]),
6822        };
6823    }
6824    if let Some(ref local_var_str) = term_side__regex {
6825        local_var_req_builder = match "multi" {
6826            "multi" => local_var_req_builder.query(
6827                &local_var_str
6828                    .into_iter()
6829                    .map(|p| ("term_side__regex".to_owned(), p.to_string()))
6830                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6831            ),
6832            _ => local_var_req_builder.query(&[(
6833                "term_side__regex",
6834                &local_var_str
6835                    .into_iter()
6836                    .map(|p| p.to_string())
6837                    .collect::<Vec<String>>()
6838                    .join(",")
6839                    .to_string(),
6840            )]),
6841        };
6842    }
6843    if let Some(ref local_var_str) = termination_id {
6844        local_var_req_builder = match "multi" {
6845            "multi" => local_var_req_builder.query(
6846                &local_var_str
6847                    .into_iter()
6848                    .map(|p| ("termination_id".to_owned(), p.to_string()))
6849                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6850            ),
6851            _ => local_var_req_builder.query(&[(
6852                "termination_id",
6853                &local_var_str
6854                    .into_iter()
6855                    .map(|p| p.to_string())
6856                    .collect::<Vec<String>>()
6857                    .join(",")
6858                    .to_string(),
6859            )]),
6860        };
6861    }
6862    if let Some(ref local_var_str) = termination_id__empty {
6863        local_var_req_builder =
6864            local_var_req_builder.query(&[("termination_id__empty", &local_var_str.to_string())]);
6865    }
6866    if let Some(ref local_var_str) = termination_id__gt {
6867        local_var_req_builder = match "multi" {
6868            "multi" => local_var_req_builder.query(
6869                &local_var_str
6870                    .into_iter()
6871                    .map(|p| ("termination_id__gt".to_owned(), p.to_string()))
6872                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6873            ),
6874            _ => local_var_req_builder.query(&[(
6875                "termination_id__gt",
6876                &local_var_str
6877                    .into_iter()
6878                    .map(|p| p.to_string())
6879                    .collect::<Vec<String>>()
6880                    .join(",")
6881                    .to_string(),
6882            )]),
6883        };
6884    }
6885    if let Some(ref local_var_str) = termination_id__gte {
6886        local_var_req_builder = match "multi" {
6887            "multi" => local_var_req_builder.query(
6888                &local_var_str
6889                    .into_iter()
6890                    .map(|p| ("termination_id__gte".to_owned(), p.to_string()))
6891                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6892            ),
6893            _ => local_var_req_builder.query(&[(
6894                "termination_id__gte",
6895                &local_var_str
6896                    .into_iter()
6897                    .map(|p| p.to_string())
6898                    .collect::<Vec<String>>()
6899                    .join(",")
6900                    .to_string(),
6901            )]),
6902        };
6903    }
6904    if let Some(ref local_var_str) = termination_id__lt {
6905        local_var_req_builder = match "multi" {
6906            "multi" => local_var_req_builder.query(
6907                &local_var_str
6908                    .into_iter()
6909                    .map(|p| ("termination_id__lt".to_owned(), p.to_string()))
6910                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6911            ),
6912            _ => local_var_req_builder.query(&[(
6913                "termination_id__lt",
6914                &local_var_str
6915                    .into_iter()
6916                    .map(|p| p.to_string())
6917                    .collect::<Vec<String>>()
6918                    .join(",")
6919                    .to_string(),
6920            )]),
6921        };
6922    }
6923    if let Some(ref local_var_str) = termination_id__lte {
6924        local_var_req_builder = match "multi" {
6925            "multi" => local_var_req_builder.query(
6926                &local_var_str
6927                    .into_iter()
6928                    .map(|p| ("termination_id__lte".to_owned(), p.to_string()))
6929                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6930            ),
6931            _ => local_var_req_builder.query(&[(
6932                "termination_id__lte",
6933                &local_var_str
6934                    .into_iter()
6935                    .map(|p| p.to_string())
6936                    .collect::<Vec<String>>()
6937                    .join(",")
6938                    .to_string(),
6939            )]),
6940        };
6941    }
6942    if let Some(ref local_var_str) = termination_id__n {
6943        local_var_req_builder = match "multi" {
6944            "multi" => local_var_req_builder.query(
6945                &local_var_str
6946                    .into_iter()
6947                    .map(|p| ("termination_id__n".to_owned(), p.to_string()))
6948                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6949            ),
6950            _ => local_var_req_builder.query(&[(
6951                "termination_id__n",
6952                &local_var_str
6953                    .into_iter()
6954                    .map(|p| p.to_string())
6955                    .collect::<Vec<String>>()
6956                    .join(",")
6957                    .to_string(),
6958            )]),
6959        };
6960    }
6961    if let Some(ref local_var_str) = termination_type {
6962        local_var_req_builder = match "multi" {
6963            "multi" => local_var_req_builder.query(
6964                &local_var_str
6965                    .into_iter()
6966                    .map(|p| ("termination_type".to_owned(), p.to_string()))
6967                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6968            ),
6969            _ => local_var_req_builder.query(&[(
6970                "termination_type",
6971                &local_var_str
6972                    .into_iter()
6973                    .map(|p| p.to_string())
6974                    .collect::<Vec<String>>()
6975                    .join(",")
6976                    .to_string(),
6977            )]),
6978        };
6979    }
6980    if let Some(ref local_var_str) = termination_type__n {
6981        local_var_req_builder = match "multi" {
6982            "multi" => local_var_req_builder.query(
6983                &local_var_str
6984                    .into_iter()
6985                    .map(|p| ("termination_type__n".to_owned(), p.to_string()))
6986                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6987            ),
6988            _ => local_var_req_builder.query(&[(
6989                "termination_type__n",
6990                &local_var_str
6991                    .into_iter()
6992                    .map(|p| p.to_string())
6993                    .collect::<Vec<String>>()
6994                    .join(",")
6995                    .to_string(),
6996            )]),
6997        };
6998    }
6999    if let Some(ref local_var_str) = updated_by_request {
7000        local_var_req_builder =
7001            local_var_req_builder.query(&[("updated_by_request", &local_var_str.to_string())]);
7002    }
7003    if let Some(ref local_var_str) = upstream_speed {
7004        local_var_req_builder = match "multi" {
7005            "multi" => local_var_req_builder.query(
7006                &local_var_str
7007                    .into_iter()
7008                    .map(|p| ("upstream_speed".to_owned(), p.to_string()))
7009                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7010            ),
7011            _ => local_var_req_builder.query(&[(
7012                "upstream_speed",
7013                &local_var_str
7014                    .into_iter()
7015                    .map(|p| p.to_string())
7016                    .collect::<Vec<String>>()
7017                    .join(",")
7018                    .to_string(),
7019            )]),
7020        };
7021    }
7022    if let Some(ref local_var_str) = upstream_speed__empty {
7023        local_var_req_builder =
7024            local_var_req_builder.query(&[("upstream_speed__empty", &local_var_str.to_string())]);
7025    }
7026    if let Some(ref local_var_str) = upstream_speed__gt {
7027        local_var_req_builder = match "multi" {
7028            "multi" => local_var_req_builder.query(
7029                &local_var_str
7030                    .into_iter()
7031                    .map(|p| ("upstream_speed__gt".to_owned(), p.to_string()))
7032                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7033            ),
7034            _ => local_var_req_builder.query(&[(
7035                "upstream_speed__gt",
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) = upstream_speed__gte {
7046        local_var_req_builder = match "multi" {
7047            "multi" => local_var_req_builder.query(
7048                &local_var_str
7049                    .into_iter()
7050                    .map(|p| ("upstream_speed__gte".to_owned(), p.to_string()))
7051                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7052            ),
7053            _ => local_var_req_builder.query(&[(
7054                "upstream_speed__gte",
7055                &local_var_str
7056                    .into_iter()
7057                    .map(|p| p.to_string())
7058                    .collect::<Vec<String>>()
7059                    .join(",")
7060                    .to_string(),
7061            )]),
7062        };
7063    }
7064    if let Some(ref local_var_str) = upstream_speed__lt {
7065        local_var_req_builder = match "multi" {
7066            "multi" => local_var_req_builder.query(
7067                &local_var_str
7068                    .into_iter()
7069                    .map(|p| ("upstream_speed__lt".to_owned(), p.to_string()))
7070                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7071            ),
7072            _ => local_var_req_builder.query(&[(
7073                "upstream_speed__lt",
7074                &local_var_str
7075                    .into_iter()
7076                    .map(|p| p.to_string())
7077                    .collect::<Vec<String>>()
7078                    .join(",")
7079                    .to_string(),
7080            )]),
7081        };
7082    }
7083    if let Some(ref local_var_str) = upstream_speed__lte {
7084        local_var_req_builder = match "multi" {
7085            "multi" => local_var_req_builder.query(
7086                &local_var_str
7087                    .into_iter()
7088                    .map(|p| ("upstream_speed__lte".to_owned(), p.to_string()))
7089                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7090            ),
7091            _ => local_var_req_builder.query(&[(
7092                "upstream_speed__lte",
7093                &local_var_str
7094                    .into_iter()
7095                    .map(|p| p.to_string())
7096                    .collect::<Vec<String>>()
7097                    .join(",")
7098                    .to_string(),
7099            )]),
7100        };
7101    }
7102    if let Some(ref local_var_str) = upstream_speed__n {
7103        local_var_req_builder = match "multi" {
7104            "multi" => local_var_req_builder.query(
7105                &local_var_str
7106                    .into_iter()
7107                    .map(|p| ("upstream_speed__n".to_owned(), p.to_string()))
7108                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7109            ),
7110            _ => local_var_req_builder.query(&[(
7111                "upstream_speed__n",
7112                &local_var_str
7113                    .into_iter()
7114                    .map(|p| p.to_string())
7115                    .collect::<Vec<String>>()
7116                    .join(",")
7117                    .to_string(),
7118            )]),
7119        };
7120    }
7121    if let Some(ref local_var_str) = xconnect_id {
7122        local_var_req_builder = match "multi" {
7123            "multi" => local_var_req_builder.query(
7124                &local_var_str
7125                    .into_iter()
7126                    .map(|p| ("xconnect_id".to_owned(), p.to_string()))
7127                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7128            ),
7129            _ => local_var_req_builder.query(&[(
7130                "xconnect_id",
7131                &local_var_str
7132                    .into_iter()
7133                    .map(|p| p.to_string())
7134                    .collect::<Vec<String>>()
7135                    .join(",")
7136                    .to_string(),
7137            )]),
7138        };
7139    }
7140    if let Some(ref local_var_str) = xconnect_id__empty {
7141        local_var_req_builder =
7142            local_var_req_builder.query(&[("xconnect_id__empty", &local_var_str.to_string())]);
7143    }
7144    if let Some(ref local_var_str) = xconnect_id__ic {
7145        local_var_req_builder = match "multi" {
7146            "multi" => local_var_req_builder.query(
7147                &local_var_str
7148                    .into_iter()
7149                    .map(|p| ("xconnect_id__ic".to_owned(), p.to_string()))
7150                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7151            ),
7152            _ => local_var_req_builder.query(&[(
7153                "xconnect_id__ic",
7154                &local_var_str
7155                    .into_iter()
7156                    .map(|p| p.to_string())
7157                    .collect::<Vec<String>>()
7158                    .join(",")
7159                    .to_string(),
7160            )]),
7161        };
7162    }
7163    if let Some(ref local_var_str) = xconnect_id__ie {
7164        local_var_req_builder = match "multi" {
7165            "multi" => local_var_req_builder.query(
7166                &local_var_str
7167                    .into_iter()
7168                    .map(|p| ("xconnect_id__ie".to_owned(), p.to_string()))
7169                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7170            ),
7171            _ => local_var_req_builder.query(&[(
7172                "xconnect_id__ie",
7173                &local_var_str
7174                    .into_iter()
7175                    .map(|p| p.to_string())
7176                    .collect::<Vec<String>>()
7177                    .join(",")
7178                    .to_string(),
7179            )]),
7180        };
7181    }
7182    if let Some(ref local_var_str) = xconnect_id__iew {
7183        local_var_req_builder = match "multi" {
7184            "multi" => local_var_req_builder.query(
7185                &local_var_str
7186                    .into_iter()
7187                    .map(|p| ("xconnect_id__iew".to_owned(), p.to_string()))
7188                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7189            ),
7190            _ => local_var_req_builder.query(&[(
7191                "xconnect_id__iew",
7192                &local_var_str
7193                    .into_iter()
7194                    .map(|p| p.to_string())
7195                    .collect::<Vec<String>>()
7196                    .join(",")
7197                    .to_string(),
7198            )]),
7199        };
7200    }
7201    if let Some(ref local_var_str) = xconnect_id__iregex {
7202        local_var_req_builder = match "multi" {
7203            "multi" => local_var_req_builder.query(
7204                &local_var_str
7205                    .into_iter()
7206                    .map(|p| ("xconnect_id__iregex".to_owned(), p.to_string()))
7207                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7208            ),
7209            _ => local_var_req_builder.query(&[(
7210                "xconnect_id__iregex",
7211                &local_var_str
7212                    .into_iter()
7213                    .map(|p| p.to_string())
7214                    .collect::<Vec<String>>()
7215                    .join(",")
7216                    .to_string(),
7217            )]),
7218        };
7219    }
7220    if let Some(ref local_var_str) = xconnect_id__isw {
7221        local_var_req_builder = match "multi" {
7222            "multi" => local_var_req_builder.query(
7223                &local_var_str
7224                    .into_iter()
7225                    .map(|p| ("xconnect_id__isw".to_owned(), p.to_string()))
7226                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7227            ),
7228            _ => local_var_req_builder.query(&[(
7229                "xconnect_id__isw",
7230                &local_var_str
7231                    .into_iter()
7232                    .map(|p| p.to_string())
7233                    .collect::<Vec<String>>()
7234                    .join(",")
7235                    .to_string(),
7236            )]),
7237        };
7238    }
7239    if let Some(ref local_var_str) = xconnect_id__n {
7240        local_var_req_builder = match "multi" {
7241            "multi" => local_var_req_builder.query(
7242                &local_var_str
7243                    .into_iter()
7244                    .map(|p| ("xconnect_id__n".to_owned(), p.to_string()))
7245                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7246            ),
7247            _ => local_var_req_builder.query(&[(
7248                "xconnect_id__n",
7249                &local_var_str
7250                    .into_iter()
7251                    .map(|p| p.to_string())
7252                    .collect::<Vec<String>>()
7253                    .join(",")
7254                    .to_string(),
7255            )]),
7256        };
7257    }
7258    if let Some(ref local_var_str) = xconnect_id__nic {
7259        local_var_req_builder = match "multi" {
7260            "multi" => local_var_req_builder.query(
7261                &local_var_str
7262                    .into_iter()
7263                    .map(|p| ("xconnect_id__nic".to_owned(), p.to_string()))
7264                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7265            ),
7266            _ => local_var_req_builder.query(&[(
7267                "xconnect_id__nic",
7268                &local_var_str
7269                    .into_iter()
7270                    .map(|p| p.to_string())
7271                    .collect::<Vec<String>>()
7272                    .join(",")
7273                    .to_string(),
7274            )]),
7275        };
7276    }
7277    if let Some(ref local_var_str) = xconnect_id__nie {
7278        local_var_req_builder = match "multi" {
7279            "multi" => local_var_req_builder.query(
7280                &local_var_str
7281                    .into_iter()
7282                    .map(|p| ("xconnect_id__nie".to_owned(), p.to_string()))
7283                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7284            ),
7285            _ => local_var_req_builder.query(&[(
7286                "xconnect_id__nie",
7287                &local_var_str
7288                    .into_iter()
7289                    .map(|p| p.to_string())
7290                    .collect::<Vec<String>>()
7291                    .join(",")
7292                    .to_string(),
7293            )]),
7294        };
7295    }
7296    if let Some(ref local_var_str) = xconnect_id__niew {
7297        local_var_req_builder = match "multi" {
7298            "multi" => local_var_req_builder.query(
7299                &local_var_str
7300                    .into_iter()
7301                    .map(|p| ("xconnect_id__niew".to_owned(), p.to_string()))
7302                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7303            ),
7304            _ => local_var_req_builder.query(&[(
7305                "xconnect_id__niew",
7306                &local_var_str
7307                    .into_iter()
7308                    .map(|p| p.to_string())
7309                    .collect::<Vec<String>>()
7310                    .join(",")
7311                    .to_string(),
7312            )]),
7313        };
7314    }
7315    if let Some(ref local_var_str) = xconnect_id__nisw {
7316        local_var_req_builder = match "multi" {
7317            "multi" => local_var_req_builder.query(
7318                &local_var_str
7319                    .into_iter()
7320                    .map(|p| ("xconnect_id__nisw".to_owned(), p.to_string()))
7321                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7322            ),
7323            _ => local_var_req_builder.query(&[(
7324                "xconnect_id__nisw",
7325                &local_var_str
7326                    .into_iter()
7327                    .map(|p| p.to_string())
7328                    .collect::<Vec<String>>()
7329                    .join(",")
7330                    .to_string(),
7331            )]),
7332        };
7333    }
7334    if let Some(ref local_var_str) = xconnect_id__regex {
7335        local_var_req_builder = match "multi" {
7336            "multi" => local_var_req_builder.query(
7337                &local_var_str
7338                    .into_iter()
7339                    .map(|p| ("xconnect_id__regex".to_owned(), p.to_string()))
7340                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7341            ),
7342            _ => local_var_req_builder.query(&[(
7343                "xconnect_id__regex",
7344                &local_var_str
7345                    .into_iter()
7346                    .map(|p| p.to_string())
7347                    .collect::<Vec<String>>()
7348                    .join(",")
7349                    .to_string(),
7350            )]),
7351        };
7352    }
7353    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
7354        local_var_req_builder =
7355            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
7356    }
7357    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
7358        let local_var_key = local_var_apikey.key.clone();
7359        let local_var_value = match local_var_apikey.prefix {
7360            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
7361            None => local_var_key,
7362        };
7363        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
7364    };
7365
7366    let local_var_req = local_var_req_builder.build()?;
7367    let local_var_resp = local_var_client.execute(local_var_req).await?;
7368
7369    let local_var_status = local_var_resp.status();
7370    let local_var_content = local_var_resp.text().await?;
7371
7372    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
7373        serde_json::from_str(&local_var_content).map_err(Error::from)
7374    } else {
7375        let local_var_entity: Option<CircuitsCircuitTerminationsListError> =
7376            serde_json::from_str(&local_var_content).ok();
7377        let local_var_error = ResponseContent {
7378            status: local_var_status,
7379            content: local_var_content,
7380            entity: local_var_entity,
7381        };
7382        Err(Error::ResponseError(local_var_error))
7383    }
7384}
7385
7386/// Patch a circuit termination object.
7387pub async fn circuits_circuit_terminations_partial_update(
7388    configuration: &configuration::Configuration,
7389    id: i32,
7390    patched_circuit_termination_request: Option<crate::models::PatchedCircuitTerminationRequest>,
7391) -> Result<crate::models::CircuitTermination, Error<CircuitsCircuitTerminationsPartialUpdateError>>
7392{
7393    let local_var_configuration = configuration;
7394
7395    let local_var_client = &local_var_configuration.client;
7396
7397    let local_var_uri_str = format!(
7398        "{}/api/circuits/circuit-terminations/{id}/",
7399        local_var_configuration.base_path,
7400        id = id
7401    );
7402    let mut local_var_req_builder =
7403        local_var_client.request(reqwest::Method::PATCH, local_var_uri_str.as_str());
7404
7405    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
7406        local_var_req_builder =
7407            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
7408    }
7409    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
7410        let local_var_key = local_var_apikey.key.clone();
7411        let local_var_value = match local_var_apikey.prefix {
7412            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
7413            None => local_var_key,
7414        };
7415        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
7416    };
7417    local_var_req_builder = local_var_req_builder.json(&patched_circuit_termination_request);
7418
7419    let local_var_req = local_var_req_builder.build()?;
7420    let local_var_resp = local_var_client.execute(local_var_req).await?;
7421
7422    let local_var_status = local_var_resp.status();
7423    let local_var_content = local_var_resp.text().await?;
7424
7425    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
7426        serde_json::from_str(&local_var_content).map_err(Error::from)
7427    } else {
7428        let local_var_entity: Option<CircuitsCircuitTerminationsPartialUpdateError> =
7429            serde_json::from_str(&local_var_content).ok();
7430        let local_var_error = ResponseContent {
7431            status: local_var_status,
7432            content: local_var_content,
7433            entity: local_var_entity,
7434        };
7435        Err(Error::ResponseError(local_var_error))
7436    }
7437}
7438
7439/// Return all CablePaths which traverse a given pass-through port.
7440pub async fn circuits_circuit_terminations_paths_retrieve(
7441    configuration: &configuration::Configuration,
7442    id: i32,
7443) -> Result<crate::models::CircuitTermination, Error<CircuitsCircuitTerminationsPathsRetrieveError>>
7444{
7445    let local_var_configuration = configuration;
7446
7447    let local_var_client = &local_var_configuration.client;
7448
7449    let local_var_uri_str = format!(
7450        "{}/api/circuits/circuit-terminations/{id}/paths/",
7451        local_var_configuration.base_path,
7452        id = id
7453    );
7454    let mut local_var_req_builder =
7455        local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
7456
7457    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
7458        local_var_req_builder =
7459            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
7460    }
7461    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
7462        let local_var_key = local_var_apikey.key.clone();
7463        let local_var_value = match local_var_apikey.prefix {
7464            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
7465            None => local_var_key,
7466        };
7467        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
7468    };
7469
7470    let local_var_req = local_var_req_builder.build()?;
7471    let local_var_resp = local_var_client.execute(local_var_req).await?;
7472
7473    let local_var_status = local_var_resp.status();
7474    let local_var_content = local_var_resp.text().await?;
7475
7476    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
7477        serde_json::from_str(&local_var_content).map_err(Error::from)
7478    } else {
7479        let local_var_entity: Option<CircuitsCircuitTerminationsPathsRetrieveError> =
7480            serde_json::from_str(&local_var_content).ok();
7481        let local_var_error = ResponseContent {
7482            status: local_var_status,
7483            content: local_var_content,
7484            entity: local_var_entity,
7485        };
7486        Err(Error::ResponseError(local_var_error))
7487    }
7488}
7489
7490/// Get a circuit termination object.
7491pub async fn circuits_circuit_terminations_retrieve(
7492    configuration: &configuration::Configuration,
7493    id: i32,
7494) -> Result<crate::models::CircuitTermination, Error<CircuitsCircuitTerminationsRetrieveError>> {
7495    let local_var_configuration = configuration;
7496
7497    let local_var_client = &local_var_configuration.client;
7498
7499    let local_var_uri_str = format!(
7500        "{}/api/circuits/circuit-terminations/{id}/",
7501        local_var_configuration.base_path,
7502        id = id
7503    );
7504    let mut local_var_req_builder =
7505        local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
7506
7507    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
7508        local_var_req_builder =
7509            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
7510    }
7511    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
7512        let local_var_key = local_var_apikey.key.clone();
7513        let local_var_value = match local_var_apikey.prefix {
7514            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
7515            None => local_var_key,
7516        };
7517        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
7518    };
7519
7520    let local_var_req = local_var_req_builder.build()?;
7521    let local_var_resp = local_var_client.execute(local_var_req).await?;
7522
7523    let local_var_status = local_var_resp.status();
7524    let local_var_content = local_var_resp.text().await?;
7525
7526    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
7527        serde_json::from_str(&local_var_content).map_err(Error::from)
7528    } else {
7529        let local_var_entity: Option<CircuitsCircuitTerminationsRetrieveError> =
7530            serde_json::from_str(&local_var_content).ok();
7531        let local_var_error = ResponseContent {
7532            status: local_var_status,
7533            content: local_var_content,
7534            entity: local_var_entity,
7535        };
7536        Err(Error::ResponseError(local_var_error))
7537    }
7538}
7539
7540/// Put a circuit termination object.
7541pub async fn circuits_circuit_terminations_update(
7542    configuration: &configuration::Configuration,
7543    id: i32,
7544    circuit_termination_request: crate::models::CircuitTerminationRequest,
7545) -> Result<crate::models::CircuitTermination, Error<CircuitsCircuitTerminationsUpdateError>> {
7546    let local_var_configuration = configuration;
7547
7548    let local_var_client = &local_var_configuration.client;
7549
7550    let local_var_uri_str = format!(
7551        "{}/api/circuits/circuit-terminations/{id}/",
7552        local_var_configuration.base_path,
7553        id = id
7554    );
7555    let mut local_var_req_builder =
7556        local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());
7557
7558    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
7559        local_var_req_builder =
7560            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
7561    }
7562    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
7563        let local_var_key = local_var_apikey.key.clone();
7564        let local_var_value = match local_var_apikey.prefix {
7565            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
7566            None => local_var_key,
7567        };
7568        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
7569    };
7570    local_var_req_builder = local_var_req_builder.json(&circuit_termination_request);
7571
7572    let local_var_req = local_var_req_builder.build()?;
7573    let local_var_resp = local_var_client.execute(local_var_req).await?;
7574
7575    let local_var_status = local_var_resp.status();
7576    let local_var_content = local_var_resp.text().await?;
7577
7578    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
7579        serde_json::from_str(&local_var_content).map_err(Error::from)
7580    } else {
7581        let local_var_entity: Option<CircuitsCircuitTerminationsUpdateError> =
7582            serde_json::from_str(&local_var_content).ok();
7583        let local_var_error = ResponseContent {
7584            status: local_var_status,
7585            content: local_var_content,
7586            entity: local_var_entity,
7587        };
7588        Err(Error::ResponseError(local_var_error))
7589    }
7590}
7591
7592/// Delete a list of circuit type objects.
7593pub async fn circuits_circuit_types_bulk_destroy(
7594    configuration: &configuration::Configuration,
7595    circuit_type_request: Vec<crate::models::CircuitTypeRequest>,
7596) -> Result<(), Error<CircuitsCircuitTypesBulkDestroyError>> {
7597    let local_var_configuration = configuration;
7598
7599    let local_var_client = &local_var_configuration.client;
7600
7601    let local_var_uri_str = format!(
7602        "{}/api/circuits/circuit-types/",
7603        local_var_configuration.base_path
7604    );
7605    let mut local_var_req_builder =
7606        local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());
7607
7608    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
7609        local_var_req_builder =
7610            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
7611    }
7612    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
7613        let local_var_key = local_var_apikey.key.clone();
7614        let local_var_value = match local_var_apikey.prefix {
7615            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
7616            None => local_var_key,
7617        };
7618        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
7619    };
7620    local_var_req_builder = local_var_req_builder.json(&circuit_type_request);
7621
7622    let local_var_req = local_var_req_builder.build()?;
7623    let local_var_resp = local_var_client.execute(local_var_req).await?;
7624
7625    let local_var_status = local_var_resp.status();
7626    let local_var_content = local_var_resp.text().await?;
7627
7628    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
7629        Ok(())
7630    } else {
7631        let local_var_entity: Option<CircuitsCircuitTypesBulkDestroyError> =
7632            serde_json::from_str(&local_var_content).ok();
7633        let local_var_error = ResponseContent {
7634            status: local_var_status,
7635            content: local_var_content,
7636            entity: local_var_entity,
7637        };
7638        Err(Error::ResponseError(local_var_error))
7639    }
7640}
7641
7642/// Patch a list of circuit type objects.
7643pub async fn circuits_circuit_types_bulk_partial_update(
7644    configuration: &configuration::Configuration,
7645    circuit_type_request: Vec<crate::models::CircuitTypeRequest>,
7646) -> Result<Vec<crate::models::CircuitType>, Error<CircuitsCircuitTypesBulkPartialUpdateError>> {
7647    let local_var_configuration = configuration;
7648
7649    let local_var_client = &local_var_configuration.client;
7650
7651    let local_var_uri_str = format!(
7652        "{}/api/circuits/circuit-types/",
7653        local_var_configuration.base_path
7654    );
7655    let mut local_var_req_builder =
7656        local_var_client.request(reqwest::Method::PATCH, local_var_uri_str.as_str());
7657
7658    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
7659        local_var_req_builder =
7660            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
7661    }
7662    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
7663        let local_var_key = local_var_apikey.key.clone();
7664        let local_var_value = match local_var_apikey.prefix {
7665            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
7666            None => local_var_key,
7667        };
7668        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
7669    };
7670    local_var_req_builder = local_var_req_builder.json(&circuit_type_request);
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<CircuitsCircuitTypesBulkPartialUpdateError> =
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/// Put a list of circuit type objects.
7693pub async fn circuits_circuit_types_bulk_update(
7694    configuration: &configuration::Configuration,
7695    circuit_type_request: Vec<crate::models::CircuitTypeRequest>,
7696) -> Result<Vec<crate::models::CircuitType>, Error<CircuitsCircuitTypesBulkUpdateError>> {
7697    let local_var_configuration = configuration;
7698
7699    let local_var_client = &local_var_configuration.client;
7700
7701    let local_var_uri_str = format!(
7702        "{}/api/circuits/circuit-types/",
7703        local_var_configuration.base_path
7704    );
7705    let mut local_var_req_builder =
7706        local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());
7707
7708    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
7709        local_var_req_builder =
7710            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
7711    }
7712    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
7713        let local_var_key = local_var_apikey.key.clone();
7714        let local_var_value = match local_var_apikey.prefix {
7715            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
7716            None => local_var_key,
7717        };
7718        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
7719    };
7720    local_var_req_builder = local_var_req_builder.json(&circuit_type_request);
7721
7722    let local_var_req = local_var_req_builder.build()?;
7723    let local_var_resp = local_var_client.execute(local_var_req).await?;
7724
7725    let local_var_status = local_var_resp.status();
7726    let local_var_content = local_var_resp.text().await?;
7727
7728    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
7729        serde_json::from_str(&local_var_content).map_err(Error::from)
7730    } else {
7731        let local_var_entity: Option<CircuitsCircuitTypesBulkUpdateError> =
7732            serde_json::from_str(&local_var_content).ok();
7733        let local_var_error = ResponseContent {
7734            status: local_var_status,
7735            content: local_var_content,
7736            entity: local_var_entity,
7737        };
7738        Err(Error::ResponseError(local_var_error))
7739    }
7740}
7741
7742/// Post a list of circuit type objects.
7743pub async fn circuits_circuit_types_create(
7744    configuration: &configuration::Configuration,
7745    circuits_circuit_types_create_request: crate::models::CircuitsCircuitTypesCreateRequest,
7746) -> Result<crate::models::CircuitType, Error<CircuitsCircuitTypesCreateError>> {
7747    let local_var_configuration = configuration;
7748
7749    let local_var_client = &local_var_configuration.client;
7750
7751    let local_var_uri_str = format!(
7752        "{}/api/circuits/circuit-types/",
7753        local_var_configuration.base_path
7754    );
7755    let mut local_var_req_builder =
7756        local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
7757
7758    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
7759        local_var_req_builder =
7760            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
7761    }
7762    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
7763        let local_var_key = local_var_apikey.key.clone();
7764        let local_var_value = match local_var_apikey.prefix {
7765            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
7766            None => local_var_key,
7767        };
7768        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
7769    };
7770    local_var_req_builder = local_var_req_builder.json(&circuits_circuit_types_create_request);
7771
7772    let local_var_req = local_var_req_builder.build()?;
7773    let local_var_resp = local_var_client.execute(local_var_req).await?;
7774
7775    let local_var_status = local_var_resp.status();
7776    let local_var_content = local_var_resp.text().await?;
7777
7778    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
7779        serde_json::from_str(&local_var_content).map_err(Error::from)
7780    } else {
7781        let local_var_entity: Option<CircuitsCircuitTypesCreateError> =
7782            serde_json::from_str(&local_var_content).ok();
7783        let local_var_error = ResponseContent {
7784            status: local_var_status,
7785            content: local_var_content,
7786            entity: local_var_entity,
7787        };
7788        Err(Error::ResponseError(local_var_error))
7789    }
7790}
7791
7792/// Delete a circuit type object.
7793pub async fn circuits_circuit_types_destroy(
7794    configuration: &configuration::Configuration,
7795    id: i32,
7796) -> Result<(), Error<CircuitsCircuitTypesDestroyError>> {
7797    let local_var_configuration = configuration;
7798
7799    let local_var_client = &local_var_configuration.client;
7800
7801    let local_var_uri_str = format!(
7802        "{}/api/circuits/circuit-types/{id}/",
7803        local_var_configuration.base_path,
7804        id = id
7805    );
7806    let mut local_var_req_builder =
7807        local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());
7808
7809    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
7810        local_var_req_builder =
7811            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
7812    }
7813    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
7814        let local_var_key = local_var_apikey.key.clone();
7815        let local_var_value = match local_var_apikey.prefix {
7816            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
7817            None => local_var_key,
7818        };
7819        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
7820    };
7821
7822    let local_var_req = local_var_req_builder.build()?;
7823    let local_var_resp = local_var_client.execute(local_var_req).await?;
7824
7825    let local_var_status = local_var_resp.status();
7826    let local_var_content = local_var_resp.text().await?;
7827
7828    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
7829        Ok(())
7830    } else {
7831        let local_var_entity: Option<CircuitsCircuitTypesDestroyError> =
7832            serde_json::from_str(&local_var_content).ok();
7833        let local_var_error = ResponseContent {
7834            status: local_var_status,
7835            content: local_var_content,
7836            entity: local_var_entity,
7837        };
7838        Err(Error::ResponseError(local_var_error))
7839    }
7840}
7841
7842/// Get a list of circuit type objects.
7843pub async fn circuits_circuit_types_list(
7844    configuration: &configuration::Configuration,
7845    color: Option<Vec<String>>,
7846    color__empty: Option<bool>,
7847    color__ic: Option<Vec<String>>,
7848    color__ie: Option<Vec<String>>,
7849    color__iew: Option<Vec<String>>,
7850    color__iregex: Option<Vec<String>>,
7851    color__isw: Option<Vec<String>>,
7852    color__n: Option<Vec<String>>,
7853    color__nic: Option<Vec<String>>,
7854    color__nie: Option<Vec<String>>,
7855    color__niew: Option<Vec<String>>,
7856    color__nisw: Option<Vec<String>>,
7857    color__regex: Option<Vec<String>>,
7858    created: Option<Vec<String>>,
7859    created__empty: Option<Vec<String>>,
7860    created__gt: Option<Vec<String>>,
7861    created__gte: Option<Vec<String>>,
7862    created__lt: Option<Vec<String>>,
7863    created__lte: Option<Vec<String>>,
7864    created__n: Option<Vec<String>>,
7865    created_by_request: Option<&str>,
7866    description: Option<Vec<String>>,
7867    description__empty: Option<bool>,
7868    description__ic: Option<Vec<String>>,
7869    description__ie: Option<Vec<String>>,
7870    description__iew: Option<Vec<String>>,
7871    description__iregex: Option<Vec<String>>,
7872    description__isw: Option<Vec<String>>,
7873    description__n: Option<Vec<String>>,
7874    description__nic: Option<Vec<String>>,
7875    description__nie: Option<Vec<String>>,
7876    description__niew: Option<Vec<String>>,
7877    description__nisw: Option<Vec<String>>,
7878    description__regex: Option<Vec<String>>,
7879    id: Option<Vec<i32>>,
7880    id__empty: Option<bool>,
7881    id__gt: Option<Vec<i32>>,
7882    id__gte: Option<Vec<i32>>,
7883    id__lt: Option<Vec<i32>>,
7884    id__lte: Option<Vec<i32>>,
7885    id__n: Option<Vec<i32>>,
7886    last_updated: Option<Vec<String>>,
7887    last_updated__empty: Option<Vec<String>>,
7888    last_updated__gt: Option<Vec<String>>,
7889    last_updated__gte: Option<Vec<String>>,
7890    last_updated__lt: Option<Vec<String>>,
7891    last_updated__lte: Option<Vec<String>>,
7892    last_updated__n: Option<Vec<String>>,
7893    limit: Option<i32>,
7894    modified_by_request: Option<&str>,
7895    name: Option<Vec<String>>,
7896    name__empty: Option<bool>,
7897    name__ic: Option<Vec<String>>,
7898    name__ie: Option<Vec<String>>,
7899    name__iew: Option<Vec<String>>,
7900    name__iregex: Option<Vec<String>>,
7901    name__isw: Option<Vec<String>>,
7902    name__n: Option<Vec<String>>,
7903    name__nic: Option<Vec<String>>,
7904    name__nie: Option<Vec<String>>,
7905    name__niew: Option<Vec<String>>,
7906    name__nisw: Option<Vec<String>>,
7907    name__regex: Option<Vec<String>>,
7908    offset: Option<i32>,
7909    ordering: Option<&str>,
7910    owner: Option<Vec<String>>,
7911    owner__n: Option<Vec<String>>,
7912    owner_group: Option<Vec<String>>,
7913    owner_group__n: Option<Vec<String>>,
7914    owner_group_id: Option<Vec<i32>>,
7915    owner_group_id__n: Option<Vec<i32>>,
7916    owner_id: Option<Vec<i32>>,
7917    owner_id__n: Option<Vec<i32>>,
7918    q: Option<&str>,
7919    slug: Option<Vec<String>>,
7920    slug__empty: Option<bool>,
7921    slug__ic: Option<Vec<String>>,
7922    slug__ie: Option<Vec<String>>,
7923    slug__iew: Option<Vec<String>>,
7924    slug__iregex: Option<Vec<String>>,
7925    slug__isw: Option<Vec<String>>,
7926    slug__n: Option<Vec<String>>,
7927    slug__nic: Option<Vec<String>>,
7928    slug__nie: Option<Vec<String>>,
7929    slug__niew: Option<Vec<String>>,
7930    slug__nisw: Option<Vec<String>>,
7931    slug__regex: Option<Vec<String>>,
7932    tag: Option<Vec<String>>,
7933    tag__n: Option<Vec<String>>,
7934    tag_id: Option<Vec<i32>>,
7935    tag_id__n: Option<Vec<i32>>,
7936    updated_by_request: Option<&str>,
7937) -> Result<crate::models::PaginatedCircuitTypeList, Error<CircuitsCircuitTypesListError>> {
7938    let local_var_configuration = configuration;
7939
7940    let local_var_client = &local_var_configuration.client;
7941
7942    let local_var_uri_str = format!(
7943        "{}/api/circuits/circuit-types/",
7944        local_var_configuration.base_path
7945    );
7946    let mut local_var_req_builder =
7947        local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
7948
7949    if let Some(ref local_var_str) = color {
7950        local_var_req_builder = match "multi" {
7951            "multi" => local_var_req_builder.query(
7952                &local_var_str
7953                    .into_iter()
7954                    .map(|p| ("color".to_owned(), p.to_string()))
7955                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7956            ),
7957            _ => local_var_req_builder.query(&[(
7958                "color",
7959                &local_var_str
7960                    .into_iter()
7961                    .map(|p| p.to_string())
7962                    .collect::<Vec<String>>()
7963                    .join(",")
7964                    .to_string(),
7965            )]),
7966        };
7967    }
7968    if let Some(ref local_var_str) = color__empty {
7969        local_var_req_builder =
7970            local_var_req_builder.query(&[("color__empty", &local_var_str.to_string())]);
7971    }
7972    if let Some(ref local_var_str) = color__ic {
7973        local_var_req_builder = match "multi" {
7974            "multi" => local_var_req_builder.query(
7975                &local_var_str
7976                    .into_iter()
7977                    .map(|p| ("color__ic".to_owned(), p.to_string()))
7978                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7979            ),
7980            _ => local_var_req_builder.query(&[(
7981                "color__ic",
7982                &local_var_str
7983                    .into_iter()
7984                    .map(|p| p.to_string())
7985                    .collect::<Vec<String>>()
7986                    .join(",")
7987                    .to_string(),
7988            )]),
7989        };
7990    }
7991    if let Some(ref local_var_str) = color__ie {
7992        local_var_req_builder = match "multi" {
7993            "multi" => local_var_req_builder.query(
7994                &local_var_str
7995                    .into_iter()
7996                    .map(|p| ("color__ie".to_owned(), p.to_string()))
7997                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7998            ),
7999            _ => local_var_req_builder.query(&[(
8000                "color__ie",
8001                &local_var_str
8002                    .into_iter()
8003                    .map(|p| p.to_string())
8004                    .collect::<Vec<String>>()
8005                    .join(",")
8006                    .to_string(),
8007            )]),
8008        };
8009    }
8010    if let Some(ref local_var_str) = color__iew {
8011        local_var_req_builder = match "multi" {
8012            "multi" => local_var_req_builder.query(
8013                &local_var_str
8014                    .into_iter()
8015                    .map(|p| ("color__iew".to_owned(), p.to_string()))
8016                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8017            ),
8018            _ => local_var_req_builder.query(&[(
8019                "color__iew",
8020                &local_var_str
8021                    .into_iter()
8022                    .map(|p| p.to_string())
8023                    .collect::<Vec<String>>()
8024                    .join(",")
8025                    .to_string(),
8026            )]),
8027        };
8028    }
8029    if let Some(ref local_var_str) = color__iregex {
8030        local_var_req_builder = match "multi" {
8031            "multi" => local_var_req_builder.query(
8032                &local_var_str
8033                    .into_iter()
8034                    .map(|p| ("color__iregex".to_owned(), p.to_string()))
8035                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8036            ),
8037            _ => local_var_req_builder.query(&[(
8038                "color__iregex",
8039                &local_var_str
8040                    .into_iter()
8041                    .map(|p| p.to_string())
8042                    .collect::<Vec<String>>()
8043                    .join(",")
8044                    .to_string(),
8045            )]),
8046        };
8047    }
8048    if let Some(ref local_var_str) = color__isw {
8049        local_var_req_builder = match "multi" {
8050            "multi" => local_var_req_builder.query(
8051                &local_var_str
8052                    .into_iter()
8053                    .map(|p| ("color__isw".to_owned(), p.to_string()))
8054                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8055            ),
8056            _ => local_var_req_builder.query(&[(
8057                "color__isw",
8058                &local_var_str
8059                    .into_iter()
8060                    .map(|p| p.to_string())
8061                    .collect::<Vec<String>>()
8062                    .join(",")
8063                    .to_string(),
8064            )]),
8065        };
8066    }
8067    if let Some(ref local_var_str) = color__n {
8068        local_var_req_builder = match "multi" {
8069            "multi" => local_var_req_builder.query(
8070                &local_var_str
8071                    .into_iter()
8072                    .map(|p| ("color__n".to_owned(), p.to_string()))
8073                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8074            ),
8075            _ => local_var_req_builder.query(&[(
8076                "color__n",
8077                &local_var_str
8078                    .into_iter()
8079                    .map(|p| p.to_string())
8080                    .collect::<Vec<String>>()
8081                    .join(",")
8082                    .to_string(),
8083            )]),
8084        };
8085    }
8086    if let Some(ref local_var_str) = color__nic {
8087        local_var_req_builder = match "multi" {
8088            "multi" => local_var_req_builder.query(
8089                &local_var_str
8090                    .into_iter()
8091                    .map(|p| ("color__nic".to_owned(), p.to_string()))
8092                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8093            ),
8094            _ => local_var_req_builder.query(&[(
8095                "color__nic",
8096                &local_var_str
8097                    .into_iter()
8098                    .map(|p| p.to_string())
8099                    .collect::<Vec<String>>()
8100                    .join(",")
8101                    .to_string(),
8102            )]),
8103        };
8104    }
8105    if let Some(ref local_var_str) = color__nie {
8106        local_var_req_builder = match "multi" {
8107            "multi" => local_var_req_builder.query(
8108                &local_var_str
8109                    .into_iter()
8110                    .map(|p| ("color__nie".to_owned(), p.to_string()))
8111                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8112            ),
8113            _ => local_var_req_builder.query(&[(
8114                "color__nie",
8115                &local_var_str
8116                    .into_iter()
8117                    .map(|p| p.to_string())
8118                    .collect::<Vec<String>>()
8119                    .join(",")
8120                    .to_string(),
8121            )]),
8122        };
8123    }
8124    if let Some(ref local_var_str) = color__niew {
8125        local_var_req_builder = match "multi" {
8126            "multi" => local_var_req_builder.query(
8127                &local_var_str
8128                    .into_iter()
8129                    .map(|p| ("color__niew".to_owned(), p.to_string()))
8130                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8131            ),
8132            _ => local_var_req_builder.query(&[(
8133                "color__niew",
8134                &local_var_str
8135                    .into_iter()
8136                    .map(|p| p.to_string())
8137                    .collect::<Vec<String>>()
8138                    .join(",")
8139                    .to_string(),
8140            )]),
8141        };
8142    }
8143    if let Some(ref local_var_str) = color__nisw {
8144        local_var_req_builder = match "multi" {
8145            "multi" => local_var_req_builder.query(
8146                &local_var_str
8147                    .into_iter()
8148                    .map(|p| ("color__nisw".to_owned(), p.to_string()))
8149                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8150            ),
8151            _ => local_var_req_builder.query(&[(
8152                "color__nisw",
8153                &local_var_str
8154                    .into_iter()
8155                    .map(|p| p.to_string())
8156                    .collect::<Vec<String>>()
8157                    .join(",")
8158                    .to_string(),
8159            )]),
8160        };
8161    }
8162    if let Some(ref local_var_str) = color__regex {
8163        local_var_req_builder = match "multi" {
8164            "multi" => local_var_req_builder.query(
8165                &local_var_str
8166                    .into_iter()
8167                    .map(|p| ("color__regex".to_owned(), p.to_string()))
8168                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8169            ),
8170            _ => local_var_req_builder.query(&[(
8171                "color__regex",
8172                &local_var_str
8173                    .into_iter()
8174                    .map(|p| p.to_string())
8175                    .collect::<Vec<String>>()
8176                    .join(",")
8177                    .to_string(),
8178            )]),
8179        };
8180    }
8181    if let Some(ref local_var_str) = created {
8182        local_var_req_builder = match "multi" {
8183            "multi" => local_var_req_builder.query(
8184                &local_var_str
8185                    .into_iter()
8186                    .map(|p| ("created".to_owned(), p.to_string()))
8187                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8188            ),
8189            _ => local_var_req_builder.query(&[(
8190                "created",
8191                &local_var_str
8192                    .into_iter()
8193                    .map(|p| p.to_string())
8194                    .collect::<Vec<String>>()
8195                    .join(",")
8196                    .to_string(),
8197            )]),
8198        };
8199    }
8200    if let Some(ref local_var_str) = created__empty {
8201        local_var_req_builder = match "multi" {
8202            "multi" => local_var_req_builder.query(
8203                &local_var_str
8204                    .into_iter()
8205                    .map(|p| ("created__empty".to_owned(), p.to_string()))
8206                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8207            ),
8208            _ => local_var_req_builder.query(&[(
8209                "created__empty",
8210                &local_var_str
8211                    .into_iter()
8212                    .map(|p| p.to_string())
8213                    .collect::<Vec<String>>()
8214                    .join(",")
8215                    .to_string(),
8216            )]),
8217        };
8218    }
8219    if let Some(ref local_var_str) = created__gt {
8220        local_var_req_builder = match "multi" {
8221            "multi" => local_var_req_builder.query(
8222                &local_var_str
8223                    .into_iter()
8224                    .map(|p| ("created__gt".to_owned(), p.to_string()))
8225                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8226            ),
8227            _ => local_var_req_builder.query(&[(
8228                "created__gt",
8229                &local_var_str
8230                    .into_iter()
8231                    .map(|p| p.to_string())
8232                    .collect::<Vec<String>>()
8233                    .join(",")
8234                    .to_string(),
8235            )]),
8236        };
8237    }
8238    if let Some(ref local_var_str) = created__gte {
8239        local_var_req_builder = match "multi" {
8240            "multi" => local_var_req_builder.query(
8241                &local_var_str
8242                    .into_iter()
8243                    .map(|p| ("created__gte".to_owned(), p.to_string()))
8244                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8245            ),
8246            _ => local_var_req_builder.query(&[(
8247                "created__gte",
8248                &local_var_str
8249                    .into_iter()
8250                    .map(|p| p.to_string())
8251                    .collect::<Vec<String>>()
8252                    .join(",")
8253                    .to_string(),
8254            )]),
8255        };
8256    }
8257    if let Some(ref local_var_str) = created__lt {
8258        local_var_req_builder = match "multi" {
8259            "multi" => local_var_req_builder.query(
8260                &local_var_str
8261                    .into_iter()
8262                    .map(|p| ("created__lt".to_owned(), p.to_string()))
8263                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8264            ),
8265            _ => local_var_req_builder.query(&[(
8266                "created__lt",
8267                &local_var_str
8268                    .into_iter()
8269                    .map(|p| p.to_string())
8270                    .collect::<Vec<String>>()
8271                    .join(",")
8272                    .to_string(),
8273            )]),
8274        };
8275    }
8276    if let Some(ref local_var_str) = created__lte {
8277        local_var_req_builder = match "multi" {
8278            "multi" => local_var_req_builder.query(
8279                &local_var_str
8280                    .into_iter()
8281                    .map(|p| ("created__lte".to_owned(), p.to_string()))
8282                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8283            ),
8284            _ => local_var_req_builder.query(&[(
8285                "created__lte",
8286                &local_var_str
8287                    .into_iter()
8288                    .map(|p| p.to_string())
8289                    .collect::<Vec<String>>()
8290                    .join(",")
8291                    .to_string(),
8292            )]),
8293        };
8294    }
8295    if let Some(ref local_var_str) = created__n {
8296        local_var_req_builder = match "multi" {
8297            "multi" => local_var_req_builder.query(
8298                &local_var_str
8299                    .into_iter()
8300                    .map(|p| ("created__n".to_owned(), p.to_string()))
8301                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8302            ),
8303            _ => local_var_req_builder.query(&[(
8304                "created__n",
8305                &local_var_str
8306                    .into_iter()
8307                    .map(|p| p.to_string())
8308                    .collect::<Vec<String>>()
8309                    .join(",")
8310                    .to_string(),
8311            )]),
8312        };
8313    }
8314    if let Some(ref local_var_str) = created_by_request {
8315        local_var_req_builder =
8316            local_var_req_builder.query(&[("created_by_request", &local_var_str.to_string())]);
8317    }
8318    if let Some(ref local_var_str) = description {
8319        local_var_req_builder = match "multi" {
8320            "multi" => local_var_req_builder.query(
8321                &local_var_str
8322                    .into_iter()
8323                    .map(|p| ("description".to_owned(), p.to_string()))
8324                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8325            ),
8326            _ => local_var_req_builder.query(&[(
8327                "description",
8328                &local_var_str
8329                    .into_iter()
8330                    .map(|p| p.to_string())
8331                    .collect::<Vec<String>>()
8332                    .join(",")
8333                    .to_string(),
8334            )]),
8335        };
8336    }
8337    if let Some(ref local_var_str) = description__empty {
8338        local_var_req_builder =
8339            local_var_req_builder.query(&[("description__empty", &local_var_str.to_string())]);
8340    }
8341    if let Some(ref local_var_str) = description__ic {
8342        local_var_req_builder = match "multi" {
8343            "multi" => local_var_req_builder.query(
8344                &local_var_str
8345                    .into_iter()
8346                    .map(|p| ("description__ic".to_owned(), p.to_string()))
8347                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8348            ),
8349            _ => local_var_req_builder.query(&[(
8350                "description__ic",
8351                &local_var_str
8352                    .into_iter()
8353                    .map(|p| p.to_string())
8354                    .collect::<Vec<String>>()
8355                    .join(",")
8356                    .to_string(),
8357            )]),
8358        };
8359    }
8360    if let Some(ref local_var_str) = description__ie {
8361        local_var_req_builder = match "multi" {
8362            "multi" => local_var_req_builder.query(
8363                &local_var_str
8364                    .into_iter()
8365                    .map(|p| ("description__ie".to_owned(), p.to_string()))
8366                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8367            ),
8368            _ => local_var_req_builder.query(&[(
8369                "description__ie",
8370                &local_var_str
8371                    .into_iter()
8372                    .map(|p| p.to_string())
8373                    .collect::<Vec<String>>()
8374                    .join(",")
8375                    .to_string(),
8376            )]),
8377        };
8378    }
8379    if let Some(ref local_var_str) = description__iew {
8380        local_var_req_builder = match "multi" {
8381            "multi" => local_var_req_builder.query(
8382                &local_var_str
8383                    .into_iter()
8384                    .map(|p| ("description__iew".to_owned(), p.to_string()))
8385                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8386            ),
8387            _ => local_var_req_builder.query(&[(
8388                "description__iew",
8389                &local_var_str
8390                    .into_iter()
8391                    .map(|p| p.to_string())
8392                    .collect::<Vec<String>>()
8393                    .join(",")
8394                    .to_string(),
8395            )]),
8396        };
8397    }
8398    if let Some(ref local_var_str) = description__iregex {
8399        local_var_req_builder = match "multi" {
8400            "multi" => local_var_req_builder.query(
8401                &local_var_str
8402                    .into_iter()
8403                    .map(|p| ("description__iregex".to_owned(), p.to_string()))
8404                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8405            ),
8406            _ => local_var_req_builder.query(&[(
8407                "description__iregex",
8408                &local_var_str
8409                    .into_iter()
8410                    .map(|p| p.to_string())
8411                    .collect::<Vec<String>>()
8412                    .join(",")
8413                    .to_string(),
8414            )]),
8415        };
8416    }
8417    if let Some(ref local_var_str) = description__isw {
8418        local_var_req_builder = match "multi" {
8419            "multi" => local_var_req_builder.query(
8420                &local_var_str
8421                    .into_iter()
8422                    .map(|p| ("description__isw".to_owned(), p.to_string()))
8423                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8424            ),
8425            _ => local_var_req_builder.query(&[(
8426                "description__isw",
8427                &local_var_str
8428                    .into_iter()
8429                    .map(|p| p.to_string())
8430                    .collect::<Vec<String>>()
8431                    .join(",")
8432                    .to_string(),
8433            )]),
8434        };
8435    }
8436    if let Some(ref local_var_str) = description__n {
8437        local_var_req_builder = match "multi" {
8438            "multi" => local_var_req_builder.query(
8439                &local_var_str
8440                    .into_iter()
8441                    .map(|p| ("description__n".to_owned(), p.to_string()))
8442                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8443            ),
8444            _ => local_var_req_builder.query(&[(
8445                "description__n",
8446                &local_var_str
8447                    .into_iter()
8448                    .map(|p| p.to_string())
8449                    .collect::<Vec<String>>()
8450                    .join(",")
8451                    .to_string(),
8452            )]),
8453        };
8454    }
8455    if let Some(ref local_var_str) = description__nic {
8456        local_var_req_builder = match "multi" {
8457            "multi" => local_var_req_builder.query(
8458                &local_var_str
8459                    .into_iter()
8460                    .map(|p| ("description__nic".to_owned(), p.to_string()))
8461                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8462            ),
8463            _ => local_var_req_builder.query(&[(
8464                "description__nic",
8465                &local_var_str
8466                    .into_iter()
8467                    .map(|p| p.to_string())
8468                    .collect::<Vec<String>>()
8469                    .join(",")
8470                    .to_string(),
8471            )]),
8472        };
8473    }
8474    if let Some(ref local_var_str) = description__nie {
8475        local_var_req_builder = match "multi" {
8476            "multi" => local_var_req_builder.query(
8477                &local_var_str
8478                    .into_iter()
8479                    .map(|p| ("description__nie".to_owned(), p.to_string()))
8480                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8481            ),
8482            _ => local_var_req_builder.query(&[(
8483                "description__nie",
8484                &local_var_str
8485                    .into_iter()
8486                    .map(|p| p.to_string())
8487                    .collect::<Vec<String>>()
8488                    .join(",")
8489                    .to_string(),
8490            )]),
8491        };
8492    }
8493    if let Some(ref local_var_str) = description__niew {
8494        local_var_req_builder = match "multi" {
8495            "multi" => local_var_req_builder.query(
8496                &local_var_str
8497                    .into_iter()
8498                    .map(|p| ("description__niew".to_owned(), p.to_string()))
8499                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8500            ),
8501            _ => local_var_req_builder.query(&[(
8502                "description__niew",
8503                &local_var_str
8504                    .into_iter()
8505                    .map(|p| p.to_string())
8506                    .collect::<Vec<String>>()
8507                    .join(",")
8508                    .to_string(),
8509            )]),
8510        };
8511    }
8512    if let Some(ref local_var_str) = description__nisw {
8513        local_var_req_builder = match "multi" {
8514            "multi" => local_var_req_builder.query(
8515                &local_var_str
8516                    .into_iter()
8517                    .map(|p| ("description__nisw".to_owned(), p.to_string()))
8518                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8519            ),
8520            _ => local_var_req_builder.query(&[(
8521                "description__nisw",
8522                &local_var_str
8523                    .into_iter()
8524                    .map(|p| p.to_string())
8525                    .collect::<Vec<String>>()
8526                    .join(",")
8527                    .to_string(),
8528            )]),
8529        };
8530    }
8531    if let Some(ref local_var_str) = description__regex {
8532        local_var_req_builder = match "multi" {
8533            "multi" => local_var_req_builder.query(
8534                &local_var_str
8535                    .into_iter()
8536                    .map(|p| ("description__regex".to_owned(), p.to_string()))
8537                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8538            ),
8539            _ => local_var_req_builder.query(&[(
8540                "description__regex",
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) = id {
8551        local_var_req_builder = match "multi" {
8552            "multi" => local_var_req_builder.query(
8553                &local_var_str
8554                    .into_iter()
8555                    .map(|p| ("id".to_owned(), p.to_string()))
8556                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8557            ),
8558            _ => local_var_req_builder.query(&[(
8559                "id",
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) = id__empty {
8570        local_var_req_builder =
8571            local_var_req_builder.query(&[("id__empty", &local_var_str.to_string())]);
8572    }
8573    if let Some(ref local_var_str) = id__gt {
8574        local_var_req_builder = match "multi" {
8575            "multi" => local_var_req_builder.query(
8576                &local_var_str
8577                    .into_iter()
8578                    .map(|p| ("id__gt".to_owned(), p.to_string()))
8579                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8580            ),
8581            _ => local_var_req_builder.query(&[(
8582                "id__gt",
8583                &local_var_str
8584                    .into_iter()
8585                    .map(|p| p.to_string())
8586                    .collect::<Vec<String>>()
8587                    .join(",")
8588                    .to_string(),
8589            )]),
8590        };
8591    }
8592    if let Some(ref local_var_str) = id__gte {
8593        local_var_req_builder = match "multi" {
8594            "multi" => local_var_req_builder.query(
8595                &local_var_str
8596                    .into_iter()
8597                    .map(|p| ("id__gte".to_owned(), p.to_string()))
8598                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8599            ),
8600            _ => local_var_req_builder.query(&[(
8601                "id__gte",
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) = id__lt {
8612        local_var_req_builder = match "multi" {
8613            "multi" => local_var_req_builder.query(
8614                &local_var_str
8615                    .into_iter()
8616                    .map(|p| ("id__lt".to_owned(), p.to_string()))
8617                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8618            ),
8619            _ => local_var_req_builder.query(&[(
8620                "id__lt",
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) = id__lte {
8631        local_var_req_builder = match "multi" {
8632            "multi" => local_var_req_builder.query(
8633                &local_var_str
8634                    .into_iter()
8635                    .map(|p| ("id__lte".to_owned(), p.to_string()))
8636                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8637            ),
8638            _ => local_var_req_builder.query(&[(
8639                "id__lte",
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) = id__n {
8650        local_var_req_builder = match "multi" {
8651            "multi" => local_var_req_builder.query(
8652                &local_var_str
8653                    .into_iter()
8654                    .map(|p| ("id__n".to_owned(), p.to_string()))
8655                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8656            ),
8657            _ => local_var_req_builder.query(&[(
8658                "id__n",
8659                &local_var_str
8660                    .into_iter()
8661                    .map(|p| p.to_string())
8662                    .collect::<Vec<String>>()
8663                    .join(",")
8664                    .to_string(),
8665            )]),
8666        };
8667    }
8668    if let Some(ref local_var_str) = last_updated {
8669        local_var_req_builder = match "multi" {
8670            "multi" => local_var_req_builder.query(
8671                &local_var_str
8672                    .into_iter()
8673                    .map(|p| ("last_updated".to_owned(), p.to_string()))
8674                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8675            ),
8676            _ => local_var_req_builder.query(&[(
8677                "last_updated",
8678                &local_var_str
8679                    .into_iter()
8680                    .map(|p| p.to_string())
8681                    .collect::<Vec<String>>()
8682                    .join(",")
8683                    .to_string(),
8684            )]),
8685        };
8686    }
8687    if let Some(ref local_var_str) = last_updated__empty {
8688        local_var_req_builder = match "multi" {
8689            "multi" => local_var_req_builder.query(
8690                &local_var_str
8691                    .into_iter()
8692                    .map(|p| ("last_updated__empty".to_owned(), p.to_string()))
8693                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8694            ),
8695            _ => local_var_req_builder.query(&[(
8696                "last_updated__empty",
8697                &local_var_str
8698                    .into_iter()
8699                    .map(|p| p.to_string())
8700                    .collect::<Vec<String>>()
8701                    .join(",")
8702                    .to_string(),
8703            )]),
8704        };
8705    }
8706    if let Some(ref local_var_str) = last_updated__gt {
8707        local_var_req_builder = match "multi" {
8708            "multi" => local_var_req_builder.query(
8709                &local_var_str
8710                    .into_iter()
8711                    .map(|p| ("last_updated__gt".to_owned(), p.to_string()))
8712                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8713            ),
8714            _ => local_var_req_builder.query(&[(
8715                "last_updated__gt",
8716                &local_var_str
8717                    .into_iter()
8718                    .map(|p| p.to_string())
8719                    .collect::<Vec<String>>()
8720                    .join(",")
8721                    .to_string(),
8722            )]),
8723        };
8724    }
8725    if let Some(ref local_var_str) = last_updated__gte {
8726        local_var_req_builder = match "multi" {
8727            "multi" => local_var_req_builder.query(
8728                &local_var_str
8729                    .into_iter()
8730                    .map(|p| ("last_updated__gte".to_owned(), p.to_string()))
8731                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8732            ),
8733            _ => local_var_req_builder.query(&[(
8734                "last_updated__gte",
8735                &local_var_str
8736                    .into_iter()
8737                    .map(|p| p.to_string())
8738                    .collect::<Vec<String>>()
8739                    .join(",")
8740                    .to_string(),
8741            )]),
8742        };
8743    }
8744    if let Some(ref local_var_str) = last_updated__lt {
8745        local_var_req_builder = match "multi" {
8746            "multi" => local_var_req_builder.query(
8747                &local_var_str
8748                    .into_iter()
8749                    .map(|p| ("last_updated__lt".to_owned(), p.to_string()))
8750                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8751            ),
8752            _ => local_var_req_builder.query(&[(
8753                "last_updated__lt",
8754                &local_var_str
8755                    .into_iter()
8756                    .map(|p| p.to_string())
8757                    .collect::<Vec<String>>()
8758                    .join(",")
8759                    .to_string(),
8760            )]),
8761        };
8762    }
8763    if let Some(ref local_var_str) = last_updated__lte {
8764        local_var_req_builder = match "multi" {
8765            "multi" => local_var_req_builder.query(
8766                &local_var_str
8767                    .into_iter()
8768                    .map(|p| ("last_updated__lte".to_owned(), p.to_string()))
8769                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8770            ),
8771            _ => local_var_req_builder.query(&[(
8772                "last_updated__lte",
8773                &local_var_str
8774                    .into_iter()
8775                    .map(|p| p.to_string())
8776                    .collect::<Vec<String>>()
8777                    .join(",")
8778                    .to_string(),
8779            )]),
8780        };
8781    }
8782    if let Some(ref local_var_str) = last_updated__n {
8783        local_var_req_builder = match "multi" {
8784            "multi" => local_var_req_builder.query(
8785                &local_var_str
8786                    .into_iter()
8787                    .map(|p| ("last_updated__n".to_owned(), p.to_string()))
8788                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8789            ),
8790            _ => local_var_req_builder.query(&[(
8791                "last_updated__n",
8792                &local_var_str
8793                    .into_iter()
8794                    .map(|p| p.to_string())
8795                    .collect::<Vec<String>>()
8796                    .join(",")
8797                    .to_string(),
8798            )]),
8799        };
8800    }
8801    if let Some(ref local_var_str) = limit {
8802        local_var_req_builder =
8803            local_var_req_builder.query(&[("limit", &local_var_str.to_string())]);
8804    }
8805    if let Some(ref local_var_str) = modified_by_request {
8806        local_var_req_builder =
8807            local_var_req_builder.query(&[("modified_by_request", &local_var_str.to_string())]);
8808    }
8809    if let Some(ref local_var_str) = name {
8810        local_var_req_builder = match "multi" {
8811            "multi" => local_var_req_builder.query(
8812                &local_var_str
8813                    .into_iter()
8814                    .map(|p| ("name".to_owned(), p.to_string()))
8815                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8816            ),
8817            _ => local_var_req_builder.query(&[(
8818                "name",
8819                &local_var_str
8820                    .into_iter()
8821                    .map(|p| p.to_string())
8822                    .collect::<Vec<String>>()
8823                    .join(",")
8824                    .to_string(),
8825            )]),
8826        };
8827    }
8828    if let Some(ref local_var_str) = name__empty {
8829        local_var_req_builder =
8830            local_var_req_builder.query(&[("name__empty", &local_var_str.to_string())]);
8831    }
8832    if let Some(ref local_var_str) = name__ic {
8833        local_var_req_builder = match "multi" {
8834            "multi" => local_var_req_builder.query(
8835                &local_var_str
8836                    .into_iter()
8837                    .map(|p| ("name__ic".to_owned(), p.to_string()))
8838                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8839            ),
8840            _ => local_var_req_builder.query(&[(
8841                "name__ic",
8842                &local_var_str
8843                    .into_iter()
8844                    .map(|p| p.to_string())
8845                    .collect::<Vec<String>>()
8846                    .join(",")
8847                    .to_string(),
8848            )]),
8849        };
8850    }
8851    if let Some(ref local_var_str) = name__ie {
8852        local_var_req_builder = match "multi" {
8853            "multi" => local_var_req_builder.query(
8854                &local_var_str
8855                    .into_iter()
8856                    .map(|p| ("name__ie".to_owned(), p.to_string()))
8857                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8858            ),
8859            _ => local_var_req_builder.query(&[(
8860                "name__ie",
8861                &local_var_str
8862                    .into_iter()
8863                    .map(|p| p.to_string())
8864                    .collect::<Vec<String>>()
8865                    .join(",")
8866                    .to_string(),
8867            )]),
8868        };
8869    }
8870    if let Some(ref local_var_str) = name__iew {
8871        local_var_req_builder = match "multi" {
8872            "multi" => local_var_req_builder.query(
8873                &local_var_str
8874                    .into_iter()
8875                    .map(|p| ("name__iew".to_owned(), p.to_string()))
8876                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8877            ),
8878            _ => local_var_req_builder.query(&[(
8879                "name__iew",
8880                &local_var_str
8881                    .into_iter()
8882                    .map(|p| p.to_string())
8883                    .collect::<Vec<String>>()
8884                    .join(",")
8885                    .to_string(),
8886            )]),
8887        };
8888    }
8889    if let Some(ref local_var_str) = name__iregex {
8890        local_var_req_builder = match "multi" {
8891            "multi" => local_var_req_builder.query(
8892                &local_var_str
8893                    .into_iter()
8894                    .map(|p| ("name__iregex".to_owned(), p.to_string()))
8895                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8896            ),
8897            _ => local_var_req_builder.query(&[(
8898                "name__iregex",
8899                &local_var_str
8900                    .into_iter()
8901                    .map(|p| p.to_string())
8902                    .collect::<Vec<String>>()
8903                    .join(",")
8904                    .to_string(),
8905            )]),
8906        };
8907    }
8908    if let Some(ref local_var_str) = name__isw {
8909        local_var_req_builder = match "multi" {
8910            "multi" => local_var_req_builder.query(
8911                &local_var_str
8912                    .into_iter()
8913                    .map(|p| ("name__isw".to_owned(), p.to_string()))
8914                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8915            ),
8916            _ => local_var_req_builder.query(&[(
8917                "name__isw",
8918                &local_var_str
8919                    .into_iter()
8920                    .map(|p| p.to_string())
8921                    .collect::<Vec<String>>()
8922                    .join(",")
8923                    .to_string(),
8924            )]),
8925        };
8926    }
8927    if let Some(ref local_var_str) = name__n {
8928        local_var_req_builder = match "multi" {
8929            "multi" => local_var_req_builder.query(
8930                &local_var_str
8931                    .into_iter()
8932                    .map(|p| ("name__n".to_owned(), p.to_string()))
8933                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8934            ),
8935            _ => local_var_req_builder.query(&[(
8936                "name__n",
8937                &local_var_str
8938                    .into_iter()
8939                    .map(|p| p.to_string())
8940                    .collect::<Vec<String>>()
8941                    .join(",")
8942                    .to_string(),
8943            )]),
8944        };
8945    }
8946    if let Some(ref local_var_str) = name__nic {
8947        local_var_req_builder = match "multi" {
8948            "multi" => local_var_req_builder.query(
8949                &local_var_str
8950                    .into_iter()
8951                    .map(|p| ("name__nic".to_owned(), p.to_string()))
8952                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8953            ),
8954            _ => local_var_req_builder.query(&[(
8955                "name__nic",
8956                &local_var_str
8957                    .into_iter()
8958                    .map(|p| p.to_string())
8959                    .collect::<Vec<String>>()
8960                    .join(",")
8961                    .to_string(),
8962            )]),
8963        };
8964    }
8965    if let Some(ref local_var_str) = name__nie {
8966        local_var_req_builder = match "multi" {
8967            "multi" => local_var_req_builder.query(
8968                &local_var_str
8969                    .into_iter()
8970                    .map(|p| ("name__nie".to_owned(), p.to_string()))
8971                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8972            ),
8973            _ => local_var_req_builder.query(&[(
8974                "name__nie",
8975                &local_var_str
8976                    .into_iter()
8977                    .map(|p| p.to_string())
8978                    .collect::<Vec<String>>()
8979                    .join(",")
8980                    .to_string(),
8981            )]),
8982        };
8983    }
8984    if let Some(ref local_var_str) = name__niew {
8985        local_var_req_builder = match "multi" {
8986            "multi" => local_var_req_builder.query(
8987                &local_var_str
8988                    .into_iter()
8989                    .map(|p| ("name__niew".to_owned(), p.to_string()))
8990                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8991            ),
8992            _ => local_var_req_builder.query(&[(
8993                "name__niew",
8994                &local_var_str
8995                    .into_iter()
8996                    .map(|p| p.to_string())
8997                    .collect::<Vec<String>>()
8998                    .join(",")
8999                    .to_string(),
9000            )]),
9001        };
9002    }
9003    if let Some(ref local_var_str) = name__nisw {
9004        local_var_req_builder = match "multi" {
9005            "multi" => local_var_req_builder.query(
9006                &local_var_str
9007                    .into_iter()
9008                    .map(|p| ("name__nisw".to_owned(), p.to_string()))
9009                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9010            ),
9011            _ => local_var_req_builder.query(&[(
9012                "name__nisw",
9013                &local_var_str
9014                    .into_iter()
9015                    .map(|p| p.to_string())
9016                    .collect::<Vec<String>>()
9017                    .join(",")
9018                    .to_string(),
9019            )]),
9020        };
9021    }
9022    if let Some(ref local_var_str) = name__regex {
9023        local_var_req_builder = match "multi" {
9024            "multi" => local_var_req_builder.query(
9025                &local_var_str
9026                    .into_iter()
9027                    .map(|p| ("name__regex".to_owned(), p.to_string()))
9028                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9029            ),
9030            _ => local_var_req_builder.query(&[(
9031                "name__regex",
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) = offset {
9042        local_var_req_builder =
9043            local_var_req_builder.query(&[("offset", &local_var_str.to_string())]);
9044    }
9045    if let Some(ref local_var_str) = ordering {
9046        local_var_req_builder =
9047            local_var_req_builder.query(&[("ordering", &local_var_str.to_string())]);
9048    }
9049    if let Some(ref local_var_str) = owner {
9050        local_var_req_builder = match "multi" {
9051            "multi" => local_var_req_builder.query(
9052                &local_var_str
9053                    .into_iter()
9054                    .map(|p| ("owner".to_owned(), p.to_string()))
9055                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9056            ),
9057            _ => local_var_req_builder.query(&[(
9058                "owner",
9059                &local_var_str
9060                    .into_iter()
9061                    .map(|p| p.to_string())
9062                    .collect::<Vec<String>>()
9063                    .join(",")
9064                    .to_string(),
9065            )]),
9066        };
9067    }
9068    if let Some(ref local_var_str) = owner__n {
9069        local_var_req_builder = match "multi" {
9070            "multi" => local_var_req_builder.query(
9071                &local_var_str
9072                    .into_iter()
9073                    .map(|p| ("owner__n".to_owned(), p.to_string()))
9074                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9075            ),
9076            _ => local_var_req_builder.query(&[(
9077                "owner__n",
9078                &local_var_str
9079                    .into_iter()
9080                    .map(|p| p.to_string())
9081                    .collect::<Vec<String>>()
9082                    .join(",")
9083                    .to_string(),
9084            )]),
9085        };
9086    }
9087    if let Some(ref local_var_str) = owner_group {
9088        local_var_req_builder = match "multi" {
9089            "multi" => local_var_req_builder.query(
9090                &local_var_str
9091                    .into_iter()
9092                    .map(|p| ("owner_group".to_owned(), p.to_string()))
9093                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9094            ),
9095            _ => local_var_req_builder.query(&[(
9096                "owner_group",
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) = owner_group__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| ("owner_group__n".to_owned(), p.to_string()))
9112                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9113            ),
9114            _ => local_var_req_builder.query(&[(
9115                "owner_group__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) = owner_group_id {
9126        local_var_req_builder = match "multi" {
9127            "multi" => local_var_req_builder.query(
9128                &local_var_str
9129                    .into_iter()
9130                    .map(|p| ("owner_group_id".to_owned(), p.to_string()))
9131                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9132            ),
9133            _ => local_var_req_builder.query(&[(
9134                "owner_group_id",
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) = owner_group_id__n {
9145        local_var_req_builder = match "multi" {
9146            "multi" => local_var_req_builder.query(
9147                &local_var_str
9148                    .into_iter()
9149                    .map(|p| ("owner_group_id__n".to_owned(), p.to_string()))
9150                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9151            ),
9152            _ => local_var_req_builder.query(&[(
9153                "owner_group_id__n",
9154                &local_var_str
9155                    .into_iter()
9156                    .map(|p| p.to_string())
9157                    .collect::<Vec<String>>()
9158                    .join(",")
9159                    .to_string(),
9160            )]),
9161        };
9162    }
9163    if let Some(ref local_var_str) = owner_id {
9164        local_var_req_builder = match "multi" {
9165            "multi" => local_var_req_builder.query(
9166                &local_var_str
9167                    .into_iter()
9168                    .map(|p| ("owner_id".to_owned(), p.to_string()))
9169                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9170            ),
9171            _ => local_var_req_builder.query(&[(
9172                "owner_id",
9173                &local_var_str
9174                    .into_iter()
9175                    .map(|p| p.to_string())
9176                    .collect::<Vec<String>>()
9177                    .join(",")
9178                    .to_string(),
9179            )]),
9180        };
9181    }
9182    if let Some(ref local_var_str) = owner_id__n {
9183        local_var_req_builder = match "multi" {
9184            "multi" => local_var_req_builder.query(
9185                &local_var_str
9186                    .into_iter()
9187                    .map(|p| ("owner_id__n".to_owned(), p.to_string()))
9188                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9189            ),
9190            _ => local_var_req_builder.query(&[(
9191                "owner_id__n",
9192                &local_var_str
9193                    .into_iter()
9194                    .map(|p| p.to_string())
9195                    .collect::<Vec<String>>()
9196                    .join(",")
9197                    .to_string(),
9198            )]),
9199        };
9200    }
9201    if let Some(ref local_var_str) = q {
9202        local_var_req_builder = local_var_req_builder.query(&[("q", &local_var_str.to_string())]);
9203    }
9204    if let Some(ref local_var_str) = slug {
9205        local_var_req_builder = match "multi" {
9206            "multi" => local_var_req_builder.query(
9207                &local_var_str
9208                    .into_iter()
9209                    .map(|p| ("slug".to_owned(), p.to_string()))
9210                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9211            ),
9212            _ => local_var_req_builder.query(&[(
9213                "slug",
9214                &local_var_str
9215                    .into_iter()
9216                    .map(|p| p.to_string())
9217                    .collect::<Vec<String>>()
9218                    .join(",")
9219                    .to_string(),
9220            )]),
9221        };
9222    }
9223    if let Some(ref local_var_str) = slug__empty {
9224        local_var_req_builder =
9225            local_var_req_builder.query(&[("slug__empty", &local_var_str.to_string())]);
9226    }
9227    if let Some(ref local_var_str) = slug__ic {
9228        local_var_req_builder = match "multi" {
9229            "multi" => local_var_req_builder.query(
9230                &local_var_str
9231                    .into_iter()
9232                    .map(|p| ("slug__ic".to_owned(), p.to_string()))
9233                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9234            ),
9235            _ => local_var_req_builder.query(&[(
9236                "slug__ic",
9237                &local_var_str
9238                    .into_iter()
9239                    .map(|p| p.to_string())
9240                    .collect::<Vec<String>>()
9241                    .join(",")
9242                    .to_string(),
9243            )]),
9244        };
9245    }
9246    if let Some(ref local_var_str) = slug__ie {
9247        local_var_req_builder = match "multi" {
9248            "multi" => local_var_req_builder.query(
9249                &local_var_str
9250                    .into_iter()
9251                    .map(|p| ("slug__ie".to_owned(), p.to_string()))
9252                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9253            ),
9254            _ => local_var_req_builder.query(&[(
9255                "slug__ie",
9256                &local_var_str
9257                    .into_iter()
9258                    .map(|p| p.to_string())
9259                    .collect::<Vec<String>>()
9260                    .join(",")
9261                    .to_string(),
9262            )]),
9263        };
9264    }
9265    if let Some(ref local_var_str) = slug__iew {
9266        local_var_req_builder = match "multi" {
9267            "multi" => local_var_req_builder.query(
9268                &local_var_str
9269                    .into_iter()
9270                    .map(|p| ("slug__iew".to_owned(), p.to_string()))
9271                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9272            ),
9273            _ => local_var_req_builder.query(&[(
9274                "slug__iew",
9275                &local_var_str
9276                    .into_iter()
9277                    .map(|p| p.to_string())
9278                    .collect::<Vec<String>>()
9279                    .join(",")
9280                    .to_string(),
9281            )]),
9282        };
9283    }
9284    if let Some(ref local_var_str) = slug__iregex {
9285        local_var_req_builder = match "multi" {
9286            "multi" => local_var_req_builder.query(
9287                &local_var_str
9288                    .into_iter()
9289                    .map(|p| ("slug__iregex".to_owned(), p.to_string()))
9290                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9291            ),
9292            _ => local_var_req_builder.query(&[(
9293                "slug__iregex",
9294                &local_var_str
9295                    .into_iter()
9296                    .map(|p| p.to_string())
9297                    .collect::<Vec<String>>()
9298                    .join(",")
9299                    .to_string(),
9300            )]),
9301        };
9302    }
9303    if let Some(ref local_var_str) = slug__isw {
9304        local_var_req_builder = match "multi" {
9305            "multi" => local_var_req_builder.query(
9306                &local_var_str
9307                    .into_iter()
9308                    .map(|p| ("slug__isw".to_owned(), p.to_string()))
9309                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9310            ),
9311            _ => local_var_req_builder.query(&[(
9312                "slug__isw",
9313                &local_var_str
9314                    .into_iter()
9315                    .map(|p| p.to_string())
9316                    .collect::<Vec<String>>()
9317                    .join(",")
9318                    .to_string(),
9319            )]),
9320        };
9321    }
9322    if let Some(ref local_var_str) = slug__n {
9323        local_var_req_builder = match "multi" {
9324            "multi" => local_var_req_builder.query(
9325                &local_var_str
9326                    .into_iter()
9327                    .map(|p| ("slug__n".to_owned(), p.to_string()))
9328                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9329            ),
9330            _ => local_var_req_builder.query(&[(
9331                "slug__n",
9332                &local_var_str
9333                    .into_iter()
9334                    .map(|p| p.to_string())
9335                    .collect::<Vec<String>>()
9336                    .join(",")
9337                    .to_string(),
9338            )]),
9339        };
9340    }
9341    if let Some(ref local_var_str) = slug__nic {
9342        local_var_req_builder = match "multi" {
9343            "multi" => local_var_req_builder.query(
9344                &local_var_str
9345                    .into_iter()
9346                    .map(|p| ("slug__nic".to_owned(), p.to_string()))
9347                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9348            ),
9349            _ => local_var_req_builder.query(&[(
9350                "slug__nic",
9351                &local_var_str
9352                    .into_iter()
9353                    .map(|p| p.to_string())
9354                    .collect::<Vec<String>>()
9355                    .join(",")
9356                    .to_string(),
9357            )]),
9358        };
9359    }
9360    if let Some(ref local_var_str) = slug__nie {
9361        local_var_req_builder = match "multi" {
9362            "multi" => local_var_req_builder.query(
9363                &local_var_str
9364                    .into_iter()
9365                    .map(|p| ("slug__nie".to_owned(), p.to_string()))
9366                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9367            ),
9368            _ => local_var_req_builder.query(&[(
9369                "slug__nie",
9370                &local_var_str
9371                    .into_iter()
9372                    .map(|p| p.to_string())
9373                    .collect::<Vec<String>>()
9374                    .join(",")
9375                    .to_string(),
9376            )]),
9377        };
9378    }
9379    if let Some(ref local_var_str) = slug__niew {
9380        local_var_req_builder = match "multi" {
9381            "multi" => local_var_req_builder.query(
9382                &local_var_str
9383                    .into_iter()
9384                    .map(|p| ("slug__niew".to_owned(), p.to_string()))
9385                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9386            ),
9387            _ => local_var_req_builder.query(&[(
9388                "slug__niew",
9389                &local_var_str
9390                    .into_iter()
9391                    .map(|p| p.to_string())
9392                    .collect::<Vec<String>>()
9393                    .join(",")
9394                    .to_string(),
9395            )]),
9396        };
9397    }
9398    if let Some(ref local_var_str) = slug__nisw {
9399        local_var_req_builder = match "multi" {
9400            "multi" => local_var_req_builder.query(
9401                &local_var_str
9402                    .into_iter()
9403                    .map(|p| ("slug__nisw".to_owned(), p.to_string()))
9404                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9405            ),
9406            _ => local_var_req_builder.query(&[(
9407                "slug__nisw",
9408                &local_var_str
9409                    .into_iter()
9410                    .map(|p| p.to_string())
9411                    .collect::<Vec<String>>()
9412                    .join(",")
9413                    .to_string(),
9414            )]),
9415        };
9416    }
9417    if let Some(ref local_var_str) = slug__regex {
9418        local_var_req_builder = match "multi" {
9419            "multi" => local_var_req_builder.query(
9420                &local_var_str
9421                    .into_iter()
9422                    .map(|p| ("slug__regex".to_owned(), p.to_string()))
9423                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9424            ),
9425            _ => local_var_req_builder.query(&[(
9426                "slug__regex",
9427                &local_var_str
9428                    .into_iter()
9429                    .map(|p| p.to_string())
9430                    .collect::<Vec<String>>()
9431                    .join(",")
9432                    .to_string(),
9433            )]),
9434        };
9435    }
9436    if let Some(ref local_var_str) = tag {
9437        local_var_req_builder = match "multi" {
9438            "multi" => local_var_req_builder.query(
9439                &local_var_str
9440                    .into_iter()
9441                    .map(|p| ("tag".to_owned(), p.to_string()))
9442                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9443            ),
9444            _ => local_var_req_builder.query(&[(
9445                "tag",
9446                &local_var_str
9447                    .into_iter()
9448                    .map(|p| p.to_string())
9449                    .collect::<Vec<String>>()
9450                    .join(",")
9451                    .to_string(),
9452            )]),
9453        };
9454    }
9455    if let Some(ref local_var_str) = tag__n {
9456        local_var_req_builder = match "multi" {
9457            "multi" => local_var_req_builder.query(
9458                &local_var_str
9459                    .into_iter()
9460                    .map(|p| ("tag__n".to_owned(), p.to_string()))
9461                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9462            ),
9463            _ => local_var_req_builder.query(&[(
9464                "tag__n",
9465                &local_var_str
9466                    .into_iter()
9467                    .map(|p| p.to_string())
9468                    .collect::<Vec<String>>()
9469                    .join(",")
9470                    .to_string(),
9471            )]),
9472        };
9473    }
9474    if let Some(ref local_var_str) = tag_id {
9475        local_var_req_builder = match "multi" {
9476            "multi" => local_var_req_builder.query(
9477                &local_var_str
9478                    .into_iter()
9479                    .map(|p| ("tag_id".to_owned(), p.to_string()))
9480                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9481            ),
9482            _ => local_var_req_builder.query(&[(
9483                "tag_id",
9484                &local_var_str
9485                    .into_iter()
9486                    .map(|p| p.to_string())
9487                    .collect::<Vec<String>>()
9488                    .join(",")
9489                    .to_string(),
9490            )]),
9491        };
9492    }
9493    if let Some(ref local_var_str) = tag_id__n {
9494        local_var_req_builder = match "multi" {
9495            "multi" => local_var_req_builder.query(
9496                &local_var_str
9497                    .into_iter()
9498                    .map(|p| ("tag_id__n".to_owned(), p.to_string()))
9499                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9500            ),
9501            _ => local_var_req_builder.query(&[(
9502                "tag_id__n",
9503                &local_var_str
9504                    .into_iter()
9505                    .map(|p| p.to_string())
9506                    .collect::<Vec<String>>()
9507                    .join(",")
9508                    .to_string(),
9509            )]),
9510        };
9511    }
9512    if let Some(ref local_var_str) = updated_by_request {
9513        local_var_req_builder =
9514            local_var_req_builder.query(&[("updated_by_request", &local_var_str.to_string())]);
9515    }
9516    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
9517        local_var_req_builder =
9518            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
9519    }
9520    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
9521        let local_var_key = local_var_apikey.key.clone();
9522        let local_var_value = match local_var_apikey.prefix {
9523            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
9524            None => local_var_key,
9525        };
9526        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
9527    };
9528
9529    let local_var_req = local_var_req_builder.build()?;
9530    let local_var_resp = local_var_client.execute(local_var_req).await?;
9531
9532    let local_var_status = local_var_resp.status();
9533    let local_var_content = local_var_resp.text().await?;
9534
9535    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
9536        serde_json::from_str(&local_var_content).map_err(Error::from)
9537    } else {
9538        let local_var_entity: Option<CircuitsCircuitTypesListError> =
9539            serde_json::from_str(&local_var_content).ok();
9540        let local_var_error = ResponseContent {
9541            status: local_var_status,
9542            content: local_var_content,
9543            entity: local_var_entity,
9544        };
9545        Err(Error::ResponseError(local_var_error))
9546    }
9547}
9548
9549/// Patch a circuit type object.
9550pub async fn circuits_circuit_types_partial_update(
9551    configuration: &configuration::Configuration,
9552    id: i32,
9553    patched_circuit_type_request: Option<crate::models::PatchedCircuitTypeRequest>,
9554) -> Result<crate::models::CircuitType, Error<CircuitsCircuitTypesPartialUpdateError>> {
9555    let local_var_configuration = configuration;
9556
9557    let local_var_client = &local_var_configuration.client;
9558
9559    let local_var_uri_str = format!(
9560        "{}/api/circuits/circuit-types/{id}/",
9561        local_var_configuration.base_path,
9562        id = id
9563    );
9564    let mut local_var_req_builder =
9565        local_var_client.request(reqwest::Method::PATCH, local_var_uri_str.as_str());
9566
9567    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
9568        local_var_req_builder =
9569            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
9570    }
9571    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
9572        let local_var_key = local_var_apikey.key.clone();
9573        let local_var_value = match local_var_apikey.prefix {
9574            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
9575            None => local_var_key,
9576        };
9577        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
9578    };
9579    local_var_req_builder = local_var_req_builder.json(&patched_circuit_type_request);
9580
9581    let local_var_req = local_var_req_builder.build()?;
9582    let local_var_resp = local_var_client.execute(local_var_req).await?;
9583
9584    let local_var_status = local_var_resp.status();
9585    let local_var_content = local_var_resp.text().await?;
9586
9587    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
9588        serde_json::from_str(&local_var_content).map_err(Error::from)
9589    } else {
9590        let local_var_entity: Option<CircuitsCircuitTypesPartialUpdateError> =
9591            serde_json::from_str(&local_var_content).ok();
9592        let local_var_error = ResponseContent {
9593            status: local_var_status,
9594            content: local_var_content,
9595            entity: local_var_entity,
9596        };
9597        Err(Error::ResponseError(local_var_error))
9598    }
9599}
9600
9601/// Get a circuit type object.
9602pub async fn circuits_circuit_types_retrieve(
9603    configuration: &configuration::Configuration,
9604    id: i32,
9605) -> Result<crate::models::CircuitType, Error<CircuitsCircuitTypesRetrieveError>> {
9606    let local_var_configuration = configuration;
9607
9608    let local_var_client = &local_var_configuration.client;
9609
9610    let local_var_uri_str = format!(
9611        "{}/api/circuits/circuit-types/{id}/",
9612        local_var_configuration.base_path,
9613        id = id
9614    );
9615    let mut local_var_req_builder =
9616        local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
9617
9618    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
9619        local_var_req_builder =
9620            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
9621    }
9622    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
9623        let local_var_key = local_var_apikey.key.clone();
9624        let local_var_value = match local_var_apikey.prefix {
9625            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
9626            None => local_var_key,
9627        };
9628        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
9629    };
9630
9631    let local_var_req = local_var_req_builder.build()?;
9632    let local_var_resp = local_var_client.execute(local_var_req).await?;
9633
9634    let local_var_status = local_var_resp.status();
9635    let local_var_content = local_var_resp.text().await?;
9636
9637    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
9638        serde_json::from_str(&local_var_content).map_err(Error::from)
9639    } else {
9640        let local_var_entity: Option<CircuitsCircuitTypesRetrieveError> =
9641            serde_json::from_str(&local_var_content).ok();
9642        let local_var_error = ResponseContent {
9643            status: local_var_status,
9644            content: local_var_content,
9645            entity: local_var_entity,
9646        };
9647        Err(Error::ResponseError(local_var_error))
9648    }
9649}
9650
9651/// Put a circuit type object.
9652pub async fn circuits_circuit_types_update(
9653    configuration: &configuration::Configuration,
9654    id: i32,
9655    circuit_type_request: crate::models::CircuitTypeRequest,
9656) -> Result<crate::models::CircuitType, Error<CircuitsCircuitTypesUpdateError>> {
9657    let local_var_configuration = configuration;
9658
9659    let local_var_client = &local_var_configuration.client;
9660
9661    let local_var_uri_str = format!(
9662        "{}/api/circuits/circuit-types/{id}/",
9663        local_var_configuration.base_path,
9664        id = id
9665    );
9666    let mut local_var_req_builder =
9667        local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());
9668
9669    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
9670        local_var_req_builder =
9671            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
9672    }
9673    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
9674        let local_var_key = local_var_apikey.key.clone();
9675        let local_var_value = match local_var_apikey.prefix {
9676            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
9677            None => local_var_key,
9678        };
9679        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
9680    };
9681    local_var_req_builder = local_var_req_builder.json(&circuit_type_request);
9682
9683    let local_var_req = local_var_req_builder.build()?;
9684    let local_var_resp = local_var_client.execute(local_var_req).await?;
9685
9686    let local_var_status = local_var_resp.status();
9687    let local_var_content = local_var_resp.text().await?;
9688
9689    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
9690        serde_json::from_str(&local_var_content).map_err(Error::from)
9691    } else {
9692        let local_var_entity: Option<CircuitsCircuitTypesUpdateError> =
9693            serde_json::from_str(&local_var_content).ok();
9694        let local_var_error = ResponseContent {
9695            status: local_var_status,
9696            content: local_var_content,
9697            entity: local_var_entity,
9698        };
9699        Err(Error::ResponseError(local_var_error))
9700    }
9701}
9702
9703/// Delete a list of circuit objects.
9704pub async fn circuits_circuits_bulk_destroy(
9705    configuration: &configuration::Configuration,
9706    circuit_request: Vec<crate::models::CircuitRequest>,
9707) -> Result<(), Error<CircuitsCircuitsBulkDestroyError>> {
9708    let local_var_configuration = configuration;
9709
9710    let local_var_client = &local_var_configuration.client;
9711
9712    let local_var_uri_str = format!(
9713        "{}/api/circuits/circuits/",
9714        local_var_configuration.base_path
9715    );
9716    let mut local_var_req_builder =
9717        local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());
9718
9719    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
9720        local_var_req_builder =
9721            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
9722    }
9723    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
9724        let local_var_key = local_var_apikey.key.clone();
9725        let local_var_value = match local_var_apikey.prefix {
9726            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
9727            None => local_var_key,
9728        };
9729        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
9730    };
9731    local_var_req_builder = local_var_req_builder.json(&circuit_request);
9732
9733    let local_var_req = local_var_req_builder.build()?;
9734    let local_var_resp = local_var_client.execute(local_var_req).await?;
9735
9736    let local_var_status = local_var_resp.status();
9737    let local_var_content = local_var_resp.text().await?;
9738
9739    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
9740        Ok(())
9741    } else {
9742        let local_var_entity: Option<CircuitsCircuitsBulkDestroyError> =
9743            serde_json::from_str(&local_var_content).ok();
9744        let local_var_error = ResponseContent {
9745            status: local_var_status,
9746            content: local_var_content,
9747            entity: local_var_entity,
9748        };
9749        Err(Error::ResponseError(local_var_error))
9750    }
9751}
9752
9753/// Patch a list of circuit objects.
9754pub async fn circuits_circuits_bulk_partial_update(
9755    configuration: &configuration::Configuration,
9756    circuit_request: Vec<crate::models::CircuitRequest>,
9757) -> Result<Vec<crate::models::Circuit>, Error<CircuitsCircuitsBulkPartialUpdateError>> {
9758    let local_var_configuration = configuration;
9759
9760    let local_var_client = &local_var_configuration.client;
9761
9762    let local_var_uri_str = format!(
9763        "{}/api/circuits/circuits/",
9764        local_var_configuration.base_path
9765    );
9766    let mut local_var_req_builder =
9767        local_var_client.request(reqwest::Method::PATCH, local_var_uri_str.as_str());
9768
9769    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
9770        local_var_req_builder =
9771            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
9772    }
9773    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
9774        let local_var_key = local_var_apikey.key.clone();
9775        let local_var_value = match local_var_apikey.prefix {
9776            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
9777            None => local_var_key,
9778        };
9779        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
9780    };
9781    local_var_req_builder = local_var_req_builder.json(&circuit_request);
9782
9783    let local_var_req = local_var_req_builder.build()?;
9784    let local_var_resp = local_var_client.execute(local_var_req).await?;
9785
9786    let local_var_status = local_var_resp.status();
9787    let local_var_content = local_var_resp.text().await?;
9788
9789    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
9790        serde_json::from_str(&local_var_content).map_err(Error::from)
9791    } else {
9792        let local_var_entity: Option<CircuitsCircuitsBulkPartialUpdateError> =
9793            serde_json::from_str(&local_var_content).ok();
9794        let local_var_error = ResponseContent {
9795            status: local_var_status,
9796            content: local_var_content,
9797            entity: local_var_entity,
9798        };
9799        Err(Error::ResponseError(local_var_error))
9800    }
9801}
9802
9803/// Put a list of circuit objects.
9804pub async fn circuits_circuits_bulk_update(
9805    configuration: &configuration::Configuration,
9806    circuit_request: Vec<crate::models::CircuitRequest>,
9807) -> Result<Vec<crate::models::Circuit>, Error<CircuitsCircuitsBulkUpdateError>> {
9808    let local_var_configuration = configuration;
9809
9810    let local_var_client = &local_var_configuration.client;
9811
9812    let local_var_uri_str = format!(
9813        "{}/api/circuits/circuits/",
9814        local_var_configuration.base_path
9815    );
9816    let mut local_var_req_builder =
9817        local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());
9818
9819    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
9820        local_var_req_builder =
9821            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
9822    }
9823    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
9824        let local_var_key = local_var_apikey.key.clone();
9825        let local_var_value = match local_var_apikey.prefix {
9826            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
9827            None => local_var_key,
9828        };
9829        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
9830    };
9831    local_var_req_builder = local_var_req_builder.json(&circuit_request);
9832
9833    let local_var_req = local_var_req_builder.build()?;
9834    let local_var_resp = local_var_client.execute(local_var_req).await?;
9835
9836    let local_var_status = local_var_resp.status();
9837    let local_var_content = local_var_resp.text().await?;
9838
9839    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
9840        serde_json::from_str(&local_var_content).map_err(Error::from)
9841    } else {
9842        let local_var_entity: Option<CircuitsCircuitsBulkUpdateError> =
9843            serde_json::from_str(&local_var_content).ok();
9844        let local_var_error = ResponseContent {
9845            status: local_var_status,
9846            content: local_var_content,
9847            entity: local_var_entity,
9848        };
9849        Err(Error::ResponseError(local_var_error))
9850    }
9851}
9852
9853/// Post a list of circuit objects.
9854pub async fn circuits_circuits_create(
9855    configuration: &configuration::Configuration,
9856    circuits_circuits_create_request: crate::models::CircuitsCircuitsCreateRequest,
9857) -> Result<crate::models::Circuit, Error<CircuitsCircuitsCreateError>> {
9858    let local_var_configuration = configuration;
9859
9860    let local_var_client = &local_var_configuration.client;
9861
9862    let local_var_uri_str = format!(
9863        "{}/api/circuits/circuits/",
9864        local_var_configuration.base_path
9865    );
9866    let mut local_var_req_builder =
9867        local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
9868
9869    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
9870        local_var_req_builder =
9871            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
9872    }
9873    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
9874        let local_var_key = local_var_apikey.key.clone();
9875        let local_var_value = match local_var_apikey.prefix {
9876            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
9877            None => local_var_key,
9878        };
9879        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
9880    };
9881    local_var_req_builder = local_var_req_builder.json(&circuits_circuits_create_request);
9882
9883    let local_var_req = local_var_req_builder.build()?;
9884    let local_var_resp = local_var_client.execute(local_var_req).await?;
9885
9886    let local_var_status = local_var_resp.status();
9887    let local_var_content = local_var_resp.text().await?;
9888
9889    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
9890        serde_json::from_str(&local_var_content).map_err(Error::from)
9891    } else {
9892        let local_var_entity: Option<CircuitsCircuitsCreateError> =
9893            serde_json::from_str(&local_var_content).ok();
9894        let local_var_error = ResponseContent {
9895            status: local_var_status,
9896            content: local_var_content,
9897            entity: local_var_entity,
9898        };
9899        Err(Error::ResponseError(local_var_error))
9900    }
9901}
9902
9903/// Delete a circuit object.
9904pub async fn circuits_circuits_destroy(
9905    configuration: &configuration::Configuration,
9906    id: i32,
9907) -> Result<(), Error<CircuitsCircuitsDestroyError>> {
9908    let local_var_configuration = configuration;
9909
9910    let local_var_client = &local_var_configuration.client;
9911
9912    let local_var_uri_str = format!(
9913        "{}/api/circuits/circuits/{id}/",
9914        local_var_configuration.base_path,
9915        id = id
9916    );
9917    let mut local_var_req_builder =
9918        local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());
9919
9920    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
9921        local_var_req_builder =
9922            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
9923    }
9924    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
9925        let local_var_key = local_var_apikey.key.clone();
9926        let local_var_value = match local_var_apikey.prefix {
9927            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
9928            None => local_var_key,
9929        };
9930        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
9931    };
9932
9933    let local_var_req = local_var_req_builder.build()?;
9934    let local_var_resp = local_var_client.execute(local_var_req).await?;
9935
9936    let local_var_status = local_var_resp.status();
9937    let local_var_content = local_var_resp.text().await?;
9938
9939    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
9940        Ok(())
9941    } else {
9942        let local_var_entity: Option<CircuitsCircuitsDestroyError> =
9943            serde_json::from_str(&local_var_content).ok();
9944        let local_var_error = ResponseContent {
9945            status: local_var_status,
9946            content: local_var_content,
9947            entity: local_var_entity,
9948        };
9949        Err(Error::ResponseError(local_var_error))
9950    }
9951}
9952
9953/// Get a list of circuit objects.
9954pub async fn circuits_circuits_list(
9955    configuration: &configuration::Configuration,
9956    cid: Option<Vec<String>>,
9957    cid__empty: Option<bool>,
9958    cid__ic: Option<Vec<String>>,
9959    cid__ie: Option<Vec<String>>,
9960    cid__iew: Option<Vec<String>>,
9961    cid__iregex: Option<Vec<String>>,
9962    cid__isw: Option<Vec<String>>,
9963    cid__n: Option<Vec<String>>,
9964    cid__nic: Option<Vec<String>>,
9965    cid__nie: Option<Vec<String>>,
9966    cid__niew: Option<Vec<String>>,
9967    cid__nisw: Option<Vec<String>>,
9968    cid__regex: Option<Vec<String>>,
9969    commit_rate: Option<Vec<i32>>,
9970    commit_rate__empty: Option<bool>,
9971    commit_rate__gt: Option<Vec<i32>>,
9972    commit_rate__gte: Option<Vec<i32>>,
9973    commit_rate__lt: Option<Vec<i32>>,
9974    commit_rate__lte: Option<Vec<i32>>,
9975    commit_rate__n: Option<Vec<i32>>,
9976    contact: Option<Vec<i32>>,
9977    contact__n: Option<Vec<i32>>,
9978    contact_group: Option<Vec<String>>,
9979    contact_group__n: Option<Vec<String>>,
9980    contact_role: Option<Vec<i32>>,
9981    contact_role__n: Option<Vec<i32>>,
9982    created: Option<Vec<String>>,
9983    created__empty: Option<Vec<String>>,
9984    created__gt: Option<Vec<String>>,
9985    created__gte: Option<Vec<String>>,
9986    created__lt: Option<Vec<String>>,
9987    created__lte: Option<Vec<String>>,
9988    created__n: Option<Vec<String>>,
9989    created_by_request: Option<&str>,
9990    description: Option<Vec<String>>,
9991    description__empty: Option<bool>,
9992    description__ic: Option<Vec<String>>,
9993    description__ie: Option<Vec<String>>,
9994    description__iew: Option<Vec<String>>,
9995    description__iregex: Option<Vec<String>>,
9996    description__isw: Option<Vec<String>>,
9997    description__n: Option<Vec<String>>,
9998    description__nic: Option<Vec<String>>,
9999    description__nie: Option<Vec<String>>,
10000    description__niew: Option<Vec<String>>,
10001    description__nisw: Option<Vec<String>>,
10002    description__regex: Option<Vec<String>>,
10003    distance: Option<Vec<f64>>,
10004    distance__empty: Option<bool>,
10005    distance__gt: Option<Vec<f64>>,
10006    distance__gte: Option<Vec<f64>>,
10007    distance__lt: Option<Vec<f64>>,
10008    distance__lte: Option<Vec<f64>>,
10009    distance__n: Option<Vec<f64>>,
10010    distance_unit: Option<&str>,
10011    distance_unit__empty: Option<bool>,
10012    distance_unit__ic: Option<Vec<String>>,
10013    distance_unit__ie: Option<Vec<String>>,
10014    distance_unit__iew: Option<Vec<String>>,
10015    distance_unit__iregex: Option<Vec<String>>,
10016    distance_unit__isw: Option<Vec<String>>,
10017    distance_unit__n: Option<&str>,
10018    distance_unit__nic: Option<Vec<String>>,
10019    distance_unit__nie: Option<Vec<String>>,
10020    distance_unit__niew: Option<Vec<String>>,
10021    distance_unit__nisw: Option<Vec<String>>,
10022    distance_unit__regex: Option<Vec<String>>,
10023    id: Option<Vec<i32>>,
10024    id__empty: Option<bool>,
10025    id__gt: Option<Vec<i32>>,
10026    id__gte: Option<Vec<i32>>,
10027    id__lt: Option<Vec<i32>>,
10028    id__lte: Option<Vec<i32>>,
10029    id__n: Option<Vec<i32>>,
10030    install_date: Option<Vec<String>>,
10031    install_date__empty: Option<bool>,
10032    install_date__gt: Option<Vec<String>>,
10033    install_date__gte: Option<Vec<String>>,
10034    install_date__lt: Option<Vec<String>>,
10035    install_date__lte: Option<Vec<String>>,
10036    install_date__n: Option<Vec<String>>,
10037    last_updated: Option<Vec<String>>,
10038    last_updated__empty: Option<Vec<String>>,
10039    last_updated__gt: Option<Vec<String>>,
10040    last_updated__gte: Option<Vec<String>>,
10041    last_updated__lt: Option<Vec<String>>,
10042    last_updated__lte: Option<Vec<String>>,
10043    last_updated__n: Option<Vec<String>>,
10044    limit: Option<i32>,
10045    location_id: Option<Vec<i32>>,
10046    location_id__n: Option<Vec<i32>>,
10047    modified_by_request: Option<&str>,
10048    offset: Option<i32>,
10049    ordering: Option<&str>,
10050    owner: Option<Vec<String>>,
10051    owner__n: Option<Vec<String>>,
10052    owner_group: Option<Vec<String>>,
10053    owner_group__n: Option<Vec<String>>,
10054    owner_group_id: Option<Vec<i32>>,
10055    owner_group_id__n: Option<Vec<i32>>,
10056    owner_id: Option<Vec<i32>>,
10057    owner_id__n: Option<Vec<i32>>,
10058    provider: Option<Vec<String>>,
10059    provider__n: Option<Vec<String>>,
10060    provider_account: Option<Vec<String>>,
10061    provider_account__n: Option<Vec<String>>,
10062    provider_account_id: Option<Vec<i32>>,
10063    provider_account_id__n: Option<Vec<i32>>,
10064    provider_id: Option<Vec<i32>>,
10065    provider_id__n: Option<Vec<i32>>,
10066    provider_network_id: Option<Vec<i32>>,
10067    provider_network_id__n: Option<Vec<i32>>,
10068    q: Option<&str>,
10069    region: Option<Vec<String>>,
10070    region__n: Option<Vec<String>>,
10071    region_id: Option<Vec<String>>,
10072    region_id__n: Option<Vec<String>>,
10073    site: Option<Vec<String>>,
10074    site__n: Option<Vec<String>>,
10075    site_group: Option<Vec<String>>,
10076    site_group__n: Option<Vec<String>>,
10077    site_group_id: Option<Vec<String>>,
10078    site_group_id__n: Option<Vec<String>>,
10079    site_id: Option<Vec<i32>>,
10080    site_id__n: Option<Vec<i32>>,
10081    status: Option<Vec<String>>,
10082    status__empty: Option<bool>,
10083    status__ic: Option<Vec<String>>,
10084    status__ie: Option<Vec<String>>,
10085    status__iew: Option<Vec<String>>,
10086    status__iregex: Option<Vec<String>>,
10087    status__isw: Option<Vec<String>>,
10088    status__n: Option<Vec<String>>,
10089    status__nic: Option<Vec<String>>,
10090    status__nie: Option<Vec<String>>,
10091    status__niew: Option<Vec<String>>,
10092    status__nisw: Option<Vec<String>>,
10093    status__regex: Option<Vec<String>>,
10094    tag: Option<Vec<String>>,
10095    tag__n: Option<Vec<String>>,
10096    tag_id: Option<Vec<i32>>,
10097    tag_id__n: Option<Vec<i32>>,
10098    tenant: Option<Vec<String>>,
10099    tenant__n: Option<Vec<String>>,
10100    tenant_group: Option<Vec<String>>,
10101    tenant_group__n: Option<Vec<String>>,
10102    tenant_group_id: Option<Vec<String>>,
10103    tenant_group_id__n: Option<Vec<String>>,
10104    tenant_id: Option<Vec<i32>>,
10105    tenant_id__n: Option<Vec<i32>>,
10106    termination_a_id: Option<Vec<i32>>,
10107    termination_a_id__n: Option<Vec<i32>>,
10108    termination_date: Option<Vec<String>>,
10109    termination_date__empty: Option<bool>,
10110    termination_date__gt: Option<Vec<String>>,
10111    termination_date__gte: Option<Vec<String>>,
10112    termination_date__lt: Option<Vec<String>>,
10113    termination_date__lte: Option<Vec<String>>,
10114    termination_date__n: Option<Vec<String>>,
10115    termination_z_id: Option<Vec<i32>>,
10116    termination_z_id__n: Option<Vec<i32>>,
10117    r#type: Option<Vec<String>>,
10118    type__n: Option<Vec<String>>,
10119    type_id: Option<Vec<i32>>,
10120    type_id__n: Option<Vec<i32>>,
10121    updated_by_request: Option<&str>,
10122) -> Result<crate::models::PaginatedCircuitList, Error<CircuitsCircuitsListError>> {
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        "{}/api/circuits/circuits/",
10129        local_var_configuration.base_path
10130    );
10131    let mut local_var_req_builder =
10132        local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
10133
10134    if let Some(ref local_var_str) = cid {
10135        local_var_req_builder = match "multi" {
10136            "multi" => local_var_req_builder.query(
10137                &local_var_str
10138                    .into_iter()
10139                    .map(|p| ("cid".to_owned(), p.to_string()))
10140                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10141            ),
10142            _ => local_var_req_builder.query(&[(
10143                "cid",
10144                &local_var_str
10145                    .into_iter()
10146                    .map(|p| p.to_string())
10147                    .collect::<Vec<String>>()
10148                    .join(",")
10149                    .to_string(),
10150            )]),
10151        };
10152    }
10153    if let Some(ref local_var_str) = cid__empty {
10154        local_var_req_builder =
10155            local_var_req_builder.query(&[("cid__empty", &local_var_str.to_string())]);
10156    }
10157    if let Some(ref local_var_str) = cid__ic {
10158        local_var_req_builder = match "multi" {
10159            "multi" => local_var_req_builder.query(
10160                &local_var_str
10161                    .into_iter()
10162                    .map(|p| ("cid__ic".to_owned(), p.to_string()))
10163                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10164            ),
10165            _ => local_var_req_builder.query(&[(
10166                "cid__ic",
10167                &local_var_str
10168                    .into_iter()
10169                    .map(|p| p.to_string())
10170                    .collect::<Vec<String>>()
10171                    .join(",")
10172                    .to_string(),
10173            )]),
10174        };
10175    }
10176    if let Some(ref local_var_str) = cid__ie {
10177        local_var_req_builder = match "multi" {
10178            "multi" => local_var_req_builder.query(
10179                &local_var_str
10180                    .into_iter()
10181                    .map(|p| ("cid__ie".to_owned(), p.to_string()))
10182                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10183            ),
10184            _ => local_var_req_builder.query(&[(
10185                "cid__ie",
10186                &local_var_str
10187                    .into_iter()
10188                    .map(|p| p.to_string())
10189                    .collect::<Vec<String>>()
10190                    .join(",")
10191                    .to_string(),
10192            )]),
10193        };
10194    }
10195    if let Some(ref local_var_str) = cid__iew {
10196        local_var_req_builder = match "multi" {
10197            "multi" => local_var_req_builder.query(
10198                &local_var_str
10199                    .into_iter()
10200                    .map(|p| ("cid__iew".to_owned(), p.to_string()))
10201                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10202            ),
10203            _ => local_var_req_builder.query(&[(
10204                "cid__iew",
10205                &local_var_str
10206                    .into_iter()
10207                    .map(|p| p.to_string())
10208                    .collect::<Vec<String>>()
10209                    .join(",")
10210                    .to_string(),
10211            )]),
10212        };
10213    }
10214    if let Some(ref local_var_str) = cid__iregex {
10215        local_var_req_builder = match "multi" {
10216            "multi" => local_var_req_builder.query(
10217                &local_var_str
10218                    .into_iter()
10219                    .map(|p| ("cid__iregex".to_owned(), p.to_string()))
10220                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10221            ),
10222            _ => local_var_req_builder.query(&[(
10223                "cid__iregex",
10224                &local_var_str
10225                    .into_iter()
10226                    .map(|p| p.to_string())
10227                    .collect::<Vec<String>>()
10228                    .join(",")
10229                    .to_string(),
10230            )]),
10231        };
10232    }
10233    if let Some(ref local_var_str) = cid__isw {
10234        local_var_req_builder = match "multi" {
10235            "multi" => local_var_req_builder.query(
10236                &local_var_str
10237                    .into_iter()
10238                    .map(|p| ("cid__isw".to_owned(), p.to_string()))
10239                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10240            ),
10241            _ => local_var_req_builder.query(&[(
10242                "cid__isw",
10243                &local_var_str
10244                    .into_iter()
10245                    .map(|p| p.to_string())
10246                    .collect::<Vec<String>>()
10247                    .join(",")
10248                    .to_string(),
10249            )]),
10250        };
10251    }
10252    if let Some(ref local_var_str) = cid__n {
10253        local_var_req_builder = match "multi" {
10254            "multi" => local_var_req_builder.query(
10255                &local_var_str
10256                    .into_iter()
10257                    .map(|p| ("cid__n".to_owned(), p.to_string()))
10258                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10259            ),
10260            _ => local_var_req_builder.query(&[(
10261                "cid__n",
10262                &local_var_str
10263                    .into_iter()
10264                    .map(|p| p.to_string())
10265                    .collect::<Vec<String>>()
10266                    .join(",")
10267                    .to_string(),
10268            )]),
10269        };
10270    }
10271    if let Some(ref local_var_str) = cid__nic {
10272        local_var_req_builder = match "multi" {
10273            "multi" => local_var_req_builder.query(
10274                &local_var_str
10275                    .into_iter()
10276                    .map(|p| ("cid__nic".to_owned(), p.to_string()))
10277                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10278            ),
10279            _ => local_var_req_builder.query(&[(
10280                "cid__nic",
10281                &local_var_str
10282                    .into_iter()
10283                    .map(|p| p.to_string())
10284                    .collect::<Vec<String>>()
10285                    .join(",")
10286                    .to_string(),
10287            )]),
10288        };
10289    }
10290    if let Some(ref local_var_str) = cid__nie {
10291        local_var_req_builder = match "multi" {
10292            "multi" => local_var_req_builder.query(
10293                &local_var_str
10294                    .into_iter()
10295                    .map(|p| ("cid__nie".to_owned(), p.to_string()))
10296                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10297            ),
10298            _ => local_var_req_builder.query(&[(
10299                "cid__nie",
10300                &local_var_str
10301                    .into_iter()
10302                    .map(|p| p.to_string())
10303                    .collect::<Vec<String>>()
10304                    .join(",")
10305                    .to_string(),
10306            )]),
10307        };
10308    }
10309    if let Some(ref local_var_str) = cid__niew {
10310        local_var_req_builder = match "multi" {
10311            "multi" => local_var_req_builder.query(
10312                &local_var_str
10313                    .into_iter()
10314                    .map(|p| ("cid__niew".to_owned(), p.to_string()))
10315                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10316            ),
10317            _ => local_var_req_builder.query(&[(
10318                "cid__niew",
10319                &local_var_str
10320                    .into_iter()
10321                    .map(|p| p.to_string())
10322                    .collect::<Vec<String>>()
10323                    .join(",")
10324                    .to_string(),
10325            )]),
10326        };
10327    }
10328    if let Some(ref local_var_str) = cid__nisw {
10329        local_var_req_builder = match "multi" {
10330            "multi" => local_var_req_builder.query(
10331                &local_var_str
10332                    .into_iter()
10333                    .map(|p| ("cid__nisw".to_owned(), p.to_string()))
10334                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10335            ),
10336            _ => local_var_req_builder.query(&[(
10337                "cid__nisw",
10338                &local_var_str
10339                    .into_iter()
10340                    .map(|p| p.to_string())
10341                    .collect::<Vec<String>>()
10342                    .join(",")
10343                    .to_string(),
10344            )]),
10345        };
10346    }
10347    if let Some(ref local_var_str) = cid__regex {
10348        local_var_req_builder = match "multi" {
10349            "multi" => local_var_req_builder.query(
10350                &local_var_str
10351                    .into_iter()
10352                    .map(|p| ("cid__regex".to_owned(), p.to_string()))
10353                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10354            ),
10355            _ => local_var_req_builder.query(&[(
10356                "cid__regex",
10357                &local_var_str
10358                    .into_iter()
10359                    .map(|p| p.to_string())
10360                    .collect::<Vec<String>>()
10361                    .join(",")
10362                    .to_string(),
10363            )]),
10364        };
10365    }
10366    if let Some(ref local_var_str) = commit_rate {
10367        local_var_req_builder = match "multi" {
10368            "multi" => local_var_req_builder.query(
10369                &local_var_str
10370                    .into_iter()
10371                    .map(|p| ("commit_rate".to_owned(), p.to_string()))
10372                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10373            ),
10374            _ => local_var_req_builder.query(&[(
10375                "commit_rate",
10376                &local_var_str
10377                    .into_iter()
10378                    .map(|p| p.to_string())
10379                    .collect::<Vec<String>>()
10380                    .join(",")
10381                    .to_string(),
10382            )]),
10383        };
10384    }
10385    if let Some(ref local_var_str) = commit_rate__empty {
10386        local_var_req_builder =
10387            local_var_req_builder.query(&[("commit_rate__empty", &local_var_str.to_string())]);
10388    }
10389    if let Some(ref local_var_str) = commit_rate__gt {
10390        local_var_req_builder = match "multi" {
10391            "multi" => local_var_req_builder.query(
10392                &local_var_str
10393                    .into_iter()
10394                    .map(|p| ("commit_rate__gt".to_owned(), p.to_string()))
10395                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10396            ),
10397            _ => local_var_req_builder.query(&[(
10398                "commit_rate__gt",
10399                &local_var_str
10400                    .into_iter()
10401                    .map(|p| p.to_string())
10402                    .collect::<Vec<String>>()
10403                    .join(",")
10404                    .to_string(),
10405            )]),
10406        };
10407    }
10408    if let Some(ref local_var_str) = commit_rate__gte {
10409        local_var_req_builder = match "multi" {
10410            "multi" => local_var_req_builder.query(
10411                &local_var_str
10412                    .into_iter()
10413                    .map(|p| ("commit_rate__gte".to_owned(), p.to_string()))
10414                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10415            ),
10416            _ => local_var_req_builder.query(&[(
10417                "commit_rate__gte",
10418                &local_var_str
10419                    .into_iter()
10420                    .map(|p| p.to_string())
10421                    .collect::<Vec<String>>()
10422                    .join(",")
10423                    .to_string(),
10424            )]),
10425        };
10426    }
10427    if let Some(ref local_var_str) = commit_rate__lt {
10428        local_var_req_builder = match "multi" {
10429            "multi" => local_var_req_builder.query(
10430                &local_var_str
10431                    .into_iter()
10432                    .map(|p| ("commit_rate__lt".to_owned(), p.to_string()))
10433                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10434            ),
10435            _ => local_var_req_builder.query(&[(
10436                "commit_rate__lt",
10437                &local_var_str
10438                    .into_iter()
10439                    .map(|p| p.to_string())
10440                    .collect::<Vec<String>>()
10441                    .join(",")
10442                    .to_string(),
10443            )]),
10444        };
10445    }
10446    if let Some(ref local_var_str) = commit_rate__lte {
10447        local_var_req_builder = match "multi" {
10448            "multi" => local_var_req_builder.query(
10449                &local_var_str
10450                    .into_iter()
10451                    .map(|p| ("commit_rate__lte".to_owned(), p.to_string()))
10452                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10453            ),
10454            _ => local_var_req_builder.query(&[(
10455                "commit_rate__lte",
10456                &local_var_str
10457                    .into_iter()
10458                    .map(|p| p.to_string())
10459                    .collect::<Vec<String>>()
10460                    .join(",")
10461                    .to_string(),
10462            )]),
10463        };
10464    }
10465    if let Some(ref local_var_str) = commit_rate__n {
10466        local_var_req_builder = match "multi" {
10467            "multi" => local_var_req_builder.query(
10468                &local_var_str
10469                    .into_iter()
10470                    .map(|p| ("commit_rate__n".to_owned(), p.to_string()))
10471                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10472            ),
10473            _ => local_var_req_builder.query(&[(
10474                "commit_rate__n",
10475                &local_var_str
10476                    .into_iter()
10477                    .map(|p| p.to_string())
10478                    .collect::<Vec<String>>()
10479                    .join(",")
10480                    .to_string(),
10481            )]),
10482        };
10483    }
10484    if let Some(ref local_var_str) = contact {
10485        local_var_req_builder = match "multi" {
10486            "multi" => local_var_req_builder.query(
10487                &local_var_str
10488                    .into_iter()
10489                    .map(|p| ("contact".to_owned(), p.to_string()))
10490                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10491            ),
10492            _ => local_var_req_builder.query(&[(
10493                "contact",
10494                &local_var_str
10495                    .into_iter()
10496                    .map(|p| p.to_string())
10497                    .collect::<Vec<String>>()
10498                    .join(",")
10499                    .to_string(),
10500            )]),
10501        };
10502    }
10503    if let Some(ref local_var_str) = contact__n {
10504        local_var_req_builder = match "multi" {
10505            "multi" => local_var_req_builder.query(
10506                &local_var_str
10507                    .into_iter()
10508                    .map(|p| ("contact__n".to_owned(), p.to_string()))
10509                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10510            ),
10511            _ => local_var_req_builder.query(&[(
10512                "contact__n",
10513                &local_var_str
10514                    .into_iter()
10515                    .map(|p| p.to_string())
10516                    .collect::<Vec<String>>()
10517                    .join(",")
10518                    .to_string(),
10519            )]),
10520        };
10521    }
10522    if let Some(ref local_var_str) = contact_group {
10523        local_var_req_builder = match "multi" {
10524            "multi" => local_var_req_builder.query(
10525                &local_var_str
10526                    .into_iter()
10527                    .map(|p| ("contact_group".to_owned(), p.to_string()))
10528                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10529            ),
10530            _ => local_var_req_builder.query(&[(
10531                "contact_group",
10532                &local_var_str
10533                    .into_iter()
10534                    .map(|p| p.to_string())
10535                    .collect::<Vec<String>>()
10536                    .join(",")
10537                    .to_string(),
10538            )]),
10539        };
10540    }
10541    if let Some(ref local_var_str) = contact_group__n {
10542        local_var_req_builder = match "multi" {
10543            "multi" => local_var_req_builder.query(
10544                &local_var_str
10545                    .into_iter()
10546                    .map(|p| ("contact_group__n".to_owned(), p.to_string()))
10547                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10548            ),
10549            _ => local_var_req_builder.query(&[(
10550                "contact_group__n",
10551                &local_var_str
10552                    .into_iter()
10553                    .map(|p| p.to_string())
10554                    .collect::<Vec<String>>()
10555                    .join(",")
10556                    .to_string(),
10557            )]),
10558        };
10559    }
10560    if let Some(ref local_var_str) = contact_role {
10561        local_var_req_builder = match "multi" {
10562            "multi" => local_var_req_builder.query(
10563                &local_var_str
10564                    .into_iter()
10565                    .map(|p| ("contact_role".to_owned(), p.to_string()))
10566                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10567            ),
10568            _ => local_var_req_builder.query(&[(
10569                "contact_role",
10570                &local_var_str
10571                    .into_iter()
10572                    .map(|p| p.to_string())
10573                    .collect::<Vec<String>>()
10574                    .join(",")
10575                    .to_string(),
10576            )]),
10577        };
10578    }
10579    if let Some(ref local_var_str) = contact_role__n {
10580        local_var_req_builder = match "multi" {
10581            "multi" => local_var_req_builder.query(
10582                &local_var_str
10583                    .into_iter()
10584                    .map(|p| ("contact_role__n".to_owned(), p.to_string()))
10585                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10586            ),
10587            _ => local_var_req_builder.query(&[(
10588                "contact_role__n",
10589                &local_var_str
10590                    .into_iter()
10591                    .map(|p| p.to_string())
10592                    .collect::<Vec<String>>()
10593                    .join(",")
10594                    .to_string(),
10595            )]),
10596        };
10597    }
10598    if let Some(ref local_var_str) = created {
10599        local_var_req_builder = match "multi" {
10600            "multi" => local_var_req_builder.query(
10601                &local_var_str
10602                    .into_iter()
10603                    .map(|p| ("created".to_owned(), p.to_string()))
10604                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10605            ),
10606            _ => local_var_req_builder.query(&[(
10607                "created",
10608                &local_var_str
10609                    .into_iter()
10610                    .map(|p| p.to_string())
10611                    .collect::<Vec<String>>()
10612                    .join(",")
10613                    .to_string(),
10614            )]),
10615        };
10616    }
10617    if let Some(ref local_var_str) = created__empty {
10618        local_var_req_builder = match "multi" {
10619            "multi" => local_var_req_builder.query(
10620                &local_var_str
10621                    .into_iter()
10622                    .map(|p| ("created__empty".to_owned(), p.to_string()))
10623                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10624            ),
10625            _ => local_var_req_builder.query(&[(
10626                "created__empty",
10627                &local_var_str
10628                    .into_iter()
10629                    .map(|p| p.to_string())
10630                    .collect::<Vec<String>>()
10631                    .join(",")
10632                    .to_string(),
10633            )]),
10634        };
10635    }
10636    if let Some(ref local_var_str) = created__gt {
10637        local_var_req_builder = match "multi" {
10638            "multi" => local_var_req_builder.query(
10639                &local_var_str
10640                    .into_iter()
10641                    .map(|p| ("created__gt".to_owned(), p.to_string()))
10642                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10643            ),
10644            _ => local_var_req_builder.query(&[(
10645                "created__gt",
10646                &local_var_str
10647                    .into_iter()
10648                    .map(|p| p.to_string())
10649                    .collect::<Vec<String>>()
10650                    .join(",")
10651                    .to_string(),
10652            )]),
10653        };
10654    }
10655    if let Some(ref local_var_str) = created__gte {
10656        local_var_req_builder = match "multi" {
10657            "multi" => local_var_req_builder.query(
10658                &local_var_str
10659                    .into_iter()
10660                    .map(|p| ("created__gte".to_owned(), p.to_string()))
10661                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10662            ),
10663            _ => local_var_req_builder.query(&[(
10664                "created__gte",
10665                &local_var_str
10666                    .into_iter()
10667                    .map(|p| p.to_string())
10668                    .collect::<Vec<String>>()
10669                    .join(",")
10670                    .to_string(),
10671            )]),
10672        };
10673    }
10674    if let Some(ref local_var_str) = created__lt {
10675        local_var_req_builder = match "multi" {
10676            "multi" => local_var_req_builder.query(
10677                &local_var_str
10678                    .into_iter()
10679                    .map(|p| ("created__lt".to_owned(), p.to_string()))
10680                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10681            ),
10682            _ => local_var_req_builder.query(&[(
10683                "created__lt",
10684                &local_var_str
10685                    .into_iter()
10686                    .map(|p| p.to_string())
10687                    .collect::<Vec<String>>()
10688                    .join(",")
10689                    .to_string(),
10690            )]),
10691        };
10692    }
10693    if let Some(ref local_var_str) = created__lte {
10694        local_var_req_builder = match "multi" {
10695            "multi" => local_var_req_builder.query(
10696                &local_var_str
10697                    .into_iter()
10698                    .map(|p| ("created__lte".to_owned(), p.to_string()))
10699                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10700            ),
10701            _ => local_var_req_builder.query(&[(
10702                "created__lte",
10703                &local_var_str
10704                    .into_iter()
10705                    .map(|p| p.to_string())
10706                    .collect::<Vec<String>>()
10707                    .join(",")
10708                    .to_string(),
10709            )]),
10710        };
10711    }
10712    if let Some(ref local_var_str) = created__n {
10713        local_var_req_builder = match "multi" {
10714            "multi" => local_var_req_builder.query(
10715                &local_var_str
10716                    .into_iter()
10717                    .map(|p| ("created__n".to_owned(), p.to_string()))
10718                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10719            ),
10720            _ => local_var_req_builder.query(&[(
10721                "created__n",
10722                &local_var_str
10723                    .into_iter()
10724                    .map(|p| p.to_string())
10725                    .collect::<Vec<String>>()
10726                    .join(",")
10727                    .to_string(),
10728            )]),
10729        };
10730    }
10731    if let Some(ref local_var_str) = created_by_request {
10732        local_var_req_builder =
10733            local_var_req_builder.query(&[("created_by_request", &local_var_str.to_string())]);
10734    }
10735    if let Some(ref local_var_str) = description {
10736        local_var_req_builder = match "multi" {
10737            "multi" => local_var_req_builder.query(
10738                &local_var_str
10739                    .into_iter()
10740                    .map(|p| ("description".to_owned(), p.to_string()))
10741                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10742            ),
10743            _ => local_var_req_builder.query(&[(
10744                "description",
10745                &local_var_str
10746                    .into_iter()
10747                    .map(|p| p.to_string())
10748                    .collect::<Vec<String>>()
10749                    .join(",")
10750                    .to_string(),
10751            )]),
10752        };
10753    }
10754    if let Some(ref local_var_str) = description__empty {
10755        local_var_req_builder =
10756            local_var_req_builder.query(&[("description__empty", &local_var_str.to_string())]);
10757    }
10758    if let Some(ref local_var_str) = description__ic {
10759        local_var_req_builder = match "multi" {
10760            "multi" => local_var_req_builder.query(
10761                &local_var_str
10762                    .into_iter()
10763                    .map(|p| ("description__ic".to_owned(), p.to_string()))
10764                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10765            ),
10766            _ => local_var_req_builder.query(&[(
10767                "description__ic",
10768                &local_var_str
10769                    .into_iter()
10770                    .map(|p| p.to_string())
10771                    .collect::<Vec<String>>()
10772                    .join(",")
10773                    .to_string(),
10774            )]),
10775        };
10776    }
10777    if let Some(ref local_var_str) = description__ie {
10778        local_var_req_builder = match "multi" {
10779            "multi" => local_var_req_builder.query(
10780                &local_var_str
10781                    .into_iter()
10782                    .map(|p| ("description__ie".to_owned(), p.to_string()))
10783                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10784            ),
10785            _ => local_var_req_builder.query(&[(
10786                "description__ie",
10787                &local_var_str
10788                    .into_iter()
10789                    .map(|p| p.to_string())
10790                    .collect::<Vec<String>>()
10791                    .join(",")
10792                    .to_string(),
10793            )]),
10794        };
10795    }
10796    if let Some(ref local_var_str) = description__iew {
10797        local_var_req_builder = match "multi" {
10798            "multi" => local_var_req_builder.query(
10799                &local_var_str
10800                    .into_iter()
10801                    .map(|p| ("description__iew".to_owned(), p.to_string()))
10802                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10803            ),
10804            _ => local_var_req_builder.query(&[(
10805                "description__iew",
10806                &local_var_str
10807                    .into_iter()
10808                    .map(|p| p.to_string())
10809                    .collect::<Vec<String>>()
10810                    .join(",")
10811                    .to_string(),
10812            )]),
10813        };
10814    }
10815    if let Some(ref local_var_str) = description__iregex {
10816        local_var_req_builder = match "multi" {
10817            "multi" => local_var_req_builder.query(
10818                &local_var_str
10819                    .into_iter()
10820                    .map(|p| ("description__iregex".to_owned(), p.to_string()))
10821                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10822            ),
10823            _ => local_var_req_builder.query(&[(
10824                "description__iregex",
10825                &local_var_str
10826                    .into_iter()
10827                    .map(|p| p.to_string())
10828                    .collect::<Vec<String>>()
10829                    .join(",")
10830                    .to_string(),
10831            )]),
10832        };
10833    }
10834    if let Some(ref local_var_str) = description__isw {
10835        local_var_req_builder = match "multi" {
10836            "multi" => local_var_req_builder.query(
10837                &local_var_str
10838                    .into_iter()
10839                    .map(|p| ("description__isw".to_owned(), p.to_string()))
10840                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10841            ),
10842            _ => local_var_req_builder.query(&[(
10843                "description__isw",
10844                &local_var_str
10845                    .into_iter()
10846                    .map(|p| p.to_string())
10847                    .collect::<Vec<String>>()
10848                    .join(",")
10849                    .to_string(),
10850            )]),
10851        };
10852    }
10853    if let Some(ref local_var_str) = description__n {
10854        local_var_req_builder = match "multi" {
10855            "multi" => local_var_req_builder.query(
10856                &local_var_str
10857                    .into_iter()
10858                    .map(|p| ("description__n".to_owned(), p.to_string()))
10859                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10860            ),
10861            _ => local_var_req_builder.query(&[(
10862                "description__n",
10863                &local_var_str
10864                    .into_iter()
10865                    .map(|p| p.to_string())
10866                    .collect::<Vec<String>>()
10867                    .join(",")
10868                    .to_string(),
10869            )]),
10870        };
10871    }
10872    if let Some(ref local_var_str) = description__nic {
10873        local_var_req_builder = match "multi" {
10874            "multi" => local_var_req_builder.query(
10875                &local_var_str
10876                    .into_iter()
10877                    .map(|p| ("description__nic".to_owned(), p.to_string()))
10878                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10879            ),
10880            _ => local_var_req_builder.query(&[(
10881                "description__nic",
10882                &local_var_str
10883                    .into_iter()
10884                    .map(|p| p.to_string())
10885                    .collect::<Vec<String>>()
10886                    .join(",")
10887                    .to_string(),
10888            )]),
10889        };
10890    }
10891    if let Some(ref local_var_str) = description__nie {
10892        local_var_req_builder = match "multi" {
10893            "multi" => local_var_req_builder.query(
10894                &local_var_str
10895                    .into_iter()
10896                    .map(|p| ("description__nie".to_owned(), p.to_string()))
10897                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10898            ),
10899            _ => local_var_req_builder.query(&[(
10900                "description__nie",
10901                &local_var_str
10902                    .into_iter()
10903                    .map(|p| p.to_string())
10904                    .collect::<Vec<String>>()
10905                    .join(",")
10906                    .to_string(),
10907            )]),
10908        };
10909    }
10910    if let Some(ref local_var_str) = description__niew {
10911        local_var_req_builder = match "multi" {
10912            "multi" => local_var_req_builder.query(
10913                &local_var_str
10914                    .into_iter()
10915                    .map(|p| ("description__niew".to_owned(), p.to_string()))
10916                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10917            ),
10918            _ => local_var_req_builder.query(&[(
10919                "description__niew",
10920                &local_var_str
10921                    .into_iter()
10922                    .map(|p| p.to_string())
10923                    .collect::<Vec<String>>()
10924                    .join(",")
10925                    .to_string(),
10926            )]),
10927        };
10928    }
10929    if let Some(ref local_var_str) = description__nisw {
10930        local_var_req_builder = match "multi" {
10931            "multi" => local_var_req_builder.query(
10932                &local_var_str
10933                    .into_iter()
10934                    .map(|p| ("description__nisw".to_owned(), p.to_string()))
10935                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10936            ),
10937            _ => local_var_req_builder.query(&[(
10938                "description__nisw",
10939                &local_var_str
10940                    .into_iter()
10941                    .map(|p| p.to_string())
10942                    .collect::<Vec<String>>()
10943                    .join(",")
10944                    .to_string(),
10945            )]),
10946        };
10947    }
10948    if let Some(ref local_var_str) = description__regex {
10949        local_var_req_builder = match "multi" {
10950            "multi" => local_var_req_builder.query(
10951                &local_var_str
10952                    .into_iter()
10953                    .map(|p| ("description__regex".to_owned(), p.to_string()))
10954                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10955            ),
10956            _ => local_var_req_builder.query(&[(
10957                "description__regex",
10958                &local_var_str
10959                    .into_iter()
10960                    .map(|p| p.to_string())
10961                    .collect::<Vec<String>>()
10962                    .join(",")
10963                    .to_string(),
10964            )]),
10965        };
10966    }
10967    if let Some(ref local_var_str) = distance {
10968        local_var_req_builder = match "multi" {
10969            "multi" => local_var_req_builder.query(
10970                &local_var_str
10971                    .into_iter()
10972                    .map(|p| ("distance".to_owned(), p.to_string()))
10973                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10974            ),
10975            _ => local_var_req_builder.query(&[(
10976                "distance",
10977                &local_var_str
10978                    .into_iter()
10979                    .map(|p| p.to_string())
10980                    .collect::<Vec<String>>()
10981                    .join(",")
10982                    .to_string(),
10983            )]),
10984        };
10985    }
10986    if let Some(ref local_var_str) = distance__empty {
10987        local_var_req_builder =
10988            local_var_req_builder.query(&[("distance__empty", &local_var_str.to_string())]);
10989    }
10990    if let Some(ref local_var_str) = distance__gt {
10991        local_var_req_builder = match "multi" {
10992            "multi" => local_var_req_builder.query(
10993                &local_var_str
10994                    .into_iter()
10995                    .map(|p| ("distance__gt".to_owned(), p.to_string()))
10996                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10997            ),
10998            _ => local_var_req_builder.query(&[(
10999                "distance__gt",
11000                &local_var_str
11001                    .into_iter()
11002                    .map(|p| p.to_string())
11003                    .collect::<Vec<String>>()
11004                    .join(",")
11005                    .to_string(),
11006            )]),
11007        };
11008    }
11009    if let Some(ref local_var_str) = distance__gte {
11010        local_var_req_builder = match "multi" {
11011            "multi" => local_var_req_builder.query(
11012                &local_var_str
11013                    .into_iter()
11014                    .map(|p| ("distance__gte".to_owned(), p.to_string()))
11015                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11016            ),
11017            _ => local_var_req_builder.query(&[(
11018                "distance__gte",
11019                &local_var_str
11020                    .into_iter()
11021                    .map(|p| p.to_string())
11022                    .collect::<Vec<String>>()
11023                    .join(",")
11024                    .to_string(),
11025            )]),
11026        };
11027    }
11028    if let Some(ref local_var_str) = distance__lt {
11029        local_var_req_builder = match "multi" {
11030            "multi" => local_var_req_builder.query(
11031                &local_var_str
11032                    .into_iter()
11033                    .map(|p| ("distance__lt".to_owned(), p.to_string()))
11034                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11035            ),
11036            _ => local_var_req_builder.query(&[(
11037                "distance__lt",
11038                &local_var_str
11039                    .into_iter()
11040                    .map(|p| p.to_string())
11041                    .collect::<Vec<String>>()
11042                    .join(",")
11043                    .to_string(),
11044            )]),
11045        };
11046    }
11047    if let Some(ref local_var_str) = distance__lte {
11048        local_var_req_builder = match "multi" {
11049            "multi" => local_var_req_builder.query(
11050                &local_var_str
11051                    .into_iter()
11052                    .map(|p| ("distance__lte".to_owned(), p.to_string()))
11053                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11054            ),
11055            _ => local_var_req_builder.query(&[(
11056                "distance__lte",
11057                &local_var_str
11058                    .into_iter()
11059                    .map(|p| p.to_string())
11060                    .collect::<Vec<String>>()
11061                    .join(",")
11062                    .to_string(),
11063            )]),
11064        };
11065    }
11066    if let Some(ref local_var_str) = distance__n {
11067        local_var_req_builder = match "multi" {
11068            "multi" => local_var_req_builder.query(
11069                &local_var_str
11070                    .into_iter()
11071                    .map(|p| ("distance__n".to_owned(), p.to_string()))
11072                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11073            ),
11074            _ => local_var_req_builder.query(&[(
11075                "distance__n",
11076                &local_var_str
11077                    .into_iter()
11078                    .map(|p| p.to_string())
11079                    .collect::<Vec<String>>()
11080                    .join(",")
11081                    .to_string(),
11082            )]),
11083        };
11084    }
11085    if let Some(ref local_var_str) = distance_unit {
11086        local_var_req_builder =
11087            local_var_req_builder.query(&[("distance_unit", &local_var_str.to_string())]);
11088    }
11089    if let Some(ref local_var_str) = distance_unit__empty {
11090        local_var_req_builder =
11091            local_var_req_builder.query(&[("distance_unit__empty", &local_var_str.to_string())]);
11092    }
11093    if let Some(ref local_var_str) = distance_unit__ic {
11094        local_var_req_builder = match "multi" {
11095            "multi" => local_var_req_builder.query(
11096                &local_var_str
11097                    .into_iter()
11098                    .map(|p| ("distance_unit__ic".to_owned(), p.to_string()))
11099                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11100            ),
11101            _ => local_var_req_builder.query(&[(
11102                "distance_unit__ic",
11103                &local_var_str
11104                    .into_iter()
11105                    .map(|p| p.to_string())
11106                    .collect::<Vec<String>>()
11107                    .join(",")
11108                    .to_string(),
11109            )]),
11110        };
11111    }
11112    if let Some(ref local_var_str) = distance_unit__ie {
11113        local_var_req_builder = match "multi" {
11114            "multi" => local_var_req_builder.query(
11115                &local_var_str
11116                    .into_iter()
11117                    .map(|p| ("distance_unit__ie".to_owned(), p.to_string()))
11118                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11119            ),
11120            _ => local_var_req_builder.query(&[(
11121                "distance_unit__ie",
11122                &local_var_str
11123                    .into_iter()
11124                    .map(|p| p.to_string())
11125                    .collect::<Vec<String>>()
11126                    .join(",")
11127                    .to_string(),
11128            )]),
11129        };
11130    }
11131    if let Some(ref local_var_str) = distance_unit__iew {
11132        local_var_req_builder = match "multi" {
11133            "multi" => local_var_req_builder.query(
11134                &local_var_str
11135                    .into_iter()
11136                    .map(|p| ("distance_unit__iew".to_owned(), p.to_string()))
11137                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11138            ),
11139            _ => local_var_req_builder.query(&[(
11140                "distance_unit__iew",
11141                &local_var_str
11142                    .into_iter()
11143                    .map(|p| p.to_string())
11144                    .collect::<Vec<String>>()
11145                    .join(",")
11146                    .to_string(),
11147            )]),
11148        };
11149    }
11150    if let Some(ref local_var_str) = distance_unit__iregex {
11151        local_var_req_builder = match "multi" {
11152            "multi" => local_var_req_builder.query(
11153                &local_var_str
11154                    .into_iter()
11155                    .map(|p| ("distance_unit__iregex".to_owned(), p.to_string()))
11156                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11157            ),
11158            _ => local_var_req_builder.query(&[(
11159                "distance_unit__iregex",
11160                &local_var_str
11161                    .into_iter()
11162                    .map(|p| p.to_string())
11163                    .collect::<Vec<String>>()
11164                    .join(",")
11165                    .to_string(),
11166            )]),
11167        };
11168    }
11169    if let Some(ref local_var_str) = distance_unit__isw {
11170        local_var_req_builder = match "multi" {
11171            "multi" => local_var_req_builder.query(
11172                &local_var_str
11173                    .into_iter()
11174                    .map(|p| ("distance_unit__isw".to_owned(), p.to_string()))
11175                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11176            ),
11177            _ => local_var_req_builder.query(&[(
11178                "distance_unit__isw",
11179                &local_var_str
11180                    .into_iter()
11181                    .map(|p| p.to_string())
11182                    .collect::<Vec<String>>()
11183                    .join(",")
11184                    .to_string(),
11185            )]),
11186        };
11187    }
11188    if let Some(ref local_var_str) = distance_unit__n {
11189        local_var_req_builder =
11190            local_var_req_builder.query(&[("distance_unit__n", &local_var_str.to_string())]);
11191    }
11192    if let Some(ref local_var_str) = distance_unit__nic {
11193        local_var_req_builder = match "multi" {
11194            "multi" => local_var_req_builder.query(
11195                &local_var_str
11196                    .into_iter()
11197                    .map(|p| ("distance_unit__nic".to_owned(), p.to_string()))
11198                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11199            ),
11200            _ => local_var_req_builder.query(&[(
11201                "distance_unit__nic",
11202                &local_var_str
11203                    .into_iter()
11204                    .map(|p| p.to_string())
11205                    .collect::<Vec<String>>()
11206                    .join(",")
11207                    .to_string(),
11208            )]),
11209        };
11210    }
11211    if let Some(ref local_var_str) = distance_unit__nie {
11212        local_var_req_builder = match "multi" {
11213            "multi" => local_var_req_builder.query(
11214                &local_var_str
11215                    .into_iter()
11216                    .map(|p| ("distance_unit__nie".to_owned(), p.to_string()))
11217                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11218            ),
11219            _ => local_var_req_builder.query(&[(
11220                "distance_unit__nie",
11221                &local_var_str
11222                    .into_iter()
11223                    .map(|p| p.to_string())
11224                    .collect::<Vec<String>>()
11225                    .join(",")
11226                    .to_string(),
11227            )]),
11228        };
11229    }
11230    if let Some(ref local_var_str) = distance_unit__niew {
11231        local_var_req_builder = match "multi" {
11232            "multi" => local_var_req_builder.query(
11233                &local_var_str
11234                    .into_iter()
11235                    .map(|p| ("distance_unit__niew".to_owned(), p.to_string()))
11236                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11237            ),
11238            _ => local_var_req_builder.query(&[(
11239                "distance_unit__niew",
11240                &local_var_str
11241                    .into_iter()
11242                    .map(|p| p.to_string())
11243                    .collect::<Vec<String>>()
11244                    .join(",")
11245                    .to_string(),
11246            )]),
11247        };
11248    }
11249    if let Some(ref local_var_str) = distance_unit__nisw {
11250        local_var_req_builder = match "multi" {
11251            "multi" => local_var_req_builder.query(
11252                &local_var_str
11253                    .into_iter()
11254                    .map(|p| ("distance_unit__nisw".to_owned(), p.to_string()))
11255                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11256            ),
11257            _ => local_var_req_builder.query(&[(
11258                "distance_unit__nisw",
11259                &local_var_str
11260                    .into_iter()
11261                    .map(|p| p.to_string())
11262                    .collect::<Vec<String>>()
11263                    .join(",")
11264                    .to_string(),
11265            )]),
11266        };
11267    }
11268    if let Some(ref local_var_str) = distance_unit__regex {
11269        local_var_req_builder = match "multi" {
11270            "multi" => local_var_req_builder.query(
11271                &local_var_str
11272                    .into_iter()
11273                    .map(|p| ("distance_unit__regex".to_owned(), p.to_string()))
11274                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11275            ),
11276            _ => local_var_req_builder.query(&[(
11277                "distance_unit__regex",
11278                &local_var_str
11279                    .into_iter()
11280                    .map(|p| p.to_string())
11281                    .collect::<Vec<String>>()
11282                    .join(",")
11283                    .to_string(),
11284            )]),
11285        };
11286    }
11287    if let Some(ref local_var_str) = id {
11288        local_var_req_builder = match "multi" {
11289            "multi" => local_var_req_builder.query(
11290                &local_var_str
11291                    .into_iter()
11292                    .map(|p| ("id".to_owned(), p.to_string()))
11293                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11294            ),
11295            _ => local_var_req_builder.query(&[(
11296                "id",
11297                &local_var_str
11298                    .into_iter()
11299                    .map(|p| p.to_string())
11300                    .collect::<Vec<String>>()
11301                    .join(",")
11302                    .to_string(),
11303            )]),
11304        };
11305    }
11306    if let Some(ref local_var_str) = id__empty {
11307        local_var_req_builder =
11308            local_var_req_builder.query(&[("id__empty", &local_var_str.to_string())]);
11309    }
11310    if let Some(ref local_var_str) = id__gt {
11311        local_var_req_builder = match "multi" {
11312            "multi" => local_var_req_builder.query(
11313                &local_var_str
11314                    .into_iter()
11315                    .map(|p| ("id__gt".to_owned(), p.to_string()))
11316                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11317            ),
11318            _ => local_var_req_builder.query(&[(
11319                "id__gt",
11320                &local_var_str
11321                    .into_iter()
11322                    .map(|p| p.to_string())
11323                    .collect::<Vec<String>>()
11324                    .join(",")
11325                    .to_string(),
11326            )]),
11327        };
11328    }
11329    if let Some(ref local_var_str) = id__gte {
11330        local_var_req_builder = match "multi" {
11331            "multi" => local_var_req_builder.query(
11332                &local_var_str
11333                    .into_iter()
11334                    .map(|p| ("id__gte".to_owned(), p.to_string()))
11335                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11336            ),
11337            _ => local_var_req_builder.query(&[(
11338                "id__gte",
11339                &local_var_str
11340                    .into_iter()
11341                    .map(|p| p.to_string())
11342                    .collect::<Vec<String>>()
11343                    .join(",")
11344                    .to_string(),
11345            )]),
11346        };
11347    }
11348    if let Some(ref local_var_str) = id__lt {
11349        local_var_req_builder = match "multi" {
11350            "multi" => local_var_req_builder.query(
11351                &local_var_str
11352                    .into_iter()
11353                    .map(|p| ("id__lt".to_owned(), p.to_string()))
11354                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11355            ),
11356            _ => local_var_req_builder.query(&[(
11357                "id__lt",
11358                &local_var_str
11359                    .into_iter()
11360                    .map(|p| p.to_string())
11361                    .collect::<Vec<String>>()
11362                    .join(",")
11363                    .to_string(),
11364            )]),
11365        };
11366    }
11367    if let Some(ref local_var_str) = id__lte {
11368        local_var_req_builder = match "multi" {
11369            "multi" => local_var_req_builder.query(
11370                &local_var_str
11371                    .into_iter()
11372                    .map(|p| ("id__lte".to_owned(), p.to_string()))
11373                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11374            ),
11375            _ => local_var_req_builder.query(&[(
11376                "id__lte",
11377                &local_var_str
11378                    .into_iter()
11379                    .map(|p| p.to_string())
11380                    .collect::<Vec<String>>()
11381                    .join(",")
11382                    .to_string(),
11383            )]),
11384        };
11385    }
11386    if let Some(ref local_var_str) = id__n {
11387        local_var_req_builder = match "multi" {
11388            "multi" => local_var_req_builder.query(
11389                &local_var_str
11390                    .into_iter()
11391                    .map(|p| ("id__n".to_owned(), p.to_string()))
11392                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11393            ),
11394            _ => local_var_req_builder.query(&[(
11395                "id__n",
11396                &local_var_str
11397                    .into_iter()
11398                    .map(|p| p.to_string())
11399                    .collect::<Vec<String>>()
11400                    .join(",")
11401                    .to_string(),
11402            )]),
11403        };
11404    }
11405    if let Some(ref local_var_str) = install_date {
11406        local_var_req_builder = match "multi" {
11407            "multi" => local_var_req_builder.query(
11408                &local_var_str
11409                    .into_iter()
11410                    .map(|p| ("install_date".to_owned(), p.to_string()))
11411                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11412            ),
11413            _ => local_var_req_builder.query(&[(
11414                "install_date",
11415                &local_var_str
11416                    .into_iter()
11417                    .map(|p| p.to_string())
11418                    .collect::<Vec<String>>()
11419                    .join(",")
11420                    .to_string(),
11421            )]),
11422        };
11423    }
11424    if let Some(ref local_var_str) = install_date__empty {
11425        local_var_req_builder =
11426            local_var_req_builder.query(&[("install_date__empty", &local_var_str.to_string())]);
11427    }
11428    if let Some(ref local_var_str) = install_date__gt {
11429        local_var_req_builder = match "multi" {
11430            "multi" => local_var_req_builder.query(
11431                &local_var_str
11432                    .into_iter()
11433                    .map(|p| ("install_date__gt".to_owned(), p.to_string()))
11434                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11435            ),
11436            _ => local_var_req_builder.query(&[(
11437                "install_date__gt",
11438                &local_var_str
11439                    .into_iter()
11440                    .map(|p| p.to_string())
11441                    .collect::<Vec<String>>()
11442                    .join(",")
11443                    .to_string(),
11444            )]),
11445        };
11446    }
11447    if let Some(ref local_var_str) = install_date__gte {
11448        local_var_req_builder = match "multi" {
11449            "multi" => local_var_req_builder.query(
11450                &local_var_str
11451                    .into_iter()
11452                    .map(|p| ("install_date__gte".to_owned(), p.to_string()))
11453                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11454            ),
11455            _ => local_var_req_builder.query(&[(
11456                "install_date__gte",
11457                &local_var_str
11458                    .into_iter()
11459                    .map(|p| p.to_string())
11460                    .collect::<Vec<String>>()
11461                    .join(",")
11462                    .to_string(),
11463            )]),
11464        };
11465    }
11466    if let Some(ref local_var_str) = install_date__lt {
11467        local_var_req_builder = match "multi" {
11468            "multi" => local_var_req_builder.query(
11469                &local_var_str
11470                    .into_iter()
11471                    .map(|p| ("install_date__lt".to_owned(), p.to_string()))
11472                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11473            ),
11474            _ => local_var_req_builder.query(&[(
11475                "install_date__lt",
11476                &local_var_str
11477                    .into_iter()
11478                    .map(|p| p.to_string())
11479                    .collect::<Vec<String>>()
11480                    .join(",")
11481                    .to_string(),
11482            )]),
11483        };
11484    }
11485    if let Some(ref local_var_str) = install_date__lte {
11486        local_var_req_builder = match "multi" {
11487            "multi" => local_var_req_builder.query(
11488                &local_var_str
11489                    .into_iter()
11490                    .map(|p| ("install_date__lte".to_owned(), p.to_string()))
11491                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11492            ),
11493            _ => local_var_req_builder.query(&[(
11494                "install_date__lte",
11495                &local_var_str
11496                    .into_iter()
11497                    .map(|p| p.to_string())
11498                    .collect::<Vec<String>>()
11499                    .join(",")
11500                    .to_string(),
11501            )]),
11502        };
11503    }
11504    if let Some(ref local_var_str) = install_date__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| ("install_date__n".to_owned(), p.to_string()))
11510                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11511            ),
11512            _ => local_var_req_builder.query(&[(
11513                "install_date__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) = last_updated {
11524        local_var_req_builder = match "multi" {
11525            "multi" => local_var_req_builder.query(
11526                &local_var_str
11527                    .into_iter()
11528                    .map(|p| ("last_updated".to_owned(), p.to_string()))
11529                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11530            ),
11531            _ => local_var_req_builder.query(&[(
11532                "last_updated",
11533                &local_var_str
11534                    .into_iter()
11535                    .map(|p| p.to_string())
11536                    .collect::<Vec<String>>()
11537                    .join(",")
11538                    .to_string(),
11539            )]),
11540        };
11541    }
11542    if let Some(ref local_var_str) = last_updated__empty {
11543        local_var_req_builder = match "multi" {
11544            "multi" => local_var_req_builder.query(
11545                &local_var_str
11546                    .into_iter()
11547                    .map(|p| ("last_updated__empty".to_owned(), p.to_string()))
11548                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11549            ),
11550            _ => local_var_req_builder.query(&[(
11551                "last_updated__empty",
11552                &local_var_str
11553                    .into_iter()
11554                    .map(|p| p.to_string())
11555                    .collect::<Vec<String>>()
11556                    .join(",")
11557                    .to_string(),
11558            )]),
11559        };
11560    }
11561    if let Some(ref local_var_str) = last_updated__gt {
11562        local_var_req_builder = match "multi" {
11563            "multi" => local_var_req_builder.query(
11564                &local_var_str
11565                    .into_iter()
11566                    .map(|p| ("last_updated__gt".to_owned(), p.to_string()))
11567                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11568            ),
11569            _ => local_var_req_builder.query(&[(
11570                "last_updated__gt",
11571                &local_var_str
11572                    .into_iter()
11573                    .map(|p| p.to_string())
11574                    .collect::<Vec<String>>()
11575                    .join(",")
11576                    .to_string(),
11577            )]),
11578        };
11579    }
11580    if let Some(ref local_var_str) = last_updated__gte {
11581        local_var_req_builder = match "multi" {
11582            "multi" => local_var_req_builder.query(
11583                &local_var_str
11584                    .into_iter()
11585                    .map(|p| ("last_updated__gte".to_owned(), p.to_string()))
11586                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11587            ),
11588            _ => local_var_req_builder.query(&[(
11589                "last_updated__gte",
11590                &local_var_str
11591                    .into_iter()
11592                    .map(|p| p.to_string())
11593                    .collect::<Vec<String>>()
11594                    .join(",")
11595                    .to_string(),
11596            )]),
11597        };
11598    }
11599    if let Some(ref local_var_str) = last_updated__lt {
11600        local_var_req_builder = match "multi" {
11601            "multi" => local_var_req_builder.query(
11602                &local_var_str
11603                    .into_iter()
11604                    .map(|p| ("last_updated__lt".to_owned(), p.to_string()))
11605                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11606            ),
11607            _ => local_var_req_builder.query(&[(
11608                "last_updated__lt",
11609                &local_var_str
11610                    .into_iter()
11611                    .map(|p| p.to_string())
11612                    .collect::<Vec<String>>()
11613                    .join(",")
11614                    .to_string(),
11615            )]),
11616        };
11617    }
11618    if let Some(ref local_var_str) = last_updated__lte {
11619        local_var_req_builder = match "multi" {
11620            "multi" => local_var_req_builder.query(
11621                &local_var_str
11622                    .into_iter()
11623                    .map(|p| ("last_updated__lte".to_owned(), p.to_string()))
11624                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11625            ),
11626            _ => local_var_req_builder.query(&[(
11627                "last_updated__lte",
11628                &local_var_str
11629                    .into_iter()
11630                    .map(|p| p.to_string())
11631                    .collect::<Vec<String>>()
11632                    .join(",")
11633                    .to_string(),
11634            )]),
11635        };
11636    }
11637    if let Some(ref local_var_str) = last_updated__n {
11638        local_var_req_builder = match "multi" {
11639            "multi" => local_var_req_builder.query(
11640                &local_var_str
11641                    .into_iter()
11642                    .map(|p| ("last_updated__n".to_owned(), p.to_string()))
11643                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11644            ),
11645            _ => local_var_req_builder.query(&[(
11646                "last_updated__n",
11647                &local_var_str
11648                    .into_iter()
11649                    .map(|p| p.to_string())
11650                    .collect::<Vec<String>>()
11651                    .join(",")
11652                    .to_string(),
11653            )]),
11654        };
11655    }
11656    if let Some(ref local_var_str) = limit {
11657        local_var_req_builder =
11658            local_var_req_builder.query(&[("limit", &local_var_str.to_string())]);
11659    }
11660    if let Some(ref local_var_str) = location_id {
11661        local_var_req_builder = match "multi" {
11662            "multi" => local_var_req_builder.query(
11663                &local_var_str
11664                    .into_iter()
11665                    .map(|p| ("location_id".to_owned(), p.to_string()))
11666                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11667            ),
11668            _ => local_var_req_builder.query(&[(
11669                "location_id",
11670                &local_var_str
11671                    .into_iter()
11672                    .map(|p| p.to_string())
11673                    .collect::<Vec<String>>()
11674                    .join(",")
11675                    .to_string(),
11676            )]),
11677        };
11678    }
11679    if let Some(ref local_var_str) = location_id__n {
11680        local_var_req_builder = match "multi" {
11681            "multi" => local_var_req_builder.query(
11682                &local_var_str
11683                    .into_iter()
11684                    .map(|p| ("location_id__n".to_owned(), p.to_string()))
11685                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11686            ),
11687            _ => local_var_req_builder.query(&[(
11688                "location_id__n",
11689                &local_var_str
11690                    .into_iter()
11691                    .map(|p| p.to_string())
11692                    .collect::<Vec<String>>()
11693                    .join(",")
11694                    .to_string(),
11695            )]),
11696        };
11697    }
11698    if let Some(ref local_var_str) = modified_by_request {
11699        local_var_req_builder =
11700            local_var_req_builder.query(&[("modified_by_request", &local_var_str.to_string())]);
11701    }
11702    if let Some(ref local_var_str) = offset {
11703        local_var_req_builder =
11704            local_var_req_builder.query(&[("offset", &local_var_str.to_string())]);
11705    }
11706    if let Some(ref local_var_str) = ordering {
11707        local_var_req_builder =
11708            local_var_req_builder.query(&[("ordering", &local_var_str.to_string())]);
11709    }
11710    if let Some(ref local_var_str) = owner {
11711        local_var_req_builder = match "multi" {
11712            "multi" => local_var_req_builder.query(
11713                &local_var_str
11714                    .into_iter()
11715                    .map(|p| ("owner".to_owned(), p.to_string()))
11716                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11717            ),
11718            _ => local_var_req_builder.query(&[(
11719                "owner",
11720                &local_var_str
11721                    .into_iter()
11722                    .map(|p| p.to_string())
11723                    .collect::<Vec<String>>()
11724                    .join(",")
11725                    .to_string(),
11726            )]),
11727        };
11728    }
11729    if let Some(ref local_var_str) = owner__n {
11730        local_var_req_builder = match "multi" {
11731            "multi" => local_var_req_builder.query(
11732                &local_var_str
11733                    .into_iter()
11734                    .map(|p| ("owner__n".to_owned(), p.to_string()))
11735                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11736            ),
11737            _ => local_var_req_builder.query(&[(
11738                "owner__n",
11739                &local_var_str
11740                    .into_iter()
11741                    .map(|p| p.to_string())
11742                    .collect::<Vec<String>>()
11743                    .join(",")
11744                    .to_string(),
11745            )]),
11746        };
11747    }
11748    if let Some(ref local_var_str) = owner_group {
11749        local_var_req_builder = match "multi" {
11750            "multi" => local_var_req_builder.query(
11751                &local_var_str
11752                    .into_iter()
11753                    .map(|p| ("owner_group".to_owned(), p.to_string()))
11754                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11755            ),
11756            _ => local_var_req_builder.query(&[(
11757                "owner_group",
11758                &local_var_str
11759                    .into_iter()
11760                    .map(|p| p.to_string())
11761                    .collect::<Vec<String>>()
11762                    .join(",")
11763                    .to_string(),
11764            )]),
11765        };
11766    }
11767    if let Some(ref local_var_str) = owner_group__n {
11768        local_var_req_builder = match "multi" {
11769            "multi" => local_var_req_builder.query(
11770                &local_var_str
11771                    .into_iter()
11772                    .map(|p| ("owner_group__n".to_owned(), p.to_string()))
11773                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11774            ),
11775            _ => local_var_req_builder.query(&[(
11776                "owner_group__n",
11777                &local_var_str
11778                    .into_iter()
11779                    .map(|p| p.to_string())
11780                    .collect::<Vec<String>>()
11781                    .join(",")
11782                    .to_string(),
11783            )]),
11784        };
11785    }
11786    if let Some(ref local_var_str) = owner_group_id {
11787        local_var_req_builder = match "multi" {
11788            "multi" => local_var_req_builder.query(
11789                &local_var_str
11790                    .into_iter()
11791                    .map(|p| ("owner_group_id".to_owned(), p.to_string()))
11792                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11793            ),
11794            _ => local_var_req_builder.query(&[(
11795                "owner_group_id",
11796                &local_var_str
11797                    .into_iter()
11798                    .map(|p| p.to_string())
11799                    .collect::<Vec<String>>()
11800                    .join(",")
11801                    .to_string(),
11802            )]),
11803        };
11804    }
11805    if let Some(ref local_var_str) = owner_group_id__n {
11806        local_var_req_builder = match "multi" {
11807            "multi" => local_var_req_builder.query(
11808                &local_var_str
11809                    .into_iter()
11810                    .map(|p| ("owner_group_id__n".to_owned(), p.to_string()))
11811                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11812            ),
11813            _ => local_var_req_builder.query(&[(
11814                "owner_group_id__n",
11815                &local_var_str
11816                    .into_iter()
11817                    .map(|p| p.to_string())
11818                    .collect::<Vec<String>>()
11819                    .join(",")
11820                    .to_string(),
11821            )]),
11822        };
11823    }
11824    if let Some(ref local_var_str) = owner_id {
11825        local_var_req_builder = match "multi" {
11826            "multi" => local_var_req_builder.query(
11827                &local_var_str
11828                    .into_iter()
11829                    .map(|p| ("owner_id".to_owned(), p.to_string()))
11830                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11831            ),
11832            _ => local_var_req_builder.query(&[(
11833                "owner_id",
11834                &local_var_str
11835                    .into_iter()
11836                    .map(|p| p.to_string())
11837                    .collect::<Vec<String>>()
11838                    .join(",")
11839                    .to_string(),
11840            )]),
11841        };
11842    }
11843    if let Some(ref local_var_str) = owner_id__n {
11844        local_var_req_builder = match "multi" {
11845            "multi" => local_var_req_builder.query(
11846                &local_var_str
11847                    .into_iter()
11848                    .map(|p| ("owner_id__n".to_owned(), p.to_string()))
11849                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11850            ),
11851            _ => local_var_req_builder.query(&[(
11852                "owner_id__n",
11853                &local_var_str
11854                    .into_iter()
11855                    .map(|p| p.to_string())
11856                    .collect::<Vec<String>>()
11857                    .join(",")
11858                    .to_string(),
11859            )]),
11860        };
11861    }
11862    if let Some(ref local_var_str) = provider {
11863        local_var_req_builder = match "multi" {
11864            "multi" => local_var_req_builder.query(
11865                &local_var_str
11866                    .into_iter()
11867                    .map(|p| ("provider".to_owned(), p.to_string()))
11868                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11869            ),
11870            _ => local_var_req_builder.query(&[(
11871                "provider",
11872                &local_var_str
11873                    .into_iter()
11874                    .map(|p| p.to_string())
11875                    .collect::<Vec<String>>()
11876                    .join(",")
11877                    .to_string(),
11878            )]),
11879        };
11880    }
11881    if let Some(ref local_var_str) = provider__n {
11882        local_var_req_builder = match "multi" {
11883            "multi" => local_var_req_builder.query(
11884                &local_var_str
11885                    .into_iter()
11886                    .map(|p| ("provider__n".to_owned(), p.to_string()))
11887                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11888            ),
11889            _ => local_var_req_builder.query(&[(
11890                "provider__n",
11891                &local_var_str
11892                    .into_iter()
11893                    .map(|p| p.to_string())
11894                    .collect::<Vec<String>>()
11895                    .join(",")
11896                    .to_string(),
11897            )]),
11898        };
11899    }
11900    if let Some(ref local_var_str) = provider_account {
11901        local_var_req_builder = match "multi" {
11902            "multi" => local_var_req_builder.query(
11903                &local_var_str
11904                    .into_iter()
11905                    .map(|p| ("provider_account".to_owned(), p.to_string()))
11906                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11907            ),
11908            _ => local_var_req_builder.query(&[(
11909                "provider_account",
11910                &local_var_str
11911                    .into_iter()
11912                    .map(|p| p.to_string())
11913                    .collect::<Vec<String>>()
11914                    .join(",")
11915                    .to_string(),
11916            )]),
11917        };
11918    }
11919    if let Some(ref local_var_str) = provider_account__n {
11920        local_var_req_builder = match "multi" {
11921            "multi" => local_var_req_builder.query(
11922                &local_var_str
11923                    .into_iter()
11924                    .map(|p| ("provider_account__n".to_owned(), p.to_string()))
11925                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11926            ),
11927            _ => local_var_req_builder.query(&[(
11928                "provider_account__n",
11929                &local_var_str
11930                    .into_iter()
11931                    .map(|p| p.to_string())
11932                    .collect::<Vec<String>>()
11933                    .join(",")
11934                    .to_string(),
11935            )]),
11936        };
11937    }
11938    if let Some(ref local_var_str) = provider_account_id {
11939        local_var_req_builder = match "multi" {
11940            "multi" => local_var_req_builder.query(
11941                &local_var_str
11942                    .into_iter()
11943                    .map(|p| ("provider_account_id".to_owned(), p.to_string()))
11944                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11945            ),
11946            _ => local_var_req_builder.query(&[(
11947                "provider_account_id",
11948                &local_var_str
11949                    .into_iter()
11950                    .map(|p| p.to_string())
11951                    .collect::<Vec<String>>()
11952                    .join(",")
11953                    .to_string(),
11954            )]),
11955        };
11956    }
11957    if let Some(ref local_var_str) = provider_account_id__n {
11958        local_var_req_builder = match "multi" {
11959            "multi" => local_var_req_builder.query(
11960                &local_var_str
11961                    .into_iter()
11962                    .map(|p| ("provider_account_id__n".to_owned(), p.to_string()))
11963                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11964            ),
11965            _ => local_var_req_builder.query(&[(
11966                "provider_account_id__n",
11967                &local_var_str
11968                    .into_iter()
11969                    .map(|p| p.to_string())
11970                    .collect::<Vec<String>>()
11971                    .join(",")
11972                    .to_string(),
11973            )]),
11974        };
11975    }
11976    if let Some(ref local_var_str) = provider_id {
11977        local_var_req_builder = match "multi" {
11978            "multi" => local_var_req_builder.query(
11979                &local_var_str
11980                    .into_iter()
11981                    .map(|p| ("provider_id".to_owned(), p.to_string()))
11982                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11983            ),
11984            _ => local_var_req_builder.query(&[(
11985                "provider_id",
11986                &local_var_str
11987                    .into_iter()
11988                    .map(|p| p.to_string())
11989                    .collect::<Vec<String>>()
11990                    .join(",")
11991                    .to_string(),
11992            )]),
11993        };
11994    }
11995    if let Some(ref local_var_str) = provider_id__n {
11996        local_var_req_builder = match "multi" {
11997            "multi" => local_var_req_builder.query(
11998                &local_var_str
11999                    .into_iter()
12000                    .map(|p| ("provider_id__n".to_owned(), p.to_string()))
12001                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12002            ),
12003            _ => local_var_req_builder.query(&[(
12004                "provider_id__n",
12005                &local_var_str
12006                    .into_iter()
12007                    .map(|p| p.to_string())
12008                    .collect::<Vec<String>>()
12009                    .join(",")
12010                    .to_string(),
12011            )]),
12012        };
12013    }
12014    if let Some(ref local_var_str) = provider_network_id {
12015        local_var_req_builder = match "multi" {
12016            "multi" => local_var_req_builder.query(
12017                &local_var_str
12018                    .into_iter()
12019                    .map(|p| ("provider_network_id".to_owned(), p.to_string()))
12020                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12021            ),
12022            _ => local_var_req_builder.query(&[(
12023                "provider_network_id",
12024                &local_var_str
12025                    .into_iter()
12026                    .map(|p| p.to_string())
12027                    .collect::<Vec<String>>()
12028                    .join(",")
12029                    .to_string(),
12030            )]),
12031        };
12032    }
12033    if let Some(ref local_var_str) = provider_network_id__n {
12034        local_var_req_builder = match "multi" {
12035            "multi" => local_var_req_builder.query(
12036                &local_var_str
12037                    .into_iter()
12038                    .map(|p| ("provider_network_id__n".to_owned(), p.to_string()))
12039                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12040            ),
12041            _ => local_var_req_builder.query(&[(
12042                "provider_network_id__n",
12043                &local_var_str
12044                    .into_iter()
12045                    .map(|p| p.to_string())
12046                    .collect::<Vec<String>>()
12047                    .join(",")
12048                    .to_string(),
12049            )]),
12050        };
12051    }
12052    if let Some(ref local_var_str) = q {
12053        local_var_req_builder = local_var_req_builder.query(&[("q", &local_var_str.to_string())]);
12054    }
12055    if let Some(ref local_var_str) = region {
12056        local_var_req_builder = match "multi" {
12057            "multi" => local_var_req_builder.query(
12058                &local_var_str
12059                    .into_iter()
12060                    .map(|p| ("region".to_owned(), p.to_string()))
12061                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12062            ),
12063            _ => local_var_req_builder.query(&[(
12064                "region",
12065                &local_var_str
12066                    .into_iter()
12067                    .map(|p| p.to_string())
12068                    .collect::<Vec<String>>()
12069                    .join(",")
12070                    .to_string(),
12071            )]),
12072        };
12073    }
12074    if let Some(ref local_var_str) = region__n {
12075        local_var_req_builder = match "multi" {
12076            "multi" => local_var_req_builder.query(
12077                &local_var_str
12078                    .into_iter()
12079                    .map(|p| ("region__n".to_owned(), p.to_string()))
12080                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12081            ),
12082            _ => local_var_req_builder.query(&[(
12083                "region__n",
12084                &local_var_str
12085                    .into_iter()
12086                    .map(|p| p.to_string())
12087                    .collect::<Vec<String>>()
12088                    .join(",")
12089                    .to_string(),
12090            )]),
12091        };
12092    }
12093    if let Some(ref local_var_str) = region_id {
12094        local_var_req_builder = match "multi" {
12095            "multi" => local_var_req_builder.query(
12096                &local_var_str
12097                    .into_iter()
12098                    .map(|p| ("region_id".to_owned(), p.to_string()))
12099                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12100            ),
12101            _ => local_var_req_builder.query(&[(
12102                "region_id",
12103                &local_var_str
12104                    .into_iter()
12105                    .map(|p| p.to_string())
12106                    .collect::<Vec<String>>()
12107                    .join(",")
12108                    .to_string(),
12109            )]),
12110        };
12111    }
12112    if let Some(ref local_var_str) = region_id__n {
12113        local_var_req_builder = match "multi" {
12114            "multi" => local_var_req_builder.query(
12115                &local_var_str
12116                    .into_iter()
12117                    .map(|p| ("region_id__n".to_owned(), p.to_string()))
12118                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12119            ),
12120            _ => local_var_req_builder.query(&[(
12121                "region_id__n",
12122                &local_var_str
12123                    .into_iter()
12124                    .map(|p| p.to_string())
12125                    .collect::<Vec<String>>()
12126                    .join(",")
12127                    .to_string(),
12128            )]),
12129        };
12130    }
12131    if let Some(ref local_var_str) = site {
12132        local_var_req_builder = match "multi" {
12133            "multi" => local_var_req_builder.query(
12134                &local_var_str
12135                    .into_iter()
12136                    .map(|p| ("site".to_owned(), p.to_string()))
12137                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12138            ),
12139            _ => local_var_req_builder.query(&[(
12140                "site",
12141                &local_var_str
12142                    .into_iter()
12143                    .map(|p| p.to_string())
12144                    .collect::<Vec<String>>()
12145                    .join(",")
12146                    .to_string(),
12147            )]),
12148        };
12149    }
12150    if let Some(ref local_var_str) = site__n {
12151        local_var_req_builder = match "multi" {
12152            "multi" => local_var_req_builder.query(
12153                &local_var_str
12154                    .into_iter()
12155                    .map(|p| ("site__n".to_owned(), p.to_string()))
12156                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12157            ),
12158            _ => local_var_req_builder.query(&[(
12159                "site__n",
12160                &local_var_str
12161                    .into_iter()
12162                    .map(|p| p.to_string())
12163                    .collect::<Vec<String>>()
12164                    .join(",")
12165                    .to_string(),
12166            )]),
12167        };
12168    }
12169    if let Some(ref local_var_str) = site_group {
12170        local_var_req_builder = match "multi" {
12171            "multi" => local_var_req_builder.query(
12172                &local_var_str
12173                    .into_iter()
12174                    .map(|p| ("site_group".to_owned(), p.to_string()))
12175                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12176            ),
12177            _ => local_var_req_builder.query(&[(
12178                "site_group",
12179                &local_var_str
12180                    .into_iter()
12181                    .map(|p| p.to_string())
12182                    .collect::<Vec<String>>()
12183                    .join(",")
12184                    .to_string(),
12185            )]),
12186        };
12187    }
12188    if let Some(ref local_var_str) = site_group__n {
12189        local_var_req_builder = match "multi" {
12190            "multi" => local_var_req_builder.query(
12191                &local_var_str
12192                    .into_iter()
12193                    .map(|p| ("site_group__n".to_owned(), p.to_string()))
12194                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12195            ),
12196            _ => local_var_req_builder.query(&[(
12197                "site_group__n",
12198                &local_var_str
12199                    .into_iter()
12200                    .map(|p| p.to_string())
12201                    .collect::<Vec<String>>()
12202                    .join(",")
12203                    .to_string(),
12204            )]),
12205        };
12206    }
12207    if let Some(ref local_var_str) = site_group_id {
12208        local_var_req_builder = match "multi" {
12209            "multi" => local_var_req_builder.query(
12210                &local_var_str
12211                    .into_iter()
12212                    .map(|p| ("site_group_id".to_owned(), p.to_string()))
12213                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12214            ),
12215            _ => local_var_req_builder.query(&[(
12216                "site_group_id",
12217                &local_var_str
12218                    .into_iter()
12219                    .map(|p| p.to_string())
12220                    .collect::<Vec<String>>()
12221                    .join(",")
12222                    .to_string(),
12223            )]),
12224        };
12225    }
12226    if let Some(ref local_var_str) = site_group_id__n {
12227        local_var_req_builder = match "multi" {
12228            "multi" => local_var_req_builder.query(
12229                &local_var_str
12230                    .into_iter()
12231                    .map(|p| ("site_group_id__n".to_owned(), p.to_string()))
12232                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12233            ),
12234            _ => local_var_req_builder.query(&[(
12235                "site_group_id__n",
12236                &local_var_str
12237                    .into_iter()
12238                    .map(|p| p.to_string())
12239                    .collect::<Vec<String>>()
12240                    .join(",")
12241                    .to_string(),
12242            )]),
12243        };
12244    }
12245    if let Some(ref local_var_str) = site_id {
12246        local_var_req_builder = match "multi" {
12247            "multi" => local_var_req_builder.query(
12248                &local_var_str
12249                    .into_iter()
12250                    .map(|p| ("site_id".to_owned(), p.to_string()))
12251                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12252            ),
12253            _ => local_var_req_builder.query(&[(
12254                "site_id",
12255                &local_var_str
12256                    .into_iter()
12257                    .map(|p| p.to_string())
12258                    .collect::<Vec<String>>()
12259                    .join(",")
12260                    .to_string(),
12261            )]),
12262        };
12263    }
12264    if let Some(ref local_var_str) = site_id__n {
12265        local_var_req_builder = match "multi" {
12266            "multi" => local_var_req_builder.query(
12267                &local_var_str
12268                    .into_iter()
12269                    .map(|p| ("site_id__n".to_owned(), p.to_string()))
12270                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12271            ),
12272            _ => local_var_req_builder.query(&[(
12273                "site_id__n",
12274                &local_var_str
12275                    .into_iter()
12276                    .map(|p| p.to_string())
12277                    .collect::<Vec<String>>()
12278                    .join(",")
12279                    .to_string(),
12280            )]),
12281        };
12282    }
12283    if let Some(ref local_var_str) = status {
12284        local_var_req_builder = match "multi" {
12285            "multi" => local_var_req_builder.query(
12286                &local_var_str
12287                    .into_iter()
12288                    .map(|p| ("status".to_owned(), p.to_string()))
12289                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12290            ),
12291            _ => local_var_req_builder.query(&[(
12292                "status",
12293                &local_var_str
12294                    .into_iter()
12295                    .map(|p| p.to_string())
12296                    .collect::<Vec<String>>()
12297                    .join(",")
12298                    .to_string(),
12299            )]),
12300        };
12301    }
12302    if let Some(ref local_var_str) = status__empty {
12303        local_var_req_builder =
12304            local_var_req_builder.query(&[("status__empty", &local_var_str.to_string())]);
12305    }
12306    if let Some(ref local_var_str) = status__ic {
12307        local_var_req_builder = match "multi" {
12308            "multi" => local_var_req_builder.query(
12309                &local_var_str
12310                    .into_iter()
12311                    .map(|p| ("status__ic".to_owned(), p.to_string()))
12312                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12313            ),
12314            _ => local_var_req_builder.query(&[(
12315                "status__ic",
12316                &local_var_str
12317                    .into_iter()
12318                    .map(|p| p.to_string())
12319                    .collect::<Vec<String>>()
12320                    .join(",")
12321                    .to_string(),
12322            )]),
12323        };
12324    }
12325    if let Some(ref local_var_str) = status__ie {
12326        local_var_req_builder = match "multi" {
12327            "multi" => local_var_req_builder.query(
12328                &local_var_str
12329                    .into_iter()
12330                    .map(|p| ("status__ie".to_owned(), p.to_string()))
12331                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12332            ),
12333            _ => local_var_req_builder.query(&[(
12334                "status__ie",
12335                &local_var_str
12336                    .into_iter()
12337                    .map(|p| p.to_string())
12338                    .collect::<Vec<String>>()
12339                    .join(",")
12340                    .to_string(),
12341            )]),
12342        };
12343    }
12344    if let Some(ref local_var_str) = status__iew {
12345        local_var_req_builder = match "multi" {
12346            "multi" => local_var_req_builder.query(
12347                &local_var_str
12348                    .into_iter()
12349                    .map(|p| ("status__iew".to_owned(), p.to_string()))
12350                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12351            ),
12352            _ => local_var_req_builder.query(&[(
12353                "status__iew",
12354                &local_var_str
12355                    .into_iter()
12356                    .map(|p| p.to_string())
12357                    .collect::<Vec<String>>()
12358                    .join(",")
12359                    .to_string(),
12360            )]),
12361        };
12362    }
12363    if let Some(ref local_var_str) = status__iregex {
12364        local_var_req_builder = match "multi" {
12365            "multi" => local_var_req_builder.query(
12366                &local_var_str
12367                    .into_iter()
12368                    .map(|p| ("status__iregex".to_owned(), p.to_string()))
12369                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12370            ),
12371            _ => local_var_req_builder.query(&[(
12372                "status__iregex",
12373                &local_var_str
12374                    .into_iter()
12375                    .map(|p| p.to_string())
12376                    .collect::<Vec<String>>()
12377                    .join(",")
12378                    .to_string(),
12379            )]),
12380        };
12381    }
12382    if let Some(ref local_var_str) = status__isw {
12383        local_var_req_builder = match "multi" {
12384            "multi" => local_var_req_builder.query(
12385                &local_var_str
12386                    .into_iter()
12387                    .map(|p| ("status__isw".to_owned(), p.to_string()))
12388                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12389            ),
12390            _ => local_var_req_builder.query(&[(
12391                "status__isw",
12392                &local_var_str
12393                    .into_iter()
12394                    .map(|p| p.to_string())
12395                    .collect::<Vec<String>>()
12396                    .join(",")
12397                    .to_string(),
12398            )]),
12399        };
12400    }
12401    if let Some(ref local_var_str) = status__n {
12402        local_var_req_builder = match "multi" {
12403            "multi" => local_var_req_builder.query(
12404                &local_var_str
12405                    .into_iter()
12406                    .map(|p| ("status__n".to_owned(), p.to_string()))
12407                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12408            ),
12409            _ => local_var_req_builder.query(&[(
12410                "status__n",
12411                &local_var_str
12412                    .into_iter()
12413                    .map(|p| p.to_string())
12414                    .collect::<Vec<String>>()
12415                    .join(",")
12416                    .to_string(),
12417            )]),
12418        };
12419    }
12420    if let Some(ref local_var_str) = status__nic {
12421        local_var_req_builder = match "multi" {
12422            "multi" => local_var_req_builder.query(
12423                &local_var_str
12424                    .into_iter()
12425                    .map(|p| ("status__nic".to_owned(), p.to_string()))
12426                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12427            ),
12428            _ => local_var_req_builder.query(&[(
12429                "status__nic",
12430                &local_var_str
12431                    .into_iter()
12432                    .map(|p| p.to_string())
12433                    .collect::<Vec<String>>()
12434                    .join(",")
12435                    .to_string(),
12436            )]),
12437        };
12438    }
12439    if let Some(ref local_var_str) = status__nie {
12440        local_var_req_builder = match "multi" {
12441            "multi" => local_var_req_builder.query(
12442                &local_var_str
12443                    .into_iter()
12444                    .map(|p| ("status__nie".to_owned(), p.to_string()))
12445                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12446            ),
12447            _ => local_var_req_builder.query(&[(
12448                "status__nie",
12449                &local_var_str
12450                    .into_iter()
12451                    .map(|p| p.to_string())
12452                    .collect::<Vec<String>>()
12453                    .join(",")
12454                    .to_string(),
12455            )]),
12456        };
12457    }
12458    if let Some(ref local_var_str) = status__niew {
12459        local_var_req_builder = match "multi" {
12460            "multi" => local_var_req_builder.query(
12461                &local_var_str
12462                    .into_iter()
12463                    .map(|p| ("status__niew".to_owned(), p.to_string()))
12464                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12465            ),
12466            _ => local_var_req_builder.query(&[(
12467                "status__niew",
12468                &local_var_str
12469                    .into_iter()
12470                    .map(|p| p.to_string())
12471                    .collect::<Vec<String>>()
12472                    .join(",")
12473                    .to_string(),
12474            )]),
12475        };
12476    }
12477    if let Some(ref local_var_str) = status__nisw {
12478        local_var_req_builder = match "multi" {
12479            "multi" => local_var_req_builder.query(
12480                &local_var_str
12481                    .into_iter()
12482                    .map(|p| ("status__nisw".to_owned(), p.to_string()))
12483                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12484            ),
12485            _ => local_var_req_builder.query(&[(
12486                "status__nisw",
12487                &local_var_str
12488                    .into_iter()
12489                    .map(|p| p.to_string())
12490                    .collect::<Vec<String>>()
12491                    .join(",")
12492                    .to_string(),
12493            )]),
12494        };
12495    }
12496    if let Some(ref local_var_str) = status__regex {
12497        local_var_req_builder = match "multi" {
12498            "multi" => local_var_req_builder.query(
12499                &local_var_str
12500                    .into_iter()
12501                    .map(|p| ("status__regex".to_owned(), p.to_string()))
12502                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12503            ),
12504            _ => local_var_req_builder.query(&[(
12505                "status__regex",
12506                &local_var_str
12507                    .into_iter()
12508                    .map(|p| p.to_string())
12509                    .collect::<Vec<String>>()
12510                    .join(",")
12511                    .to_string(),
12512            )]),
12513        };
12514    }
12515    if let Some(ref local_var_str) = tag {
12516        local_var_req_builder = match "multi" {
12517            "multi" => local_var_req_builder.query(
12518                &local_var_str
12519                    .into_iter()
12520                    .map(|p| ("tag".to_owned(), p.to_string()))
12521                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12522            ),
12523            _ => local_var_req_builder.query(&[(
12524                "tag",
12525                &local_var_str
12526                    .into_iter()
12527                    .map(|p| p.to_string())
12528                    .collect::<Vec<String>>()
12529                    .join(",")
12530                    .to_string(),
12531            )]),
12532        };
12533    }
12534    if let Some(ref local_var_str) = tag__n {
12535        local_var_req_builder = match "multi" {
12536            "multi" => local_var_req_builder.query(
12537                &local_var_str
12538                    .into_iter()
12539                    .map(|p| ("tag__n".to_owned(), p.to_string()))
12540                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12541            ),
12542            _ => local_var_req_builder.query(&[(
12543                "tag__n",
12544                &local_var_str
12545                    .into_iter()
12546                    .map(|p| p.to_string())
12547                    .collect::<Vec<String>>()
12548                    .join(",")
12549                    .to_string(),
12550            )]),
12551        };
12552    }
12553    if let Some(ref local_var_str) = tag_id {
12554        local_var_req_builder = match "multi" {
12555            "multi" => local_var_req_builder.query(
12556                &local_var_str
12557                    .into_iter()
12558                    .map(|p| ("tag_id".to_owned(), p.to_string()))
12559                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12560            ),
12561            _ => local_var_req_builder.query(&[(
12562                "tag_id",
12563                &local_var_str
12564                    .into_iter()
12565                    .map(|p| p.to_string())
12566                    .collect::<Vec<String>>()
12567                    .join(",")
12568                    .to_string(),
12569            )]),
12570        };
12571    }
12572    if let Some(ref local_var_str) = tag_id__n {
12573        local_var_req_builder = match "multi" {
12574            "multi" => local_var_req_builder.query(
12575                &local_var_str
12576                    .into_iter()
12577                    .map(|p| ("tag_id__n".to_owned(), p.to_string()))
12578                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12579            ),
12580            _ => local_var_req_builder.query(&[(
12581                "tag_id__n",
12582                &local_var_str
12583                    .into_iter()
12584                    .map(|p| p.to_string())
12585                    .collect::<Vec<String>>()
12586                    .join(",")
12587                    .to_string(),
12588            )]),
12589        };
12590    }
12591    if let Some(ref local_var_str) = tenant {
12592        local_var_req_builder = match "multi" {
12593            "multi" => local_var_req_builder.query(
12594                &local_var_str
12595                    .into_iter()
12596                    .map(|p| ("tenant".to_owned(), p.to_string()))
12597                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12598            ),
12599            _ => local_var_req_builder.query(&[(
12600                "tenant",
12601                &local_var_str
12602                    .into_iter()
12603                    .map(|p| p.to_string())
12604                    .collect::<Vec<String>>()
12605                    .join(",")
12606                    .to_string(),
12607            )]),
12608        };
12609    }
12610    if let Some(ref local_var_str) = tenant__n {
12611        local_var_req_builder = match "multi" {
12612            "multi" => local_var_req_builder.query(
12613                &local_var_str
12614                    .into_iter()
12615                    .map(|p| ("tenant__n".to_owned(), p.to_string()))
12616                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12617            ),
12618            _ => local_var_req_builder.query(&[(
12619                "tenant__n",
12620                &local_var_str
12621                    .into_iter()
12622                    .map(|p| p.to_string())
12623                    .collect::<Vec<String>>()
12624                    .join(",")
12625                    .to_string(),
12626            )]),
12627        };
12628    }
12629    if let Some(ref local_var_str) = tenant_group {
12630        local_var_req_builder = match "multi" {
12631            "multi" => local_var_req_builder.query(
12632                &local_var_str
12633                    .into_iter()
12634                    .map(|p| ("tenant_group".to_owned(), p.to_string()))
12635                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12636            ),
12637            _ => local_var_req_builder.query(&[(
12638                "tenant_group",
12639                &local_var_str
12640                    .into_iter()
12641                    .map(|p| p.to_string())
12642                    .collect::<Vec<String>>()
12643                    .join(",")
12644                    .to_string(),
12645            )]),
12646        };
12647    }
12648    if let Some(ref local_var_str) = tenant_group__n {
12649        local_var_req_builder = match "multi" {
12650            "multi" => local_var_req_builder.query(
12651                &local_var_str
12652                    .into_iter()
12653                    .map(|p| ("tenant_group__n".to_owned(), p.to_string()))
12654                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12655            ),
12656            _ => local_var_req_builder.query(&[(
12657                "tenant_group__n",
12658                &local_var_str
12659                    .into_iter()
12660                    .map(|p| p.to_string())
12661                    .collect::<Vec<String>>()
12662                    .join(",")
12663                    .to_string(),
12664            )]),
12665        };
12666    }
12667    if let Some(ref local_var_str) = tenant_group_id {
12668        local_var_req_builder = match "multi" {
12669            "multi" => local_var_req_builder.query(
12670                &local_var_str
12671                    .into_iter()
12672                    .map(|p| ("tenant_group_id".to_owned(), p.to_string()))
12673                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12674            ),
12675            _ => local_var_req_builder.query(&[(
12676                "tenant_group_id",
12677                &local_var_str
12678                    .into_iter()
12679                    .map(|p| p.to_string())
12680                    .collect::<Vec<String>>()
12681                    .join(",")
12682                    .to_string(),
12683            )]),
12684        };
12685    }
12686    if let Some(ref local_var_str) = tenant_group_id__n {
12687        local_var_req_builder = match "multi" {
12688            "multi" => local_var_req_builder.query(
12689                &local_var_str
12690                    .into_iter()
12691                    .map(|p| ("tenant_group_id__n".to_owned(), p.to_string()))
12692                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12693            ),
12694            _ => local_var_req_builder.query(&[(
12695                "tenant_group_id__n",
12696                &local_var_str
12697                    .into_iter()
12698                    .map(|p| p.to_string())
12699                    .collect::<Vec<String>>()
12700                    .join(",")
12701                    .to_string(),
12702            )]),
12703        };
12704    }
12705    if let Some(ref local_var_str) = tenant_id {
12706        local_var_req_builder = match "multi" {
12707            "multi" => local_var_req_builder.query(
12708                &local_var_str
12709                    .into_iter()
12710                    .map(|p| ("tenant_id".to_owned(), p.to_string()))
12711                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12712            ),
12713            _ => local_var_req_builder.query(&[(
12714                "tenant_id",
12715                &local_var_str
12716                    .into_iter()
12717                    .map(|p| p.to_string())
12718                    .collect::<Vec<String>>()
12719                    .join(",")
12720                    .to_string(),
12721            )]),
12722        };
12723    }
12724    if let Some(ref local_var_str) = tenant_id__n {
12725        local_var_req_builder = match "multi" {
12726            "multi" => local_var_req_builder.query(
12727                &local_var_str
12728                    .into_iter()
12729                    .map(|p| ("tenant_id__n".to_owned(), p.to_string()))
12730                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12731            ),
12732            _ => local_var_req_builder.query(&[(
12733                "tenant_id__n",
12734                &local_var_str
12735                    .into_iter()
12736                    .map(|p| p.to_string())
12737                    .collect::<Vec<String>>()
12738                    .join(",")
12739                    .to_string(),
12740            )]),
12741        };
12742    }
12743    if let Some(ref local_var_str) = termination_a_id {
12744        local_var_req_builder = match "multi" {
12745            "multi" => local_var_req_builder.query(
12746                &local_var_str
12747                    .into_iter()
12748                    .map(|p| ("termination_a_id".to_owned(), p.to_string()))
12749                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12750            ),
12751            _ => local_var_req_builder.query(&[(
12752                "termination_a_id",
12753                &local_var_str
12754                    .into_iter()
12755                    .map(|p| p.to_string())
12756                    .collect::<Vec<String>>()
12757                    .join(",")
12758                    .to_string(),
12759            )]),
12760        };
12761    }
12762    if let Some(ref local_var_str) = termination_a_id__n {
12763        local_var_req_builder = match "multi" {
12764            "multi" => local_var_req_builder.query(
12765                &local_var_str
12766                    .into_iter()
12767                    .map(|p| ("termination_a_id__n".to_owned(), p.to_string()))
12768                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12769            ),
12770            _ => local_var_req_builder.query(&[(
12771                "termination_a_id__n",
12772                &local_var_str
12773                    .into_iter()
12774                    .map(|p| p.to_string())
12775                    .collect::<Vec<String>>()
12776                    .join(",")
12777                    .to_string(),
12778            )]),
12779        };
12780    }
12781    if let Some(ref local_var_str) = termination_date {
12782        local_var_req_builder = match "multi" {
12783            "multi" => local_var_req_builder.query(
12784                &local_var_str
12785                    .into_iter()
12786                    .map(|p| ("termination_date".to_owned(), p.to_string()))
12787                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12788            ),
12789            _ => local_var_req_builder.query(&[(
12790                "termination_date",
12791                &local_var_str
12792                    .into_iter()
12793                    .map(|p| p.to_string())
12794                    .collect::<Vec<String>>()
12795                    .join(",")
12796                    .to_string(),
12797            )]),
12798        };
12799    }
12800    if let Some(ref local_var_str) = termination_date__empty {
12801        local_var_req_builder =
12802            local_var_req_builder.query(&[("termination_date__empty", &local_var_str.to_string())]);
12803    }
12804    if let Some(ref local_var_str) = termination_date__gt {
12805        local_var_req_builder = match "multi" {
12806            "multi" => local_var_req_builder.query(
12807                &local_var_str
12808                    .into_iter()
12809                    .map(|p| ("termination_date__gt".to_owned(), p.to_string()))
12810                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12811            ),
12812            _ => local_var_req_builder.query(&[(
12813                "termination_date__gt",
12814                &local_var_str
12815                    .into_iter()
12816                    .map(|p| p.to_string())
12817                    .collect::<Vec<String>>()
12818                    .join(",")
12819                    .to_string(),
12820            )]),
12821        };
12822    }
12823    if let Some(ref local_var_str) = termination_date__gte {
12824        local_var_req_builder = match "multi" {
12825            "multi" => local_var_req_builder.query(
12826                &local_var_str
12827                    .into_iter()
12828                    .map(|p| ("termination_date__gte".to_owned(), p.to_string()))
12829                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12830            ),
12831            _ => local_var_req_builder.query(&[(
12832                "termination_date__gte",
12833                &local_var_str
12834                    .into_iter()
12835                    .map(|p| p.to_string())
12836                    .collect::<Vec<String>>()
12837                    .join(",")
12838                    .to_string(),
12839            )]),
12840        };
12841    }
12842    if let Some(ref local_var_str) = termination_date__lt {
12843        local_var_req_builder = match "multi" {
12844            "multi" => local_var_req_builder.query(
12845                &local_var_str
12846                    .into_iter()
12847                    .map(|p| ("termination_date__lt".to_owned(), p.to_string()))
12848                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12849            ),
12850            _ => local_var_req_builder.query(&[(
12851                "termination_date__lt",
12852                &local_var_str
12853                    .into_iter()
12854                    .map(|p| p.to_string())
12855                    .collect::<Vec<String>>()
12856                    .join(",")
12857                    .to_string(),
12858            )]),
12859        };
12860    }
12861    if let Some(ref local_var_str) = termination_date__lte {
12862        local_var_req_builder = match "multi" {
12863            "multi" => local_var_req_builder.query(
12864                &local_var_str
12865                    .into_iter()
12866                    .map(|p| ("termination_date__lte".to_owned(), p.to_string()))
12867                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12868            ),
12869            _ => local_var_req_builder.query(&[(
12870                "termination_date__lte",
12871                &local_var_str
12872                    .into_iter()
12873                    .map(|p| p.to_string())
12874                    .collect::<Vec<String>>()
12875                    .join(",")
12876                    .to_string(),
12877            )]),
12878        };
12879    }
12880    if let Some(ref local_var_str) = termination_date__n {
12881        local_var_req_builder = match "multi" {
12882            "multi" => local_var_req_builder.query(
12883                &local_var_str
12884                    .into_iter()
12885                    .map(|p| ("termination_date__n".to_owned(), p.to_string()))
12886                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12887            ),
12888            _ => local_var_req_builder.query(&[(
12889                "termination_date__n",
12890                &local_var_str
12891                    .into_iter()
12892                    .map(|p| p.to_string())
12893                    .collect::<Vec<String>>()
12894                    .join(",")
12895                    .to_string(),
12896            )]),
12897        };
12898    }
12899    if let Some(ref local_var_str) = termination_z_id {
12900        local_var_req_builder = match "multi" {
12901            "multi" => local_var_req_builder.query(
12902                &local_var_str
12903                    .into_iter()
12904                    .map(|p| ("termination_z_id".to_owned(), p.to_string()))
12905                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12906            ),
12907            _ => local_var_req_builder.query(&[(
12908                "termination_z_id",
12909                &local_var_str
12910                    .into_iter()
12911                    .map(|p| p.to_string())
12912                    .collect::<Vec<String>>()
12913                    .join(",")
12914                    .to_string(),
12915            )]),
12916        };
12917    }
12918    if let Some(ref local_var_str) = termination_z_id__n {
12919        local_var_req_builder = match "multi" {
12920            "multi" => local_var_req_builder.query(
12921                &local_var_str
12922                    .into_iter()
12923                    .map(|p| ("termination_z_id__n".to_owned(), p.to_string()))
12924                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12925            ),
12926            _ => local_var_req_builder.query(&[(
12927                "termination_z_id__n",
12928                &local_var_str
12929                    .into_iter()
12930                    .map(|p| p.to_string())
12931                    .collect::<Vec<String>>()
12932                    .join(",")
12933                    .to_string(),
12934            )]),
12935        };
12936    }
12937    if let Some(ref local_var_str) = r#type {
12938        local_var_req_builder = match "multi" {
12939            "multi" => local_var_req_builder.query(
12940                &local_var_str
12941                    .into_iter()
12942                    .map(|p| ("type".to_owned(), p.to_string()))
12943                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12944            ),
12945            _ => local_var_req_builder.query(&[(
12946                "type",
12947                &local_var_str
12948                    .into_iter()
12949                    .map(|p| p.to_string())
12950                    .collect::<Vec<String>>()
12951                    .join(",")
12952                    .to_string(),
12953            )]),
12954        };
12955    }
12956    if let Some(ref local_var_str) = type__n {
12957        local_var_req_builder = match "multi" {
12958            "multi" => local_var_req_builder.query(
12959                &local_var_str
12960                    .into_iter()
12961                    .map(|p| ("type__n".to_owned(), p.to_string()))
12962                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12963            ),
12964            _ => local_var_req_builder.query(&[(
12965                "type__n",
12966                &local_var_str
12967                    .into_iter()
12968                    .map(|p| p.to_string())
12969                    .collect::<Vec<String>>()
12970                    .join(",")
12971                    .to_string(),
12972            )]),
12973        };
12974    }
12975    if let Some(ref local_var_str) = type_id {
12976        local_var_req_builder = match "multi" {
12977            "multi" => local_var_req_builder.query(
12978                &local_var_str
12979                    .into_iter()
12980                    .map(|p| ("type_id".to_owned(), p.to_string()))
12981                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12982            ),
12983            _ => local_var_req_builder.query(&[(
12984                "type_id",
12985                &local_var_str
12986                    .into_iter()
12987                    .map(|p| p.to_string())
12988                    .collect::<Vec<String>>()
12989                    .join(",")
12990                    .to_string(),
12991            )]),
12992        };
12993    }
12994    if let Some(ref local_var_str) = type_id__n {
12995        local_var_req_builder = match "multi" {
12996            "multi" => local_var_req_builder.query(
12997                &local_var_str
12998                    .into_iter()
12999                    .map(|p| ("type_id__n".to_owned(), p.to_string()))
13000                    .collect::<Vec<(std::string::String, std::string::String)>>(),
13001            ),
13002            _ => local_var_req_builder.query(&[(
13003                "type_id__n",
13004                &local_var_str
13005                    .into_iter()
13006                    .map(|p| p.to_string())
13007                    .collect::<Vec<String>>()
13008                    .join(",")
13009                    .to_string(),
13010            )]),
13011        };
13012    }
13013    if let Some(ref local_var_str) = updated_by_request {
13014        local_var_req_builder =
13015            local_var_req_builder.query(&[("updated_by_request", &local_var_str.to_string())]);
13016    }
13017    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
13018        local_var_req_builder =
13019            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
13020    }
13021    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
13022        let local_var_key = local_var_apikey.key.clone();
13023        let local_var_value = match local_var_apikey.prefix {
13024            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
13025            None => local_var_key,
13026        };
13027        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
13028    };
13029
13030    let local_var_req = local_var_req_builder.build()?;
13031    let local_var_resp = local_var_client.execute(local_var_req).await?;
13032
13033    let local_var_status = local_var_resp.status();
13034    let local_var_content = local_var_resp.text().await?;
13035
13036    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
13037        serde_json::from_str(&local_var_content).map_err(Error::from)
13038    } else {
13039        let local_var_entity: Option<CircuitsCircuitsListError> =
13040            serde_json::from_str(&local_var_content).ok();
13041        let local_var_error = ResponseContent {
13042            status: local_var_status,
13043            content: local_var_content,
13044            entity: local_var_entity,
13045        };
13046        Err(Error::ResponseError(local_var_error))
13047    }
13048}
13049
13050/// Patch a circuit object.
13051pub async fn circuits_circuits_partial_update(
13052    configuration: &configuration::Configuration,
13053    id: i32,
13054    patched_writable_circuit_request: Option<crate::models::PatchedWritableCircuitRequest>,
13055) -> Result<crate::models::Circuit, Error<CircuitsCircuitsPartialUpdateError>> {
13056    let local_var_configuration = configuration;
13057
13058    let local_var_client = &local_var_configuration.client;
13059
13060    let local_var_uri_str = format!(
13061        "{}/api/circuits/circuits/{id}/",
13062        local_var_configuration.base_path,
13063        id = id
13064    );
13065    let mut local_var_req_builder =
13066        local_var_client.request(reqwest::Method::PATCH, local_var_uri_str.as_str());
13067
13068    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
13069        local_var_req_builder =
13070            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
13071    }
13072    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
13073        let local_var_key = local_var_apikey.key.clone();
13074        let local_var_value = match local_var_apikey.prefix {
13075            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
13076            None => local_var_key,
13077        };
13078        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
13079    };
13080    local_var_req_builder = local_var_req_builder.json(&patched_writable_circuit_request);
13081
13082    let local_var_req = local_var_req_builder.build()?;
13083    let local_var_resp = local_var_client.execute(local_var_req).await?;
13084
13085    let local_var_status = local_var_resp.status();
13086    let local_var_content = local_var_resp.text().await?;
13087
13088    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
13089        serde_json::from_str(&local_var_content).map_err(Error::from)
13090    } else {
13091        let local_var_entity: Option<CircuitsCircuitsPartialUpdateError> =
13092            serde_json::from_str(&local_var_content).ok();
13093        let local_var_error = ResponseContent {
13094            status: local_var_status,
13095            content: local_var_content,
13096            entity: local_var_entity,
13097        };
13098        Err(Error::ResponseError(local_var_error))
13099    }
13100}
13101
13102/// Get a circuit object.
13103pub async fn circuits_circuits_retrieve(
13104    configuration: &configuration::Configuration,
13105    id: i32,
13106) -> Result<crate::models::Circuit, Error<CircuitsCircuitsRetrieveError>> {
13107    let local_var_configuration = configuration;
13108
13109    let local_var_client = &local_var_configuration.client;
13110
13111    let local_var_uri_str = format!(
13112        "{}/api/circuits/circuits/{id}/",
13113        local_var_configuration.base_path,
13114        id = id
13115    );
13116    let mut local_var_req_builder =
13117        local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
13118
13119    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
13120        local_var_req_builder =
13121            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
13122    }
13123    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
13124        let local_var_key = local_var_apikey.key.clone();
13125        let local_var_value = match local_var_apikey.prefix {
13126            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
13127            None => local_var_key,
13128        };
13129        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
13130    };
13131
13132    let local_var_req = local_var_req_builder.build()?;
13133    let local_var_resp = local_var_client.execute(local_var_req).await?;
13134
13135    let local_var_status = local_var_resp.status();
13136    let local_var_content = local_var_resp.text().await?;
13137
13138    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
13139        serde_json::from_str(&local_var_content).map_err(Error::from)
13140    } else {
13141        let local_var_entity: Option<CircuitsCircuitsRetrieveError> =
13142            serde_json::from_str(&local_var_content).ok();
13143        let local_var_error = ResponseContent {
13144            status: local_var_status,
13145            content: local_var_content,
13146            entity: local_var_entity,
13147        };
13148        Err(Error::ResponseError(local_var_error))
13149    }
13150}
13151
13152/// Put a circuit object.
13153pub async fn circuits_circuits_update(
13154    configuration: &configuration::Configuration,
13155    id: i32,
13156    writable_circuit_request: crate::models::WritableCircuitRequest,
13157) -> Result<crate::models::Circuit, Error<CircuitsCircuitsUpdateError>> {
13158    let local_var_configuration = configuration;
13159
13160    let local_var_client = &local_var_configuration.client;
13161
13162    let local_var_uri_str = format!(
13163        "{}/api/circuits/circuits/{id}/",
13164        local_var_configuration.base_path,
13165        id = id
13166    );
13167    let mut local_var_req_builder =
13168        local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());
13169
13170    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
13171        local_var_req_builder =
13172            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
13173    }
13174    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
13175        let local_var_key = local_var_apikey.key.clone();
13176        let local_var_value = match local_var_apikey.prefix {
13177            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
13178            None => local_var_key,
13179        };
13180        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
13181    };
13182    local_var_req_builder = local_var_req_builder.json(&writable_circuit_request);
13183
13184    let local_var_req = local_var_req_builder.build()?;
13185    let local_var_resp = local_var_client.execute(local_var_req).await?;
13186
13187    let local_var_status = local_var_resp.status();
13188    let local_var_content = local_var_resp.text().await?;
13189
13190    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
13191        serde_json::from_str(&local_var_content).map_err(Error::from)
13192    } else {
13193        let local_var_entity: Option<CircuitsCircuitsUpdateError> =
13194            serde_json::from_str(&local_var_content).ok();
13195        let local_var_error = ResponseContent {
13196            status: local_var_status,
13197            content: local_var_content,
13198            entity: local_var_entity,
13199        };
13200        Err(Error::ResponseError(local_var_error))
13201    }
13202}
13203
13204/// Delete a list of provider account objects.
13205pub async fn circuits_provider_accounts_bulk_destroy(
13206    configuration: &configuration::Configuration,
13207    provider_account_request: Vec<crate::models::ProviderAccountRequest>,
13208) -> Result<(), Error<CircuitsProviderAccountsBulkDestroyError>> {
13209    let local_var_configuration = configuration;
13210
13211    let local_var_client = &local_var_configuration.client;
13212
13213    let local_var_uri_str = format!(
13214        "{}/api/circuits/provider-accounts/",
13215        local_var_configuration.base_path
13216    );
13217    let mut local_var_req_builder =
13218        local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());
13219
13220    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
13221        local_var_req_builder =
13222            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
13223    }
13224    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
13225        let local_var_key = local_var_apikey.key.clone();
13226        let local_var_value = match local_var_apikey.prefix {
13227            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
13228            None => local_var_key,
13229        };
13230        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
13231    };
13232    local_var_req_builder = local_var_req_builder.json(&provider_account_request);
13233
13234    let local_var_req = local_var_req_builder.build()?;
13235    let local_var_resp = local_var_client.execute(local_var_req).await?;
13236
13237    let local_var_status = local_var_resp.status();
13238    let local_var_content = local_var_resp.text().await?;
13239
13240    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
13241        Ok(())
13242    } else {
13243        let local_var_entity: Option<CircuitsProviderAccountsBulkDestroyError> =
13244            serde_json::from_str(&local_var_content).ok();
13245        let local_var_error = ResponseContent {
13246            status: local_var_status,
13247            content: local_var_content,
13248            entity: local_var_entity,
13249        };
13250        Err(Error::ResponseError(local_var_error))
13251    }
13252}
13253
13254/// Patch a list of provider account objects.
13255pub async fn circuits_provider_accounts_bulk_partial_update(
13256    configuration: &configuration::Configuration,
13257    provider_account_request: Vec<crate::models::ProviderAccountRequest>,
13258) -> Result<
13259    Vec<crate::models::ProviderAccount>,
13260    Error<CircuitsProviderAccountsBulkPartialUpdateError>,
13261> {
13262    let local_var_configuration = configuration;
13263
13264    let local_var_client = &local_var_configuration.client;
13265
13266    let local_var_uri_str = format!(
13267        "{}/api/circuits/provider-accounts/",
13268        local_var_configuration.base_path
13269    );
13270    let mut local_var_req_builder =
13271        local_var_client.request(reqwest::Method::PATCH, local_var_uri_str.as_str());
13272
13273    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
13274        local_var_req_builder =
13275            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
13276    }
13277    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
13278        let local_var_key = local_var_apikey.key.clone();
13279        let local_var_value = match local_var_apikey.prefix {
13280            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
13281            None => local_var_key,
13282        };
13283        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
13284    };
13285    local_var_req_builder = local_var_req_builder.json(&provider_account_request);
13286
13287    let local_var_req = local_var_req_builder.build()?;
13288    let local_var_resp = local_var_client.execute(local_var_req).await?;
13289
13290    let local_var_status = local_var_resp.status();
13291    let local_var_content = local_var_resp.text().await?;
13292
13293    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
13294        serde_json::from_str(&local_var_content).map_err(Error::from)
13295    } else {
13296        let local_var_entity: Option<CircuitsProviderAccountsBulkPartialUpdateError> =
13297            serde_json::from_str(&local_var_content).ok();
13298        let local_var_error = ResponseContent {
13299            status: local_var_status,
13300            content: local_var_content,
13301            entity: local_var_entity,
13302        };
13303        Err(Error::ResponseError(local_var_error))
13304    }
13305}
13306
13307/// Put a list of provider account objects.
13308pub async fn circuits_provider_accounts_bulk_update(
13309    configuration: &configuration::Configuration,
13310    provider_account_request: Vec<crate::models::ProviderAccountRequest>,
13311) -> Result<Vec<crate::models::ProviderAccount>, Error<CircuitsProviderAccountsBulkUpdateError>> {
13312    let local_var_configuration = configuration;
13313
13314    let local_var_client = &local_var_configuration.client;
13315
13316    let local_var_uri_str = format!(
13317        "{}/api/circuits/provider-accounts/",
13318        local_var_configuration.base_path
13319    );
13320    let mut local_var_req_builder =
13321        local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());
13322
13323    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
13324        local_var_req_builder =
13325            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
13326    }
13327    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
13328        let local_var_key = local_var_apikey.key.clone();
13329        let local_var_value = match local_var_apikey.prefix {
13330            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
13331            None => local_var_key,
13332        };
13333        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
13334    };
13335    local_var_req_builder = local_var_req_builder.json(&provider_account_request);
13336
13337    let local_var_req = local_var_req_builder.build()?;
13338    let local_var_resp = local_var_client.execute(local_var_req).await?;
13339
13340    let local_var_status = local_var_resp.status();
13341    let local_var_content = local_var_resp.text().await?;
13342
13343    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
13344        serde_json::from_str(&local_var_content).map_err(Error::from)
13345    } else {
13346        let local_var_entity: Option<CircuitsProviderAccountsBulkUpdateError> =
13347            serde_json::from_str(&local_var_content).ok();
13348        let local_var_error = ResponseContent {
13349            status: local_var_status,
13350            content: local_var_content,
13351            entity: local_var_entity,
13352        };
13353        Err(Error::ResponseError(local_var_error))
13354    }
13355}
13356
13357/// Post a list of provider account objects.
13358pub async fn circuits_provider_accounts_create(
13359    configuration: &configuration::Configuration,
13360    circuits_provider_accounts_create_request: crate::models::CircuitsProviderAccountsCreateRequest,
13361) -> Result<crate::models::ProviderAccount, Error<CircuitsProviderAccountsCreateError>> {
13362    let local_var_configuration = configuration;
13363
13364    let local_var_client = &local_var_configuration.client;
13365
13366    let local_var_uri_str = format!(
13367        "{}/api/circuits/provider-accounts/",
13368        local_var_configuration.base_path
13369    );
13370    let mut local_var_req_builder =
13371        local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
13372
13373    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
13374        local_var_req_builder =
13375            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
13376    }
13377    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
13378        let local_var_key = local_var_apikey.key.clone();
13379        let local_var_value = match local_var_apikey.prefix {
13380            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
13381            None => local_var_key,
13382        };
13383        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
13384    };
13385    local_var_req_builder = local_var_req_builder.json(&circuits_provider_accounts_create_request);
13386
13387    let local_var_req = local_var_req_builder.build()?;
13388    let local_var_resp = local_var_client.execute(local_var_req).await?;
13389
13390    let local_var_status = local_var_resp.status();
13391    let local_var_content = local_var_resp.text().await?;
13392
13393    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
13394        serde_json::from_str(&local_var_content).map_err(Error::from)
13395    } else {
13396        let local_var_entity: Option<CircuitsProviderAccountsCreateError> =
13397            serde_json::from_str(&local_var_content).ok();
13398        let local_var_error = ResponseContent {
13399            status: local_var_status,
13400            content: local_var_content,
13401            entity: local_var_entity,
13402        };
13403        Err(Error::ResponseError(local_var_error))
13404    }
13405}
13406
13407/// Delete a provider account object.
13408pub async fn circuits_provider_accounts_destroy(
13409    configuration: &configuration::Configuration,
13410    id: i32,
13411) -> Result<(), Error<CircuitsProviderAccountsDestroyError>> {
13412    let local_var_configuration = configuration;
13413
13414    let local_var_client = &local_var_configuration.client;
13415
13416    let local_var_uri_str = format!(
13417        "{}/api/circuits/provider-accounts/{id}/",
13418        local_var_configuration.base_path,
13419        id = id
13420    );
13421    let mut local_var_req_builder =
13422        local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());
13423
13424    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
13425        local_var_req_builder =
13426            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
13427    }
13428    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
13429        let local_var_key = local_var_apikey.key.clone();
13430        let local_var_value = match local_var_apikey.prefix {
13431            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
13432            None => local_var_key,
13433        };
13434        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
13435    };
13436
13437    let local_var_req = local_var_req_builder.build()?;
13438    let local_var_resp = local_var_client.execute(local_var_req).await?;
13439
13440    let local_var_status = local_var_resp.status();
13441    let local_var_content = local_var_resp.text().await?;
13442
13443    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
13444        Ok(())
13445    } else {
13446        let local_var_entity: Option<CircuitsProviderAccountsDestroyError> =
13447            serde_json::from_str(&local_var_content).ok();
13448        let local_var_error = ResponseContent {
13449            status: local_var_status,
13450            content: local_var_content,
13451            entity: local_var_entity,
13452        };
13453        Err(Error::ResponseError(local_var_error))
13454    }
13455}
13456
13457/// Get a list of provider account objects.
13458pub async fn circuits_provider_accounts_list(
13459    configuration: &configuration::Configuration,
13460    account: Option<Vec<String>>,
13461    account__empty: Option<bool>,
13462    account__ic: Option<Vec<String>>,
13463    account__ie: Option<Vec<String>>,
13464    account__iew: Option<Vec<String>>,
13465    account__iregex: Option<Vec<String>>,
13466    account__isw: Option<Vec<String>>,
13467    account__n: Option<Vec<String>>,
13468    account__nic: Option<Vec<String>>,
13469    account__nie: Option<Vec<String>>,
13470    account__niew: Option<Vec<String>>,
13471    account__nisw: Option<Vec<String>>,
13472    account__regex: Option<Vec<String>>,
13473    contact: Option<Vec<i32>>,
13474    contact__n: Option<Vec<i32>>,
13475    contact_group: Option<Vec<String>>,
13476    contact_group__n: Option<Vec<String>>,
13477    contact_role: Option<Vec<i32>>,
13478    contact_role__n: Option<Vec<i32>>,
13479    created: Option<Vec<String>>,
13480    created__empty: Option<Vec<String>>,
13481    created__gt: Option<Vec<String>>,
13482    created__gte: Option<Vec<String>>,
13483    created__lt: Option<Vec<String>>,
13484    created__lte: Option<Vec<String>>,
13485    created__n: Option<Vec<String>>,
13486    created_by_request: Option<&str>,
13487    description: Option<Vec<String>>,
13488    description__empty: Option<bool>,
13489    description__ic: Option<Vec<String>>,
13490    description__ie: Option<Vec<String>>,
13491    description__iew: Option<Vec<String>>,
13492    description__iregex: Option<Vec<String>>,
13493    description__isw: Option<Vec<String>>,
13494    description__n: Option<Vec<String>>,
13495    description__nic: Option<Vec<String>>,
13496    description__nie: Option<Vec<String>>,
13497    description__niew: Option<Vec<String>>,
13498    description__nisw: Option<Vec<String>>,
13499    description__regex: Option<Vec<String>>,
13500    id: Option<Vec<i32>>,
13501    id__empty: Option<bool>,
13502    id__gt: Option<Vec<i32>>,
13503    id__gte: Option<Vec<i32>>,
13504    id__lt: Option<Vec<i32>>,
13505    id__lte: Option<Vec<i32>>,
13506    id__n: Option<Vec<i32>>,
13507    last_updated: Option<Vec<String>>,
13508    last_updated__empty: Option<Vec<String>>,
13509    last_updated__gt: Option<Vec<String>>,
13510    last_updated__gte: Option<Vec<String>>,
13511    last_updated__lt: Option<Vec<String>>,
13512    last_updated__lte: Option<Vec<String>>,
13513    last_updated__n: Option<Vec<String>>,
13514    limit: Option<i32>,
13515    modified_by_request: Option<&str>,
13516    name: Option<Vec<String>>,
13517    name__empty: Option<bool>,
13518    name__ic: Option<Vec<String>>,
13519    name__ie: Option<Vec<String>>,
13520    name__iew: Option<Vec<String>>,
13521    name__iregex: Option<Vec<String>>,
13522    name__isw: Option<Vec<String>>,
13523    name__n: Option<Vec<String>>,
13524    name__nic: Option<Vec<String>>,
13525    name__nie: Option<Vec<String>>,
13526    name__niew: Option<Vec<String>>,
13527    name__nisw: Option<Vec<String>>,
13528    name__regex: Option<Vec<String>>,
13529    offset: Option<i32>,
13530    ordering: Option<&str>,
13531    owner: Option<Vec<String>>,
13532    owner__n: Option<Vec<String>>,
13533    owner_group: Option<Vec<String>>,
13534    owner_group__n: Option<Vec<String>>,
13535    owner_group_id: Option<Vec<i32>>,
13536    owner_group_id__n: Option<Vec<i32>>,
13537    owner_id: Option<Vec<i32>>,
13538    owner_id__n: Option<Vec<i32>>,
13539    provider: Option<Vec<String>>,
13540    provider__n: Option<Vec<String>>,
13541    provider_id: Option<Vec<i32>>,
13542    provider_id__n: Option<Vec<i32>>,
13543    q: Option<&str>,
13544    tag: Option<Vec<String>>,
13545    tag__n: Option<Vec<String>>,
13546    tag_id: Option<Vec<i32>>,
13547    tag_id__n: Option<Vec<i32>>,
13548    updated_by_request: Option<&str>,
13549) -> Result<crate::models::PaginatedProviderAccountList, Error<CircuitsProviderAccountsListError>> {
13550    let local_var_configuration = configuration;
13551
13552    let local_var_client = &local_var_configuration.client;
13553
13554    let local_var_uri_str = format!(
13555        "{}/api/circuits/provider-accounts/",
13556        local_var_configuration.base_path
13557    );
13558    let mut local_var_req_builder =
13559        local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
13560
13561    if let Some(ref local_var_str) = account {
13562        local_var_req_builder = match "multi" {
13563            "multi" => local_var_req_builder.query(
13564                &local_var_str
13565                    .into_iter()
13566                    .map(|p| ("account".to_owned(), p.to_string()))
13567                    .collect::<Vec<(std::string::String, std::string::String)>>(),
13568            ),
13569            _ => local_var_req_builder.query(&[(
13570                "account",
13571                &local_var_str
13572                    .into_iter()
13573                    .map(|p| p.to_string())
13574                    .collect::<Vec<String>>()
13575                    .join(",")
13576                    .to_string(),
13577            )]),
13578        };
13579    }
13580    if let Some(ref local_var_str) = account__empty {
13581        local_var_req_builder =
13582            local_var_req_builder.query(&[("account__empty", &local_var_str.to_string())]);
13583    }
13584    if let Some(ref local_var_str) = account__ic {
13585        local_var_req_builder = match "multi" {
13586            "multi" => local_var_req_builder.query(
13587                &local_var_str
13588                    .into_iter()
13589                    .map(|p| ("account__ic".to_owned(), p.to_string()))
13590                    .collect::<Vec<(std::string::String, std::string::String)>>(),
13591            ),
13592            _ => local_var_req_builder.query(&[(
13593                "account__ic",
13594                &local_var_str
13595                    .into_iter()
13596                    .map(|p| p.to_string())
13597                    .collect::<Vec<String>>()
13598                    .join(",")
13599                    .to_string(),
13600            )]),
13601        };
13602    }
13603    if let Some(ref local_var_str) = account__ie {
13604        local_var_req_builder = match "multi" {
13605            "multi" => local_var_req_builder.query(
13606                &local_var_str
13607                    .into_iter()
13608                    .map(|p| ("account__ie".to_owned(), p.to_string()))
13609                    .collect::<Vec<(std::string::String, std::string::String)>>(),
13610            ),
13611            _ => local_var_req_builder.query(&[(
13612                "account__ie",
13613                &local_var_str
13614                    .into_iter()
13615                    .map(|p| p.to_string())
13616                    .collect::<Vec<String>>()
13617                    .join(",")
13618                    .to_string(),
13619            )]),
13620        };
13621    }
13622    if let Some(ref local_var_str) = account__iew {
13623        local_var_req_builder = match "multi" {
13624            "multi" => local_var_req_builder.query(
13625                &local_var_str
13626                    .into_iter()
13627                    .map(|p| ("account__iew".to_owned(), p.to_string()))
13628                    .collect::<Vec<(std::string::String, std::string::String)>>(),
13629            ),
13630            _ => local_var_req_builder.query(&[(
13631                "account__iew",
13632                &local_var_str
13633                    .into_iter()
13634                    .map(|p| p.to_string())
13635                    .collect::<Vec<String>>()
13636                    .join(",")
13637                    .to_string(),
13638            )]),
13639        };
13640    }
13641    if let Some(ref local_var_str) = account__iregex {
13642        local_var_req_builder = match "multi" {
13643            "multi" => local_var_req_builder.query(
13644                &local_var_str
13645                    .into_iter()
13646                    .map(|p| ("account__iregex".to_owned(), p.to_string()))
13647                    .collect::<Vec<(std::string::String, std::string::String)>>(),
13648            ),
13649            _ => local_var_req_builder.query(&[(
13650                "account__iregex",
13651                &local_var_str
13652                    .into_iter()
13653                    .map(|p| p.to_string())
13654                    .collect::<Vec<String>>()
13655                    .join(",")
13656                    .to_string(),
13657            )]),
13658        };
13659    }
13660    if let Some(ref local_var_str) = account__isw {
13661        local_var_req_builder = match "multi" {
13662            "multi" => local_var_req_builder.query(
13663                &local_var_str
13664                    .into_iter()
13665                    .map(|p| ("account__isw".to_owned(), p.to_string()))
13666                    .collect::<Vec<(std::string::String, std::string::String)>>(),
13667            ),
13668            _ => local_var_req_builder.query(&[(
13669                "account__isw",
13670                &local_var_str
13671                    .into_iter()
13672                    .map(|p| p.to_string())
13673                    .collect::<Vec<String>>()
13674                    .join(",")
13675                    .to_string(),
13676            )]),
13677        };
13678    }
13679    if let Some(ref local_var_str) = account__n {
13680        local_var_req_builder = match "multi" {
13681            "multi" => local_var_req_builder.query(
13682                &local_var_str
13683                    .into_iter()
13684                    .map(|p| ("account__n".to_owned(), p.to_string()))
13685                    .collect::<Vec<(std::string::String, std::string::String)>>(),
13686            ),
13687            _ => local_var_req_builder.query(&[(
13688                "account__n",
13689                &local_var_str
13690                    .into_iter()
13691                    .map(|p| p.to_string())
13692                    .collect::<Vec<String>>()
13693                    .join(",")
13694                    .to_string(),
13695            )]),
13696        };
13697    }
13698    if let Some(ref local_var_str) = account__nic {
13699        local_var_req_builder = match "multi" {
13700            "multi" => local_var_req_builder.query(
13701                &local_var_str
13702                    .into_iter()
13703                    .map(|p| ("account__nic".to_owned(), p.to_string()))
13704                    .collect::<Vec<(std::string::String, std::string::String)>>(),
13705            ),
13706            _ => local_var_req_builder.query(&[(
13707                "account__nic",
13708                &local_var_str
13709                    .into_iter()
13710                    .map(|p| p.to_string())
13711                    .collect::<Vec<String>>()
13712                    .join(",")
13713                    .to_string(),
13714            )]),
13715        };
13716    }
13717    if let Some(ref local_var_str) = account__nie {
13718        local_var_req_builder = match "multi" {
13719            "multi" => local_var_req_builder.query(
13720                &local_var_str
13721                    .into_iter()
13722                    .map(|p| ("account__nie".to_owned(), p.to_string()))
13723                    .collect::<Vec<(std::string::String, std::string::String)>>(),
13724            ),
13725            _ => local_var_req_builder.query(&[(
13726                "account__nie",
13727                &local_var_str
13728                    .into_iter()
13729                    .map(|p| p.to_string())
13730                    .collect::<Vec<String>>()
13731                    .join(",")
13732                    .to_string(),
13733            )]),
13734        };
13735    }
13736    if let Some(ref local_var_str) = account__niew {
13737        local_var_req_builder = match "multi" {
13738            "multi" => local_var_req_builder.query(
13739                &local_var_str
13740                    .into_iter()
13741                    .map(|p| ("account__niew".to_owned(), p.to_string()))
13742                    .collect::<Vec<(std::string::String, std::string::String)>>(),
13743            ),
13744            _ => local_var_req_builder.query(&[(
13745                "account__niew",
13746                &local_var_str
13747                    .into_iter()
13748                    .map(|p| p.to_string())
13749                    .collect::<Vec<String>>()
13750                    .join(",")
13751                    .to_string(),
13752            )]),
13753        };
13754    }
13755    if let Some(ref local_var_str) = account__nisw {
13756        local_var_req_builder = match "multi" {
13757            "multi" => local_var_req_builder.query(
13758                &local_var_str
13759                    .into_iter()
13760                    .map(|p| ("account__nisw".to_owned(), p.to_string()))
13761                    .collect::<Vec<(std::string::String, std::string::String)>>(),
13762            ),
13763            _ => local_var_req_builder.query(&[(
13764                "account__nisw",
13765                &local_var_str
13766                    .into_iter()
13767                    .map(|p| p.to_string())
13768                    .collect::<Vec<String>>()
13769                    .join(",")
13770                    .to_string(),
13771            )]),
13772        };
13773    }
13774    if let Some(ref local_var_str) = account__regex {
13775        local_var_req_builder = match "multi" {
13776            "multi" => local_var_req_builder.query(
13777                &local_var_str
13778                    .into_iter()
13779                    .map(|p| ("account__regex".to_owned(), p.to_string()))
13780                    .collect::<Vec<(std::string::String, std::string::String)>>(),
13781            ),
13782            _ => local_var_req_builder.query(&[(
13783                "account__regex",
13784                &local_var_str
13785                    .into_iter()
13786                    .map(|p| p.to_string())
13787                    .collect::<Vec<String>>()
13788                    .join(",")
13789                    .to_string(),
13790            )]),
13791        };
13792    }
13793    if let Some(ref local_var_str) = contact {
13794        local_var_req_builder = match "multi" {
13795            "multi" => local_var_req_builder.query(
13796                &local_var_str
13797                    .into_iter()
13798                    .map(|p| ("contact".to_owned(), p.to_string()))
13799                    .collect::<Vec<(std::string::String, std::string::String)>>(),
13800            ),
13801            _ => local_var_req_builder.query(&[(
13802                "contact",
13803                &local_var_str
13804                    .into_iter()
13805                    .map(|p| p.to_string())
13806                    .collect::<Vec<String>>()
13807                    .join(",")
13808                    .to_string(),
13809            )]),
13810        };
13811    }
13812    if let Some(ref local_var_str) = contact__n {
13813        local_var_req_builder = match "multi" {
13814            "multi" => local_var_req_builder.query(
13815                &local_var_str
13816                    .into_iter()
13817                    .map(|p| ("contact__n".to_owned(), p.to_string()))
13818                    .collect::<Vec<(std::string::String, std::string::String)>>(),
13819            ),
13820            _ => local_var_req_builder.query(&[(
13821                "contact__n",
13822                &local_var_str
13823                    .into_iter()
13824                    .map(|p| p.to_string())
13825                    .collect::<Vec<String>>()
13826                    .join(",")
13827                    .to_string(),
13828            )]),
13829        };
13830    }
13831    if let Some(ref local_var_str) = contact_group {
13832        local_var_req_builder = match "multi" {
13833            "multi" => local_var_req_builder.query(
13834                &local_var_str
13835                    .into_iter()
13836                    .map(|p| ("contact_group".to_owned(), p.to_string()))
13837                    .collect::<Vec<(std::string::String, std::string::String)>>(),
13838            ),
13839            _ => local_var_req_builder.query(&[(
13840                "contact_group",
13841                &local_var_str
13842                    .into_iter()
13843                    .map(|p| p.to_string())
13844                    .collect::<Vec<String>>()
13845                    .join(",")
13846                    .to_string(),
13847            )]),
13848        };
13849    }
13850    if let Some(ref local_var_str) = contact_group__n {
13851        local_var_req_builder = match "multi" {
13852            "multi" => local_var_req_builder.query(
13853                &local_var_str
13854                    .into_iter()
13855                    .map(|p| ("contact_group__n".to_owned(), p.to_string()))
13856                    .collect::<Vec<(std::string::String, std::string::String)>>(),
13857            ),
13858            _ => local_var_req_builder.query(&[(
13859                "contact_group__n",
13860                &local_var_str
13861                    .into_iter()
13862                    .map(|p| p.to_string())
13863                    .collect::<Vec<String>>()
13864                    .join(",")
13865                    .to_string(),
13866            )]),
13867        };
13868    }
13869    if let Some(ref local_var_str) = contact_role {
13870        local_var_req_builder = match "multi" {
13871            "multi" => local_var_req_builder.query(
13872                &local_var_str
13873                    .into_iter()
13874                    .map(|p| ("contact_role".to_owned(), p.to_string()))
13875                    .collect::<Vec<(std::string::String, std::string::String)>>(),
13876            ),
13877            _ => local_var_req_builder.query(&[(
13878                "contact_role",
13879                &local_var_str
13880                    .into_iter()
13881                    .map(|p| p.to_string())
13882                    .collect::<Vec<String>>()
13883                    .join(",")
13884                    .to_string(),
13885            )]),
13886        };
13887    }
13888    if let Some(ref local_var_str) = contact_role__n {
13889        local_var_req_builder = match "multi" {
13890            "multi" => local_var_req_builder.query(
13891                &local_var_str
13892                    .into_iter()
13893                    .map(|p| ("contact_role__n".to_owned(), p.to_string()))
13894                    .collect::<Vec<(std::string::String, std::string::String)>>(),
13895            ),
13896            _ => local_var_req_builder.query(&[(
13897                "contact_role__n",
13898                &local_var_str
13899                    .into_iter()
13900                    .map(|p| p.to_string())
13901                    .collect::<Vec<String>>()
13902                    .join(",")
13903                    .to_string(),
13904            )]),
13905        };
13906    }
13907    if let Some(ref local_var_str) = created {
13908        local_var_req_builder = match "multi" {
13909            "multi" => local_var_req_builder.query(
13910                &local_var_str
13911                    .into_iter()
13912                    .map(|p| ("created".to_owned(), p.to_string()))
13913                    .collect::<Vec<(std::string::String, std::string::String)>>(),
13914            ),
13915            _ => local_var_req_builder.query(&[(
13916                "created",
13917                &local_var_str
13918                    .into_iter()
13919                    .map(|p| p.to_string())
13920                    .collect::<Vec<String>>()
13921                    .join(",")
13922                    .to_string(),
13923            )]),
13924        };
13925    }
13926    if let Some(ref local_var_str) = created__empty {
13927        local_var_req_builder = match "multi" {
13928            "multi" => local_var_req_builder.query(
13929                &local_var_str
13930                    .into_iter()
13931                    .map(|p| ("created__empty".to_owned(), p.to_string()))
13932                    .collect::<Vec<(std::string::String, std::string::String)>>(),
13933            ),
13934            _ => local_var_req_builder.query(&[(
13935                "created__empty",
13936                &local_var_str
13937                    .into_iter()
13938                    .map(|p| p.to_string())
13939                    .collect::<Vec<String>>()
13940                    .join(",")
13941                    .to_string(),
13942            )]),
13943        };
13944    }
13945    if let Some(ref local_var_str) = created__gt {
13946        local_var_req_builder = match "multi" {
13947            "multi" => local_var_req_builder.query(
13948                &local_var_str
13949                    .into_iter()
13950                    .map(|p| ("created__gt".to_owned(), p.to_string()))
13951                    .collect::<Vec<(std::string::String, std::string::String)>>(),
13952            ),
13953            _ => local_var_req_builder.query(&[(
13954                "created__gt",
13955                &local_var_str
13956                    .into_iter()
13957                    .map(|p| p.to_string())
13958                    .collect::<Vec<String>>()
13959                    .join(",")
13960                    .to_string(),
13961            )]),
13962        };
13963    }
13964    if let Some(ref local_var_str) = created__gte {
13965        local_var_req_builder = match "multi" {
13966            "multi" => local_var_req_builder.query(
13967                &local_var_str
13968                    .into_iter()
13969                    .map(|p| ("created__gte".to_owned(), p.to_string()))
13970                    .collect::<Vec<(std::string::String, std::string::String)>>(),
13971            ),
13972            _ => local_var_req_builder.query(&[(
13973                "created__gte",
13974                &local_var_str
13975                    .into_iter()
13976                    .map(|p| p.to_string())
13977                    .collect::<Vec<String>>()
13978                    .join(",")
13979                    .to_string(),
13980            )]),
13981        };
13982    }
13983    if let Some(ref local_var_str) = created__lt {
13984        local_var_req_builder = match "multi" {
13985            "multi" => local_var_req_builder.query(
13986                &local_var_str
13987                    .into_iter()
13988                    .map(|p| ("created__lt".to_owned(), p.to_string()))
13989                    .collect::<Vec<(std::string::String, std::string::String)>>(),
13990            ),
13991            _ => local_var_req_builder.query(&[(
13992                "created__lt",
13993                &local_var_str
13994                    .into_iter()
13995                    .map(|p| p.to_string())
13996                    .collect::<Vec<String>>()
13997                    .join(",")
13998                    .to_string(),
13999            )]),
14000        };
14001    }
14002    if let Some(ref local_var_str) = created__lte {
14003        local_var_req_builder = match "multi" {
14004            "multi" => local_var_req_builder.query(
14005                &local_var_str
14006                    .into_iter()
14007                    .map(|p| ("created__lte".to_owned(), p.to_string()))
14008                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14009            ),
14010            _ => local_var_req_builder.query(&[(
14011                "created__lte",
14012                &local_var_str
14013                    .into_iter()
14014                    .map(|p| p.to_string())
14015                    .collect::<Vec<String>>()
14016                    .join(",")
14017                    .to_string(),
14018            )]),
14019        };
14020    }
14021    if let Some(ref local_var_str) = created__n {
14022        local_var_req_builder = match "multi" {
14023            "multi" => local_var_req_builder.query(
14024                &local_var_str
14025                    .into_iter()
14026                    .map(|p| ("created__n".to_owned(), p.to_string()))
14027                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14028            ),
14029            _ => local_var_req_builder.query(&[(
14030                "created__n",
14031                &local_var_str
14032                    .into_iter()
14033                    .map(|p| p.to_string())
14034                    .collect::<Vec<String>>()
14035                    .join(",")
14036                    .to_string(),
14037            )]),
14038        };
14039    }
14040    if let Some(ref local_var_str) = created_by_request {
14041        local_var_req_builder =
14042            local_var_req_builder.query(&[("created_by_request", &local_var_str.to_string())]);
14043    }
14044    if let Some(ref local_var_str) = description {
14045        local_var_req_builder = match "multi" {
14046            "multi" => local_var_req_builder.query(
14047                &local_var_str
14048                    .into_iter()
14049                    .map(|p| ("description".to_owned(), p.to_string()))
14050                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14051            ),
14052            _ => local_var_req_builder.query(&[(
14053                "description",
14054                &local_var_str
14055                    .into_iter()
14056                    .map(|p| p.to_string())
14057                    .collect::<Vec<String>>()
14058                    .join(",")
14059                    .to_string(),
14060            )]),
14061        };
14062    }
14063    if let Some(ref local_var_str) = description__empty {
14064        local_var_req_builder =
14065            local_var_req_builder.query(&[("description__empty", &local_var_str.to_string())]);
14066    }
14067    if let Some(ref local_var_str) = description__ic {
14068        local_var_req_builder = match "multi" {
14069            "multi" => local_var_req_builder.query(
14070                &local_var_str
14071                    .into_iter()
14072                    .map(|p| ("description__ic".to_owned(), p.to_string()))
14073                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14074            ),
14075            _ => local_var_req_builder.query(&[(
14076                "description__ic",
14077                &local_var_str
14078                    .into_iter()
14079                    .map(|p| p.to_string())
14080                    .collect::<Vec<String>>()
14081                    .join(",")
14082                    .to_string(),
14083            )]),
14084        };
14085    }
14086    if let Some(ref local_var_str) = description__ie {
14087        local_var_req_builder = match "multi" {
14088            "multi" => local_var_req_builder.query(
14089                &local_var_str
14090                    .into_iter()
14091                    .map(|p| ("description__ie".to_owned(), p.to_string()))
14092                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14093            ),
14094            _ => local_var_req_builder.query(&[(
14095                "description__ie",
14096                &local_var_str
14097                    .into_iter()
14098                    .map(|p| p.to_string())
14099                    .collect::<Vec<String>>()
14100                    .join(",")
14101                    .to_string(),
14102            )]),
14103        };
14104    }
14105    if let Some(ref local_var_str) = description__iew {
14106        local_var_req_builder = match "multi" {
14107            "multi" => local_var_req_builder.query(
14108                &local_var_str
14109                    .into_iter()
14110                    .map(|p| ("description__iew".to_owned(), p.to_string()))
14111                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14112            ),
14113            _ => local_var_req_builder.query(&[(
14114                "description__iew",
14115                &local_var_str
14116                    .into_iter()
14117                    .map(|p| p.to_string())
14118                    .collect::<Vec<String>>()
14119                    .join(",")
14120                    .to_string(),
14121            )]),
14122        };
14123    }
14124    if let Some(ref local_var_str) = description__iregex {
14125        local_var_req_builder = match "multi" {
14126            "multi" => local_var_req_builder.query(
14127                &local_var_str
14128                    .into_iter()
14129                    .map(|p| ("description__iregex".to_owned(), p.to_string()))
14130                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14131            ),
14132            _ => local_var_req_builder.query(&[(
14133                "description__iregex",
14134                &local_var_str
14135                    .into_iter()
14136                    .map(|p| p.to_string())
14137                    .collect::<Vec<String>>()
14138                    .join(",")
14139                    .to_string(),
14140            )]),
14141        };
14142    }
14143    if let Some(ref local_var_str) = description__isw {
14144        local_var_req_builder = match "multi" {
14145            "multi" => local_var_req_builder.query(
14146                &local_var_str
14147                    .into_iter()
14148                    .map(|p| ("description__isw".to_owned(), p.to_string()))
14149                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14150            ),
14151            _ => local_var_req_builder.query(&[(
14152                "description__isw",
14153                &local_var_str
14154                    .into_iter()
14155                    .map(|p| p.to_string())
14156                    .collect::<Vec<String>>()
14157                    .join(",")
14158                    .to_string(),
14159            )]),
14160        };
14161    }
14162    if let Some(ref local_var_str) = description__n {
14163        local_var_req_builder = match "multi" {
14164            "multi" => local_var_req_builder.query(
14165                &local_var_str
14166                    .into_iter()
14167                    .map(|p| ("description__n".to_owned(), p.to_string()))
14168                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14169            ),
14170            _ => local_var_req_builder.query(&[(
14171                "description__n",
14172                &local_var_str
14173                    .into_iter()
14174                    .map(|p| p.to_string())
14175                    .collect::<Vec<String>>()
14176                    .join(",")
14177                    .to_string(),
14178            )]),
14179        };
14180    }
14181    if let Some(ref local_var_str) = description__nic {
14182        local_var_req_builder = match "multi" {
14183            "multi" => local_var_req_builder.query(
14184                &local_var_str
14185                    .into_iter()
14186                    .map(|p| ("description__nic".to_owned(), p.to_string()))
14187                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14188            ),
14189            _ => local_var_req_builder.query(&[(
14190                "description__nic",
14191                &local_var_str
14192                    .into_iter()
14193                    .map(|p| p.to_string())
14194                    .collect::<Vec<String>>()
14195                    .join(",")
14196                    .to_string(),
14197            )]),
14198        };
14199    }
14200    if let Some(ref local_var_str) = description__nie {
14201        local_var_req_builder = match "multi" {
14202            "multi" => local_var_req_builder.query(
14203                &local_var_str
14204                    .into_iter()
14205                    .map(|p| ("description__nie".to_owned(), p.to_string()))
14206                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14207            ),
14208            _ => local_var_req_builder.query(&[(
14209                "description__nie",
14210                &local_var_str
14211                    .into_iter()
14212                    .map(|p| p.to_string())
14213                    .collect::<Vec<String>>()
14214                    .join(",")
14215                    .to_string(),
14216            )]),
14217        };
14218    }
14219    if let Some(ref local_var_str) = description__niew {
14220        local_var_req_builder = match "multi" {
14221            "multi" => local_var_req_builder.query(
14222                &local_var_str
14223                    .into_iter()
14224                    .map(|p| ("description__niew".to_owned(), p.to_string()))
14225                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14226            ),
14227            _ => local_var_req_builder.query(&[(
14228                "description__niew",
14229                &local_var_str
14230                    .into_iter()
14231                    .map(|p| p.to_string())
14232                    .collect::<Vec<String>>()
14233                    .join(",")
14234                    .to_string(),
14235            )]),
14236        };
14237    }
14238    if let Some(ref local_var_str) = description__nisw {
14239        local_var_req_builder = match "multi" {
14240            "multi" => local_var_req_builder.query(
14241                &local_var_str
14242                    .into_iter()
14243                    .map(|p| ("description__nisw".to_owned(), p.to_string()))
14244                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14245            ),
14246            _ => local_var_req_builder.query(&[(
14247                "description__nisw",
14248                &local_var_str
14249                    .into_iter()
14250                    .map(|p| p.to_string())
14251                    .collect::<Vec<String>>()
14252                    .join(",")
14253                    .to_string(),
14254            )]),
14255        };
14256    }
14257    if let Some(ref local_var_str) = description__regex {
14258        local_var_req_builder = match "multi" {
14259            "multi" => local_var_req_builder.query(
14260                &local_var_str
14261                    .into_iter()
14262                    .map(|p| ("description__regex".to_owned(), p.to_string()))
14263                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14264            ),
14265            _ => local_var_req_builder.query(&[(
14266                "description__regex",
14267                &local_var_str
14268                    .into_iter()
14269                    .map(|p| p.to_string())
14270                    .collect::<Vec<String>>()
14271                    .join(",")
14272                    .to_string(),
14273            )]),
14274        };
14275    }
14276    if let Some(ref local_var_str) = id {
14277        local_var_req_builder = match "multi" {
14278            "multi" => local_var_req_builder.query(
14279                &local_var_str
14280                    .into_iter()
14281                    .map(|p| ("id".to_owned(), p.to_string()))
14282                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14283            ),
14284            _ => local_var_req_builder.query(&[(
14285                "id",
14286                &local_var_str
14287                    .into_iter()
14288                    .map(|p| p.to_string())
14289                    .collect::<Vec<String>>()
14290                    .join(",")
14291                    .to_string(),
14292            )]),
14293        };
14294    }
14295    if let Some(ref local_var_str) = id__empty {
14296        local_var_req_builder =
14297            local_var_req_builder.query(&[("id__empty", &local_var_str.to_string())]);
14298    }
14299    if let Some(ref local_var_str) = id__gt {
14300        local_var_req_builder = match "multi" {
14301            "multi" => local_var_req_builder.query(
14302                &local_var_str
14303                    .into_iter()
14304                    .map(|p| ("id__gt".to_owned(), p.to_string()))
14305                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14306            ),
14307            _ => local_var_req_builder.query(&[(
14308                "id__gt",
14309                &local_var_str
14310                    .into_iter()
14311                    .map(|p| p.to_string())
14312                    .collect::<Vec<String>>()
14313                    .join(",")
14314                    .to_string(),
14315            )]),
14316        };
14317    }
14318    if let Some(ref local_var_str) = id__gte {
14319        local_var_req_builder = match "multi" {
14320            "multi" => local_var_req_builder.query(
14321                &local_var_str
14322                    .into_iter()
14323                    .map(|p| ("id__gte".to_owned(), p.to_string()))
14324                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14325            ),
14326            _ => local_var_req_builder.query(&[(
14327                "id__gte",
14328                &local_var_str
14329                    .into_iter()
14330                    .map(|p| p.to_string())
14331                    .collect::<Vec<String>>()
14332                    .join(",")
14333                    .to_string(),
14334            )]),
14335        };
14336    }
14337    if let Some(ref local_var_str) = id__lt {
14338        local_var_req_builder = match "multi" {
14339            "multi" => local_var_req_builder.query(
14340                &local_var_str
14341                    .into_iter()
14342                    .map(|p| ("id__lt".to_owned(), p.to_string()))
14343                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14344            ),
14345            _ => local_var_req_builder.query(&[(
14346                "id__lt",
14347                &local_var_str
14348                    .into_iter()
14349                    .map(|p| p.to_string())
14350                    .collect::<Vec<String>>()
14351                    .join(",")
14352                    .to_string(),
14353            )]),
14354        };
14355    }
14356    if let Some(ref local_var_str) = id__lte {
14357        local_var_req_builder = match "multi" {
14358            "multi" => local_var_req_builder.query(
14359                &local_var_str
14360                    .into_iter()
14361                    .map(|p| ("id__lte".to_owned(), p.to_string()))
14362                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14363            ),
14364            _ => local_var_req_builder.query(&[(
14365                "id__lte",
14366                &local_var_str
14367                    .into_iter()
14368                    .map(|p| p.to_string())
14369                    .collect::<Vec<String>>()
14370                    .join(",")
14371                    .to_string(),
14372            )]),
14373        };
14374    }
14375    if let Some(ref local_var_str) = id__n {
14376        local_var_req_builder = match "multi" {
14377            "multi" => local_var_req_builder.query(
14378                &local_var_str
14379                    .into_iter()
14380                    .map(|p| ("id__n".to_owned(), p.to_string()))
14381                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14382            ),
14383            _ => local_var_req_builder.query(&[(
14384                "id__n",
14385                &local_var_str
14386                    .into_iter()
14387                    .map(|p| p.to_string())
14388                    .collect::<Vec<String>>()
14389                    .join(",")
14390                    .to_string(),
14391            )]),
14392        };
14393    }
14394    if let Some(ref local_var_str) = last_updated {
14395        local_var_req_builder = match "multi" {
14396            "multi" => local_var_req_builder.query(
14397                &local_var_str
14398                    .into_iter()
14399                    .map(|p| ("last_updated".to_owned(), p.to_string()))
14400                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14401            ),
14402            _ => local_var_req_builder.query(&[(
14403                "last_updated",
14404                &local_var_str
14405                    .into_iter()
14406                    .map(|p| p.to_string())
14407                    .collect::<Vec<String>>()
14408                    .join(",")
14409                    .to_string(),
14410            )]),
14411        };
14412    }
14413    if let Some(ref local_var_str) = last_updated__empty {
14414        local_var_req_builder = match "multi" {
14415            "multi" => local_var_req_builder.query(
14416                &local_var_str
14417                    .into_iter()
14418                    .map(|p| ("last_updated__empty".to_owned(), p.to_string()))
14419                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14420            ),
14421            _ => local_var_req_builder.query(&[(
14422                "last_updated__empty",
14423                &local_var_str
14424                    .into_iter()
14425                    .map(|p| p.to_string())
14426                    .collect::<Vec<String>>()
14427                    .join(",")
14428                    .to_string(),
14429            )]),
14430        };
14431    }
14432    if let Some(ref local_var_str) = last_updated__gt {
14433        local_var_req_builder = match "multi" {
14434            "multi" => local_var_req_builder.query(
14435                &local_var_str
14436                    .into_iter()
14437                    .map(|p| ("last_updated__gt".to_owned(), p.to_string()))
14438                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14439            ),
14440            _ => local_var_req_builder.query(&[(
14441                "last_updated__gt",
14442                &local_var_str
14443                    .into_iter()
14444                    .map(|p| p.to_string())
14445                    .collect::<Vec<String>>()
14446                    .join(",")
14447                    .to_string(),
14448            )]),
14449        };
14450    }
14451    if let Some(ref local_var_str) = last_updated__gte {
14452        local_var_req_builder = match "multi" {
14453            "multi" => local_var_req_builder.query(
14454                &local_var_str
14455                    .into_iter()
14456                    .map(|p| ("last_updated__gte".to_owned(), p.to_string()))
14457                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14458            ),
14459            _ => local_var_req_builder.query(&[(
14460                "last_updated__gte",
14461                &local_var_str
14462                    .into_iter()
14463                    .map(|p| p.to_string())
14464                    .collect::<Vec<String>>()
14465                    .join(",")
14466                    .to_string(),
14467            )]),
14468        };
14469    }
14470    if let Some(ref local_var_str) = last_updated__lt {
14471        local_var_req_builder = match "multi" {
14472            "multi" => local_var_req_builder.query(
14473                &local_var_str
14474                    .into_iter()
14475                    .map(|p| ("last_updated__lt".to_owned(), p.to_string()))
14476                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14477            ),
14478            _ => local_var_req_builder.query(&[(
14479                "last_updated__lt",
14480                &local_var_str
14481                    .into_iter()
14482                    .map(|p| p.to_string())
14483                    .collect::<Vec<String>>()
14484                    .join(",")
14485                    .to_string(),
14486            )]),
14487        };
14488    }
14489    if let Some(ref local_var_str) = last_updated__lte {
14490        local_var_req_builder = match "multi" {
14491            "multi" => local_var_req_builder.query(
14492                &local_var_str
14493                    .into_iter()
14494                    .map(|p| ("last_updated__lte".to_owned(), p.to_string()))
14495                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14496            ),
14497            _ => local_var_req_builder.query(&[(
14498                "last_updated__lte",
14499                &local_var_str
14500                    .into_iter()
14501                    .map(|p| p.to_string())
14502                    .collect::<Vec<String>>()
14503                    .join(",")
14504                    .to_string(),
14505            )]),
14506        };
14507    }
14508    if let Some(ref local_var_str) = last_updated__n {
14509        local_var_req_builder = match "multi" {
14510            "multi" => local_var_req_builder.query(
14511                &local_var_str
14512                    .into_iter()
14513                    .map(|p| ("last_updated__n".to_owned(), p.to_string()))
14514                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14515            ),
14516            _ => local_var_req_builder.query(&[(
14517                "last_updated__n",
14518                &local_var_str
14519                    .into_iter()
14520                    .map(|p| p.to_string())
14521                    .collect::<Vec<String>>()
14522                    .join(",")
14523                    .to_string(),
14524            )]),
14525        };
14526    }
14527    if let Some(ref local_var_str) = limit {
14528        local_var_req_builder =
14529            local_var_req_builder.query(&[("limit", &local_var_str.to_string())]);
14530    }
14531    if let Some(ref local_var_str) = modified_by_request {
14532        local_var_req_builder =
14533            local_var_req_builder.query(&[("modified_by_request", &local_var_str.to_string())]);
14534    }
14535    if let Some(ref local_var_str) = name {
14536        local_var_req_builder = match "multi" {
14537            "multi" => local_var_req_builder.query(
14538                &local_var_str
14539                    .into_iter()
14540                    .map(|p| ("name".to_owned(), p.to_string()))
14541                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14542            ),
14543            _ => local_var_req_builder.query(&[(
14544                "name",
14545                &local_var_str
14546                    .into_iter()
14547                    .map(|p| p.to_string())
14548                    .collect::<Vec<String>>()
14549                    .join(",")
14550                    .to_string(),
14551            )]),
14552        };
14553    }
14554    if let Some(ref local_var_str) = name__empty {
14555        local_var_req_builder =
14556            local_var_req_builder.query(&[("name__empty", &local_var_str.to_string())]);
14557    }
14558    if let Some(ref local_var_str) = name__ic {
14559        local_var_req_builder = match "multi" {
14560            "multi" => local_var_req_builder.query(
14561                &local_var_str
14562                    .into_iter()
14563                    .map(|p| ("name__ic".to_owned(), p.to_string()))
14564                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14565            ),
14566            _ => local_var_req_builder.query(&[(
14567                "name__ic",
14568                &local_var_str
14569                    .into_iter()
14570                    .map(|p| p.to_string())
14571                    .collect::<Vec<String>>()
14572                    .join(",")
14573                    .to_string(),
14574            )]),
14575        };
14576    }
14577    if let Some(ref local_var_str) = name__ie {
14578        local_var_req_builder = match "multi" {
14579            "multi" => local_var_req_builder.query(
14580                &local_var_str
14581                    .into_iter()
14582                    .map(|p| ("name__ie".to_owned(), p.to_string()))
14583                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14584            ),
14585            _ => local_var_req_builder.query(&[(
14586                "name__ie",
14587                &local_var_str
14588                    .into_iter()
14589                    .map(|p| p.to_string())
14590                    .collect::<Vec<String>>()
14591                    .join(",")
14592                    .to_string(),
14593            )]),
14594        };
14595    }
14596    if let Some(ref local_var_str) = name__iew {
14597        local_var_req_builder = match "multi" {
14598            "multi" => local_var_req_builder.query(
14599                &local_var_str
14600                    .into_iter()
14601                    .map(|p| ("name__iew".to_owned(), p.to_string()))
14602                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14603            ),
14604            _ => local_var_req_builder.query(&[(
14605                "name__iew",
14606                &local_var_str
14607                    .into_iter()
14608                    .map(|p| p.to_string())
14609                    .collect::<Vec<String>>()
14610                    .join(",")
14611                    .to_string(),
14612            )]),
14613        };
14614    }
14615    if let Some(ref local_var_str) = name__iregex {
14616        local_var_req_builder = match "multi" {
14617            "multi" => local_var_req_builder.query(
14618                &local_var_str
14619                    .into_iter()
14620                    .map(|p| ("name__iregex".to_owned(), p.to_string()))
14621                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14622            ),
14623            _ => local_var_req_builder.query(&[(
14624                "name__iregex",
14625                &local_var_str
14626                    .into_iter()
14627                    .map(|p| p.to_string())
14628                    .collect::<Vec<String>>()
14629                    .join(",")
14630                    .to_string(),
14631            )]),
14632        };
14633    }
14634    if let Some(ref local_var_str) = name__isw {
14635        local_var_req_builder = match "multi" {
14636            "multi" => local_var_req_builder.query(
14637                &local_var_str
14638                    .into_iter()
14639                    .map(|p| ("name__isw".to_owned(), p.to_string()))
14640                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14641            ),
14642            _ => local_var_req_builder.query(&[(
14643                "name__isw",
14644                &local_var_str
14645                    .into_iter()
14646                    .map(|p| p.to_string())
14647                    .collect::<Vec<String>>()
14648                    .join(",")
14649                    .to_string(),
14650            )]),
14651        };
14652    }
14653    if let Some(ref local_var_str) = name__n {
14654        local_var_req_builder = match "multi" {
14655            "multi" => local_var_req_builder.query(
14656                &local_var_str
14657                    .into_iter()
14658                    .map(|p| ("name__n".to_owned(), p.to_string()))
14659                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14660            ),
14661            _ => local_var_req_builder.query(&[(
14662                "name__n",
14663                &local_var_str
14664                    .into_iter()
14665                    .map(|p| p.to_string())
14666                    .collect::<Vec<String>>()
14667                    .join(",")
14668                    .to_string(),
14669            )]),
14670        };
14671    }
14672    if let Some(ref local_var_str) = name__nic {
14673        local_var_req_builder = match "multi" {
14674            "multi" => local_var_req_builder.query(
14675                &local_var_str
14676                    .into_iter()
14677                    .map(|p| ("name__nic".to_owned(), p.to_string()))
14678                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14679            ),
14680            _ => local_var_req_builder.query(&[(
14681                "name__nic",
14682                &local_var_str
14683                    .into_iter()
14684                    .map(|p| p.to_string())
14685                    .collect::<Vec<String>>()
14686                    .join(",")
14687                    .to_string(),
14688            )]),
14689        };
14690    }
14691    if let Some(ref local_var_str) = name__nie {
14692        local_var_req_builder = match "multi" {
14693            "multi" => local_var_req_builder.query(
14694                &local_var_str
14695                    .into_iter()
14696                    .map(|p| ("name__nie".to_owned(), p.to_string()))
14697                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14698            ),
14699            _ => local_var_req_builder.query(&[(
14700                "name__nie",
14701                &local_var_str
14702                    .into_iter()
14703                    .map(|p| p.to_string())
14704                    .collect::<Vec<String>>()
14705                    .join(",")
14706                    .to_string(),
14707            )]),
14708        };
14709    }
14710    if let Some(ref local_var_str) = name__niew {
14711        local_var_req_builder = match "multi" {
14712            "multi" => local_var_req_builder.query(
14713                &local_var_str
14714                    .into_iter()
14715                    .map(|p| ("name__niew".to_owned(), p.to_string()))
14716                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14717            ),
14718            _ => local_var_req_builder.query(&[(
14719                "name__niew",
14720                &local_var_str
14721                    .into_iter()
14722                    .map(|p| p.to_string())
14723                    .collect::<Vec<String>>()
14724                    .join(",")
14725                    .to_string(),
14726            )]),
14727        };
14728    }
14729    if let Some(ref local_var_str) = name__nisw {
14730        local_var_req_builder = match "multi" {
14731            "multi" => local_var_req_builder.query(
14732                &local_var_str
14733                    .into_iter()
14734                    .map(|p| ("name__nisw".to_owned(), p.to_string()))
14735                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14736            ),
14737            _ => local_var_req_builder.query(&[(
14738                "name__nisw",
14739                &local_var_str
14740                    .into_iter()
14741                    .map(|p| p.to_string())
14742                    .collect::<Vec<String>>()
14743                    .join(",")
14744                    .to_string(),
14745            )]),
14746        };
14747    }
14748    if let Some(ref local_var_str) = name__regex {
14749        local_var_req_builder = match "multi" {
14750            "multi" => local_var_req_builder.query(
14751                &local_var_str
14752                    .into_iter()
14753                    .map(|p| ("name__regex".to_owned(), p.to_string()))
14754                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14755            ),
14756            _ => local_var_req_builder.query(&[(
14757                "name__regex",
14758                &local_var_str
14759                    .into_iter()
14760                    .map(|p| p.to_string())
14761                    .collect::<Vec<String>>()
14762                    .join(",")
14763                    .to_string(),
14764            )]),
14765        };
14766    }
14767    if let Some(ref local_var_str) = offset {
14768        local_var_req_builder =
14769            local_var_req_builder.query(&[("offset", &local_var_str.to_string())]);
14770    }
14771    if let Some(ref local_var_str) = ordering {
14772        local_var_req_builder =
14773            local_var_req_builder.query(&[("ordering", &local_var_str.to_string())]);
14774    }
14775    if let Some(ref local_var_str) = owner {
14776        local_var_req_builder = match "multi" {
14777            "multi" => local_var_req_builder.query(
14778                &local_var_str
14779                    .into_iter()
14780                    .map(|p| ("owner".to_owned(), p.to_string()))
14781                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14782            ),
14783            _ => local_var_req_builder.query(&[(
14784                "owner",
14785                &local_var_str
14786                    .into_iter()
14787                    .map(|p| p.to_string())
14788                    .collect::<Vec<String>>()
14789                    .join(",")
14790                    .to_string(),
14791            )]),
14792        };
14793    }
14794    if let Some(ref local_var_str) = owner__n {
14795        local_var_req_builder = match "multi" {
14796            "multi" => local_var_req_builder.query(
14797                &local_var_str
14798                    .into_iter()
14799                    .map(|p| ("owner__n".to_owned(), p.to_string()))
14800                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14801            ),
14802            _ => local_var_req_builder.query(&[(
14803                "owner__n",
14804                &local_var_str
14805                    .into_iter()
14806                    .map(|p| p.to_string())
14807                    .collect::<Vec<String>>()
14808                    .join(",")
14809                    .to_string(),
14810            )]),
14811        };
14812    }
14813    if let Some(ref local_var_str) = owner_group {
14814        local_var_req_builder = match "multi" {
14815            "multi" => local_var_req_builder.query(
14816                &local_var_str
14817                    .into_iter()
14818                    .map(|p| ("owner_group".to_owned(), p.to_string()))
14819                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14820            ),
14821            _ => local_var_req_builder.query(&[(
14822                "owner_group",
14823                &local_var_str
14824                    .into_iter()
14825                    .map(|p| p.to_string())
14826                    .collect::<Vec<String>>()
14827                    .join(",")
14828                    .to_string(),
14829            )]),
14830        };
14831    }
14832    if let Some(ref local_var_str) = owner_group__n {
14833        local_var_req_builder = match "multi" {
14834            "multi" => local_var_req_builder.query(
14835                &local_var_str
14836                    .into_iter()
14837                    .map(|p| ("owner_group__n".to_owned(), p.to_string()))
14838                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14839            ),
14840            _ => local_var_req_builder.query(&[(
14841                "owner_group__n",
14842                &local_var_str
14843                    .into_iter()
14844                    .map(|p| p.to_string())
14845                    .collect::<Vec<String>>()
14846                    .join(",")
14847                    .to_string(),
14848            )]),
14849        };
14850    }
14851    if let Some(ref local_var_str) = owner_group_id {
14852        local_var_req_builder = match "multi" {
14853            "multi" => local_var_req_builder.query(
14854                &local_var_str
14855                    .into_iter()
14856                    .map(|p| ("owner_group_id".to_owned(), p.to_string()))
14857                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14858            ),
14859            _ => local_var_req_builder.query(&[(
14860                "owner_group_id",
14861                &local_var_str
14862                    .into_iter()
14863                    .map(|p| p.to_string())
14864                    .collect::<Vec<String>>()
14865                    .join(",")
14866                    .to_string(),
14867            )]),
14868        };
14869    }
14870    if let Some(ref local_var_str) = owner_group_id__n {
14871        local_var_req_builder = match "multi" {
14872            "multi" => local_var_req_builder.query(
14873                &local_var_str
14874                    .into_iter()
14875                    .map(|p| ("owner_group_id__n".to_owned(), p.to_string()))
14876                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14877            ),
14878            _ => local_var_req_builder.query(&[(
14879                "owner_group_id__n",
14880                &local_var_str
14881                    .into_iter()
14882                    .map(|p| p.to_string())
14883                    .collect::<Vec<String>>()
14884                    .join(",")
14885                    .to_string(),
14886            )]),
14887        };
14888    }
14889    if let Some(ref local_var_str) = owner_id {
14890        local_var_req_builder = match "multi" {
14891            "multi" => local_var_req_builder.query(
14892                &local_var_str
14893                    .into_iter()
14894                    .map(|p| ("owner_id".to_owned(), p.to_string()))
14895                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14896            ),
14897            _ => local_var_req_builder.query(&[(
14898                "owner_id",
14899                &local_var_str
14900                    .into_iter()
14901                    .map(|p| p.to_string())
14902                    .collect::<Vec<String>>()
14903                    .join(",")
14904                    .to_string(),
14905            )]),
14906        };
14907    }
14908    if let Some(ref local_var_str) = owner_id__n {
14909        local_var_req_builder = match "multi" {
14910            "multi" => local_var_req_builder.query(
14911                &local_var_str
14912                    .into_iter()
14913                    .map(|p| ("owner_id__n".to_owned(), p.to_string()))
14914                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14915            ),
14916            _ => local_var_req_builder.query(&[(
14917                "owner_id__n",
14918                &local_var_str
14919                    .into_iter()
14920                    .map(|p| p.to_string())
14921                    .collect::<Vec<String>>()
14922                    .join(",")
14923                    .to_string(),
14924            )]),
14925        };
14926    }
14927    if let Some(ref local_var_str) = provider {
14928        local_var_req_builder = match "multi" {
14929            "multi" => local_var_req_builder.query(
14930                &local_var_str
14931                    .into_iter()
14932                    .map(|p| ("provider".to_owned(), p.to_string()))
14933                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14934            ),
14935            _ => local_var_req_builder.query(&[(
14936                "provider",
14937                &local_var_str
14938                    .into_iter()
14939                    .map(|p| p.to_string())
14940                    .collect::<Vec<String>>()
14941                    .join(",")
14942                    .to_string(),
14943            )]),
14944        };
14945    }
14946    if let Some(ref local_var_str) = provider__n {
14947        local_var_req_builder = match "multi" {
14948            "multi" => local_var_req_builder.query(
14949                &local_var_str
14950                    .into_iter()
14951                    .map(|p| ("provider__n".to_owned(), p.to_string()))
14952                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14953            ),
14954            _ => local_var_req_builder.query(&[(
14955                "provider__n",
14956                &local_var_str
14957                    .into_iter()
14958                    .map(|p| p.to_string())
14959                    .collect::<Vec<String>>()
14960                    .join(",")
14961                    .to_string(),
14962            )]),
14963        };
14964    }
14965    if let Some(ref local_var_str) = provider_id {
14966        local_var_req_builder = match "multi" {
14967            "multi" => local_var_req_builder.query(
14968                &local_var_str
14969                    .into_iter()
14970                    .map(|p| ("provider_id".to_owned(), p.to_string()))
14971                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14972            ),
14973            _ => local_var_req_builder.query(&[(
14974                "provider_id",
14975                &local_var_str
14976                    .into_iter()
14977                    .map(|p| p.to_string())
14978                    .collect::<Vec<String>>()
14979                    .join(",")
14980                    .to_string(),
14981            )]),
14982        };
14983    }
14984    if let Some(ref local_var_str) = provider_id__n {
14985        local_var_req_builder = match "multi" {
14986            "multi" => local_var_req_builder.query(
14987                &local_var_str
14988                    .into_iter()
14989                    .map(|p| ("provider_id__n".to_owned(), p.to_string()))
14990                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14991            ),
14992            _ => local_var_req_builder.query(&[(
14993                "provider_id__n",
14994                &local_var_str
14995                    .into_iter()
14996                    .map(|p| p.to_string())
14997                    .collect::<Vec<String>>()
14998                    .join(",")
14999                    .to_string(),
15000            )]),
15001        };
15002    }
15003    if let Some(ref local_var_str) = q {
15004        local_var_req_builder = local_var_req_builder.query(&[("q", &local_var_str.to_string())]);
15005    }
15006    if let Some(ref local_var_str) = tag {
15007        local_var_req_builder = match "multi" {
15008            "multi" => local_var_req_builder.query(
15009                &local_var_str
15010                    .into_iter()
15011                    .map(|p| ("tag".to_owned(), p.to_string()))
15012                    .collect::<Vec<(std::string::String, std::string::String)>>(),
15013            ),
15014            _ => local_var_req_builder.query(&[(
15015                "tag",
15016                &local_var_str
15017                    .into_iter()
15018                    .map(|p| p.to_string())
15019                    .collect::<Vec<String>>()
15020                    .join(",")
15021                    .to_string(),
15022            )]),
15023        };
15024    }
15025    if let Some(ref local_var_str) = tag__n {
15026        local_var_req_builder = match "multi" {
15027            "multi" => local_var_req_builder.query(
15028                &local_var_str
15029                    .into_iter()
15030                    .map(|p| ("tag__n".to_owned(), p.to_string()))
15031                    .collect::<Vec<(std::string::String, std::string::String)>>(),
15032            ),
15033            _ => local_var_req_builder.query(&[(
15034                "tag__n",
15035                &local_var_str
15036                    .into_iter()
15037                    .map(|p| p.to_string())
15038                    .collect::<Vec<String>>()
15039                    .join(",")
15040                    .to_string(),
15041            )]),
15042        };
15043    }
15044    if let Some(ref local_var_str) = tag_id {
15045        local_var_req_builder = match "multi" {
15046            "multi" => local_var_req_builder.query(
15047                &local_var_str
15048                    .into_iter()
15049                    .map(|p| ("tag_id".to_owned(), p.to_string()))
15050                    .collect::<Vec<(std::string::String, std::string::String)>>(),
15051            ),
15052            _ => local_var_req_builder.query(&[(
15053                "tag_id",
15054                &local_var_str
15055                    .into_iter()
15056                    .map(|p| p.to_string())
15057                    .collect::<Vec<String>>()
15058                    .join(",")
15059                    .to_string(),
15060            )]),
15061        };
15062    }
15063    if let Some(ref local_var_str) = tag_id__n {
15064        local_var_req_builder = match "multi" {
15065            "multi" => local_var_req_builder.query(
15066                &local_var_str
15067                    .into_iter()
15068                    .map(|p| ("tag_id__n".to_owned(), p.to_string()))
15069                    .collect::<Vec<(std::string::String, std::string::String)>>(),
15070            ),
15071            _ => local_var_req_builder.query(&[(
15072                "tag_id__n",
15073                &local_var_str
15074                    .into_iter()
15075                    .map(|p| p.to_string())
15076                    .collect::<Vec<String>>()
15077                    .join(",")
15078                    .to_string(),
15079            )]),
15080        };
15081    }
15082    if let Some(ref local_var_str) = updated_by_request {
15083        local_var_req_builder =
15084            local_var_req_builder.query(&[("updated_by_request", &local_var_str.to_string())]);
15085    }
15086    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
15087        local_var_req_builder =
15088            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
15089    }
15090    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
15091        let local_var_key = local_var_apikey.key.clone();
15092        let local_var_value = match local_var_apikey.prefix {
15093            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
15094            None => local_var_key,
15095        };
15096        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
15097    };
15098
15099    let local_var_req = local_var_req_builder.build()?;
15100    let local_var_resp = local_var_client.execute(local_var_req).await?;
15101
15102    let local_var_status = local_var_resp.status();
15103    let local_var_content = local_var_resp.text().await?;
15104
15105    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
15106        serde_json::from_str(&local_var_content).map_err(Error::from)
15107    } else {
15108        let local_var_entity: Option<CircuitsProviderAccountsListError> =
15109            serde_json::from_str(&local_var_content).ok();
15110        let local_var_error = ResponseContent {
15111            status: local_var_status,
15112            content: local_var_content,
15113            entity: local_var_entity,
15114        };
15115        Err(Error::ResponseError(local_var_error))
15116    }
15117}
15118
15119/// Patch a provider account object.
15120pub async fn circuits_provider_accounts_partial_update(
15121    configuration: &configuration::Configuration,
15122    id: i32,
15123    patched_provider_account_request: Option<crate::models::PatchedProviderAccountRequest>,
15124) -> Result<crate::models::ProviderAccount, Error<CircuitsProviderAccountsPartialUpdateError>> {
15125    let local_var_configuration = configuration;
15126
15127    let local_var_client = &local_var_configuration.client;
15128
15129    let local_var_uri_str = format!(
15130        "{}/api/circuits/provider-accounts/{id}/",
15131        local_var_configuration.base_path,
15132        id = id
15133    );
15134    let mut local_var_req_builder =
15135        local_var_client.request(reqwest::Method::PATCH, local_var_uri_str.as_str());
15136
15137    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
15138        local_var_req_builder =
15139            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
15140    }
15141    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
15142        let local_var_key = local_var_apikey.key.clone();
15143        let local_var_value = match local_var_apikey.prefix {
15144            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
15145            None => local_var_key,
15146        };
15147        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
15148    };
15149    local_var_req_builder = local_var_req_builder.json(&patched_provider_account_request);
15150
15151    let local_var_req = local_var_req_builder.build()?;
15152    let local_var_resp = local_var_client.execute(local_var_req).await?;
15153
15154    let local_var_status = local_var_resp.status();
15155    let local_var_content = local_var_resp.text().await?;
15156
15157    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
15158        serde_json::from_str(&local_var_content).map_err(Error::from)
15159    } else {
15160        let local_var_entity: Option<CircuitsProviderAccountsPartialUpdateError> =
15161            serde_json::from_str(&local_var_content).ok();
15162        let local_var_error = ResponseContent {
15163            status: local_var_status,
15164            content: local_var_content,
15165            entity: local_var_entity,
15166        };
15167        Err(Error::ResponseError(local_var_error))
15168    }
15169}
15170
15171/// Get a provider account object.
15172pub async fn circuits_provider_accounts_retrieve(
15173    configuration: &configuration::Configuration,
15174    id: i32,
15175) -> Result<crate::models::ProviderAccount, Error<CircuitsProviderAccountsRetrieveError>> {
15176    let local_var_configuration = configuration;
15177
15178    let local_var_client = &local_var_configuration.client;
15179
15180    let local_var_uri_str = format!(
15181        "{}/api/circuits/provider-accounts/{id}/",
15182        local_var_configuration.base_path,
15183        id = id
15184    );
15185    let mut local_var_req_builder =
15186        local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
15187
15188    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
15189        local_var_req_builder =
15190            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
15191    }
15192    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
15193        let local_var_key = local_var_apikey.key.clone();
15194        let local_var_value = match local_var_apikey.prefix {
15195            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
15196            None => local_var_key,
15197        };
15198        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
15199    };
15200
15201    let local_var_req = local_var_req_builder.build()?;
15202    let local_var_resp = local_var_client.execute(local_var_req).await?;
15203
15204    let local_var_status = local_var_resp.status();
15205    let local_var_content = local_var_resp.text().await?;
15206
15207    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
15208        serde_json::from_str(&local_var_content).map_err(Error::from)
15209    } else {
15210        let local_var_entity: Option<CircuitsProviderAccountsRetrieveError> =
15211            serde_json::from_str(&local_var_content).ok();
15212        let local_var_error = ResponseContent {
15213            status: local_var_status,
15214            content: local_var_content,
15215            entity: local_var_entity,
15216        };
15217        Err(Error::ResponseError(local_var_error))
15218    }
15219}
15220
15221/// Put a provider account object.
15222pub async fn circuits_provider_accounts_update(
15223    configuration: &configuration::Configuration,
15224    id: i32,
15225    provider_account_request: crate::models::ProviderAccountRequest,
15226) -> Result<crate::models::ProviderAccount, Error<CircuitsProviderAccountsUpdateError>> {
15227    let local_var_configuration = configuration;
15228
15229    let local_var_client = &local_var_configuration.client;
15230
15231    let local_var_uri_str = format!(
15232        "{}/api/circuits/provider-accounts/{id}/",
15233        local_var_configuration.base_path,
15234        id = id
15235    );
15236    let mut local_var_req_builder =
15237        local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());
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(&provider_account_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<CircuitsProviderAccountsUpdateError> =
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/// Delete a list of provider network objects.
15274pub async fn circuits_provider_networks_bulk_destroy(
15275    configuration: &configuration::Configuration,
15276    provider_network_request: Vec<crate::models::ProviderNetworkRequest>,
15277) -> Result<(), Error<CircuitsProviderNetworksBulkDestroyError>> {
15278    let local_var_configuration = configuration;
15279
15280    let local_var_client = &local_var_configuration.client;
15281
15282    let local_var_uri_str = format!(
15283        "{}/api/circuits/provider-networks/",
15284        local_var_configuration.base_path
15285    );
15286    let mut local_var_req_builder =
15287        local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());
15288
15289    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
15290        local_var_req_builder =
15291            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
15292    }
15293    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
15294        let local_var_key = local_var_apikey.key.clone();
15295        let local_var_value = match local_var_apikey.prefix {
15296            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
15297            None => local_var_key,
15298        };
15299        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
15300    };
15301    local_var_req_builder = local_var_req_builder.json(&provider_network_request);
15302
15303    let local_var_req = local_var_req_builder.build()?;
15304    let local_var_resp = local_var_client.execute(local_var_req).await?;
15305
15306    let local_var_status = local_var_resp.status();
15307    let local_var_content = local_var_resp.text().await?;
15308
15309    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
15310        Ok(())
15311    } else {
15312        let local_var_entity: Option<CircuitsProviderNetworksBulkDestroyError> =
15313            serde_json::from_str(&local_var_content).ok();
15314        let local_var_error = ResponseContent {
15315            status: local_var_status,
15316            content: local_var_content,
15317            entity: local_var_entity,
15318        };
15319        Err(Error::ResponseError(local_var_error))
15320    }
15321}
15322
15323/// Patch a list of provider network objects.
15324pub async fn circuits_provider_networks_bulk_partial_update(
15325    configuration: &configuration::Configuration,
15326    provider_network_request: Vec<crate::models::ProviderNetworkRequest>,
15327) -> Result<
15328    Vec<crate::models::ProviderNetwork>,
15329    Error<CircuitsProviderNetworksBulkPartialUpdateError>,
15330> {
15331    let local_var_configuration = configuration;
15332
15333    let local_var_client = &local_var_configuration.client;
15334
15335    let local_var_uri_str = format!(
15336        "{}/api/circuits/provider-networks/",
15337        local_var_configuration.base_path
15338    );
15339    let mut local_var_req_builder =
15340        local_var_client.request(reqwest::Method::PATCH, local_var_uri_str.as_str());
15341
15342    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
15343        local_var_req_builder =
15344            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
15345    }
15346    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
15347        let local_var_key = local_var_apikey.key.clone();
15348        let local_var_value = match local_var_apikey.prefix {
15349            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
15350            None => local_var_key,
15351        };
15352        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
15353    };
15354    local_var_req_builder = local_var_req_builder.json(&provider_network_request);
15355
15356    let local_var_req = local_var_req_builder.build()?;
15357    let local_var_resp = local_var_client.execute(local_var_req).await?;
15358
15359    let local_var_status = local_var_resp.status();
15360    let local_var_content = local_var_resp.text().await?;
15361
15362    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
15363        serde_json::from_str(&local_var_content).map_err(Error::from)
15364    } else {
15365        let local_var_entity: Option<CircuitsProviderNetworksBulkPartialUpdateError> =
15366            serde_json::from_str(&local_var_content).ok();
15367        let local_var_error = ResponseContent {
15368            status: local_var_status,
15369            content: local_var_content,
15370            entity: local_var_entity,
15371        };
15372        Err(Error::ResponseError(local_var_error))
15373    }
15374}
15375
15376/// Put a list of provider network objects.
15377pub async fn circuits_provider_networks_bulk_update(
15378    configuration: &configuration::Configuration,
15379    provider_network_request: Vec<crate::models::ProviderNetworkRequest>,
15380) -> Result<Vec<crate::models::ProviderNetwork>, Error<CircuitsProviderNetworksBulkUpdateError>> {
15381    let local_var_configuration = configuration;
15382
15383    let local_var_client = &local_var_configuration.client;
15384
15385    let local_var_uri_str = format!(
15386        "{}/api/circuits/provider-networks/",
15387        local_var_configuration.base_path
15388    );
15389    let mut local_var_req_builder =
15390        local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());
15391
15392    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
15393        local_var_req_builder =
15394            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
15395    }
15396    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
15397        let local_var_key = local_var_apikey.key.clone();
15398        let local_var_value = match local_var_apikey.prefix {
15399            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
15400            None => local_var_key,
15401        };
15402        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
15403    };
15404    local_var_req_builder = local_var_req_builder.json(&provider_network_request);
15405
15406    let local_var_req = local_var_req_builder.build()?;
15407    let local_var_resp = local_var_client.execute(local_var_req).await?;
15408
15409    let local_var_status = local_var_resp.status();
15410    let local_var_content = local_var_resp.text().await?;
15411
15412    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
15413        serde_json::from_str(&local_var_content).map_err(Error::from)
15414    } else {
15415        let local_var_entity: Option<CircuitsProviderNetworksBulkUpdateError> =
15416            serde_json::from_str(&local_var_content).ok();
15417        let local_var_error = ResponseContent {
15418            status: local_var_status,
15419            content: local_var_content,
15420            entity: local_var_entity,
15421        };
15422        Err(Error::ResponseError(local_var_error))
15423    }
15424}
15425
15426/// Post a list of provider network objects.
15427pub async fn circuits_provider_networks_create(
15428    configuration: &configuration::Configuration,
15429    circuits_provider_networks_create_request: crate::models::CircuitsProviderNetworksCreateRequest,
15430) -> Result<crate::models::ProviderNetwork, Error<CircuitsProviderNetworksCreateError>> {
15431    let local_var_configuration = configuration;
15432
15433    let local_var_client = &local_var_configuration.client;
15434
15435    let local_var_uri_str = format!(
15436        "{}/api/circuits/provider-networks/",
15437        local_var_configuration.base_path
15438    );
15439    let mut local_var_req_builder =
15440        local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
15441
15442    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
15443        local_var_req_builder =
15444            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
15445    }
15446    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
15447        let local_var_key = local_var_apikey.key.clone();
15448        let local_var_value = match local_var_apikey.prefix {
15449            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
15450            None => local_var_key,
15451        };
15452        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
15453    };
15454    local_var_req_builder = local_var_req_builder.json(&circuits_provider_networks_create_request);
15455
15456    let local_var_req = local_var_req_builder.build()?;
15457    let local_var_resp = local_var_client.execute(local_var_req).await?;
15458
15459    let local_var_status = local_var_resp.status();
15460    let local_var_content = local_var_resp.text().await?;
15461
15462    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
15463        serde_json::from_str(&local_var_content).map_err(Error::from)
15464    } else {
15465        let local_var_entity: Option<CircuitsProviderNetworksCreateError> =
15466            serde_json::from_str(&local_var_content).ok();
15467        let local_var_error = ResponseContent {
15468            status: local_var_status,
15469            content: local_var_content,
15470            entity: local_var_entity,
15471        };
15472        Err(Error::ResponseError(local_var_error))
15473    }
15474}
15475
15476/// Delete a provider network object.
15477pub async fn circuits_provider_networks_destroy(
15478    configuration: &configuration::Configuration,
15479    id: i32,
15480) -> Result<(), Error<CircuitsProviderNetworksDestroyError>> {
15481    let local_var_configuration = configuration;
15482
15483    let local_var_client = &local_var_configuration.client;
15484
15485    let local_var_uri_str = format!(
15486        "{}/api/circuits/provider-networks/{id}/",
15487        local_var_configuration.base_path,
15488        id = id
15489    );
15490    let mut local_var_req_builder =
15491        local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());
15492
15493    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
15494        local_var_req_builder =
15495            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
15496    }
15497    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
15498        let local_var_key = local_var_apikey.key.clone();
15499        let local_var_value = match local_var_apikey.prefix {
15500            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
15501            None => local_var_key,
15502        };
15503        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
15504    };
15505
15506    let local_var_req = local_var_req_builder.build()?;
15507    let local_var_resp = local_var_client.execute(local_var_req).await?;
15508
15509    let local_var_status = local_var_resp.status();
15510    let local_var_content = local_var_resp.text().await?;
15511
15512    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
15513        Ok(())
15514    } else {
15515        let local_var_entity: Option<CircuitsProviderNetworksDestroyError> =
15516            serde_json::from_str(&local_var_content).ok();
15517        let local_var_error = ResponseContent {
15518            status: local_var_status,
15519            content: local_var_content,
15520            entity: local_var_entity,
15521        };
15522        Err(Error::ResponseError(local_var_error))
15523    }
15524}
15525
15526/// Get a list of provider network objects.
15527pub async fn circuits_provider_networks_list(
15528    configuration: &configuration::Configuration,
15529    created: Option<Vec<String>>,
15530    created__empty: Option<Vec<String>>,
15531    created__gt: Option<Vec<String>>,
15532    created__gte: Option<Vec<String>>,
15533    created__lt: Option<Vec<String>>,
15534    created__lte: Option<Vec<String>>,
15535    created__n: Option<Vec<String>>,
15536    created_by_request: Option<&str>,
15537    description: Option<Vec<String>>,
15538    description__empty: Option<bool>,
15539    description__ic: Option<Vec<String>>,
15540    description__ie: Option<Vec<String>>,
15541    description__iew: Option<Vec<String>>,
15542    description__iregex: Option<Vec<String>>,
15543    description__isw: Option<Vec<String>>,
15544    description__n: Option<Vec<String>>,
15545    description__nic: Option<Vec<String>>,
15546    description__nie: Option<Vec<String>>,
15547    description__niew: Option<Vec<String>>,
15548    description__nisw: Option<Vec<String>>,
15549    description__regex: Option<Vec<String>>,
15550    id: Option<Vec<i32>>,
15551    id__empty: Option<bool>,
15552    id__gt: Option<Vec<i32>>,
15553    id__gte: Option<Vec<i32>>,
15554    id__lt: Option<Vec<i32>>,
15555    id__lte: Option<Vec<i32>>,
15556    id__n: Option<Vec<i32>>,
15557    last_updated: Option<Vec<String>>,
15558    last_updated__empty: Option<Vec<String>>,
15559    last_updated__gt: Option<Vec<String>>,
15560    last_updated__gte: Option<Vec<String>>,
15561    last_updated__lt: Option<Vec<String>>,
15562    last_updated__lte: Option<Vec<String>>,
15563    last_updated__n: Option<Vec<String>>,
15564    limit: Option<i32>,
15565    modified_by_request: Option<&str>,
15566    name: Option<Vec<String>>,
15567    name__empty: Option<bool>,
15568    name__ic: Option<Vec<String>>,
15569    name__ie: Option<Vec<String>>,
15570    name__iew: Option<Vec<String>>,
15571    name__iregex: Option<Vec<String>>,
15572    name__isw: Option<Vec<String>>,
15573    name__n: Option<Vec<String>>,
15574    name__nic: Option<Vec<String>>,
15575    name__nie: Option<Vec<String>>,
15576    name__niew: Option<Vec<String>>,
15577    name__nisw: Option<Vec<String>>,
15578    name__regex: Option<Vec<String>>,
15579    offset: Option<i32>,
15580    ordering: Option<&str>,
15581    owner: Option<Vec<String>>,
15582    owner__n: Option<Vec<String>>,
15583    owner_group: Option<Vec<String>>,
15584    owner_group__n: Option<Vec<String>>,
15585    owner_group_id: Option<Vec<i32>>,
15586    owner_group_id__n: Option<Vec<i32>>,
15587    owner_id: Option<Vec<i32>>,
15588    owner_id__n: Option<Vec<i32>>,
15589    provider: Option<Vec<String>>,
15590    provider__n: Option<Vec<String>>,
15591    provider_id: Option<Vec<i32>>,
15592    provider_id__n: Option<Vec<i32>>,
15593    q: Option<&str>,
15594    service_id: Option<Vec<String>>,
15595    service_id__empty: Option<bool>,
15596    service_id__ic: Option<Vec<String>>,
15597    service_id__ie: Option<Vec<String>>,
15598    service_id__iew: Option<Vec<String>>,
15599    service_id__iregex: Option<Vec<String>>,
15600    service_id__isw: Option<Vec<String>>,
15601    service_id__n: Option<Vec<String>>,
15602    service_id__nic: Option<Vec<String>>,
15603    service_id__nie: Option<Vec<String>>,
15604    service_id__niew: Option<Vec<String>>,
15605    service_id__nisw: Option<Vec<String>>,
15606    service_id__regex: Option<Vec<String>>,
15607    tag: Option<Vec<String>>,
15608    tag__n: Option<Vec<String>>,
15609    tag_id: Option<Vec<i32>>,
15610    tag_id__n: Option<Vec<i32>>,
15611    updated_by_request: Option<&str>,
15612) -> Result<crate::models::PaginatedProviderNetworkList, Error<CircuitsProviderNetworksListError>> {
15613    let local_var_configuration = configuration;
15614
15615    let local_var_client = &local_var_configuration.client;
15616
15617    let local_var_uri_str = format!(
15618        "{}/api/circuits/provider-networks/",
15619        local_var_configuration.base_path
15620    );
15621    let mut local_var_req_builder =
15622        local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
15623
15624    if let Some(ref local_var_str) = created {
15625        local_var_req_builder = match "multi" {
15626            "multi" => local_var_req_builder.query(
15627                &local_var_str
15628                    .into_iter()
15629                    .map(|p| ("created".to_owned(), p.to_string()))
15630                    .collect::<Vec<(std::string::String, std::string::String)>>(),
15631            ),
15632            _ => local_var_req_builder.query(&[(
15633                "created",
15634                &local_var_str
15635                    .into_iter()
15636                    .map(|p| p.to_string())
15637                    .collect::<Vec<String>>()
15638                    .join(",")
15639                    .to_string(),
15640            )]),
15641        };
15642    }
15643    if let Some(ref local_var_str) = created__empty {
15644        local_var_req_builder = match "multi" {
15645            "multi" => local_var_req_builder.query(
15646                &local_var_str
15647                    .into_iter()
15648                    .map(|p| ("created__empty".to_owned(), p.to_string()))
15649                    .collect::<Vec<(std::string::String, std::string::String)>>(),
15650            ),
15651            _ => local_var_req_builder.query(&[(
15652                "created__empty",
15653                &local_var_str
15654                    .into_iter()
15655                    .map(|p| p.to_string())
15656                    .collect::<Vec<String>>()
15657                    .join(",")
15658                    .to_string(),
15659            )]),
15660        };
15661    }
15662    if let Some(ref local_var_str) = created__gt {
15663        local_var_req_builder = match "multi" {
15664            "multi" => local_var_req_builder.query(
15665                &local_var_str
15666                    .into_iter()
15667                    .map(|p| ("created__gt".to_owned(), p.to_string()))
15668                    .collect::<Vec<(std::string::String, std::string::String)>>(),
15669            ),
15670            _ => local_var_req_builder.query(&[(
15671                "created__gt",
15672                &local_var_str
15673                    .into_iter()
15674                    .map(|p| p.to_string())
15675                    .collect::<Vec<String>>()
15676                    .join(",")
15677                    .to_string(),
15678            )]),
15679        };
15680    }
15681    if let Some(ref local_var_str) = created__gte {
15682        local_var_req_builder = match "multi" {
15683            "multi" => local_var_req_builder.query(
15684                &local_var_str
15685                    .into_iter()
15686                    .map(|p| ("created__gte".to_owned(), p.to_string()))
15687                    .collect::<Vec<(std::string::String, std::string::String)>>(),
15688            ),
15689            _ => local_var_req_builder.query(&[(
15690                "created__gte",
15691                &local_var_str
15692                    .into_iter()
15693                    .map(|p| p.to_string())
15694                    .collect::<Vec<String>>()
15695                    .join(",")
15696                    .to_string(),
15697            )]),
15698        };
15699    }
15700    if let Some(ref local_var_str) = created__lt {
15701        local_var_req_builder = match "multi" {
15702            "multi" => local_var_req_builder.query(
15703                &local_var_str
15704                    .into_iter()
15705                    .map(|p| ("created__lt".to_owned(), p.to_string()))
15706                    .collect::<Vec<(std::string::String, std::string::String)>>(),
15707            ),
15708            _ => local_var_req_builder.query(&[(
15709                "created__lt",
15710                &local_var_str
15711                    .into_iter()
15712                    .map(|p| p.to_string())
15713                    .collect::<Vec<String>>()
15714                    .join(",")
15715                    .to_string(),
15716            )]),
15717        };
15718    }
15719    if let Some(ref local_var_str) = created__lte {
15720        local_var_req_builder = match "multi" {
15721            "multi" => local_var_req_builder.query(
15722                &local_var_str
15723                    .into_iter()
15724                    .map(|p| ("created__lte".to_owned(), p.to_string()))
15725                    .collect::<Vec<(std::string::String, std::string::String)>>(),
15726            ),
15727            _ => local_var_req_builder.query(&[(
15728                "created__lte",
15729                &local_var_str
15730                    .into_iter()
15731                    .map(|p| p.to_string())
15732                    .collect::<Vec<String>>()
15733                    .join(",")
15734                    .to_string(),
15735            )]),
15736        };
15737    }
15738    if let Some(ref local_var_str) = created__n {
15739        local_var_req_builder = match "multi" {
15740            "multi" => local_var_req_builder.query(
15741                &local_var_str
15742                    .into_iter()
15743                    .map(|p| ("created__n".to_owned(), p.to_string()))
15744                    .collect::<Vec<(std::string::String, std::string::String)>>(),
15745            ),
15746            _ => local_var_req_builder.query(&[(
15747                "created__n",
15748                &local_var_str
15749                    .into_iter()
15750                    .map(|p| p.to_string())
15751                    .collect::<Vec<String>>()
15752                    .join(",")
15753                    .to_string(),
15754            )]),
15755        };
15756    }
15757    if let Some(ref local_var_str) = created_by_request {
15758        local_var_req_builder =
15759            local_var_req_builder.query(&[("created_by_request", &local_var_str.to_string())]);
15760    }
15761    if let Some(ref local_var_str) = description {
15762        local_var_req_builder = match "multi" {
15763            "multi" => local_var_req_builder.query(
15764                &local_var_str
15765                    .into_iter()
15766                    .map(|p| ("description".to_owned(), p.to_string()))
15767                    .collect::<Vec<(std::string::String, std::string::String)>>(),
15768            ),
15769            _ => local_var_req_builder.query(&[(
15770                "description",
15771                &local_var_str
15772                    .into_iter()
15773                    .map(|p| p.to_string())
15774                    .collect::<Vec<String>>()
15775                    .join(",")
15776                    .to_string(),
15777            )]),
15778        };
15779    }
15780    if let Some(ref local_var_str) = description__empty {
15781        local_var_req_builder =
15782            local_var_req_builder.query(&[("description__empty", &local_var_str.to_string())]);
15783    }
15784    if let Some(ref local_var_str) = description__ic {
15785        local_var_req_builder = match "multi" {
15786            "multi" => local_var_req_builder.query(
15787                &local_var_str
15788                    .into_iter()
15789                    .map(|p| ("description__ic".to_owned(), p.to_string()))
15790                    .collect::<Vec<(std::string::String, std::string::String)>>(),
15791            ),
15792            _ => local_var_req_builder.query(&[(
15793                "description__ic",
15794                &local_var_str
15795                    .into_iter()
15796                    .map(|p| p.to_string())
15797                    .collect::<Vec<String>>()
15798                    .join(",")
15799                    .to_string(),
15800            )]),
15801        };
15802    }
15803    if let Some(ref local_var_str) = description__ie {
15804        local_var_req_builder = match "multi" {
15805            "multi" => local_var_req_builder.query(
15806                &local_var_str
15807                    .into_iter()
15808                    .map(|p| ("description__ie".to_owned(), p.to_string()))
15809                    .collect::<Vec<(std::string::String, std::string::String)>>(),
15810            ),
15811            _ => local_var_req_builder.query(&[(
15812                "description__ie",
15813                &local_var_str
15814                    .into_iter()
15815                    .map(|p| p.to_string())
15816                    .collect::<Vec<String>>()
15817                    .join(",")
15818                    .to_string(),
15819            )]),
15820        };
15821    }
15822    if let Some(ref local_var_str) = description__iew {
15823        local_var_req_builder = match "multi" {
15824            "multi" => local_var_req_builder.query(
15825                &local_var_str
15826                    .into_iter()
15827                    .map(|p| ("description__iew".to_owned(), p.to_string()))
15828                    .collect::<Vec<(std::string::String, std::string::String)>>(),
15829            ),
15830            _ => local_var_req_builder.query(&[(
15831                "description__iew",
15832                &local_var_str
15833                    .into_iter()
15834                    .map(|p| p.to_string())
15835                    .collect::<Vec<String>>()
15836                    .join(",")
15837                    .to_string(),
15838            )]),
15839        };
15840    }
15841    if let Some(ref local_var_str) = description__iregex {
15842        local_var_req_builder = match "multi" {
15843            "multi" => local_var_req_builder.query(
15844                &local_var_str
15845                    .into_iter()
15846                    .map(|p| ("description__iregex".to_owned(), p.to_string()))
15847                    .collect::<Vec<(std::string::String, std::string::String)>>(),
15848            ),
15849            _ => local_var_req_builder.query(&[(
15850                "description__iregex",
15851                &local_var_str
15852                    .into_iter()
15853                    .map(|p| p.to_string())
15854                    .collect::<Vec<String>>()
15855                    .join(",")
15856                    .to_string(),
15857            )]),
15858        };
15859    }
15860    if let Some(ref local_var_str) = description__isw {
15861        local_var_req_builder = match "multi" {
15862            "multi" => local_var_req_builder.query(
15863                &local_var_str
15864                    .into_iter()
15865                    .map(|p| ("description__isw".to_owned(), p.to_string()))
15866                    .collect::<Vec<(std::string::String, std::string::String)>>(),
15867            ),
15868            _ => local_var_req_builder.query(&[(
15869                "description__isw",
15870                &local_var_str
15871                    .into_iter()
15872                    .map(|p| p.to_string())
15873                    .collect::<Vec<String>>()
15874                    .join(",")
15875                    .to_string(),
15876            )]),
15877        };
15878    }
15879    if let Some(ref local_var_str) = description__n {
15880        local_var_req_builder = match "multi" {
15881            "multi" => local_var_req_builder.query(
15882                &local_var_str
15883                    .into_iter()
15884                    .map(|p| ("description__n".to_owned(), p.to_string()))
15885                    .collect::<Vec<(std::string::String, std::string::String)>>(),
15886            ),
15887            _ => local_var_req_builder.query(&[(
15888                "description__n",
15889                &local_var_str
15890                    .into_iter()
15891                    .map(|p| p.to_string())
15892                    .collect::<Vec<String>>()
15893                    .join(",")
15894                    .to_string(),
15895            )]),
15896        };
15897    }
15898    if let Some(ref local_var_str) = description__nic {
15899        local_var_req_builder = match "multi" {
15900            "multi" => local_var_req_builder.query(
15901                &local_var_str
15902                    .into_iter()
15903                    .map(|p| ("description__nic".to_owned(), p.to_string()))
15904                    .collect::<Vec<(std::string::String, std::string::String)>>(),
15905            ),
15906            _ => local_var_req_builder.query(&[(
15907                "description__nic",
15908                &local_var_str
15909                    .into_iter()
15910                    .map(|p| p.to_string())
15911                    .collect::<Vec<String>>()
15912                    .join(",")
15913                    .to_string(),
15914            )]),
15915        };
15916    }
15917    if let Some(ref local_var_str) = description__nie {
15918        local_var_req_builder = match "multi" {
15919            "multi" => local_var_req_builder.query(
15920                &local_var_str
15921                    .into_iter()
15922                    .map(|p| ("description__nie".to_owned(), p.to_string()))
15923                    .collect::<Vec<(std::string::String, std::string::String)>>(),
15924            ),
15925            _ => local_var_req_builder.query(&[(
15926                "description__nie",
15927                &local_var_str
15928                    .into_iter()
15929                    .map(|p| p.to_string())
15930                    .collect::<Vec<String>>()
15931                    .join(",")
15932                    .to_string(),
15933            )]),
15934        };
15935    }
15936    if let Some(ref local_var_str) = description__niew {
15937        local_var_req_builder = match "multi" {
15938            "multi" => local_var_req_builder.query(
15939                &local_var_str
15940                    .into_iter()
15941                    .map(|p| ("description__niew".to_owned(), p.to_string()))
15942                    .collect::<Vec<(std::string::String, std::string::String)>>(),
15943            ),
15944            _ => local_var_req_builder.query(&[(
15945                "description__niew",
15946                &local_var_str
15947                    .into_iter()
15948                    .map(|p| p.to_string())
15949                    .collect::<Vec<String>>()
15950                    .join(",")
15951                    .to_string(),
15952            )]),
15953        };
15954    }
15955    if let Some(ref local_var_str) = description__nisw {
15956        local_var_req_builder = match "multi" {
15957            "multi" => local_var_req_builder.query(
15958                &local_var_str
15959                    .into_iter()
15960                    .map(|p| ("description__nisw".to_owned(), p.to_string()))
15961                    .collect::<Vec<(std::string::String, std::string::String)>>(),
15962            ),
15963            _ => local_var_req_builder.query(&[(
15964                "description__nisw",
15965                &local_var_str
15966                    .into_iter()
15967                    .map(|p| p.to_string())
15968                    .collect::<Vec<String>>()
15969                    .join(",")
15970                    .to_string(),
15971            )]),
15972        };
15973    }
15974    if let Some(ref local_var_str) = description__regex {
15975        local_var_req_builder = match "multi" {
15976            "multi" => local_var_req_builder.query(
15977                &local_var_str
15978                    .into_iter()
15979                    .map(|p| ("description__regex".to_owned(), p.to_string()))
15980                    .collect::<Vec<(std::string::String, std::string::String)>>(),
15981            ),
15982            _ => local_var_req_builder.query(&[(
15983                "description__regex",
15984                &local_var_str
15985                    .into_iter()
15986                    .map(|p| p.to_string())
15987                    .collect::<Vec<String>>()
15988                    .join(",")
15989                    .to_string(),
15990            )]),
15991        };
15992    }
15993    if let Some(ref local_var_str) = id {
15994        local_var_req_builder = match "multi" {
15995            "multi" => local_var_req_builder.query(
15996                &local_var_str
15997                    .into_iter()
15998                    .map(|p| ("id".to_owned(), p.to_string()))
15999                    .collect::<Vec<(std::string::String, std::string::String)>>(),
16000            ),
16001            _ => local_var_req_builder.query(&[(
16002                "id",
16003                &local_var_str
16004                    .into_iter()
16005                    .map(|p| p.to_string())
16006                    .collect::<Vec<String>>()
16007                    .join(",")
16008                    .to_string(),
16009            )]),
16010        };
16011    }
16012    if let Some(ref local_var_str) = id__empty {
16013        local_var_req_builder =
16014            local_var_req_builder.query(&[("id__empty", &local_var_str.to_string())]);
16015    }
16016    if let Some(ref local_var_str) = id__gt {
16017        local_var_req_builder = match "multi" {
16018            "multi" => local_var_req_builder.query(
16019                &local_var_str
16020                    .into_iter()
16021                    .map(|p| ("id__gt".to_owned(), p.to_string()))
16022                    .collect::<Vec<(std::string::String, std::string::String)>>(),
16023            ),
16024            _ => local_var_req_builder.query(&[(
16025                "id__gt",
16026                &local_var_str
16027                    .into_iter()
16028                    .map(|p| p.to_string())
16029                    .collect::<Vec<String>>()
16030                    .join(",")
16031                    .to_string(),
16032            )]),
16033        };
16034    }
16035    if let Some(ref local_var_str) = id__gte {
16036        local_var_req_builder = match "multi" {
16037            "multi" => local_var_req_builder.query(
16038                &local_var_str
16039                    .into_iter()
16040                    .map(|p| ("id__gte".to_owned(), p.to_string()))
16041                    .collect::<Vec<(std::string::String, std::string::String)>>(),
16042            ),
16043            _ => local_var_req_builder.query(&[(
16044                "id__gte",
16045                &local_var_str
16046                    .into_iter()
16047                    .map(|p| p.to_string())
16048                    .collect::<Vec<String>>()
16049                    .join(",")
16050                    .to_string(),
16051            )]),
16052        };
16053    }
16054    if let Some(ref local_var_str) = id__lt {
16055        local_var_req_builder = match "multi" {
16056            "multi" => local_var_req_builder.query(
16057                &local_var_str
16058                    .into_iter()
16059                    .map(|p| ("id__lt".to_owned(), p.to_string()))
16060                    .collect::<Vec<(std::string::String, std::string::String)>>(),
16061            ),
16062            _ => local_var_req_builder.query(&[(
16063                "id__lt",
16064                &local_var_str
16065                    .into_iter()
16066                    .map(|p| p.to_string())
16067                    .collect::<Vec<String>>()
16068                    .join(",")
16069                    .to_string(),
16070            )]),
16071        };
16072    }
16073    if let Some(ref local_var_str) = id__lte {
16074        local_var_req_builder = match "multi" {
16075            "multi" => local_var_req_builder.query(
16076                &local_var_str
16077                    .into_iter()
16078                    .map(|p| ("id__lte".to_owned(), p.to_string()))
16079                    .collect::<Vec<(std::string::String, std::string::String)>>(),
16080            ),
16081            _ => local_var_req_builder.query(&[(
16082                "id__lte",
16083                &local_var_str
16084                    .into_iter()
16085                    .map(|p| p.to_string())
16086                    .collect::<Vec<String>>()
16087                    .join(",")
16088                    .to_string(),
16089            )]),
16090        };
16091    }
16092    if let Some(ref local_var_str) = id__n {
16093        local_var_req_builder = match "multi" {
16094            "multi" => local_var_req_builder.query(
16095                &local_var_str
16096                    .into_iter()
16097                    .map(|p| ("id__n".to_owned(), p.to_string()))
16098                    .collect::<Vec<(std::string::String, std::string::String)>>(),
16099            ),
16100            _ => local_var_req_builder.query(&[(
16101                "id__n",
16102                &local_var_str
16103                    .into_iter()
16104                    .map(|p| p.to_string())
16105                    .collect::<Vec<String>>()
16106                    .join(",")
16107                    .to_string(),
16108            )]),
16109        };
16110    }
16111    if let Some(ref local_var_str) = last_updated {
16112        local_var_req_builder = match "multi" {
16113            "multi" => local_var_req_builder.query(
16114                &local_var_str
16115                    .into_iter()
16116                    .map(|p| ("last_updated".to_owned(), p.to_string()))
16117                    .collect::<Vec<(std::string::String, std::string::String)>>(),
16118            ),
16119            _ => local_var_req_builder.query(&[(
16120                "last_updated",
16121                &local_var_str
16122                    .into_iter()
16123                    .map(|p| p.to_string())
16124                    .collect::<Vec<String>>()
16125                    .join(",")
16126                    .to_string(),
16127            )]),
16128        };
16129    }
16130    if let Some(ref local_var_str) = last_updated__empty {
16131        local_var_req_builder = match "multi" {
16132            "multi" => local_var_req_builder.query(
16133                &local_var_str
16134                    .into_iter()
16135                    .map(|p| ("last_updated__empty".to_owned(), p.to_string()))
16136                    .collect::<Vec<(std::string::String, std::string::String)>>(),
16137            ),
16138            _ => local_var_req_builder.query(&[(
16139                "last_updated__empty",
16140                &local_var_str
16141                    .into_iter()
16142                    .map(|p| p.to_string())
16143                    .collect::<Vec<String>>()
16144                    .join(",")
16145                    .to_string(),
16146            )]),
16147        };
16148    }
16149    if let Some(ref local_var_str) = last_updated__gt {
16150        local_var_req_builder = match "multi" {
16151            "multi" => local_var_req_builder.query(
16152                &local_var_str
16153                    .into_iter()
16154                    .map(|p| ("last_updated__gt".to_owned(), p.to_string()))
16155                    .collect::<Vec<(std::string::String, std::string::String)>>(),
16156            ),
16157            _ => local_var_req_builder.query(&[(
16158                "last_updated__gt",
16159                &local_var_str
16160                    .into_iter()
16161                    .map(|p| p.to_string())
16162                    .collect::<Vec<String>>()
16163                    .join(",")
16164                    .to_string(),
16165            )]),
16166        };
16167    }
16168    if let Some(ref local_var_str) = last_updated__gte {
16169        local_var_req_builder = match "multi" {
16170            "multi" => local_var_req_builder.query(
16171                &local_var_str
16172                    .into_iter()
16173                    .map(|p| ("last_updated__gte".to_owned(), p.to_string()))
16174                    .collect::<Vec<(std::string::String, std::string::String)>>(),
16175            ),
16176            _ => local_var_req_builder.query(&[(
16177                "last_updated__gte",
16178                &local_var_str
16179                    .into_iter()
16180                    .map(|p| p.to_string())
16181                    .collect::<Vec<String>>()
16182                    .join(",")
16183                    .to_string(),
16184            )]),
16185        };
16186    }
16187    if let Some(ref local_var_str) = last_updated__lt {
16188        local_var_req_builder = match "multi" {
16189            "multi" => local_var_req_builder.query(
16190                &local_var_str
16191                    .into_iter()
16192                    .map(|p| ("last_updated__lt".to_owned(), p.to_string()))
16193                    .collect::<Vec<(std::string::String, std::string::String)>>(),
16194            ),
16195            _ => local_var_req_builder.query(&[(
16196                "last_updated__lt",
16197                &local_var_str
16198                    .into_iter()
16199                    .map(|p| p.to_string())
16200                    .collect::<Vec<String>>()
16201                    .join(",")
16202                    .to_string(),
16203            )]),
16204        };
16205    }
16206    if let Some(ref local_var_str) = last_updated__lte {
16207        local_var_req_builder = match "multi" {
16208            "multi" => local_var_req_builder.query(
16209                &local_var_str
16210                    .into_iter()
16211                    .map(|p| ("last_updated__lte".to_owned(), p.to_string()))
16212                    .collect::<Vec<(std::string::String, std::string::String)>>(),
16213            ),
16214            _ => local_var_req_builder.query(&[(
16215                "last_updated__lte",
16216                &local_var_str
16217                    .into_iter()
16218                    .map(|p| p.to_string())
16219                    .collect::<Vec<String>>()
16220                    .join(",")
16221                    .to_string(),
16222            )]),
16223        };
16224    }
16225    if let Some(ref local_var_str) = last_updated__n {
16226        local_var_req_builder = match "multi" {
16227            "multi" => local_var_req_builder.query(
16228                &local_var_str
16229                    .into_iter()
16230                    .map(|p| ("last_updated__n".to_owned(), p.to_string()))
16231                    .collect::<Vec<(std::string::String, std::string::String)>>(),
16232            ),
16233            _ => local_var_req_builder.query(&[(
16234                "last_updated__n",
16235                &local_var_str
16236                    .into_iter()
16237                    .map(|p| p.to_string())
16238                    .collect::<Vec<String>>()
16239                    .join(",")
16240                    .to_string(),
16241            )]),
16242        };
16243    }
16244    if let Some(ref local_var_str) = limit {
16245        local_var_req_builder =
16246            local_var_req_builder.query(&[("limit", &local_var_str.to_string())]);
16247    }
16248    if let Some(ref local_var_str) = modified_by_request {
16249        local_var_req_builder =
16250            local_var_req_builder.query(&[("modified_by_request", &local_var_str.to_string())]);
16251    }
16252    if let Some(ref local_var_str) = name {
16253        local_var_req_builder = match "multi" {
16254            "multi" => local_var_req_builder.query(
16255                &local_var_str
16256                    .into_iter()
16257                    .map(|p| ("name".to_owned(), p.to_string()))
16258                    .collect::<Vec<(std::string::String, std::string::String)>>(),
16259            ),
16260            _ => local_var_req_builder.query(&[(
16261                "name",
16262                &local_var_str
16263                    .into_iter()
16264                    .map(|p| p.to_string())
16265                    .collect::<Vec<String>>()
16266                    .join(",")
16267                    .to_string(),
16268            )]),
16269        };
16270    }
16271    if let Some(ref local_var_str) = name__empty {
16272        local_var_req_builder =
16273            local_var_req_builder.query(&[("name__empty", &local_var_str.to_string())]);
16274    }
16275    if let Some(ref local_var_str) = name__ic {
16276        local_var_req_builder = match "multi" {
16277            "multi" => local_var_req_builder.query(
16278                &local_var_str
16279                    .into_iter()
16280                    .map(|p| ("name__ic".to_owned(), p.to_string()))
16281                    .collect::<Vec<(std::string::String, std::string::String)>>(),
16282            ),
16283            _ => local_var_req_builder.query(&[(
16284                "name__ic",
16285                &local_var_str
16286                    .into_iter()
16287                    .map(|p| p.to_string())
16288                    .collect::<Vec<String>>()
16289                    .join(",")
16290                    .to_string(),
16291            )]),
16292        };
16293    }
16294    if let Some(ref local_var_str) = name__ie {
16295        local_var_req_builder = match "multi" {
16296            "multi" => local_var_req_builder.query(
16297                &local_var_str
16298                    .into_iter()
16299                    .map(|p| ("name__ie".to_owned(), p.to_string()))
16300                    .collect::<Vec<(std::string::String, std::string::String)>>(),
16301            ),
16302            _ => local_var_req_builder.query(&[(
16303                "name__ie",
16304                &local_var_str
16305                    .into_iter()
16306                    .map(|p| p.to_string())
16307                    .collect::<Vec<String>>()
16308                    .join(",")
16309                    .to_string(),
16310            )]),
16311        };
16312    }
16313    if let Some(ref local_var_str) = name__iew {
16314        local_var_req_builder = match "multi" {
16315            "multi" => local_var_req_builder.query(
16316                &local_var_str
16317                    .into_iter()
16318                    .map(|p| ("name__iew".to_owned(), p.to_string()))
16319                    .collect::<Vec<(std::string::String, std::string::String)>>(),
16320            ),
16321            _ => local_var_req_builder.query(&[(
16322                "name__iew",
16323                &local_var_str
16324                    .into_iter()
16325                    .map(|p| p.to_string())
16326                    .collect::<Vec<String>>()
16327                    .join(",")
16328                    .to_string(),
16329            )]),
16330        };
16331    }
16332    if let Some(ref local_var_str) = name__iregex {
16333        local_var_req_builder = match "multi" {
16334            "multi" => local_var_req_builder.query(
16335                &local_var_str
16336                    .into_iter()
16337                    .map(|p| ("name__iregex".to_owned(), p.to_string()))
16338                    .collect::<Vec<(std::string::String, std::string::String)>>(),
16339            ),
16340            _ => local_var_req_builder.query(&[(
16341                "name__iregex",
16342                &local_var_str
16343                    .into_iter()
16344                    .map(|p| p.to_string())
16345                    .collect::<Vec<String>>()
16346                    .join(",")
16347                    .to_string(),
16348            )]),
16349        };
16350    }
16351    if let Some(ref local_var_str) = name__isw {
16352        local_var_req_builder = match "multi" {
16353            "multi" => local_var_req_builder.query(
16354                &local_var_str
16355                    .into_iter()
16356                    .map(|p| ("name__isw".to_owned(), p.to_string()))
16357                    .collect::<Vec<(std::string::String, std::string::String)>>(),
16358            ),
16359            _ => local_var_req_builder.query(&[(
16360                "name__isw",
16361                &local_var_str
16362                    .into_iter()
16363                    .map(|p| p.to_string())
16364                    .collect::<Vec<String>>()
16365                    .join(",")
16366                    .to_string(),
16367            )]),
16368        };
16369    }
16370    if let Some(ref local_var_str) = name__n {
16371        local_var_req_builder = match "multi" {
16372            "multi" => local_var_req_builder.query(
16373                &local_var_str
16374                    .into_iter()
16375                    .map(|p| ("name__n".to_owned(), p.to_string()))
16376                    .collect::<Vec<(std::string::String, std::string::String)>>(),
16377            ),
16378            _ => local_var_req_builder.query(&[(
16379                "name__n",
16380                &local_var_str
16381                    .into_iter()
16382                    .map(|p| p.to_string())
16383                    .collect::<Vec<String>>()
16384                    .join(",")
16385                    .to_string(),
16386            )]),
16387        };
16388    }
16389    if let Some(ref local_var_str) = name__nic {
16390        local_var_req_builder = match "multi" {
16391            "multi" => local_var_req_builder.query(
16392                &local_var_str
16393                    .into_iter()
16394                    .map(|p| ("name__nic".to_owned(), p.to_string()))
16395                    .collect::<Vec<(std::string::String, std::string::String)>>(),
16396            ),
16397            _ => local_var_req_builder.query(&[(
16398                "name__nic",
16399                &local_var_str
16400                    .into_iter()
16401                    .map(|p| p.to_string())
16402                    .collect::<Vec<String>>()
16403                    .join(",")
16404                    .to_string(),
16405            )]),
16406        };
16407    }
16408    if let Some(ref local_var_str) = name__nie {
16409        local_var_req_builder = match "multi" {
16410            "multi" => local_var_req_builder.query(
16411                &local_var_str
16412                    .into_iter()
16413                    .map(|p| ("name__nie".to_owned(), p.to_string()))
16414                    .collect::<Vec<(std::string::String, std::string::String)>>(),
16415            ),
16416            _ => local_var_req_builder.query(&[(
16417                "name__nie",
16418                &local_var_str
16419                    .into_iter()
16420                    .map(|p| p.to_string())
16421                    .collect::<Vec<String>>()
16422                    .join(",")
16423                    .to_string(),
16424            )]),
16425        };
16426    }
16427    if let Some(ref local_var_str) = name__niew {
16428        local_var_req_builder = match "multi" {
16429            "multi" => local_var_req_builder.query(
16430                &local_var_str
16431                    .into_iter()
16432                    .map(|p| ("name__niew".to_owned(), p.to_string()))
16433                    .collect::<Vec<(std::string::String, std::string::String)>>(),
16434            ),
16435            _ => local_var_req_builder.query(&[(
16436                "name__niew",
16437                &local_var_str
16438                    .into_iter()
16439                    .map(|p| p.to_string())
16440                    .collect::<Vec<String>>()
16441                    .join(",")
16442                    .to_string(),
16443            )]),
16444        };
16445    }
16446    if let Some(ref local_var_str) = name__nisw {
16447        local_var_req_builder = match "multi" {
16448            "multi" => local_var_req_builder.query(
16449                &local_var_str
16450                    .into_iter()
16451                    .map(|p| ("name__nisw".to_owned(), p.to_string()))
16452                    .collect::<Vec<(std::string::String, std::string::String)>>(),
16453            ),
16454            _ => local_var_req_builder.query(&[(
16455                "name__nisw",
16456                &local_var_str
16457                    .into_iter()
16458                    .map(|p| p.to_string())
16459                    .collect::<Vec<String>>()
16460                    .join(",")
16461                    .to_string(),
16462            )]),
16463        };
16464    }
16465    if let Some(ref local_var_str) = name__regex {
16466        local_var_req_builder = match "multi" {
16467            "multi" => local_var_req_builder.query(
16468                &local_var_str
16469                    .into_iter()
16470                    .map(|p| ("name__regex".to_owned(), p.to_string()))
16471                    .collect::<Vec<(std::string::String, std::string::String)>>(),
16472            ),
16473            _ => local_var_req_builder.query(&[(
16474                "name__regex",
16475                &local_var_str
16476                    .into_iter()
16477                    .map(|p| p.to_string())
16478                    .collect::<Vec<String>>()
16479                    .join(",")
16480                    .to_string(),
16481            )]),
16482        };
16483    }
16484    if let Some(ref local_var_str) = offset {
16485        local_var_req_builder =
16486            local_var_req_builder.query(&[("offset", &local_var_str.to_string())]);
16487    }
16488    if let Some(ref local_var_str) = ordering {
16489        local_var_req_builder =
16490            local_var_req_builder.query(&[("ordering", &local_var_str.to_string())]);
16491    }
16492    if let Some(ref local_var_str) = owner {
16493        local_var_req_builder = match "multi" {
16494            "multi" => local_var_req_builder.query(
16495                &local_var_str
16496                    .into_iter()
16497                    .map(|p| ("owner".to_owned(), p.to_string()))
16498                    .collect::<Vec<(std::string::String, std::string::String)>>(),
16499            ),
16500            _ => local_var_req_builder.query(&[(
16501                "owner",
16502                &local_var_str
16503                    .into_iter()
16504                    .map(|p| p.to_string())
16505                    .collect::<Vec<String>>()
16506                    .join(",")
16507                    .to_string(),
16508            )]),
16509        };
16510    }
16511    if let Some(ref local_var_str) = owner__n {
16512        local_var_req_builder = match "multi" {
16513            "multi" => local_var_req_builder.query(
16514                &local_var_str
16515                    .into_iter()
16516                    .map(|p| ("owner__n".to_owned(), p.to_string()))
16517                    .collect::<Vec<(std::string::String, std::string::String)>>(),
16518            ),
16519            _ => local_var_req_builder.query(&[(
16520                "owner__n",
16521                &local_var_str
16522                    .into_iter()
16523                    .map(|p| p.to_string())
16524                    .collect::<Vec<String>>()
16525                    .join(",")
16526                    .to_string(),
16527            )]),
16528        };
16529    }
16530    if let Some(ref local_var_str) = owner_group {
16531        local_var_req_builder = match "multi" {
16532            "multi" => local_var_req_builder.query(
16533                &local_var_str
16534                    .into_iter()
16535                    .map(|p| ("owner_group".to_owned(), p.to_string()))
16536                    .collect::<Vec<(std::string::String, std::string::String)>>(),
16537            ),
16538            _ => local_var_req_builder.query(&[(
16539                "owner_group",
16540                &local_var_str
16541                    .into_iter()
16542                    .map(|p| p.to_string())
16543                    .collect::<Vec<String>>()
16544                    .join(",")
16545                    .to_string(),
16546            )]),
16547        };
16548    }
16549    if let Some(ref local_var_str) = owner_group__n {
16550        local_var_req_builder = match "multi" {
16551            "multi" => local_var_req_builder.query(
16552                &local_var_str
16553                    .into_iter()
16554                    .map(|p| ("owner_group__n".to_owned(), p.to_string()))
16555                    .collect::<Vec<(std::string::String, std::string::String)>>(),
16556            ),
16557            _ => local_var_req_builder.query(&[(
16558                "owner_group__n",
16559                &local_var_str
16560                    .into_iter()
16561                    .map(|p| p.to_string())
16562                    .collect::<Vec<String>>()
16563                    .join(",")
16564                    .to_string(),
16565            )]),
16566        };
16567    }
16568    if let Some(ref local_var_str) = owner_group_id {
16569        local_var_req_builder = match "multi" {
16570            "multi" => local_var_req_builder.query(
16571                &local_var_str
16572                    .into_iter()
16573                    .map(|p| ("owner_group_id".to_owned(), p.to_string()))
16574                    .collect::<Vec<(std::string::String, std::string::String)>>(),
16575            ),
16576            _ => local_var_req_builder.query(&[(
16577                "owner_group_id",
16578                &local_var_str
16579                    .into_iter()
16580                    .map(|p| p.to_string())
16581                    .collect::<Vec<String>>()
16582                    .join(",")
16583                    .to_string(),
16584            )]),
16585        };
16586    }
16587    if let Some(ref local_var_str) = owner_group_id__n {
16588        local_var_req_builder = match "multi" {
16589            "multi" => local_var_req_builder.query(
16590                &local_var_str
16591                    .into_iter()
16592                    .map(|p| ("owner_group_id__n".to_owned(), p.to_string()))
16593                    .collect::<Vec<(std::string::String, std::string::String)>>(),
16594            ),
16595            _ => local_var_req_builder.query(&[(
16596                "owner_group_id__n",
16597                &local_var_str
16598                    .into_iter()
16599                    .map(|p| p.to_string())
16600                    .collect::<Vec<String>>()
16601                    .join(",")
16602                    .to_string(),
16603            )]),
16604        };
16605    }
16606    if let Some(ref local_var_str) = owner_id {
16607        local_var_req_builder = match "multi" {
16608            "multi" => local_var_req_builder.query(
16609                &local_var_str
16610                    .into_iter()
16611                    .map(|p| ("owner_id".to_owned(), p.to_string()))
16612                    .collect::<Vec<(std::string::String, std::string::String)>>(),
16613            ),
16614            _ => local_var_req_builder.query(&[(
16615                "owner_id",
16616                &local_var_str
16617                    .into_iter()
16618                    .map(|p| p.to_string())
16619                    .collect::<Vec<String>>()
16620                    .join(",")
16621                    .to_string(),
16622            )]),
16623        };
16624    }
16625    if let Some(ref local_var_str) = owner_id__n {
16626        local_var_req_builder = match "multi" {
16627            "multi" => local_var_req_builder.query(
16628                &local_var_str
16629                    .into_iter()
16630                    .map(|p| ("owner_id__n".to_owned(), p.to_string()))
16631                    .collect::<Vec<(std::string::String, std::string::String)>>(),
16632            ),
16633            _ => local_var_req_builder.query(&[(
16634                "owner_id__n",
16635                &local_var_str
16636                    .into_iter()
16637                    .map(|p| p.to_string())
16638                    .collect::<Vec<String>>()
16639                    .join(",")
16640                    .to_string(),
16641            )]),
16642        };
16643    }
16644    if let Some(ref local_var_str) = provider {
16645        local_var_req_builder = match "multi" {
16646            "multi" => local_var_req_builder.query(
16647                &local_var_str
16648                    .into_iter()
16649                    .map(|p| ("provider".to_owned(), p.to_string()))
16650                    .collect::<Vec<(std::string::String, std::string::String)>>(),
16651            ),
16652            _ => local_var_req_builder.query(&[(
16653                "provider",
16654                &local_var_str
16655                    .into_iter()
16656                    .map(|p| p.to_string())
16657                    .collect::<Vec<String>>()
16658                    .join(",")
16659                    .to_string(),
16660            )]),
16661        };
16662    }
16663    if let Some(ref local_var_str) = provider__n {
16664        local_var_req_builder = match "multi" {
16665            "multi" => local_var_req_builder.query(
16666                &local_var_str
16667                    .into_iter()
16668                    .map(|p| ("provider__n".to_owned(), p.to_string()))
16669                    .collect::<Vec<(std::string::String, std::string::String)>>(),
16670            ),
16671            _ => local_var_req_builder.query(&[(
16672                "provider__n",
16673                &local_var_str
16674                    .into_iter()
16675                    .map(|p| p.to_string())
16676                    .collect::<Vec<String>>()
16677                    .join(",")
16678                    .to_string(),
16679            )]),
16680        };
16681    }
16682    if let Some(ref local_var_str) = provider_id {
16683        local_var_req_builder = match "multi" {
16684            "multi" => local_var_req_builder.query(
16685                &local_var_str
16686                    .into_iter()
16687                    .map(|p| ("provider_id".to_owned(), p.to_string()))
16688                    .collect::<Vec<(std::string::String, std::string::String)>>(),
16689            ),
16690            _ => local_var_req_builder.query(&[(
16691                "provider_id",
16692                &local_var_str
16693                    .into_iter()
16694                    .map(|p| p.to_string())
16695                    .collect::<Vec<String>>()
16696                    .join(",")
16697                    .to_string(),
16698            )]),
16699        };
16700    }
16701    if let Some(ref local_var_str) = provider_id__n {
16702        local_var_req_builder = match "multi" {
16703            "multi" => local_var_req_builder.query(
16704                &local_var_str
16705                    .into_iter()
16706                    .map(|p| ("provider_id__n".to_owned(), p.to_string()))
16707                    .collect::<Vec<(std::string::String, std::string::String)>>(),
16708            ),
16709            _ => local_var_req_builder.query(&[(
16710                "provider_id__n",
16711                &local_var_str
16712                    .into_iter()
16713                    .map(|p| p.to_string())
16714                    .collect::<Vec<String>>()
16715                    .join(",")
16716                    .to_string(),
16717            )]),
16718        };
16719    }
16720    if let Some(ref local_var_str) = q {
16721        local_var_req_builder = local_var_req_builder.query(&[("q", &local_var_str.to_string())]);
16722    }
16723    if let Some(ref local_var_str) = service_id {
16724        local_var_req_builder = match "multi" {
16725            "multi" => local_var_req_builder.query(
16726                &local_var_str
16727                    .into_iter()
16728                    .map(|p| ("service_id".to_owned(), p.to_string()))
16729                    .collect::<Vec<(std::string::String, std::string::String)>>(),
16730            ),
16731            _ => local_var_req_builder.query(&[(
16732                "service_id",
16733                &local_var_str
16734                    .into_iter()
16735                    .map(|p| p.to_string())
16736                    .collect::<Vec<String>>()
16737                    .join(",")
16738                    .to_string(),
16739            )]),
16740        };
16741    }
16742    if let Some(ref local_var_str) = service_id__empty {
16743        local_var_req_builder =
16744            local_var_req_builder.query(&[("service_id__empty", &local_var_str.to_string())]);
16745    }
16746    if let Some(ref local_var_str) = service_id__ic {
16747        local_var_req_builder = match "multi" {
16748            "multi" => local_var_req_builder.query(
16749                &local_var_str
16750                    .into_iter()
16751                    .map(|p| ("service_id__ic".to_owned(), p.to_string()))
16752                    .collect::<Vec<(std::string::String, std::string::String)>>(),
16753            ),
16754            _ => local_var_req_builder.query(&[(
16755                "service_id__ic",
16756                &local_var_str
16757                    .into_iter()
16758                    .map(|p| p.to_string())
16759                    .collect::<Vec<String>>()
16760                    .join(",")
16761                    .to_string(),
16762            )]),
16763        };
16764    }
16765    if let Some(ref local_var_str) = service_id__ie {
16766        local_var_req_builder = match "multi" {
16767            "multi" => local_var_req_builder.query(
16768                &local_var_str
16769                    .into_iter()
16770                    .map(|p| ("service_id__ie".to_owned(), p.to_string()))
16771                    .collect::<Vec<(std::string::String, std::string::String)>>(),
16772            ),
16773            _ => local_var_req_builder.query(&[(
16774                "service_id__ie",
16775                &local_var_str
16776                    .into_iter()
16777                    .map(|p| p.to_string())
16778                    .collect::<Vec<String>>()
16779                    .join(",")
16780                    .to_string(),
16781            )]),
16782        };
16783    }
16784    if let Some(ref local_var_str) = service_id__iew {
16785        local_var_req_builder = match "multi" {
16786            "multi" => local_var_req_builder.query(
16787                &local_var_str
16788                    .into_iter()
16789                    .map(|p| ("service_id__iew".to_owned(), p.to_string()))
16790                    .collect::<Vec<(std::string::String, std::string::String)>>(),
16791            ),
16792            _ => local_var_req_builder.query(&[(
16793                "service_id__iew",
16794                &local_var_str
16795                    .into_iter()
16796                    .map(|p| p.to_string())
16797                    .collect::<Vec<String>>()
16798                    .join(",")
16799                    .to_string(),
16800            )]),
16801        };
16802    }
16803    if let Some(ref local_var_str) = service_id__iregex {
16804        local_var_req_builder = match "multi" {
16805            "multi" => local_var_req_builder.query(
16806                &local_var_str
16807                    .into_iter()
16808                    .map(|p| ("service_id__iregex".to_owned(), p.to_string()))
16809                    .collect::<Vec<(std::string::String, std::string::String)>>(),
16810            ),
16811            _ => local_var_req_builder.query(&[(
16812                "service_id__iregex",
16813                &local_var_str
16814                    .into_iter()
16815                    .map(|p| p.to_string())
16816                    .collect::<Vec<String>>()
16817                    .join(",")
16818                    .to_string(),
16819            )]),
16820        };
16821    }
16822    if let Some(ref local_var_str) = service_id__isw {
16823        local_var_req_builder = match "multi" {
16824            "multi" => local_var_req_builder.query(
16825                &local_var_str
16826                    .into_iter()
16827                    .map(|p| ("service_id__isw".to_owned(), p.to_string()))
16828                    .collect::<Vec<(std::string::String, std::string::String)>>(),
16829            ),
16830            _ => local_var_req_builder.query(&[(
16831                "service_id__isw",
16832                &local_var_str
16833                    .into_iter()
16834                    .map(|p| p.to_string())
16835                    .collect::<Vec<String>>()
16836                    .join(",")
16837                    .to_string(),
16838            )]),
16839        };
16840    }
16841    if let Some(ref local_var_str) = service_id__n {
16842        local_var_req_builder = match "multi" {
16843            "multi" => local_var_req_builder.query(
16844                &local_var_str
16845                    .into_iter()
16846                    .map(|p| ("service_id__n".to_owned(), p.to_string()))
16847                    .collect::<Vec<(std::string::String, std::string::String)>>(),
16848            ),
16849            _ => local_var_req_builder.query(&[(
16850                "service_id__n",
16851                &local_var_str
16852                    .into_iter()
16853                    .map(|p| p.to_string())
16854                    .collect::<Vec<String>>()
16855                    .join(",")
16856                    .to_string(),
16857            )]),
16858        };
16859    }
16860    if let Some(ref local_var_str) = service_id__nic {
16861        local_var_req_builder = match "multi" {
16862            "multi" => local_var_req_builder.query(
16863                &local_var_str
16864                    .into_iter()
16865                    .map(|p| ("service_id__nic".to_owned(), p.to_string()))
16866                    .collect::<Vec<(std::string::String, std::string::String)>>(),
16867            ),
16868            _ => local_var_req_builder.query(&[(
16869                "service_id__nic",
16870                &local_var_str
16871                    .into_iter()
16872                    .map(|p| p.to_string())
16873                    .collect::<Vec<String>>()
16874                    .join(",")
16875                    .to_string(),
16876            )]),
16877        };
16878    }
16879    if let Some(ref local_var_str) = service_id__nie {
16880        local_var_req_builder = match "multi" {
16881            "multi" => local_var_req_builder.query(
16882                &local_var_str
16883                    .into_iter()
16884                    .map(|p| ("service_id__nie".to_owned(), p.to_string()))
16885                    .collect::<Vec<(std::string::String, std::string::String)>>(),
16886            ),
16887            _ => local_var_req_builder.query(&[(
16888                "service_id__nie",
16889                &local_var_str
16890                    .into_iter()
16891                    .map(|p| p.to_string())
16892                    .collect::<Vec<String>>()
16893                    .join(",")
16894                    .to_string(),
16895            )]),
16896        };
16897    }
16898    if let Some(ref local_var_str) = service_id__niew {
16899        local_var_req_builder = match "multi" {
16900            "multi" => local_var_req_builder.query(
16901                &local_var_str
16902                    .into_iter()
16903                    .map(|p| ("service_id__niew".to_owned(), p.to_string()))
16904                    .collect::<Vec<(std::string::String, std::string::String)>>(),
16905            ),
16906            _ => local_var_req_builder.query(&[(
16907                "service_id__niew",
16908                &local_var_str
16909                    .into_iter()
16910                    .map(|p| p.to_string())
16911                    .collect::<Vec<String>>()
16912                    .join(",")
16913                    .to_string(),
16914            )]),
16915        };
16916    }
16917    if let Some(ref local_var_str) = service_id__nisw {
16918        local_var_req_builder = match "multi" {
16919            "multi" => local_var_req_builder.query(
16920                &local_var_str
16921                    .into_iter()
16922                    .map(|p| ("service_id__nisw".to_owned(), p.to_string()))
16923                    .collect::<Vec<(std::string::String, std::string::String)>>(),
16924            ),
16925            _ => local_var_req_builder.query(&[(
16926                "service_id__nisw",
16927                &local_var_str
16928                    .into_iter()
16929                    .map(|p| p.to_string())
16930                    .collect::<Vec<String>>()
16931                    .join(",")
16932                    .to_string(),
16933            )]),
16934        };
16935    }
16936    if let Some(ref local_var_str) = service_id__regex {
16937        local_var_req_builder = match "multi" {
16938            "multi" => local_var_req_builder.query(
16939                &local_var_str
16940                    .into_iter()
16941                    .map(|p| ("service_id__regex".to_owned(), p.to_string()))
16942                    .collect::<Vec<(std::string::String, std::string::String)>>(),
16943            ),
16944            _ => local_var_req_builder.query(&[(
16945                "service_id__regex",
16946                &local_var_str
16947                    .into_iter()
16948                    .map(|p| p.to_string())
16949                    .collect::<Vec<String>>()
16950                    .join(",")
16951                    .to_string(),
16952            )]),
16953        };
16954    }
16955    if let Some(ref local_var_str) = tag {
16956        local_var_req_builder = match "multi" {
16957            "multi" => local_var_req_builder.query(
16958                &local_var_str
16959                    .into_iter()
16960                    .map(|p| ("tag".to_owned(), p.to_string()))
16961                    .collect::<Vec<(std::string::String, std::string::String)>>(),
16962            ),
16963            _ => local_var_req_builder.query(&[(
16964                "tag",
16965                &local_var_str
16966                    .into_iter()
16967                    .map(|p| p.to_string())
16968                    .collect::<Vec<String>>()
16969                    .join(",")
16970                    .to_string(),
16971            )]),
16972        };
16973    }
16974    if let Some(ref local_var_str) = tag__n {
16975        local_var_req_builder = match "multi" {
16976            "multi" => local_var_req_builder.query(
16977                &local_var_str
16978                    .into_iter()
16979                    .map(|p| ("tag__n".to_owned(), p.to_string()))
16980                    .collect::<Vec<(std::string::String, std::string::String)>>(),
16981            ),
16982            _ => local_var_req_builder.query(&[(
16983                "tag__n",
16984                &local_var_str
16985                    .into_iter()
16986                    .map(|p| p.to_string())
16987                    .collect::<Vec<String>>()
16988                    .join(",")
16989                    .to_string(),
16990            )]),
16991        };
16992    }
16993    if let Some(ref local_var_str) = tag_id {
16994        local_var_req_builder = match "multi" {
16995            "multi" => local_var_req_builder.query(
16996                &local_var_str
16997                    .into_iter()
16998                    .map(|p| ("tag_id".to_owned(), p.to_string()))
16999                    .collect::<Vec<(std::string::String, std::string::String)>>(),
17000            ),
17001            _ => local_var_req_builder.query(&[(
17002                "tag_id",
17003                &local_var_str
17004                    .into_iter()
17005                    .map(|p| p.to_string())
17006                    .collect::<Vec<String>>()
17007                    .join(",")
17008                    .to_string(),
17009            )]),
17010        };
17011    }
17012    if let Some(ref local_var_str) = tag_id__n {
17013        local_var_req_builder = match "multi" {
17014            "multi" => local_var_req_builder.query(
17015                &local_var_str
17016                    .into_iter()
17017                    .map(|p| ("tag_id__n".to_owned(), p.to_string()))
17018                    .collect::<Vec<(std::string::String, std::string::String)>>(),
17019            ),
17020            _ => local_var_req_builder.query(&[(
17021                "tag_id__n",
17022                &local_var_str
17023                    .into_iter()
17024                    .map(|p| p.to_string())
17025                    .collect::<Vec<String>>()
17026                    .join(",")
17027                    .to_string(),
17028            )]),
17029        };
17030    }
17031    if let Some(ref local_var_str) = updated_by_request {
17032        local_var_req_builder =
17033            local_var_req_builder.query(&[("updated_by_request", &local_var_str.to_string())]);
17034    }
17035    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
17036        local_var_req_builder =
17037            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
17038    }
17039    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
17040        let local_var_key = local_var_apikey.key.clone();
17041        let local_var_value = match local_var_apikey.prefix {
17042            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
17043            None => local_var_key,
17044        };
17045        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
17046    };
17047
17048    let local_var_req = local_var_req_builder.build()?;
17049    let local_var_resp = local_var_client.execute(local_var_req).await?;
17050
17051    let local_var_status = local_var_resp.status();
17052    let local_var_content = local_var_resp.text().await?;
17053
17054    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
17055        serde_json::from_str(&local_var_content).map_err(Error::from)
17056    } else {
17057        let local_var_entity: Option<CircuitsProviderNetworksListError> =
17058            serde_json::from_str(&local_var_content).ok();
17059        let local_var_error = ResponseContent {
17060            status: local_var_status,
17061            content: local_var_content,
17062            entity: local_var_entity,
17063        };
17064        Err(Error::ResponseError(local_var_error))
17065    }
17066}
17067
17068/// Patch a provider network object.
17069pub async fn circuits_provider_networks_partial_update(
17070    configuration: &configuration::Configuration,
17071    id: i32,
17072    patched_provider_network_request: Option<crate::models::PatchedProviderNetworkRequest>,
17073) -> Result<crate::models::ProviderNetwork, Error<CircuitsProviderNetworksPartialUpdateError>> {
17074    let local_var_configuration = configuration;
17075
17076    let local_var_client = &local_var_configuration.client;
17077
17078    let local_var_uri_str = format!(
17079        "{}/api/circuits/provider-networks/{id}/",
17080        local_var_configuration.base_path,
17081        id = id
17082    );
17083    let mut local_var_req_builder =
17084        local_var_client.request(reqwest::Method::PATCH, local_var_uri_str.as_str());
17085
17086    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
17087        local_var_req_builder =
17088            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
17089    }
17090    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
17091        let local_var_key = local_var_apikey.key.clone();
17092        let local_var_value = match local_var_apikey.prefix {
17093            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
17094            None => local_var_key,
17095        };
17096        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
17097    };
17098    local_var_req_builder = local_var_req_builder.json(&patched_provider_network_request);
17099
17100    let local_var_req = local_var_req_builder.build()?;
17101    let local_var_resp = local_var_client.execute(local_var_req).await?;
17102
17103    let local_var_status = local_var_resp.status();
17104    let local_var_content = local_var_resp.text().await?;
17105
17106    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
17107        serde_json::from_str(&local_var_content).map_err(Error::from)
17108    } else {
17109        let local_var_entity: Option<CircuitsProviderNetworksPartialUpdateError> =
17110            serde_json::from_str(&local_var_content).ok();
17111        let local_var_error = ResponseContent {
17112            status: local_var_status,
17113            content: local_var_content,
17114            entity: local_var_entity,
17115        };
17116        Err(Error::ResponseError(local_var_error))
17117    }
17118}
17119
17120/// Get a provider network object.
17121pub async fn circuits_provider_networks_retrieve(
17122    configuration: &configuration::Configuration,
17123    id: i32,
17124) -> Result<crate::models::ProviderNetwork, Error<CircuitsProviderNetworksRetrieveError>> {
17125    let local_var_configuration = configuration;
17126
17127    let local_var_client = &local_var_configuration.client;
17128
17129    let local_var_uri_str = format!(
17130        "{}/api/circuits/provider-networks/{id}/",
17131        local_var_configuration.base_path,
17132        id = id
17133    );
17134    let mut local_var_req_builder =
17135        local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
17136
17137    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
17138        local_var_req_builder =
17139            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
17140    }
17141    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
17142        let local_var_key = local_var_apikey.key.clone();
17143        let local_var_value = match local_var_apikey.prefix {
17144            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
17145            None => local_var_key,
17146        };
17147        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
17148    };
17149
17150    let local_var_req = local_var_req_builder.build()?;
17151    let local_var_resp = local_var_client.execute(local_var_req).await?;
17152
17153    let local_var_status = local_var_resp.status();
17154    let local_var_content = local_var_resp.text().await?;
17155
17156    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
17157        serde_json::from_str(&local_var_content).map_err(Error::from)
17158    } else {
17159        let local_var_entity: Option<CircuitsProviderNetworksRetrieveError> =
17160            serde_json::from_str(&local_var_content).ok();
17161        let local_var_error = ResponseContent {
17162            status: local_var_status,
17163            content: local_var_content,
17164            entity: local_var_entity,
17165        };
17166        Err(Error::ResponseError(local_var_error))
17167    }
17168}
17169
17170/// Put a provider network object.
17171pub async fn circuits_provider_networks_update(
17172    configuration: &configuration::Configuration,
17173    id: i32,
17174    provider_network_request: crate::models::ProviderNetworkRequest,
17175) -> Result<crate::models::ProviderNetwork, Error<CircuitsProviderNetworksUpdateError>> {
17176    let local_var_configuration = configuration;
17177
17178    let local_var_client = &local_var_configuration.client;
17179
17180    let local_var_uri_str = format!(
17181        "{}/api/circuits/provider-networks/{id}/",
17182        local_var_configuration.base_path,
17183        id = id
17184    );
17185    let mut local_var_req_builder =
17186        local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());
17187
17188    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
17189        local_var_req_builder =
17190            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
17191    }
17192    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
17193        let local_var_key = local_var_apikey.key.clone();
17194        let local_var_value = match local_var_apikey.prefix {
17195            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
17196            None => local_var_key,
17197        };
17198        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
17199    };
17200    local_var_req_builder = local_var_req_builder.json(&provider_network_request);
17201
17202    let local_var_req = local_var_req_builder.build()?;
17203    let local_var_resp = local_var_client.execute(local_var_req).await?;
17204
17205    let local_var_status = local_var_resp.status();
17206    let local_var_content = local_var_resp.text().await?;
17207
17208    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
17209        serde_json::from_str(&local_var_content).map_err(Error::from)
17210    } else {
17211        let local_var_entity: Option<CircuitsProviderNetworksUpdateError> =
17212            serde_json::from_str(&local_var_content).ok();
17213        let local_var_error = ResponseContent {
17214            status: local_var_status,
17215            content: local_var_content,
17216            entity: local_var_entity,
17217        };
17218        Err(Error::ResponseError(local_var_error))
17219    }
17220}
17221
17222/// Delete a list of provider objects.
17223pub async fn circuits_providers_bulk_destroy(
17224    configuration: &configuration::Configuration,
17225    provider_request: Vec<crate::models::ProviderRequest>,
17226) -> Result<(), Error<CircuitsProvidersBulkDestroyError>> {
17227    let local_var_configuration = configuration;
17228
17229    let local_var_client = &local_var_configuration.client;
17230
17231    let local_var_uri_str = format!(
17232        "{}/api/circuits/providers/",
17233        local_var_configuration.base_path
17234    );
17235    let mut local_var_req_builder =
17236        local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());
17237
17238    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
17239        local_var_req_builder =
17240            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
17241    }
17242    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
17243        let local_var_key = local_var_apikey.key.clone();
17244        let local_var_value = match local_var_apikey.prefix {
17245            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
17246            None => local_var_key,
17247        };
17248        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
17249    };
17250    local_var_req_builder = local_var_req_builder.json(&provider_request);
17251
17252    let local_var_req = local_var_req_builder.build()?;
17253    let local_var_resp = local_var_client.execute(local_var_req).await?;
17254
17255    let local_var_status = local_var_resp.status();
17256    let local_var_content = local_var_resp.text().await?;
17257
17258    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
17259        Ok(())
17260    } else {
17261        let local_var_entity: Option<CircuitsProvidersBulkDestroyError> =
17262            serde_json::from_str(&local_var_content).ok();
17263        let local_var_error = ResponseContent {
17264            status: local_var_status,
17265            content: local_var_content,
17266            entity: local_var_entity,
17267        };
17268        Err(Error::ResponseError(local_var_error))
17269    }
17270}
17271
17272/// Patch a list of provider objects.
17273pub async fn circuits_providers_bulk_partial_update(
17274    configuration: &configuration::Configuration,
17275    provider_request: Vec<crate::models::ProviderRequest>,
17276) -> Result<Vec<crate::models::Provider>, Error<CircuitsProvidersBulkPartialUpdateError>> {
17277    let local_var_configuration = configuration;
17278
17279    let local_var_client = &local_var_configuration.client;
17280
17281    let local_var_uri_str = format!(
17282        "{}/api/circuits/providers/",
17283        local_var_configuration.base_path
17284    );
17285    let mut local_var_req_builder =
17286        local_var_client.request(reqwest::Method::PATCH, local_var_uri_str.as_str());
17287
17288    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
17289        local_var_req_builder =
17290            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
17291    }
17292    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
17293        let local_var_key = local_var_apikey.key.clone();
17294        let local_var_value = match local_var_apikey.prefix {
17295            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
17296            None => local_var_key,
17297        };
17298        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
17299    };
17300    local_var_req_builder = local_var_req_builder.json(&provider_request);
17301
17302    let local_var_req = local_var_req_builder.build()?;
17303    let local_var_resp = local_var_client.execute(local_var_req).await?;
17304
17305    let local_var_status = local_var_resp.status();
17306    let local_var_content = local_var_resp.text().await?;
17307
17308    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
17309        serde_json::from_str(&local_var_content).map_err(Error::from)
17310    } else {
17311        let local_var_entity: Option<CircuitsProvidersBulkPartialUpdateError> =
17312            serde_json::from_str(&local_var_content).ok();
17313        let local_var_error = ResponseContent {
17314            status: local_var_status,
17315            content: local_var_content,
17316            entity: local_var_entity,
17317        };
17318        Err(Error::ResponseError(local_var_error))
17319    }
17320}
17321
17322/// Put a list of provider objects.
17323pub async fn circuits_providers_bulk_update(
17324    configuration: &configuration::Configuration,
17325    provider_request: Vec<crate::models::ProviderRequest>,
17326) -> Result<Vec<crate::models::Provider>, Error<CircuitsProvidersBulkUpdateError>> {
17327    let local_var_configuration = configuration;
17328
17329    let local_var_client = &local_var_configuration.client;
17330
17331    let local_var_uri_str = format!(
17332        "{}/api/circuits/providers/",
17333        local_var_configuration.base_path
17334    );
17335    let mut local_var_req_builder =
17336        local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());
17337
17338    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
17339        local_var_req_builder =
17340            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
17341    }
17342    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
17343        let local_var_key = local_var_apikey.key.clone();
17344        let local_var_value = match local_var_apikey.prefix {
17345            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
17346            None => local_var_key,
17347        };
17348        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
17349    };
17350    local_var_req_builder = local_var_req_builder.json(&provider_request);
17351
17352    let local_var_req = local_var_req_builder.build()?;
17353    let local_var_resp = local_var_client.execute(local_var_req).await?;
17354
17355    let local_var_status = local_var_resp.status();
17356    let local_var_content = local_var_resp.text().await?;
17357
17358    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
17359        serde_json::from_str(&local_var_content).map_err(Error::from)
17360    } else {
17361        let local_var_entity: Option<CircuitsProvidersBulkUpdateError> =
17362            serde_json::from_str(&local_var_content).ok();
17363        let local_var_error = ResponseContent {
17364            status: local_var_status,
17365            content: local_var_content,
17366            entity: local_var_entity,
17367        };
17368        Err(Error::ResponseError(local_var_error))
17369    }
17370}
17371
17372/// Post a list of provider objects.
17373pub async fn circuits_providers_create(
17374    configuration: &configuration::Configuration,
17375    circuits_providers_create_request: crate::models::CircuitsProvidersCreateRequest,
17376) -> Result<crate::models::Provider, Error<CircuitsProvidersCreateError>> {
17377    let local_var_configuration = configuration;
17378
17379    let local_var_client = &local_var_configuration.client;
17380
17381    let local_var_uri_str = format!(
17382        "{}/api/circuits/providers/",
17383        local_var_configuration.base_path
17384    );
17385    let mut local_var_req_builder =
17386        local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
17387
17388    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
17389        local_var_req_builder =
17390            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
17391    }
17392    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
17393        let local_var_key = local_var_apikey.key.clone();
17394        let local_var_value = match local_var_apikey.prefix {
17395            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
17396            None => local_var_key,
17397        };
17398        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
17399    };
17400    local_var_req_builder = local_var_req_builder.json(&circuits_providers_create_request);
17401
17402    let local_var_req = local_var_req_builder.build()?;
17403    let local_var_resp = local_var_client.execute(local_var_req).await?;
17404
17405    let local_var_status = local_var_resp.status();
17406    let local_var_content = local_var_resp.text().await?;
17407
17408    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
17409        serde_json::from_str(&local_var_content).map_err(Error::from)
17410    } else {
17411        let local_var_entity: Option<CircuitsProvidersCreateError> =
17412            serde_json::from_str(&local_var_content).ok();
17413        let local_var_error = ResponseContent {
17414            status: local_var_status,
17415            content: local_var_content,
17416            entity: local_var_entity,
17417        };
17418        Err(Error::ResponseError(local_var_error))
17419    }
17420}
17421
17422/// Delete a provider object.
17423pub async fn circuits_providers_destroy(
17424    configuration: &configuration::Configuration,
17425    id: i32,
17426) -> Result<(), Error<CircuitsProvidersDestroyError>> {
17427    let local_var_configuration = configuration;
17428
17429    let local_var_client = &local_var_configuration.client;
17430
17431    let local_var_uri_str = format!(
17432        "{}/api/circuits/providers/{id}/",
17433        local_var_configuration.base_path,
17434        id = id
17435    );
17436    let mut local_var_req_builder =
17437        local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());
17438
17439    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
17440        local_var_req_builder =
17441            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
17442    }
17443    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
17444        let local_var_key = local_var_apikey.key.clone();
17445        let local_var_value = match local_var_apikey.prefix {
17446            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
17447            None => local_var_key,
17448        };
17449        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
17450    };
17451
17452    let local_var_req = local_var_req_builder.build()?;
17453    let local_var_resp = local_var_client.execute(local_var_req).await?;
17454
17455    let local_var_status = local_var_resp.status();
17456    let local_var_content = local_var_resp.text().await?;
17457
17458    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
17459        Ok(())
17460    } else {
17461        let local_var_entity: Option<CircuitsProvidersDestroyError> =
17462            serde_json::from_str(&local_var_content).ok();
17463        let local_var_error = ResponseContent {
17464            status: local_var_status,
17465            content: local_var_content,
17466            entity: local_var_entity,
17467        };
17468        Err(Error::ResponseError(local_var_error))
17469    }
17470}
17471
17472/// Get a list of provider objects.
17473pub async fn circuits_providers_list(
17474    configuration: &configuration::Configuration,
17475    asn: Option<Vec<i64>>,
17476    asn__n: Option<Vec<i64>>,
17477    asn_id: Option<Vec<i32>>,
17478    asn_id__n: Option<Vec<i32>>,
17479    contact: Option<Vec<i32>>,
17480    contact__n: Option<Vec<i32>>,
17481    contact_group: Option<Vec<String>>,
17482    contact_group__n: Option<Vec<String>>,
17483    contact_role: Option<Vec<i32>>,
17484    contact_role__n: Option<Vec<i32>>,
17485    created: Option<Vec<String>>,
17486    created__empty: Option<Vec<String>>,
17487    created__gt: Option<Vec<String>>,
17488    created__gte: Option<Vec<String>>,
17489    created__lt: Option<Vec<String>>,
17490    created__lte: Option<Vec<String>>,
17491    created__n: Option<Vec<String>>,
17492    created_by_request: Option<&str>,
17493    description: Option<Vec<String>>,
17494    description__empty: Option<bool>,
17495    description__ic: Option<Vec<String>>,
17496    description__ie: Option<Vec<String>>,
17497    description__iew: Option<Vec<String>>,
17498    description__iregex: Option<Vec<String>>,
17499    description__isw: Option<Vec<String>>,
17500    description__n: Option<Vec<String>>,
17501    description__nic: Option<Vec<String>>,
17502    description__nie: Option<Vec<String>>,
17503    description__niew: Option<Vec<String>>,
17504    description__nisw: Option<Vec<String>>,
17505    description__regex: Option<Vec<String>>,
17506    id: Option<Vec<i32>>,
17507    id__empty: Option<bool>,
17508    id__gt: Option<Vec<i32>>,
17509    id__gte: Option<Vec<i32>>,
17510    id__lt: Option<Vec<i32>>,
17511    id__lte: Option<Vec<i32>>,
17512    id__n: Option<Vec<i32>>,
17513    last_updated: Option<Vec<String>>,
17514    last_updated__empty: Option<Vec<String>>,
17515    last_updated__gt: Option<Vec<String>>,
17516    last_updated__gte: Option<Vec<String>>,
17517    last_updated__lt: Option<Vec<String>>,
17518    last_updated__lte: Option<Vec<String>>,
17519    last_updated__n: Option<Vec<String>>,
17520    limit: Option<i32>,
17521    modified_by_request: Option<&str>,
17522    name: Option<Vec<String>>,
17523    name__empty: Option<bool>,
17524    name__ic: Option<Vec<String>>,
17525    name__ie: Option<Vec<String>>,
17526    name__iew: Option<Vec<String>>,
17527    name__iregex: Option<Vec<String>>,
17528    name__isw: Option<Vec<String>>,
17529    name__n: Option<Vec<String>>,
17530    name__nic: Option<Vec<String>>,
17531    name__nie: Option<Vec<String>>,
17532    name__niew: Option<Vec<String>>,
17533    name__nisw: Option<Vec<String>>,
17534    name__regex: Option<Vec<String>>,
17535    offset: Option<i32>,
17536    ordering: Option<&str>,
17537    owner: Option<Vec<String>>,
17538    owner__n: Option<Vec<String>>,
17539    owner_group: Option<Vec<String>>,
17540    owner_group__n: Option<Vec<String>>,
17541    owner_group_id: Option<Vec<i32>>,
17542    owner_group_id__n: Option<Vec<i32>>,
17543    owner_id: Option<Vec<i32>>,
17544    owner_id__n: Option<Vec<i32>>,
17545    q: Option<&str>,
17546    region: Option<Vec<String>>,
17547    region__n: Option<Vec<String>>,
17548    region_id: Option<Vec<String>>,
17549    region_id__n: Option<Vec<String>>,
17550    site: Option<Vec<String>>,
17551    site__n: Option<Vec<String>>,
17552    site_group: Option<Vec<String>>,
17553    site_group__n: Option<Vec<String>>,
17554    site_group_id: Option<Vec<String>>,
17555    site_group_id__n: Option<Vec<String>>,
17556    site_id: Option<Vec<i32>>,
17557    site_id__n: Option<Vec<i32>>,
17558    slug: Option<Vec<String>>,
17559    slug__empty: Option<bool>,
17560    slug__ic: Option<Vec<String>>,
17561    slug__ie: Option<Vec<String>>,
17562    slug__iew: Option<Vec<String>>,
17563    slug__iregex: Option<Vec<String>>,
17564    slug__isw: Option<Vec<String>>,
17565    slug__n: Option<Vec<String>>,
17566    slug__nic: Option<Vec<String>>,
17567    slug__nie: Option<Vec<String>>,
17568    slug__niew: Option<Vec<String>>,
17569    slug__nisw: Option<Vec<String>>,
17570    slug__regex: Option<Vec<String>>,
17571    tag: Option<Vec<String>>,
17572    tag__n: Option<Vec<String>>,
17573    tag_id: Option<Vec<i32>>,
17574    tag_id__n: Option<Vec<i32>>,
17575    updated_by_request: Option<&str>,
17576) -> Result<crate::models::PaginatedProviderList, Error<CircuitsProvidersListError>> {
17577    let local_var_configuration = configuration;
17578
17579    let local_var_client = &local_var_configuration.client;
17580
17581    let local_var_uri_str = format!(
17582        "{}/api/circuits/providers/",
17583        local_var_configuration.base_path
17584    );
17585    let mut local_var_req_builder =
17586        local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
17587
17588    if let Some(ref local_var_str) = asn {
17589        local_var_req_builder = match "multi" {
17590            "multi" => local_var_req_builder.query(
17591                &local_var_str
17592                    .into_iter()
17593                    .map(|p| ("asn".to_owned(), p.to_string()))
17594                    .collect::<Vec<(std::string::String, std::string::String)>>(),
17595            ),
17596            _ => local_var_req_builder.query(&[(
17597                "asn",
17598                &local_var_str
17599                    .into_iter()
17600                    .map(|p| p.to_string())
17601                    .collect::<Vec<String>>()
17602                    .join(",")
17603                    .to_string(),
17604            )]),
17605        };
17606    }
17607    if let Some(ref local_var_str) = asn__n {
17608        local_var_req_builder = match "multi" {
17609            "multi" => local_var_req_builder.query(
17610                &local_var_str
17611                    .into_iter()
17612                    .map(|p| ("asn__n".to_owned(), p.to_string()))
17613                    .collect::<Vec<(std::string::String, std::string::String)>>(),
17614            ),
17615            _ => local_var_req_builder.query(&[(
17616                "asn__n",
17617                &local_var_str
17618                    .into_iter()
17619                    .map(|p| p.to_string())
17620                    .collect::<Vec<String>>()
17621                    .join(",")
17622                    .to_string(),
17623            )]),
17624        };
17625    }
17626    if let Some(ref local_var_str) = asn_id {
17627        local_var_req_builder = match "multi" {
17628            "multi" => local_var_req_builder.query(
17629                &local_var_str
17630                    .into_iter()
17631                    .map(|p| ("asn_id".to_owned(), p.to_string()))
17632                    .collect::<Vec<(std::string::String, std::string::String)>>(),
17633            ),
17634            _ => local_var_req_builder.query(&[(
17635                "asn_id",
17636                &local_var_str
17637                    .into_iter()
17638                    .map(|p| p.to_string())
17639                    .collect::<Vec<String>>()
17640                    .join(",")
17641                    .to_string(),
17642            )]),
17643        };
17644    }
17645    if let Some(ref local_var_str) = asn_id__n {
17646        local_var_req_builder = match "multi" {
17647            "multi" => local_var_req_builder.query(
17648                &local_var_str
17649                    .into_iter()
17650                    .map(|p| ("asn_id__n".to_owned(), p.to_string()))
17651                    .collect::<Vec<(std::string::String, std::string::String)>>(),
17652            ),
17653            _ => local_var_req_builder.query(&[(
17654                "asn_id__n",
17655                &local_var_str
17656                    .into_iter()
17657                    .map(|p| p.to_string())
17658                    .collect::<Vec<String>>()
17659                    .join(",")
17660                    .to_string(),
17661            )]),
17662        };
17663    }
17664    if let Some(ref local_var_str) = contact {
17665        local_var_req_builder = match "multi" {
17666            "multi" => local_var_req_builder.query(
17667                &local_var_str
17668                    .into_iter()
17669                    .map(|p| ("contact".to_owned(), p.to_string()))
17670                    .collect::<Vec<(std::string::String, std::string::String)>>(),
17671            ),
17672            _ => local_var_req_builder.query(&[(
17673                "contact",
17674                &local_var_str
17675                    .into_iter()
17676                    .map(|p| p.to_string())
17677                    .collect::<Vec<String>>()
17678                    .join(",")
17679                    .to_string(),
17680            )]),
17681        };
17682    }
17683    if let Some(ref local_var_str) = contact__n {
17684        local_var_req_builder = match "multi" {
17685            "multi" => local_var_req_builder.query(
17686                &local_var_str
17687                    .into_iter()
17688                    .map(|p| ("contact__n".to_owned(), p.to_string()))
17689                    .collect::<Vec<(std::string::String, std::string::String)>>(),
17690            ),
17691            _ => local_var_req_builder.query(&[(
17692                "contact__n",
17693                &local_var_str
17694                    .into_iter()
17695                    .map(|p| p.to_string())
17696                    .collect::<Vec<String>>()
17697                    .join(",")
17698                    .to_string(),
17699            )]),
17700        };
17701    }
17702    if let Some(ref local_var_str) = contact_group {
17703        local_var_req_builder = match "multi" {
17704            "multi" => local_var_req_builder.query(
17705                &local_var_str
17706                    .into_iter()
17707                    .map(|p| ("contact_group".to_owned(), p.to_string()))
17708                    .collect::<Vec<(std::string::String, std::string::String)>>(),
17709            ),
17710            _ => local_var_req_builder.query(&[(
17711                "contact_group",
17712                &local_var_str
17713                    .into_iter()
17714                    .map(|p| p.to_string())
17715                    .collect::<Vec<String>>()
17716                    .join(",")
17717                    .to_string(),
17718            )]),
17719        };
17720    }
17721    if let Some(ref local_var_str) = contact_group__n {
17722        local_var_req_builder = match "multi" {
17723            "multi" => local_var_req_builder.query(
17724                &local_var_str
17725                    .into_iter()
17726                    .map(|p| ("contact_group__n".to_owned(), p.to_string()))
17727                    .collect::<Vec<(std::string::String, std::string::String)>>(),
17728            ),
17729            _ => local_var_req_builder.query(&[(
17730                "contact_group__n",
17731                &local_var_str
17732                    .into_iter()
17733                    .map(|p| p.to_string())
17734                    .collect::<Vec<String>>()
17735                    .join(",")
17736                    .to_string(),
17737            )]),
17738        };
17739    }
17740    if let Some(ref local_var_str) = contact_role {
17741        local_var_req_builder = match "multi" {
17742            "multi" => local_var_req_builder.query(
17743                &local_var_str
17744                    .into_iter()
17745                    .map(|p| ("contact_role".to_owned(), p.to_string()))
17746                    .collect::<Vec<(std::string::String, std::string::String)>>(),
17747            ),
17748            _ => local_var_req_builder.query(&[(
17749                "contact_role",
17750                &local_var_str
17751                    .into_iter()
17752                    .map(|p| p.to_string())
17753                    .collect::<Vec<String>>()
17754                    .join(",")
17755                    .to_string(),
17756            )]),
17757        };
17758    }
17759    if let Some(ref local_var_str) = contact_role__n {
17760        local_var_req_builder = match "multi" {
17761            "multi" => local_var_req_builder.query(
17762                &local_var_str
17763                    .into_iter()
17764                    .map(|p| ("contact_role__n".to_owned(), p.to_string()))
17765                    .collect::<Vec<(std::string::String, std::string::String)>>(),
17766            ),
17767            _ => local_var_req_builder.query(&[(
17768                "contact_role__n",
17769                &local_var_str
17770                    .into_iter()
17771                    .map(|p| p.to_string())
17772                    .collect::<Vec<String>>()
17773                    .join(",")
17774                    .to_string(),
17775            )]),
17776        };
17777    }
17778    if let Some(ref local_var_str) = created {
17779        local_var_req_builder = match "multi" {
17780            "multi" => local_var_req_builder.query(
17781                &local_var_str
17782                    .into_iter()
17783                    .map(|p| ("created".to_owned(), p.to_string()))
17784                    .collect::<Vec<(std::string::String, std::string::String)>>(),
17785            ),
17786            _ => local_var_req_builder.query(&[(
17787                "created",
17788                &local_var_str
17789                    .into_iter()
17790                    .map(|p| p.to_string())
17791                    .collect::<Vec<String>>()
17792                    .join(",")
17793                    .to_string(),
17794            )]),
17795        };
17796    }
17797    if let Some(ref local_var_str) = created__empty {
17798        local_var_req_builder = match "multi" {
17799            "multi" => local_var_req_builder.query(
17800                &local_var_str
17801                    .into_iter()
17802                    .map(|p| ("created__empty".to_owned(), p.to_string()))
17803                    .collect::<Vec<(std::string::String, std::string::String)>>(),
17804            ),
17805            _ => local_var_req_builder.query(&[(
17806                "created__empty",
17807                &local_var_str
17808                    .into_iter()
17809                    .map(|p| p.to_string())
17810                    .collect::<Vec<String>>()
17811                    .join(",")
17812                    .to_string(),
17813            )]),
17814        };
17815    }
17816    if let Some(ref local_var_str) = created__gt {
17817        local_var_req_builder = match "multi" {
17818            "multi" => local_var_req_builder.query(
17819                &local_var_str
17820                    .into_iter()
17821                    .map(|p| ("created__gt".to_owned(), p.to_string()))
17822                    .collect::<Vec<(std::string::String, std::string::String)>>(),
17823            ),
17824            _ => local_var_req_builder.query(&[(
17825                "created__gt",
17826                &local_var_str
17827                    .into_iter()
17828                    .map(|p| p.to_string())
17829                    .collect::<Vec<String>>()
17830                    .join(",")
17831                    .to_string(),
17832            )]),
17833        };
17834    }
17835    if let Some(ref local_var_str) = created__gte {
17836        local_var_req_builder = match "multi" {
17837            "multi" => local_var_req_builder.query(
17838                &local_var_str
17839                    .into_iter()
17840                    .map(|p| ("created__gte".to_owned(), p.to_string()))
17841                    .collect::<Vec<(std::string::String, std::string::String)>>(),
17842            ),
17843            _ => local_var_req_builder.query(&[(
17844                "created__gte",
17845                &local_var_str
17846                    .into_iter()
17847                    .map(|p| p.to_string())
17848                    .collect::<Vec<String>>()
17849                    .join(",")
17850                    .to_string(),
17851            )]),
17852        };
17853    }
17854    if let Some(ref local_var_str) = created__lt {
17855        local_var_req_builder = match "multi" {
17856            "multi" => local_var_req_builder.query(
17857                &local_var_str
17858                    .into_iter()
17859                    .map(|p| ("created__lt".to_owned(), p.to_string()))
17860                    .collect::<Vec<(std::string::String, std::string::String)>>(),
17861            ),
17862            _ => local_var_req_builder.query(&[(
17863                "created__lt",
17864                &local_var_str
17865                    .into_iter()
17866                    .map(|p| p.to_string())
17867                    .collect::<Vec<String>>()
17868                    .join(",")
17869                    .to_string(),
17870            )]),
17871        };
17872    }
17873    if let Some(ref local_var_str) = created__lte {
17874        local_var_req_builder = match "multi" {
17875            "multi" => local_var_req_builder.query(
17876                &local_var_str
17877                    .into_iter()
17878                    .map(|p| ("created__lte".to_owned(), p.to_string()))
17879                    .collect::<Vec<(std::string::String, std::string::String)>>(),
17880            ),
17881            _ => local_var_req_builder.query(&[(
17882                "created__lte",
17883                &local_var_str
17884                    .into_iter()
17885                    .map(|p| p.to_string())
17886                    .collect::<Vec<String>>()
17887                    .join(",")
17888                    .to_string(),
17889            )]),
17890        };
17891    }
17892    if let Some(ref local_var_str) = created__n {
17893        local_var_req_builder = match "multi" {
17894            "multi" => local_var_req_builder.query(
17895                &local_var_str
17896                    .into_iter()
17897                    .map(|p| ("created__n".to_owned(), p.to_string()))
17898                    .collect::<Vec<(std::string::String, std::string::String)>>(),
17899            ),
17900            _ => local_var_req_builder.query(&[(
17901                "created__n",
17902                &local_var_str
17903                    .into_iter()
17904                    .map(|p| p.to_string())
17905                    .collect::<Vec<String>>()
17906                    .join(",")
17907                    .to_string(),
17908            )]),
17909        };
17910    }
17911    if let Some(ref local_var_str) = created_by_request {
17912        local_var_req_builder =
17913            local_var_req_builder.query(&[("created_by_request", &local_var_str.to_string())]);
17914    }
17915    if let Some(ref local_var_str) = description {
17916        local_var_req_builder = match "multi" {
17917            "multi" => local_var_req_builder.query(
17918                &local_var_str
17919                    .into_iter()
17920                    .map(|p| ("description".to_owned(), p.to_string()))
17921                    .collect::<Vec<(std::string::String, std::string::String)>>(),
17922            ),
17923            _ => local_var_req_builder.query(&[(
17924                "description",
17925                &local_var_str
17926                    .into_iter()
17927                    .map(|p| p.to_string())
17928                    .collect::<Vec<String>>()
17929                    .join(",")
17930                    .to_string(),
17931            )]),
17932        };
17933    }
17934    if let Some(ref local_var_str) = description__empty {
17935        local_var_req_builder =
17936            local_var_req_builder.query(&[("description__empty", &local_var_str.to_string())]);
17937    }
17938    if let Some(ref local_var_str) = description__ic {
17939        local_var_req_builder = match "multi" {
17940            "multi" => local_var_req_builder.query(
17941                &local_var_str
17942                    .into_iter()
17943                    .map(|p| ("description__ic".to_owned(), p.to_string()))
17944                    .collect::<Vec<(std::string::String, std::string::String)>>(),
17945            ),
17946            _ => local_var_req_builder.query(&[(
17947                "description__ic",
17948                &local_var_str
17949                    .into_iter()
17950                    .map(|p| p.to_string())
17951                    .collect::<Vec<String>>()
17952                    .join(",")
17953                    .to_string(),
17954            )]),
17955        };
17956    }
17957    if let Some(ref local_var_str) = description__ie {
17958        local_var_req_builder = match "multi" {
17959            "multi" => local_var_req_builder.query(
17960                &local_var_str
17961                    .into_iter()
17962                    .map(|p| ("description__ie".to_owned(), p.to_string()))
17963                    .collect::<Vec<(std::string::String, std::string::String)>>(),
17964            ),
17965            _ => local_var_req_builder.query(&[(
17966                "description__ie",
17967                &local_var_str
17968                    .into_iter()
17969                    .map(|p| p.to_string())
17970                    .collect::<Vec<String>>()
17971                    .join(",")
17972                    .to_string(),
17973            )]),
17974        };
17975    }
17976    if let Some(ref local_var_str) = description__iew {
17977        local_var_req_builder = match "multi" {
17978            "multi" => local_var_req_builder.query(
17979                &local_var_str
17980                    .into_iter()
17981                    .map(|p| ("description__iew".to_owned(), p.to_string()))
17982                    .collect::<Vec<(std::string::String, std::string::String)>>(),
17983            ),
17984            _ => local_var_req_builder.query(&[(
17985                "description__iew",
17986                &local_var_str
17987                    .into_iter()
17988                    .map(|p| p.to_string())
17989                    .collect::<Vec<String>>()
17990                    .join(",")
17991                    .to_string(),
17992            )]),
17993        };
17994    }
17995    if let Some(ref local_var_str) = description__iregex {
17996        local_var_req_builder = match "multi" {
17997            "multi" => local_var_req_builder.query(
17998                &local_var_str
17999                    .into_iter()
18000                    .map(|p| ("description__iregex".to_owned(), p.to_string()))
18001                    .collect::<Vec<(std::string::String, std::string::String)>>(),
18002            ),
18003            _ => local_var_req_builder.query(&[(
18004                "description__iregex",
18005                &local_var_str
18006                    .into_iter()
18007                    .map(|p| p.to_string())
18008                    .collect::<Vec<String>>()
18009                    .join(",")
18010                    .to_string(),
18011            )]),
18012        };
18013    }
18014    if let Some(ref local_var_str) = description__isw {
18015        local_var_req_builder = match "multi" {
18016            "multi" => local_var_req_builder.query(
18017                &local_var_str
18018                    .into_iter()
18019                    .map(|p| ("description__isw".to_owned(), p.to_string()))
18020                    .collect::<Vec<(std::string::String, std::string::String)>>(),
18021            ),
18022            _ => local_var_req_builder.query(&[(
18023                "description__isw",
18024                &local_var_str
18025                    .into_iter()
18026                    .map(|p| p.to_string())
18027                    .collect::<Vec<String>>()
18028                    .join(",")
18029                    .to_string(),
18030            )]),
18031        };
18032    }
18033    if let Some(ref local_var_str) = description__n {
18034        local_var_req_builder = match "multi" {
18035            "multi" => local_var_req_builder.query(
18036                &local_var_str
18037                    .into_iter()
18038                    .map(|p| ("description__n".to_owned(), p.to_string()))
18039                    .collect::<Vec<(std::string::String, std::string::String)>>(),
18040            ),
18041            _ => local_var_req_builder.query(&[(
18042                "description__n",
18043                &local_var_str
18044                    .into_iter()
18045                    .map(|p| p.to_string())
18046                    .collect::<Vec<String>>()
18047                    .join(",")
18048                    .to_string(),
18049            )]),
18050        };
18051    }
18052    if let Some(ref local_var_str) = description__nic {
18053        local_var_req_builder = match "multi" {
18054            "multi" => local_var_req_builder.query(
18055                &local_var_str
18056                    .into_iter()
18057                    .map(|p| ("description__nic".to_owned(), p.to_string()))
18058                    .collect::<Vec<(std::string::String, std::string::String)>>(),
18059            ),
18060            _ => local_var_req_builder.query(&[(
18061                "description__nic",
18062                &local_var_str
18063                    .into_iter()
18064                    .map(|p| p.to_string())
18065                    .collect::<Vec<String>>()
18066                    .join(",")
18067                    .to_string(),
18068            )]),
18069        };
18070    }
18071    if let Some(ref local_var_str) = description__nie {
18072        local_var_req_builder = match "multi" {
18073            "multi" => local_var_req_builder.query(
18074                &local_var_str
18075                    .into_iter()
18076                    .map(|p| ("description__nie".to_owned(), p.to_string()))
18077                    .collect::<Vec<(std::string::String, std::string::String)>>(),
18078            ),
18079            _ => local_var_req_builder.query(&[(
18080                "description__nie",
18081                &local_var_str
18082                    .into_iter()
18083                    .map(|p| p.to_string())
18084                    .collect::<Vec<String>>()
18085                    .join(",")
18086                    .to_string(),
18087            )]),
18088        };
18089    }
18090    if let Some(ref local_var_str) = description__niew {
18091        local_var_req_builder = match "multi" {
18092            "multi" => local_var_req_builder.query(
18093                &local_var_str
18094                    .into_iter()
18095                    .map(|p| ("description__niew".to_owned(), p.to_string()))
18096                    .collect::<Vec<(std::string::String, std::string::String)>>(),
18097            ),
18098            _ => local_var_req_builder.query(&[(
18099                "description__niew",
18100                &local_var_str
18101                    .into_iter()
18102                    .map(|p| p.to_string())
18103                    .collect::<Vec<String>>()
18104                    .join(",")
18105                    .to_string(),
18106            )]),
18107        };
18108    }
18109    if let Some(ref local_var_str) = description__nisw {
18110        local_var_req_builder = match "multi" {
18111            "multi" => local_var_req_builder.query(
18112                &local_var_str
18113                    .into_iter()
18114                    .map(|p| ("description__nisw".to_owned(), p.to_string()))
18115                    .collect::<Vec<(std::string::String, std::string::String)>>(),
18116            ),
18117            _ => local_var_req_builder.query(&[(
18118                "description__nisw",
18119                &local_var_str
18120                    .into_iter()
18121                    .map(|p| p.to_string())
18122                    .collect::<Vec<String>>()
18123                    .join(",")
18124                    .to_string(),
18125            )]),
18126        };
18127    }
18128    if let Some(ref local_var_str) = description__regex {
18129        local_var_req_builder = match "multi" {
18130            "multi" => local_var_req_builder.query(
18131                &local_var_str
18132                    .into_iter()
18133                    .map(|p| ("description__regex".to_owned(), p.to_string()))
18134                    .collect::<Vec<(std::string::String, std::string::String)>>(),
18135            ),
18136            _ => local_var_req_builder.query(&[(
18137                "description__regex",
18138                &local_var_str
18139                    .into_iter()
18140                    .map(|p| p.to_string())
18141                    .collect::<Vec<String>>()
18142                    .join(",")
18143                    .to_string(),
18144            )]),
18145        };
18146    }
18147    if let Some(ref local_var_str) = id {
18148        local_var_req_builder = match "multi" {
18149            "multi" => local_var_req_builder.query(
18150                &local_var_str
18151                    .into_iter()
18152                    .map(|p| ("id".to_owned(), p.to_string()))
18153                    .collect::<Vec<(std::string::String, std::string::String)>>(),
18154            ),
18155            _ => local_var_req_builder.query(&[(
18156                "id",
18157                &local_var_str
18158                    .into_iter()
18159                    .map(|p| p.to_string())
18160                    .collect::<Vec<String>>()
18161                    .join(",")
18162                    .to_string(),
18163            )]),
18164        };
18165    }
18166    if let Some(ref local_var_str) = id__empty {
18167        local_var_req_builder =
18168            local_var_req_builder.query(&[("id__empty", &local_var_str.to_string())]);
18169    }
18170    if let Some(ref local_var_str) = id__gt {
18171        local_var_req_builder = match "multi" {
18172            "multi" => local_var_req_builder.query(
18173                &local_var_str
18174                    .into_iter()
18175                    .map(|p| ("id__gt".to_owned(), p.to_string()))
18176                    .collect::<Vec<(std::string::String, std::string::String)>>(),
18177            ),
18178            _ => local_var_req_builder.query(&[(
18179                "id__gt",
18180                &local_var_str
18181                    .into_iter()
18182                    .map(|p| p.to_string())
18183                    .collect::<Vec<String>>()
18184                    .join(",")
18185                    .to_string(),
18186            )]),
18187        };
18188    }
18189    if let Some(ref local_var_str) = id__gte {
18190        local_var_req_builder = match "multi" {
18191            "multi" => local_var_req_builder.query(
18192                &local_var_str
18193                    .into_iter()
18194                    .map(|p| ("id__gte".to_owned(), p.to_string()))
18195                    .collect::<Vec<(std::string::String, std::string::String)>>(),
18196            ),
18197            _ => local_var_req_builder.query(&[(
18198                "id__gte",
18199                &local_var_str
18200                    .into_iter()
18201                    .map(|p| p.to_string())
18202                    .collect::<Vec<String>>()
18203                    .join(",")
18204                    .to_string(),
18205            )]),
18206        };
18207    }
18208    if let Some(ref local_var_str) = id__lt {
18209        local_var_req_builder = match "multi" {
18210            "multi" => local_var_req_builder.query(
18211                &local_var_str
18212                    .into_iter()
18213                    .map(|p| ("id__lt".to_owned(), p.to_string()))
18214                    .collect::<Vec<(std::string::String, std::string::String)>>(),
18215            ),
18216            _ => local_var_req_builder.query(&[(
18217                "id__lt",
18218                &local_var_str
18219                    .into_iter()
18220                    .map(|p| p.to_string())
18221                    .collect::<Vec<String>>()
18222                    .join(",")
18223                    .to_string(),
18224            )]),
18225        };
18226    }
18227    if let Some(ref local_var_str) = id__lte {
18228        local_var_req_builder = match "multi" {
18229            "multi" => local_var_req_builder.query(
18230                &local_var_str
18231                    .into_iter()
18232                    .map(|p| ("id__lte".to_owned(), p.to_string()))
18233                    .collect::<Vec<(std::string::String, std::string::String)>>(),
18234            ),
18235            _ => local_var_req_builder.query(&[(
18236                "id__lte",
18237                &local_var_str
18238                    .into_iter()
18239                    .map(|p| p.to_string())
18240                    .collect::<Vec<String>>()
18241                    .join(",")
18242                    .to_string(),
18243            )]),
18244        };
18245    }
18246    if let Some(ref local_var_str) = id__n {
18247        local_var_req_builder = match "multi" {
18248            "multi" => local_var_req_builder.query(
18249                &local_var_str
18250                    .into_iter()
18251                    .map(|p| ("id__n".to_owned(), p.to_string()))
18252                    .collect::<Vec<(std::string::String, std::string::String)>>(),
18253            ),
18254            _ => local_var_req_builder.query(&[(
18255                "id__n",
18256                &local_var_str
18257                    .into_iter()
18258                    .map(|p| p.to_string())
18259                    .collect::<Vec<String>>()
18260                    .join(",")
18261                    .to_string(),
18262            )]),
18263        };
18264    }
18265    if let Some(ref local_var_str) = last_updated {
18266        local_var_req_builder = match "multi" {
18267            "multi" => local_var_req_builder.query(
18268                &local_var_str
18269                    .into_iter()
18270                    .map(|p| ("last_updated".to_owned(), p.to_string()))
18271                    .collect::<Vec<(std::string::String, std::string::String)>>(),
18272            ),
18273            _ => local_var_req_builder.query(&[(
18274                "last_updated",
18275                &local_var_str
18276                    .into_iter()
18277                    .map(|p| p.to_string())
18278                    .collect::<Vec<String>>()
18279                    .join(",")
18280                    .to_string(),
18281            )]),
18282        };
18283    }
18284    if let Some(ref local_var_str) = last_updated__empty {
18285        local_var_req_builder = match "multi" {
18286            "multi" => local_var_req_builder.query(
18287                &local_var_str
18288                    .into_iter()
18289                    .map(|p| ("last_updated__empty".to_owned(), p.to_string()))
18290                    .collect::<Vec<(std::string::String, std::string::String)>>(),
18291            ),
18292            _ => local_var_req_builder.query(&[(
18293                "last_updated__empty",
18294                &local_var_str
18295                    .into_iter()
18296                    .map(|p| p.to_string())
18297                    .collect::<Vec<String>>()
18298                    .join(",")
18299                    .to_string(),
18300            )]),
18301        };
18302    }
18303    if let Some(ref local_var_str) = last_updated__gt {
18304        local_var_req_builder = match "multi" {
18305            "multi" => local_var_req_builder.query(
18306                &local_var_str
18307                    .into_iter()
18308                    .map(|p| ("last_updated__gt".to_owned(), p.to_string()))
18309                    .collect::<Vec<(std::string::String, std::string::String)>>(),
18310            ),
18311            _ => local_var_req_builder.query(&[(
18312                "last_updated__gt",
18313                &local_var_str
18314                    .into_iter()
18315                    .map(|p| p.to_string())
18316                    .collect::<Vec<String>>()
18317                    .join(",")
18318                    .to_string(),
18319            )]),
18320        };
18321    }
18322    if let Some(ref local_var_str) = last_updated__gte {
18323        local_var_req_builder = match "multi" {
18324            "multi" => local_var_req_builder.query(
18325                &local_var_str
18326                    .into_iter()
18327                    .map(|p| ("last_updated__gte".to_owned(), p.to_string()))
18328                    .collect::<Vec<(std::string::String, std::string::String)>>(),
18329            ),
18330            _ => local_var_req_builder.query(&[(
18331                "last_updated__gte",
18332                &local_var_str
18333                    .into_iter()
18334                    .map(|p| p.to_string())
18335                    .collect::<Vec<String>>()
18336                    .join(",")
18337                    .to_string(),
18338            )]),
18339        };
18340    }
18341    if let Some(ref local_var_str) = last_updated__lt {
18342        local_var_req_builder = match "multi" {
18343            "multi" => local_var_req_builder.query(
18344                &local_var_str
18345                    .into_iter()
18346                    .map(|p| ("last_updated__lt".to_owned(), p.to_string()))
18347                    .collect::<Vec<(std::string::String, std::string::String)>>(),
18348            ),
18349            _ => local_var_req_builder.query(&[(
18350                "last_updated__lt",
18351                &local_var_str
18352                    .into_iter()
18353                    .map(|p| p.to_string())
18354                    .collect::<Vec<String>>()
18355                    .join(",")
18356                    .to_string(),
18357            )]),
18358        };
18359    }
18360    if let Some(ref local_var_str) = last_updated__lte {
18361        local_var_req_builder = match "multi" {
18362            "multi" => local_var_req_builder.query(
18363                &local_var_str
18364                    .into_iter()
18365                    .map(|p| ("last_updated__lte".to_owned(), p.to_string()))
18366                    .collect::<Vec<(std::string::String, std::string::String)>>(),
18367            ),
18368            _ => local_var_req_builder.query(&[(
18369                "last_updated__lte",
18370                &local_var_str
18371                    .into_iter()
18372                    .map(|p| p.to_string())
18373                    .collect::<Vec<String>>()
18374                    .join(",")
18375                    .to_string(),
18376            )]),
18377        };
18378    }
18379    if let Some(ref local_var_str) = last_updated__n {
18380        local_var_req_builder = match "multi" {
18381            "multi" => local_var_req_builder.query(
18382                &local_var_str
18383                    .into_iter()
18384                    .map(|p| ("last_updated__n".to_owned(), p.to_string()))
18385                    .collect::<Vec<(std::string::String, std::string::String)>>(),
18386            ),
18387            _ => local_var_req_builder.query(&[(
18388                "last_updated__n",
18389                &local_var_str
18390                    .into_iter()
18391                    .map(|p| p.to_string())
18392                    .collect::<Vec<String>>()
18393                    .join(",")
18394                    .to_string(),
18395            )]),
18396        };
18397    }
18398    if let Some(ref local_var_str) = limit {
18399        local_var_req_builder =
18400            local_var_req_builder.query(&[("limit", &local_var_str.to_string())]);
18401    }
18402    if let Some(ref local_var_str) = modified_by_request {
18403        local_var_req_builder =
18404            local_var_req_builder.query(&[("modified_by_request", &local_var_str.to_string())]);
18405    }
18406    if let Some(ref local_var_str) = name {
18407        local_var_req_builder = match "multi" {
18408            "multi" => local_var_req_builder.query(
18409                &local_var_str
18410                    .into_iter()
18411                    .map(|p| ("name".to_owned(), p.to_string()))
18412                    .collect::<Vec<(std::string::String, std::string::String)>>(),
18413            ),
18414            _ => local_var_req_builder.query(&[(
18415                "name",
18416                &local_var_str
18417                    .into_iter()
18418                    .map(|p| p.to_string())
18419                    .collect::<Vec<String>>()
18420                    .join(",")
18421                    .to_string(),
18422            )]),
18423        };
18424    }
18425    if let Some(ref local_var_str) = name__empty {
18426        local_var_req_builder =
18427            local_var_req_builder.query(&[("name__empty", &local_var_str.to_string())]);
18428    }
18429    if let Some(ref local_var_str) = name__ic {
18430        local_var_req_builder = match "multi" {
18431            "multi" => local_var_req_builder.query(
18432                &local_var_str
18433                    .into_iter()
18434                    .map(|p| ("name__ic".to_owned(), p.to_string()))
18435                    .collect::<Vec<(std::string::String, std::string::String)>>(),
18436            ),
18437            _ => local_var_req_builder.query(&[(
18438                "name__ic",
18439                &local_var_str
18440                    .into_iter()
18441                    .map(|p| p.to_string())
18442                    .collect::<Vec<String>>()
18443                    .join(",")
18444                    .to_string(),
18445            )]),
18446        };
18447    }
18448    if let Some(ref local_var_str) = name__ie {
18449        local_var_req_builder = match "multi" {
18450            "multi" => local_var_req_builder.query(
18451                &local_var_str
18452                    .into_iter()
18453                    .map(|p| ("name__ie".to_owned(), p.to_string()))
18454                    .collect::<Vec<(std::string::String, std::string::String)>>(),
18455            ),
18456            _ => local_var_req_builder.query(&[(
18457                "name__ie",
18458                &local_var_str
18459                    .into_iter()
18460                    .map(|p| p.to_string())
18461                    .collect::<Vec<String>>()
18462                    .join(",")
18463                    .to_string(),
18464            )]),
18465        };
18466    }
18467    if let Some(ref local_var_str) = name__iew {
18468        local_var_req_builder = match "multi" {
18469            "multi" => local_var_req_builder.query(
18470                &local_var_str
18471                    .into_iter()
18472                    .map(|p| ("name__iew".to_owned(), p.to_string()))
18473                    .collect::<Vec<(std::string::String, std::string::String)>>(),
18474            ),
18475            _ => local_var_req_builder.query(&[(
18476                "name__iew",
18477                &local_var_str
18478                    .into_iter()
18479                    .map(|p| p.to_string())
18480                    .collect::<Vec<String>>()
18481                    .join(",")
18482                    .to_string(),
18483            )]),
18484        };
18485    }
18486    if let Some(ref local_var_str) = name__iregex {
18487        local_var_req_builder = match "multi" {
18488            "multi" => local_var_req_builder.query(
18489                &local_var_str
18490                    .into_iter()
18491                    .map(|p| ("name__iregex".to_owned(), p.to_string()))
18492                    .collect::<Vec<(std::string::String, std::string::String)>>(),
18493            ),
18494            _ => local_var_req_builder.query(&[(
18495                "name__iregex",
18496                &local_var_str
18497                    .into_iter()
18498                    .map(|p| p.to_string())
18499                    .collect::<Vec<String>>()
18500                    .join(",")
18501                    .to_string(),
18502            )]),
18503        };
18504    }
18505    if let Some(ref local_var_str) = name__isw {
18506        local_var_req_builder = match "multi" {
18507            "multi" => local_var_req_builder.query(
18508                &local_var_str
18509                    .into_iter()
18510                    .map(|p| ("name__isw".to_owned(), p.to_string()))
18511                    .collect::<Vec<(std::string::String, std::string::String)>>(),
18512            ),
18513            _ => local_var_req_builder.query(&[(
18514                "name__isw",
18515                &local_var_str
18516                    .into_iter()
18517                    .map(|p| p.to_string())
18518                    .collect::<Vec<String>>()
18519                    .join(",")
18520                    .to_string(),
18521            )]),
18522        };
18523    }
18524    if let Some(ref local_var_str) = name__n {
18525        local_var_req_builder = match "multi" {
18526            "multi" => local_var_req_builder.query(
18527                &local_var_str
18528                    .into_iter()
18529                    .map(|p| ("name__n".to_owned(), p.to_string()))
18530                    .collect::<Vec<(std::string::String, std::string::String)>>(),
18531            ),
18532            _ => local_var_req_builder.query(&[(
18533                "name__n",
18534                &local_var_str
18535                    .into_iter()
18536                    .map(|p| p.to_string())
18537                    .collect::<Vec<String>>()
18538                    .join(",")
18539                    .to_string(),
18540            )]),
18541        };
18542    }
18543    if let Some(ref local_var_str) = name__nic {
18544        local_var_req_builder = match "multi" {
18545            "multi" => local_var_req_builder.query(
18546                &local_var_str
18547                    .into_iter()
18548                    .map(|p| ("name__nic".to_owned(), p.to_string()))
18549                    .collect::<Vec<(std::string::String, std::string::String)>>(),
18550            ),
18551            _ => local_var_req_builder.query(&[(
18552                "name__nic",
18553                &local_var_str
18554                    .into_iter()
18555                    .map(|p| p.to_string())
18556                    .collect::<Vec<String>>()
18557                    .join(",")
18558                    .to_string(),
18559            )]),
18560        };
18561    }
18562    if let Some(ref local_var_str) = name__nie {
18563        local_var_req_builder = match "multi" {
18564            "multi" => local_var_req_builder.query(
18565                &local_var_str
18566                    .into_iter()
18567                    .map(|p| ("name__nie".to_owned(), p.to_string()))
18568                    .collect::<Vec<(std::string::String, std::string::String)>>(),
18569            ),
18570            _ => local_var_req_builder.query(&[(
18571                "name__nie",
18572                &local_var_str
18573                    .into_iter()
18574                    .map(|p| p.to_string())
18575                    .collect::<Vec<String>>()
18576                    .join(",")
18577                    .to_string(),
18578            )]),
18579        };
18580    }
18581    if let Some(ref local_var_str) = name__niew {
18582        local_var_req_builder = match "multi" {
18583            "multi" => local_var_req_builder.query(
18584                &local_var_str
18585                    .into_iter()
18586                    .map(|p| ("name__niew".to_owned(), p.to_string()))
18587                    .collect::<Vec<(std::string::String, std::string::String)>>(),
18588            ),
18589            _ => local_var_req_builder.query(&[(
18590                "name__niew",
18591                &local_var_str
18592                    .into_iter()
18593                    .map(|p| p.to_string())
18594                    .collect::<Vec<String>>()
18595                    .join(",")
18596                    .to_string(),
18597            )]),
18598        };
18599    }
18600    if let Some(ref local_var_str) = name__nisw {
18601        local_var_req_builder = match "multi" {
18602            "multi" => local_var_req_builder.query(
18603                &local_var_str
18604                    .into_iter()
18605                    .map(|p| ("name__nisw".to_owned(), p.to_string()))
18606                    .collect::<Vec<(std::string::String, std::string::String)>>(),
18607            ),
18608            _ => local_var_req_builder.query(&[(
18609                "name__nisw",
18610                &local_var_str
18611                    .into_iter()
18612                    .map(|p| p.to_string())
18613                    .collect::<Vec<String>>()
18614                    .join(",")
18615                    .to_string(),
18616            )]),
18617        };
18618    }
18619    if let Some(ref local_var_str) = name__regex {
18620        local_var_req_builder = match "multi" {
18621            "multi" => local_var_req_builder.query(
18622                &local_var_str
18623                    .into_iter()
18624                    .map(|p| ("name__regex".to_owned(), p.to_string()))
18625                    .collect::<Vec<(std::string::String, std::string::String)>>(),
18626            ),
18627            _ => local_var_req_builder.query(&[(
18628                "name__regex",
18629                &local_var_str
18630                    .into_iter()
18631                    .map(|p| p.to_string())
18632                    .collect::<Vec<String>>()
18633                    .join(",")
18634                    .to_string(),
18635            )]),
18636        };
18637    }
18638    if let Some(ref local_var_str) = offset {
18639        local_var_req_builder =
18640            local_var_req_builder.query(&[("offset", &local_var_str.to_string())]);
18641    }
18642    if let Some(ref local_var_str) = ordering {
18643        local_var_req_builder =
18644            local_var_req_builder.query(&[("ordering", &local_var_str.to_string())]);
18645    }
18646    if let Some(ref local_var_str) = owner {
18647        local_var_req_builder = match "multi" {
18648            "multi" => local_var_req_builder.query(
18649                &local_var_str
18650                    .into_iter()
18651                    .map(|p| ("owner".to_owned(), p.to_string()))
18652                    .collect::<Vec<(std::string::String, std::string::String)>>(),
18653            ),
18654            _ => local_var_req_builder.query(&[(
18655                "owner",
18656                &local_var_str
18657                    .into_iter()
18658                    .map(|p| p.to_string())
18659                    .collect::<Vec<String>>()
18660                    .join(",")
18661                    .to_string(),
18662            )]),
18663        };
18664    }
18665    if let Some(ref local_var_str) = owner__n {
18666        local_var_req_builder = match "multi" {
18667            "multi" => local_var_req_builder.query(
18668                &local_var_str
18669                    .into_iter()
18670                    .map(|p| ("owner__n".to_owned(), p.to_string()))
18671                    .collect::<Vec<(std::string::String, std::string::String)>>(),
18672            ),
18673            _ => local_var_req_builder.query(&[(
18674                "owner__n",
18675                &local_var_str
18676                    .into_iter()
18677                    .map(|p| p.to_string())
18678                    .collect::<Vec<String>>()
18679                    .join(",")
18680                    .to_string(),
18681            )]),
18682        };
18683    }
18684    if let Some(ref local_var_str) = owner_group {
18685        local_var_req_builder = match "multi" {
18686            "multi" => local_var_req_builder.query(
18687                &local_var_str
18688                    .into_iter()
18689                    .map(|p| ("owner_group".to_owned(), p.to_string()))
18690                    .collect::<Vec<(std::string::String, std::string::String)>>(),
18691            ),
18692            _ => local_var_req_builder.query(&[(
18693                "owner_group",
18694                &local_var_str
18695                    .into_iter()
18696                    .map(|p| p.to_string())
18697                    .collect::<Vec<String>>()
18698                    .join(",")
18699                    .to_string(),
18700            )]),
18701        };
18702    }
18703    if let Some(ref local_var_str) = owner_group__n {
18704        local_var_req_builder = match "multi" {
18705            "multi" => local_var_req_builder.query(
18706                &local_var_str
18707                    .into_iter()
18708                    .map(|p| ("owner_group__n".to_owned(), p.to_string()))
18709                    .collect::<Vec<(std::string::String, std::string::String)>>(),
18710            ),
18711            _ => local_var_req_builder.query(&[(
18712                "owner_group__n",
18713                &local_var_str
18714                    .into_iter()
18715                    .map(|p| p.to_string())
18716                    .collect::<Vec<String>>()
18717                    .join(",")
18718                    .to_string(),
18719            )]),
18720        };
18721    }
18722    if let Some(ref local_var_str) = owner_group_id {
18723        local_var_req_builder = match "multi" {
18724            "multi" => local_var_req_builder.query(
18725                &local_var_str
18726                    .into_iter()
18727                    .map(|p| ("owner_group_id".to_owned(), p.to_string()))
18728                    .collect::<Vec<(std::string::String, std::string::String)>>(),
18729            ),
18730            _ => local_var_req_builder.query(&[(
18731                "owner_group_id",
18732                &local_var_str
18733                    .into_iter()
18734                    .map(|p| p.to_string())
18735                    .collect::<Vec<String>>()
18736                    .join(",")
18737                    .to_string(),
18738            )]),
18739        };
18740    }
18741    if let Some(ref local_var_str) = owner_group_id__n {
18742        local_var_req_builder = match "multi" {
18743            "multi" => local_var_req_builder.query(
18744                &local_var_str
18745                    .into_iter()
18746                    .map(|p| ("owner_group_id__n".to_owned(), p.to_string()))
18747                    .collect::<Vec<(std::string::String, std::string::String)>>(),
18748            ),
18749            _ => local_var_req_builder.query(&[(
18750                "owner_group_id__n",
18751                &local_var_str
18752                    .into_iter()
18753                    .map(|p| p.to_string())
18754                    .collect::<Vec<String>>()
18755                    .join(",")
18756                    .to_string(),
18757            )]),
18758        };
18759    }
18760    if let Some(ref local_var_str) = owner_id {
18761        local_var_req_builder = match "multi" {
18762            "multi" => local_var_req_builder.query(
18763                &local_var_str
18764                    .into_iter()
18765                    .map(|p| ("owner_id".to_owned(), p.to_string()))
18766                    .collect::<Vec<(std::string::String, std::string::String)>>(),
18767            ),
18768            _ => local_var_req_builder.query(&[(
18769                "owner_id",
18770                &local_var_str
18771                    .into_iter()
18772                    .map(|p| p.to_string())
18773                    .collect::<Vec<String>>()
18774                    .join(",")
18775                    .to_string(),
18776            )]),
18777        };
18778    }
18779    if let Some(ref local_var_str) = owner_id__n {
18780        local_var_req_builder = match "multi" {
18781            "multi" => local_var_req_builder.query(
18782                &local_var_str
18783                    .into_iter()
18784                    .map(|p| ("owner_id__n".to_owned(), p.to_string()))
18785                    .collect::<Vec<(std::string::String, std::string::String)>>(),
18786            ),
18787            _ => local_var_req_builder.query(&[(
18788                "owner_id__n",
18789                &local_var_str
18790                    .into_iter()
18791                    .map(|p| p.to_string())
18792                    .collect::<Vec<String>>()
18793                    .join(",")
18794                    .to_string(),
18795            )]),
18796        };
18797    }
18798    if let Some(ref local_var_str) = q {
18799        local_var_req_builder = local_var_req_builder.query(&[("q", &local_var_str.to_string())]);
18800    }
18801    if let Some(ref local_var_str) = region {
18802        local_var_req_builder = match "multi" {
18803            "multi" => local_var_req_builder.query(
18804                &local_var_str
18805                    .into_iter()
18806                    .map(|p| ("region".to_owned(), p.to_string()))
18807                    .collect::<Vec<(std::string::String, std::string::String)>>(),
18808            ),
18809            _ => local_var_req_builder.query(&[(
18810                "region",
18811                &local_var_str
18812                    .into_iter()
18813                    .map(|p| p.to_string())
18814                    .collect::<Vec<String>>()
18815                    .join(",")
18816                    .to_string(),
18817            )]),
18818        };
18819    }
18820    if let Some(ref local_var_str) = region__n {
18821        local_var_req_builder = match "multi" {
18822            "multi" => local_var_req_builder.query(
18823                &local_var_str
18824                    .into_iter()
18825                    .map(|p| ("region__n".to_owned(), p.to_string()))
18826                    .collect::<Vec<(std::string::String, std::string::String)>>(),
18827            ),
18828            _ => local_var_req_builder.query(&[(
18829                "region__n",
18830                &local_var_str
18831                    .into_iter()
18832                    .map(|p| p.to_string())
18833                    .collect::<Vec<String>>()
18834                    .join(",")
18835                    .to_string(),
18836            )]),
18837        };
18838    }
18839    if let Some(ref local_var_str) = region_id {
18840        local_var_req_builder = match "multi" {
18841            "multi" => local_var_req_builder.query(
18842                &local_var_str
18843                    .into_iter()
18844                    .map(|p| ("region_id".to_owned(), p.to_string()))
18845                    .collect::<Vec<(std::string::String, std::string::String)>>(),
18846            ),
18847            _ => local_var_req_builder.query(&[(
18848                "region_id",
18849                &local_var_str
18850                    .into_iter()
18851                    .map(|p| p.to_string())
18852                    .collect::<Vec<String>>()
18853                    .join(",")
18854                    .to_string(),
18855            )]),
18856        };
18857    }
18858    if let Some(ref local_var_str) = region_id__n {
18859        local_var_req_builder = match "multi" {
18860            "multi" => local_var_req_builder.query(
18861                &local_var_str
18862                    .into_iter()
18863                    .map(|p| ("region_id__n".to_owned(), p.to_string()))
18864                    .collect::<Vec<(std::string::String, std::string::String)>>(),
18865            ),
18866            _ => local_var_req_builder.query(&[(
18867                "region_id__n",
18868                &local_var_str
18869                    .into_iter()
18870                    .map(|p| p.to_string())
18871                    .collect::<Vec<String>>()
18872                    .join(",")
18873                    .to_string(),
18874            )]),
18875        };
18876    }
18877    if let Some(ref local_var_str) = site {
18878        local_var_req_builder = match "multi" {
18879            "multi" => local_var_req_builder.query(
18880                &local_var_str
18881                    .into_iter()
18882                    .map(|p| ("site".to_owned(), p.to_string()))
18883                    .collect::<Vec<(std::string::String, std::string::String)>>(),
18884            ),
18885            _ => local_var_req_builder.query(&[(
18886                "site",
18887                &local_var_str
18888                    .into_iter()
18889                    .map(|p| p.to_string())
18890                    .collect::<Vec<String>>()
18891                    .join(",")
18892                    .to_string(),
18893            )]),
18894        };
18895    }
18896    if let Some(ref local_var_str) = site__n {
18897        local_var_req_builder = match "multi" {
18898            "multi" => local_var_req_builder.query(
18899                &local_var_str
18900                    .into_iter()
18901                    .map(|p| ("site__n".to_owned(), p.to_string()))
18902                    .collect::<Vec<(std::string::String, std::string::String)>>(),
18903            ),
18904            _ => local_var_req_builder.query(&[(
18905                "site__n",
18906                &local_var_str
18907                    .into_iter()
18908                    .map(|p| p.to_string())
18909                    .collect::<Vec<String>>()
18910                    .join(",")
18911                    .to_string(),
18912            )]),
18913        };
18914    }
18915    if let Some(ref local_var_str) = site_group {
18916        local_var_req_builder = match "multi" {
18917            "multi" => local_var_req_builder.query(
18918                &local_var_str
18919                    .into_iter()
18920                    .map(|p| ("site_group".to_owned(), p.to_string()))
18921                    .collect::<Vec<(std::string::String, std::string::String)>>(),
18922            ),
18923            _ => local_var_req_builder.query(&[(
18924                "site_group",
18925                &local_var_str
18926                    .into_iter()
18927                    .map(|p| p.to_string())
18928                    .collect::<Vec<String>>()
18929                    .join(",")
18930                    .to_string(),
18931            )]),
18932        };
18933    }
18934    if let Some(ref local_var_str) = site_group__n {
18935        local_var_req_builder = match "multi" {
18936            "multi" => local_var_req_builder.query(
18937                &local_var_str
18938                    .into_iter()
18939                    .map(|p| ("site_group__n".to_owned(), p.to_string()))
18940                    .collect::<Vec<(std::string::String, std::string::String)>>(),
18941            ),
18942            _ => local_var_req_builder.query(&[(
18943                "site_group__n",
18944                &local_var_str
18945                    .into_iter()
18946                    .map(|p| p.to_string())
18947                    .collect::<Vec<String>>()
18948                    .join(",")
18949                    .to_string(),
18950            )]),
18951        };
18952    }
18953    if let Some(ref local_var_str) = site_group_id {
18954        local_var_req_builder = match "multi" {
18955            "multi" => local_var_req_builder.query(
18956                &local_var_str
18957                    .into_iter()
18958                    .map(|p| ("site_group_id".to_owned(), p.to_string()))
18959                    .collect::<Vec<(std::string::String, std::string::String)>>(),
18960            ),
18961            _ => local_var_req_builder.query(&[(
18962                "site_group_id",
18963                &local_var_str
18964                    .into_iter()
18965                    .map(|p| p.to_string())
18966                    .collect::<Vec<String>>()
18967                    .join(",")
18968                    .to_string(),
18969            )]),
18970        };
18971    }
18972    if let Some(ref local_var_str) = site_group_id__n {
18973        local_var_req_builder = match "multi" {
18974            "multi" => local_var_req_builder.query(
18975                &local_var_str
18976                    .into_iter()
18977                    .map(|p| ("site_group_id__n".to_owned(), p.to_string()))
18978                    .collect::<Vec<(std::string::String, std::string::String)>>(),
18979            ),
18980            _ => local_var_req_builder.query(&[(
18981                "site_group_id__n",
18982                &local_var_str
18983                    .into_iter()
18984                    .map(|p| p.to_string())
18985                    .collect::<Vec<String>>()
18986                    .join(",")
18987                    .to_string(),
18988            )]),
18989        };
18990    }
18991    if let Some(ref local_var_str) = site_id {
18992        local_var_req_builder = match "multi" {
18993            "multi" => local_var_req_builder.query(
18994                &local_var_str
18995                    .into_iter()
18996                    .map(|p| ("site_id".to_owned(), p.to_string()))
18997                    .collect::<Vec<(std::string::String, std::string::String)>>(),
18998            ),
18999            _ => local_var_req_builder.query(&[(
19000                "site_id",
19001                &local_var_str
19002                    .into_iter()
19003                    .map(|p| p.to_string())
19004                    .collect::<Vec<String>>()
19005                    .join(",")
19006                    .to_string(),
19007            )]),
19008        };
19009    }
19010    if let Some(ref local_var_str) = site_id__n {
19011        local_var_req_builder = match "multi" {
19012            "multi" => local_var_req_builder.query(
19013                &local_var_str
19014                    .into_iter()
19015                    .map(|p| ("site_id__n".to_owned(), p.to_string()))
19016                    .collect::<Vec<(std::string::String, std::string::String)>>(),
19017            ),
19018            _ => local_var_req_builder.query(&[(
19019                "site_id__n",
19020                &local_var_str
19021                    .into_iter()
19022                    .map(|p| p.to_string())
19023                    .collect::<Vec<String>>()
19024                    .join(",")
19025                    .to_string(),
19026            )]),
19027        };
19028    }
19029    if let Some(ref local_var_str) = slug {
19030        local_var_req_builder = match "multi" {
19031            "multi" => local_var_req_builder.query(
19032                &local_var_str
19033                    .into_iter()
19034                    .map(|p| ("slug".to_owned(), p.to_string()))
19035                    .collect::<Vec<(std::string::String, std::string::String)>>(),
19036            ),
19037            _ => local_var_req_builder.query(&[(
19038                "slug",
19039                &local_var_str
19040                    .into_iter()
19041                    .map(|p| p.to_string())
19042                    .collect::<Vec<String>>()
19043                    .join(",")
19044                    .to_string(),
19045            )]),
19046        };
19047    }
19048    if let Some(ref local_var_str) = slug__empty {
19049        local_var_req_builder =
19050            local_var_req_builder.query(&[("slug__empty", &local_var_str.to_string())]);
19051    }
19052    if let Some(ref local_var_str) = slug__ic {
19053        local_var_req_builder = match "multi" {
19054            "multi" => local_var_req_builder.query(
19055                &local_var_str
19056                    .into_iter()
19057                    .map(|p| ("slug__ic".to_owned(), p.to_string()))
19058                    .collect::<Vec<(std::string::String, std::string::String)>>(),
19059            ),
19060            _ => local_var_req_builder.query(&[(
19061                "slug__ic",
19062                &local_var_str
19063                    .into_iter()
19064                    .map(|p| p.to_string())
19065                    .collect::<Vec<String>>()
19066                    .join(",")
19067                    .to_string(),
19068            )]),
19069        };
19070    }
19071    if let Some(ref local_var_str) = slug__ie {
19072        local_var_req_builder = match "multi" {
19073            "multi" => local_var_req_builder.query(
19074                &local_var_str
19075                    .into_iter()
19076                    .map(|p| ("slug__ie".to_owned(), p.to_string()))
19077                    .collect::<Vec<(std::string::String, std::string::String)>>(),
19078            ),
19079            _ => local_var_req_builder.query(&[(
19080                "slug__ie",
19081                &local_var_str
19082                    .into_iter()
19083                    .map(|p| p.to_string())
19084                    .collect::<Vec<String>>()
19085                    .join(",")
19086                    .to_string(),
19087            )]),
19088        };
19089    }
19090    if let Some(ref local_var_str) = slug__iew {
19091        local_var_req_builder = match "multi" {
19092            "multi" => local_var_req_builder.query(
19093                &local_var_str
19094                    .into_iter()
19095                    .map(|p| ("slug__iew".to_owned(), p.to_string()))
19096                    .collect::<Vec<(std::string::String, std::string::String)>>(),
19097            ),
19098            _ => local_var_req_builder.query(&[(
19099                "slug__iew",
19100                &local_var_str
19101                    .into_iter()
19102                    .map(|p| p.to_string())
19103                    .collect::<Vec<String>>()
19104                    .join(",")
19105                    .to_string(),
19106            )]),
19107        };
19108    }
19109    if let Some(ref local_var_str) = slug__iregex {
19110        local_var_req_builder = match "multi" {
19111            "multi" => local_var_req_builder.query(
19112                &local_var_str
19113                    .into_iter()
19114                    .map(|p| ("slug__iregex".to_owned(), p.to_string()))
19115                    .collect::<Vec<(std::string::String, std::string::String)>>(),
19116            ),
19117            _ => local_var_req_builder.query(&[(
19118                "slug__iregex",
19119                &local_var_str
19120                    .into_iter()
19121                    .map(|p| p.to_string())
19122                    .collect::<Vec<String>>()
19123                    .join(",")
19124                    .to_string(),
19125            )]),
19126        };
19127    }
19128    if let Some(ref local_var_str) = slug__isw {
19129        local_var_req_builder = match "multi" {
19130            "multi" => local_var_req_builder.query(
19131                &local_var_str
19132                    .into_iter()
19133                    .map(|p| ("slug__isw".to_owned(), p.to_string()))
19134                    .collect::<Vec<(std::string::String, std::string::String)>>(),
19135            ),
19136            _ => local_var_req_builder.query(&[(
19137                "slug__isw",
19138                &local_var_str
19139                    .into_iter()
19140                    .map(|p| p.to_string())
19141                    .collect::<Vec<String>>()
19142                    .join(",")
19143                    .to_string(),
19144            )]),
19145        };
19146    }
19147    if let Some(ref local_var_str) = slug__n {
19148        local_var_req_builder = match "multi" {
19149            "multi" => local_var_req_builder.query(
19150                &local_var_str
19151                    .into_iter()
19152                    .map(|p| ("slug__n".to_owned(), p.to_string()))
19153                    .collect::<Vec<(std::string::String, std::string::String)>>(),
19154            ),
19155            _ => local_var_req_builder.query(&[(
19156                "slug__n",
19157                &local_var_str
19158                    .into_iter()
19159                    .map(|p| p.to_string())
19160                    .collect::<Vec<String>>()
19161                    .join(",")
19162                    .to_string(),
19163            )]),
19164        };
19165    }
19166    if let Some(ref local_var_str) = slug__nic {
19167        local_var_req_builder = match "multi" {
19168            "multi" => local_var_req_builder.query(
19169                &local_var_str
19170                    .into_iter()
19171                    .map(|p| ("slug__nic".to_owned(), p.to_string()))
19172                    .collect::<Vec<(std::string::String, std::string::String)>>(),
19173            ),
19174            _ => local_var_req_builder.query(&[(
19175                "slug__nic",
19176                &local_var_str
19177                    .into_iter()
19178                    .map(|p| p.to_string())
19179                    .collect::<Vec<String>>()
19180                    .join(",")
19181                    .to_string(),
19182            )]),
19183        };
19184    }
19185    if let Some(ref local_var_str) = slug__nie {
19186        local_var_req_builder = match "multi" {
19187            "multi" => local_var_req_builder.query(
19188                &local_var_str
19189                    .into_iter()
19190                    .map(|p| ("slug__nie".to_owned(), p.to_string()))
19191                    .collect::<Vec<(std::string::String, std::string::String)>>(),
19192            ),
19193            _ => local_var_req_builder.query(&[(
19194                "slug__nie",
19195                &local_var_str
19196                    .into_iter()
19197                    .map(|p| p.to_string())
19198                    .collect::<Vec<String>>()
19199                    .join(",")
19200                    .to_string(),
19201            )]),
19202        };
19203    }
19204    if let Some(ref local_var_str) = slug__niew {
19205        local_var_req_builder = match "multi" {
19206            "multi" => local_var_req_builder.query(
19207                &local_var_str
19208                    .into_iter()
19209                    .map(|p| ("slug__niew".to_owned(), p.to_string()))
19210                    .collect::<Vec<(std::string::String, std::string::String)>>(),
19211            ),
19212            _ => local_var_req_builder.query(&[(
19213                "slug__niew",
19214                &local_var_str
19215                    .into_iter()
19216                    .map(|p| p.to_string())
19217                    .collect::<Vec<String>>()
19218                    .join(",")
19219                    .to_string(),
19220            )]),
19221        };
19222    }
19223    if let Some(ref local_var_str) = slug__nisw {
19224        local_var_req_builder = match "multi" {
19225            "multi" => local_var_req_builder.query(
19226                &local_var_str
19227                    .into_iter()
19228                    .map(|p| ("slug__nisw".to_owned(), p.to_string()))
19229                    .collect::<Vec<(std::string::String, std::string::String)>>(),
19230            ),
19231            _ => local_var_req_builder.query(&[(
19232                "slug__nisw",
19233                &local_var_str
19234                    .into_iter()
19235                    .map(|p| p.to_string())
19236                    .collect::<Vec<String>>()
19237                    .join(",")
19238                    .to_string(),
19239            )]),
19240        };
19241    }
19242    if let Some(ref local_var_str) = slug__regex {
19243        local_var_req_builder = match "multi" {
19244            "multi" => local_var_req_builder.query(
19245                &local_var_str
19246                    .into_iter()
19247                    .map(|p| ("slug__regex".to_owned(), p.to_string()))
19248                    .collect::<Vec<(std::string::String, std::string::String)>>(),
19249            ),
19250            _ => local_var_req_builder.query(&[(
19251                "slug__regex",
19252                &local_var_str
19253                    .into_iter()
19254                    .map(|p| p.to_string())
19255                    .collect::<Vec<String>>()
19256                    .join(",")
19257                    .to_string(),
19258            )]),
19259        };
19260    }
19261    if let Some(ref local_var_str) = tag {
19262        local_var_req_builder = match "multi" {
19263            "multi" => local_var_req_builder.query(
19264                &local_var_str
19265                    .into_iter()
19266                    .map(|p| ("tag".to_owned(), p.to_string()))
19267                    .collect::<Vec<(std::string::String, std::string::String)>>(),
19268            ),
19269            _ => local_var_req_builder.query(&[(
19270                "tag",
19271                &local_var_str
19272                    .into_iter()
19273                    .map(|p| p.to_string())
19274                    .collect::<Vec<String>>()
19275                    .join(",")
19276                    .to_string(),
19277            )]),
19278        };
19279    }
19280    if let Some(ref local_var_str) = tag__n {
19281        local_var_req_builder = match "multi" {
19282            "multi" => local_var_req_builder.query(
19283                &local_var_str
19284                    .into_iter()
19285                    .map(|p| ("tag__n".to_owned(), p.to_string()))
19286                    .collect::<Vec<(std::string::String, std::string::String)>>(),
19287            ),
19288            _ => local_var_req_builder.query(&[(
19289                "tag__n",
19290                &local_var_str
19291                    .into_iter()
19292                    .map(|p| p.to_string())
19293                    .collect::<Vec<String>>()
19294                    .join(",")
19295                    .to_string(),
19296            )]),
19297        };
19298    }
19299    if let Some(ref local_var_str) = tag_id {
19300        local_var_req_builder = match "multi" {
19301            "multi" => local_var_req_builder.query(
19302                &local_var_str
19303                    .into_iter()
19304                    .map(|p| ("tag_id".to_owned(), p.to_string()))
19305                    .collect::<Vec<(std::string::String, std::string::String)>>(),
19306            ),
19307            _ => local_var_req_builder.query(&[(
19308                "tag_id",
19309                &local_var_str
19310                    .into_iter()
19311                    .map(|p| p.to_string())
19312                    .collect::<Vec<String>>()
19313                    .join(",")
19314                    .to_string(),
19315            )]),
19316        };
19317    }
19318    if let Some(ref local_var_str) = tag_id__n {
19319        local_var_req_builder = match "multi" {
19320            "multi" => local_var_req_builder.query(
19321                &local_var_str
19322                    .into_iter()
19323                    .map(|p| ("tag_id__n".to_owned(), p.to_string()))
19324                    .collect::<Vec<(std::string::String, std::string::String)>>(),
19325            ),
19326            _ => local_var_req_builder.query(&[(
19327                "tag_id__n",
19328                &local_var_str
19329                    .into_iter()
19330                    .map(|p| p.to_string())
19331                    .collect::<Vec<String>>()
19332                    .join(",")
19333                    .to_string(),
19334            )]),
19335        };
19336    }
19337    if let Some(ref local_var_str) = updated_by_request {
19338        local_var_req_builder =
19339            local_var_req_builder.query(&[("updated_by_request", &local_var_str.to_string())]);
19340    }
19341    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
19342        local_var_req_builder =
19343            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
19344    }
19345    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
19346        let local_var_key = local_var_apikey.key.clone();
19347        let local_var_value = match local_var_apikey.prefix {
19348            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
19349            None => local_var_key,
19350        };
19351        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
19352    };
19353
19354    let local_var_req = local_var_req_builder.build()?;
19355    let local_var_resp = local_var_client.execute(local_var_req).await?;
19356
19357    let local_var_status = local_var_resp.status();
19358    let local_var_content = local_var_resp.text().await?;
19359
19360    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
19361        serde_json::from_str(&local_var_content).map_err(Error::from)
19362    } else {
19363        let local_var_entity: Option<CircuitsProvidersListError> =
19364            serde_json::from_str(&local_var_content).ok();
19365        let local_var_error = ResponseContent {
19366            status: local_var_status,
19367            content: local_var_content,
19368            entity: local_var_entity,
19369        };
19370        Err(Error::ResponseError(local_var_error))
19371    }
19372}
19373
19374/// Patch a provider object.
19375pub async fn circuits_providers_partial_update(
19376    configuration: &configuration::Configuration,
19377    id: i32,
19378    patched_provider_request: Option<crate::models::PatchedProviderRequest>,
19379) -> Result<crate::models::Provider, Error<CircuitsProvidersPartialUpdateError>> {
19380    let local_var_configuration = configuration;
19381
19382    let local_var_client = &local_var_configuration.client;
19383
19384    let local_var_uri_str = format!(
19385        "{}/api/circuits/providers/{id}/",
19386        local_var_configuration.base_path,
19387        id = id
19388    );
19389    let mut local_var_req_builder =
19390        local_var_client.request(reqwest::Method::PATCH, local_var_uri_str.as_str());
19391
19392    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
19393        local_var_req_builder =
19394            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
19395    }
19396    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
19397        let local_var_key = local_var_apikey.key.clone();
19398        let local_var_value = match local_var_apikey.prefix {
19399            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
19400            None => local_var_key,
19401        };
19402        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
19403    };
19404    local_var_req_builder = local_var_req_builder.json(&patched_provider_request);
19405
19406    let local_var_req = local_var_req_builder.build()?;
19407    let local_var_resp = local_var_client.execute(local_var_req).await?;
19408
19409    let local_var_status = local_var_resp.status();
19410    let local_var_content = local_var_resp.text().await?;
19411
19412    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
19413        serde_json::from_str(&local_var_content).map_err(Error::from)
19414    } else {
19415        let local_var_entity: Option<CircuitsProvidersPartialUpdateError> =
19416            serde_json::from_str(&local_var_content).ok();
19417        let local_var_error = ResponseContent {
19418            status: local_var_status,
19419            content: local_var_content,
19420            entity: local_var_entity,
19421        };
19422        Err(Error::ResponseError(local_var_error))
19423    }
19424}
19425
19426/// Get a provider object.
19427pub async fn circuits_providers_retrieve(
19428    configuration: &configuration::Configuration,
19429    id: i32,
19430) -> Result<crate::models::Provider, Error<CircuitsProvidersRetrieveError>> {
19431    let local_var_configuration = configuration;
19432
19433    let local_var_client = &local_var_configuration.client;
19434
19435    let local_var_uri_str = format!(
19436        "{}/api/circuits/providers/{id}/",
19437        local_var_configuration.base_path,
19438        id = id
19439    );
19440    let mut local_var_req_builder =
19441        local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
19442
19443    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
19444        local_var_req_builder =
19445            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
19446    }
19447    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
19448        let local_var_key = local_var_apikey.key.clone();
19449        let local_var_value = match local_var_apikey.prefix {
19450            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
19451            None => local_var_key,
19452        };
19453        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
19454    };
19455
19456    let local_var_req = local_var_req_builder.build()?;
19457    let local_var_resp = local_var_client.execute(local_var_req).await?;
19458
19459    let local_var_status = local_var_resp.status();
19460    let local_var_content = local_var_resp.text().await?;
19461
19462    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
19463        serde_json::from_str(&local_var_content).map_err(Error::from)
19464    } else {
19465        let local_var_entity: Option<CircuitsProvidersRetrieveError> =
19466            serde_json::from_str(&local_var_content).ok();
19467        let local_var_error = ResponseContent {
19468            status: local_var_status,
19469            content: local_var_content,
19470            entity: local_var_entity,
19471        };
19472        Err(Error::ResponseError(local_var_error))
19473    }
19474}
19475
19476/// Put a provider object.
19477pub async fn circuits_providers_update(
19478    configuration: &configuration::Configuration,
19479    id: i32,
19480    provider_request: crate::models::ProviderRequest,
19481) -> Result<crate::models::Provider, Error<CircuitsProvidersUpdateError>> {
19482    let local_var_configuration = configuration;
19483
19484    let local_var_client = &local_var_configuration.client;
19485
19486    let local_var_uri_str = format!(
19487        "{}/api/circuits/providers/{id}/",
19488        local_var_configuration.base_path,
19489        id = id
19490    );
19491    let mut local_var_req_builder =
19492        local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());
19493
19494    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
19495        local_var_req_builder =
19496            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
19497    }
19498    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
19499        let local_var_key = local_var_apikey.key.clone();
19500        let local_var_value = match local_var_apikey.prefix {
19501            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
19502            None => local_var_key,
19503        };
19504        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
19505    };
19506    local_var_req_builder = local_var_req_builder.json(&provider_request);
19507
19508    let local_var_req = local_var_req_builder.build()?;
19509    let local_var_resp = local_var_client.execute(local_var_req).await?;
19510
19511    let local_var_status = local_var_resp.status();
19512    let local_var_content = local_var_resp.text().await?;
19513
19514    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
19515        serde_json::from_str(&local_var_content).map_err(Error::from)
19516    } else {
19517        let local_var_entity: Option<CircuitsProvidersUpdateError> =
19518            serde_json::from_str(&local_var_content).ok();
19519        let local_var_error = ResponseContent {
19520            status: local_var_status,
19521            content: local_var_content,
19522            entity: local_var_entity,
19523        };
19524        Err(Error::ResponseError(local_var_error))
19525    }
19526}
19527
19528/// Delete a list of virtual circuit termination objects.
19529pub async fn circuits_virtual_circuit_terminations_bulk_destroy(
19530    configuration: &configuration::Configuration,
19531    virtual_circuit_termination_request: Vec<crate::models::VirtualCircuitTerminationRequest>,
19532) -> Result<(), Error<CircuitsVirtualCircuitTerminationsBulkDestroyError>> {
19533    let local_var_configuration = configuration;
19534
19535    let local_var_client = &local_var_configuration.client;
19536
19537    let local_var_uri_str = format!(
19538        "{}/api/circuits/virtual-circuit-terminations/",
19539        local_var_configuration.base_path
19540    );
19541    let mut local_var_req_builder =
19542        local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());
19543
19544    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
19545        local_var_req_builder =
19546            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
19547    }
19548    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
19549        let local_var_key = local_var_apikey.key.clone();
19550        let local_var_value = match local_var_apikey.prefix {
19551            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
19552            None => local_var_key,
19553        };
19554        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
19555    };
19556    local_var_req_builder = local_var_req_builder.json(&virtual_circuit_termination_request);
19557
19558    let local_var_req = local_var_req_builder.build()?;
19559    let local_var_resp = local_var_client.execute(local_var_req).await?;
19560
19561    let local_var_status = local_var_resp.status();
19562    let local_var_content = local_var_resp.text().await?;
19563
19564    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
19565        Ok(())
19566    } else {
19567        let local_var_entity: Option<CircuitsVirtualCircuitTerminationsBulkDestroyError> =
19568            serde_json::from_str(&local_var_content).ok();
19569        let local_var_error = ResponseContent {
19570            status: local_var_status,
19571            content: local_var_content,
19572            entity: local_var_entity,
19573        };
19574        Err(Error::ResponseError(local_var_error))
19575    }
19576}
19577
19578/// Patch a list of virtual circuit termination objects.
19579pub async fn circuits_virtual_circuit_terminations_bulk_partial_update(
19580    configuration: &configuration::Configuration,
19581    virtual_circuit_termination_request: Vec<crate::models::VirtualCircuitTerminationRequest>,
19582) -> Result<
19583    Vec<crate::models::VirtualCircuitTermination>,
19584    Error<CircuitsVirtualCircuitTerminationsBulkPartialUpdateError>,
19585> {
19586    let local_var_configuration = configuration;
19587
19588    let local_var_client = &local_var_configuration.client;
19589
19590    let local_var_uri_str = format!(
19591        "{}/api/circuits/virtual-circuit-terminations/",
19592        local_var_configuration.base_path
19593    );
19594    let mut local_var_req_builder =
19595        local_var_client.request(reqwest::Method::PATCH, local_var_uri_str.as_str());
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(&virtual_circuit_termination_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<CircuitsVirtualCircuitTerminationsBulkPartialUpdateError> =
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/// Put a list of virtual circuit termination objects.
19632pub async fn circuits_virtual_circuit_terminations_bulk_update(
19633    configuration: &configuration::Configuration,
19634    virtual_circuit_termination_request: Vec<crate::models::VirtualCircuitTerminationRequest>,
19635) -> Result<
19636    Vec<crate::models::VirtualCircuitTermination>,
19637    Error<CircuitsVirtualCircuitTerminationsBulkUpdateError>,
19638> {
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        "{}/api/circuits/virtual-circuit-terminations/",
19645        local_var_configuration.base_path
19646    );
19647    let mut local_var_req_builder =
19648        local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());
19649
19650    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
19651        local_var_req_builder =
19652            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
19653    }
19654    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
19655        let local_var_key = local_var_apikey.key.clone();
19656        let local_var_value = match local_var_apikey.prefix {
19657            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
19658            None => local_var_key,
19659        };
19660        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
19661    };
19662    local_var_req_builder = local_var_req_builder.json(&virtual_circuit_termination_request);
19663
19664    let local_var_req = local_var_req_builder.build()?;
19665    let local_var_resp = local_var_client.execute(local_var_req).await?;
19666
19667    let local_var_status = local_var_resp.status();
19668    let local_var_content = local_var_resp.text().await?;
19669
19670    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
19671        serde_json::from_str(&local_var_content).map_err(Error::from)
19672    } else {
19673        let local_var_entity: Option<CircuitsVirtualCircuitTerminationsBulkUpdateError> =
19674            serde_json::from_str(&local_var_content).ok();
19675        let local_var_error = ResponseContent {
19676            status: local_var_status,
19677            content: local_var_content,
19678            entity: local_var_entity,
19679        };
19680        Err(Error::ResponseError(local_var_error))
19681    }
19682}
19683
19684/// Post a list of virtual circuit termination objects.
19685pub async fn circuits_virtual_circuit_terminations_create(
19686    configuration: &configuration::Configuration,
19687    circuits_virtual_circuit_terminations_create_request: crate::models::CircuitsVirtualCircuitTerminationsCreateRequest,
19688) -> Result<
19689    crate::models::VirtualCircuitTermination,
19690    Error<CircuitsVirtualCircuitTerminationsCreateError>,
19691> {
19692    let local_var_configuration = configuration;
19693
19694    let local_var_client = &local_var_configuration.client;
19695
19696    let local_var_uri_str = format!(
19697        "{}/api/circuits/virtual-circuit-terminations/",
19698        local_var_configuration.base_path
19699    );
19700    let mut local_var_req_builder =
19701        local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
19702
19703    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
19704        local_var_req_builder =
19705            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
19706    }
19707    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
19708        let local_var_key = local_var_apikey.key.clone();
19709        let local_var_value = match local_var_apikey.prefix {
19710            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
19711            None => local_var_key,
19712        };
19713        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
19714    };
19715    local_var_req_builder =
19716        local_var_req_builder.json(&circuits_virtual_circuit_terminations_create_request);
19717
19718    let local_var_req = local_var_req_builder.build()?;
19719    let local_var_resp = local_var_client.execute(local_var_req).await?;
19720
19721    let local_var_status = local_var_resp.status();
19722    let local_var_content = local_var_resp.text().await?;
19723
19724    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
19725        serde_json::from_str(&local_var_content).map_err(Error::from)
19726    } else {
19727        let local_var_entity: Option<CircuitsVirtualCircuitTerminationsCreateError> =
19728            serde_json::from_str(&local_var_content).ok();
19729        let local_var_error = ResponseContent {
19730            status: local_var_status,
19731            content: local_var_content,
19732            entity: local_var_entity,
19733        };
19734        Err(Error::ResponseError(local_var_error))
19735    }
19736}
19737
19738/// Delete a virtual circuit termination object.
19739pub async fn circuits_virtual_circuit_terminations_destroy(
19740    configuration: &configuration::Configuration,
19741    id: i32,
19742) -> Result<(), Error<CircuitsVirtualCircuitTerminationsDestroyError>> {
19743    let local_var_configuration = configuration;
19744
19745    let local_var_client = &local_var_configuration.client;
19746
19747    let local_var_uri_str = format!(
19748        "{}/api/circuits/virtual-circuit-terminations/{id}/",
19749        local_var_configuration.base_path,
19750        id = id
19751    );
19752    let mut local_var_req_builder =
19753        local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());
19754
19755    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
19756        local_var_req_builder =
19757            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
19758    }
19759    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
19760        let local_var_key = local_var_apikey.key.clone();
19761        let local_var_value = match local_var_apikey.prefix {
19762            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
19763            None => local_var_key,
19764        };
19765        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
19766    };
19767
19768    let local_var_req = local_var_req_builder.build()?;
19769    let local_var_resp = local_var_client.execute(local_var_req).await?;
19770
19771    let local_var_status = local_var_resp.status();
19772    let local_var_content = local_var_resp.text().await?;
19773
19774    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
19775        Ok(())
19776    } else {
19777        let local_var_entity: Option<CircuitsVirtualCircuitTerminationsDestroyError> =
19778            serde_json::from_str(&local_var_content).ok();
19779        let local_var_error = ResponseContent {
19780            status: local_var_status,
19781            content: local_var_content,
19782            entity: local_var_entity,
19783        };
19784        Err(Error::ResponseError(local_var_error))
19785    }
19786}
19787
19788/// Get a list of virtual circuit termination objects.
19789pub async fn circuits_virtual_circuit_terminations_list(
19790    configuration: &configuration::Configuration,
19791    created: Option<Vec<String>>,
19792    created__empty: Option<Vec<String>>,
19793    created__gt: Option<Vec<String>>,
19794    created__gte: Option<Vec<String>>,
19795    created__lt: Option<Vec<String>>,
19796    created__lte: Option<Vec<String>>,
19797    created__n: Option<Vec<String>>,
19798    created_by_request: Option<&str>,
19799    description: Option<Vec<String>>,
19800    description__empty: Option<bool>,
19801    description__ic: Option<Vec<String>>,
19802    description__ie: Option<Vec<String>>,
19803    description__iew: Option<Vec<String>>,
19804    description__iregex: Option<Vec<String>>,
19805    description__isw: Option<Vec<String>>,
19806    description__n: Option<Vec<String>>,
19807    description__nic: Option<Vec<String>>,
19808    description__nie: Option<Vec<String>>,
19809    description__niew: Option<Vec<String>>,
19810    description__nisw: Option<Vec<String>>,
19811    description__regex: Option<Vec<String>>,
19812    id: Option<Vec<i32>>,
19813    id__empty: Option<bool>,
19814    id__gt: Option<Vec<i32>>,
19815    id__gte: Option<Vec<i32>>,
19816    id__lt: Option<Vec<i32>>,
19817    id__lte: Option<Vec<i32>>,
19818    id__n: Option<Vec<i32>>,
19819    interface_id: Option<Vec<i32>>,
19820    interface_id__n: Option<Vec<i32>>,
19821    last_updated: Option<Vec<String>>,
19822    last_updated__empty: Option<Vec<String>>,
19823    last_updated__gt: Option<Vec<String>>,
19824    last_updated__gte: Option<Vec<String>>,
19825    last_updated__lt: Option<Vec<String>>,
19826    last_updated__lte: Option<Vec<String>>,
19827    last_updated__n: Option<Vec<String>>,
19828    limit: Option<i32>,
19829    modified_by_request: Option<&str>,
19830    offset: Option<i32>,
19831    ordering: Option<&str>,
19832    provider: Option<Vec<String>>,
19833    provider__n: Option<Vec<String>>,
19834    provider_account: Option<Vec<String>>,
19835    provider_account__n: Option<Vec<String>>,
19836    provider_account_id: Option<Vec<i32>>,
19837    provider_account_id__n: Option<Vec<i32>>,
19838    provider_id: Option<Vec<i32>>,
19839    provider_id__n: Option<Vec<i32>>,
19840    provider_network_id: Option<Vec<i32>>,
19841    provider_network_id__n: Option<Vec<i32>>,
19842    q: Option<&str>,
19843    role: Option<Vec<String>>,
19844    role__empty: Option<bool>,
19845    role__ic: Option<Vec<String>>,
19846    role__ie: Option<Vec<String>>,
19847    role__iew: Option<Vec<String>>,
19848    role__iregex: Option<Vec<String>>,
19849    role__isw: Option<Vec<String>>,
19850    role__n: Option<Vec<String>>,
19851    role__nic: Option<Vec<String>>,
19852    role__nie: Option<Vec<String>>,
19853    role__niew: Option<Vec<String>>,
19854    role__nisw: Option<Vec<String>>,
19855    role__regex: Option<Vec<String>>,
19856    tag: Option<Vec<String>>,
19857    tag__n: Option<Vec<String>>,
19858    tag_id: Option<Vec<i32>>,
19859    tag_id__n: Option<Vec<i32>>,
19860    updated_by_request: Option<&str>,
19861    virtual_circuit_id: Option<Vec<i32>>,
19862    virtual_circuit_id__n: Option<Vec<i32>>,
19863) -> Result<
19864    crate::models::PaginatedVirtualCircuitTerminationList,
19865    Error<CircuitsVirtualCircuitTerminationsListError>,
19866> {
19867    let local_var_configuration = configuration;
19868
19869    let local_var_client = &local_var_configuration.client;
19870
19871    let local_var_uri_str = format!(
19872        "{}/api/circuits/virtual-circuit-terminations/",
19873        local_var_configuration.base_path
19874    );
19875    let mut local_var_req_builder =
19876        local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
19877
19878    if let Some(ref local_var_str) = created {
19879        local_var_req_builder = match "multi" {
19880            "multi" => local_var_req_builder.query(
19881                &local_var_str
19882                    .into_iter()
19883                    .map(|p| ("created".to_owned(), p.to_string()))
19884                    .collect::<Vec<(std::string::String, std::string::String)>>(),
19885            ),
19886            _ => local_var_req_builder.query(&[(
19887                "created",
19888                &local_var_str
19889                    .into_iter()
19890                    .map(|p| p.to_string())
19891                    .collect::<Vec<String>>()
19892                    .join(",")
19893                    .to_string(),
19894            )]),
19895        };
19896    }
19897    if let Some(ref local_var_str) = created__empty {
19898        local_var_req_builder = match "multi" {
19899            "multi" => local_var_req_builder.query(
19900                &local_var_str
19901                    .into_iter()
19902                    .map(|p| ("created__empty".to_owned(), p.to_string()))
19903                    .collect::<Vec<(std::string::String, std::string::String)>>(),
19904            ),
19905            _ => local_var_req_builder.query(&[(
19906                "created__empty",
19907                &local_var_str
19908                    .into_iter()
19909                    .map(|p| p.to_string())
19910                    .collect::<Vec<String>>()
19911                    .join(",")
19912                    .to_string(),
19913            )]),
19914        };
19915    }
19916    if let Some(ref local_var_str) = created__gt {
19917        local_var_req_builder = match "multi" {
19918            "multi" => local_var_req_builder.query(
19919                &local_var_str
19920                    .into_iter()
19921                    .map(|p| ("created__gt".to_owned(), p.to_string()))
19922                    .collect::<Vec<(std::string::String, std::string::String)>>(),
19923            ),
19924            _ => local_var_req_builder.query(&[(
19925                "created__gt",
19926                &local_var_str
19927                    .into_iter()
19928                    .map(|p| p.to_string())
19929                    .collect::<Vec<String>>()
19930                    .join(",")
19931                    .to_string(),
19932            )]),
19933        };
19934    }
19935    if let Some(ref local_var_str) = created__gte {
19936        local_var_req_builder = match "multi" {
19937            "multi" => local_var_req_builder.query(
19938                &local_var_str
19939                    .into_iter()
19940                    .map(|p| ("created__gte".to_owned(), p.to_string()))
19941                    .collect::<Vec<(std::string::String, std::string::String)>>(),
19942            ),
19943            _ => local_var_req_builder.query(&[(
19944                "created__gte",
19945                &local_var_str
19946                    .into_iter()
19947                    .map(|p| p.to_string())
19948                    .collect::<Vec<String>>()
19949                    .join(",")
19950                    .to_string(),
19951            )]),
19952        };
19953    }
19954    if let Some(ref local_var_str) = created__lt {
19955        local_var_req_builder = match "multi" {
19956            "multi" => local_var_req_builder.query(
19957                &local_var_str
19958                    .into_iter()
19959                    .map(|p| ("created__lt".to_owned(), p.to_string()))
19960                    .collect::<Vec<(std::string::String, std::string::String)>>(),
19961            ),
19962            _ => local_var_req_builder.query(&[(
19963                "created__lt",
19964                &local_var_str
19965                    .into_iter()
19966                    .map(|p| p.to_string())
19967                    .collect::<Vec<String>>()
19968                    .join(",")
19969                    .to_string(),
19970            )]),
19971        };
19972    }
19973    if let Some(ref local_var_str) = created__lte {
19974        local_var_req_builder = match "multi" {
19975            "multi" => local_var_req_builder.query(
19976                &local_var_str
19977                    .into_iter()
19978                    .map(|p| ("created__lte".to_owned(), p.to_string()))
19979                    .collect::<Vec<(std::string::String, std::string::String)>>(),
19980            ),
19981            _ => local_var_req_builder.query(&[(
19982                "created__lte",
19983                &local_var_str
19984                    .into_iter()
19985                    .map(|p| p.to_string())
19986                    .collect::<Vec<String>>()
19987                    .join(",")
19988                    .to_string(),
19989            )]),
19990        };
19991    }
19992    if let Some(ref local_var_str) = created__n {
19993        local_var_req_builder = match "multi" {
19994            "multi" => local_var_req_builder.query(
19995                &local_var_str
19996                    .into_iter()
19997                    .map(|p| ("created__n".to_owned(), p.to_string()))
19998                    .collect::<Vec<(std::string::String, std::string::String)>>(),
19999            ),
20000            _ => local_var_req_builder.query(&[(
20001                "created__n",
20002                &local_var_str
20003                    .into_iter()
20004                    .map(|p| p.to_string())
20005                    .collect::<Vec<String>>()
20006                    .join(",")
20007                    .to_string(),
20008            )]),
20009        };
20010    }
20011    if let Some(ref local_var_str) = created_by_request {
20012        local_var_req_builder =
20013            local_var_req_builder.query(&[("created_by_request", &local_var_str.to_string())]);
20014    }
20015    if let Some(ref local_var_str) = description {
20016        local_var_req_builder = match "multi" {
20017            "multi" => local_var_req_builder.query(
20018                &local_var_str
20019                    .into_iter()
20020                    .map(|p| ("description".to_owned(), p.to_string()))
20021                    .collect::<Vec<(std::string::String, std::string::String)>>(),
20022            ),
20023            _ => local_var_req_builder.query(&[(
20024                "description",
20025                &local_var_str
20026                    .into_iter()
20027                    .map(|p| p.to_string())
20028                    .collect::<Vec<String>>()
20029                    .join(",")
20030                    .to_string(),
20031            )]),
20032        };
20033    }
20034    if let Some(ref local_var_str) = description__empty {
20035        local_var_req_builder =
20036            local_var_req_builder.query(&[("description__empty", &local_var_str.to_string())]);
20037    }
20038    if let Some(ref local_var_str) = description__ic {
20039        local_var_req_builder = match "multi" {
20040            "multi" => local_var_req_builder.query(
20041                &local_var_str
20042                    .into_iter()
20043                    .map(|p| ("description__ic".to_owned(), p.to_string()))
20044                    .collect::<Vec<(std::string::String, std::string::String)>>(),
20045            ),
20046            _ => local_var_req_builder.query(&[(
20047                "description__ic",
20048                &local_var_str
20049                    .into_iter()
20050                    .map(|p| p.to_string())
20051                    .collect::<Vec<String>>()
20052                    .join(",")
20053                    .to_string(),
20054            )]),
20055        };
20056    }
20057    if let Some(ref local_var_str) = description__ie {
20058        local_var_req_builder = match "multi" {
20059            "multi" => local_var_req_builder.query(
20060                &local_var_str
20061                    .into_iter()
20062                    .map(|p| ("description__ie".to_owned(), p.to_string()))
20063                    .collect::<Vec<(std::string::String, std::string::String)>>(),
20064            ),
20065            _ => local_var_req_builder.query(&[(
20066                "description__ie",
20067                &local_var_str
20068                    .into_iter()
20069                    .map(|p| p.to_string())
20070                    .collect::<Vec<String>>()
20071                    .join(",")
20072                    .to_string(),
20073            )]),
20074        };
20075    }
20076    if let Some(ref local_var_str) = description__iew {
20077        local_var_req_builder = match "multi" {
20078            "multi" => local_var_req_builder.query(
20079                &local_var_str
20080                    .into_iter()
20081                    .map(|p| ("description__iew".to_owned(), p.to_string()))
20082                    .collect::<Vec<(std::string::String, std::string::String)>>(),
20083            ),
20084            _ => local_var_req_builder.query(&[(
20085                "description__iew",
20086                &local_var_str
20087                    .into_iter()
20088                    .map(|p| p.to_string())
20089                    .collect::<Vec<String>>()
20090                    .join(",")
20091                    .to_string(),
20092            )]),
20093        };
20094    }
20095    if let Some(ref local_var_str) = description__iregex {
20096        local_var_req_builder = match "multi" {
20097            "multi" => local_var_req_builder.query(
20098                &local_var_str
20099                    .into_iter()
20100                    .map(|p| ("description__iregex".to_owned(), p.to_string()))
20101                    .collect::<Vec<(std::string::String, std::string::String)>>(),
20102            ),
20103            _ => local_var_req_builder.query(&[(
20104                "description__iregex",
20105                &local_var_str
20106                    .into_iter()
20107                    .map(|p| p.to_string())
20108                    .collect::<Vec<String>>()
20109                    .join(",")
20110                    .to_string(),
20111            )]),
20112        };
20113    }
20114    if let Some(ref local_var_str) = description__isw {
20115        local_var_req_builder = match "multi" {
20116            "multi" => local_var_req_builder.query(
20117                &local_var_str
20118                    .into_iter()
20119                    .map(|p| ("description__isw".to_owned(), p.to_string()))
20120                    .collect::<Vec<(std::string::String, std::string::String)>>(),
20121            ),
20122            _ => local_var_req_builder.query(&[(
20123                "description__isw",
20124                &local_var_str
20125                    .into_iter()
20126                    .map(|p| p.to_string())
20127                    .collect::<Vec<String>>()
20128                    .join(",")
20129                    .to_string(),
20130            )]),
20131        };
20132    }
20133    if let Some(ref local_var_str) = description__n {
20134        local_var_req_builder = match "multi" {
20135            "multi" => local_var_req_builder.query(
20136                &local_var_str
20137                    .into_iter()
20138                    .map(|p| ("description__n".to_owned(), p.to_string()))
20139                    .collect::<Vec<(std::string::String, std::string::String)>>(),
20140            ),
20141            _ => local_var_req_builder.query(&[(
20142                "description__n",
20143                &local_var_str
20144                    .into_iter()
20145                    .map(|p| p.to_string())
20146                    .collect::<Vec<String>>()
20147                    .join(",")
20148                    .to_string(),
20149            )]),
20150        };
20151    }
20152    if let Some(ref local_var_str) = description__nic {
20153        local_var_req_builder = match "multi" {
20154            "multi" => local_var_req_builder.query(
20155                &local_var_str
20156                    .into_iter()
20157                    .map(|p| ("description__nic".to_owned(), p.to_string()))
20158                    .collect::<Vec<(std::string::String, std::string::String)>>(),
20159            ),
20160            _ => local_var_req_builder.query(&[(
20161                "description__nic",
20162                &local_var_str
20163                    .into_iter()
20164                    .map(|p| p.to_string())
20165                    .collect::<Vec<String>>()
20166                    .join(",")
20167                    .to_string(),
20168            )]),
20169        };
20170    }
20171    if let Some(ref local_var_str) = description__nie {
20172        local_var_req_builder = match "multi" {
20173            "multi" => local_var_req_builder.query(
20174                &local_var_str
20175                    .into_iter()
20176                    .map(|p| ("description__nie".to_owned(), p.to_string()))
20177                    .collect::<Vec<(std::string::String, std::string::String)>>(),
20178            ),
20179            _ => local_var_req_builder.query(&[(
20180                "description__nie",
20181                &local_var_str
20182                    .into_iter()
20183                    .map(|p| p.to_string())
20184                    .collect::<Vec<String>>()
20185                    .join(",")
20186                    .to_string(),
20187            )]),
20188        };
20189    }
20190    if let Some(ref local_var_str) = description__niew {
20191        local_var_req_builder = match "multi" {
20192            "multi" => local_var_req_builder.query(
20193                &local_var_str
20194                    .into_iter()
20195                    .map(|p| ("description__niew".to_owned(), p.to_string()))
20196                    .collect::<Vec<(std::string::String, std::string::String)>>(),
20197            ),
20198            _ => local_var_req_builder.query(&[(
20199                "description__niew",
20200                &local_var_str
20201                    .into_iter()
20202                    .map(|p| p.to_string())
20203                    .collect::<Vec<String>>()
20204                    .join(",")
20205                    .to_string(),
20206            )]),
20207        };
20208    }
20209    if let Some(ref local_var_str) = description__nisw {
20210        local_var_req_builder = match "multi" {
20211            "multi" => local_var_req_builder.query(
20212                &local_var_str
20213                    .into_iter()
20214                    .map(|p| ("description__nisw".to_owned(), p.to_string()))
20215                    .collect::<Vec<(std::string::String, std::string::String)>>(),
20216            ),
20217            _ => local_var_req_builder.query(&[(
20218                "description__nisw",
20219                &local_var_str
20220                    .into_iter()
20221                    .map(|p| p.to_string())
20222                    .collect::<Vec<String>>()
20223                    .join(",")
20224                    .to_string(),
20225            )]),
20226        };
20227    }
20228    if let Some(ref local_var_str) = description__regex {
20229        local_var_req_builder = match "multi" {
20230            "multi" => local_var_req_builder.query(
20231                &local_var_str
20232                    .into_iter()
20233                    .map(|p| ("description__regex".to_owned(), p.to_string()))
20234                    .collect::<Vec<(std::string::String, std::string::String)>>(),
20235            ),
20236            _ => local_var_req_builder.query(&[(
20237                "description__regex",
20238                &local_var_str
20239                    .into_iter()
20240                    .map(|p| p.to_string())
20241                    .collect::<Vec<String>>()
20242                    .join(",")
20243                    .to_string(),
20244            )]),
20245        };
20246    }
20247    if let Some(ref local_var_str) = id {
20248        local_var_req_builder = match "multi" {
20249            "multi" => local_var_req_builder.query(
20250                &local_var_str
20251                    .into_iter()
20252                    .map(|p| ("id".to_owned(), p.to_string()))
20253                    .collect::<Vec<(std::string::String, std::string::String)>>(),
20254            ),
20255            _ => local_var_req_builder.query(&[(
20256                "id",
20257                &local_var_str
20258                    .into_iter()
20259                    .map(|p| p.to_string())
20260                    .collect::<Vec<String>>()
20261                    .join(",")
20262                    .to_string(),
20263            )]),
20264        };
20265    }
20266    if let Some(ref local_var_str) = id__empty {
20267        local_var_req_builder =
20268            local_var_req_builder.query(&[("id__empty", &local_var_str.to_string())]);
20269    }
20270    if let Some(ref local_var_str) = id__gt {
20271        local_var_req_builder = match "multi" {
20272            "multi" => local_var_req_builder.query(
20273                &local_var_str
20274                    .into_iter()
20275                    .map(|p| ("id__gt".to_owned(), p.to_string()))
20276                    .collect::<Vec<(std::string::String, std::string::String)>>(),
20277            ),
20278            _ => local_var_req_builder.query(&[(
20279                "id__gt",
20280                &local_var_str
20281                    .into_iter()
20282                    .map(|p| p.to_string())
20283                    .collect::<Vec<String>>()
20284                    .join(",")
20285                    .to_string(),
20286            )]),
20287        };
20288    }
20289    if let Some(ref local_var_str) = id__gte {
20290        local_var_req_builder = match "multi" {
20291            "multi" => local_var_req_builder.query(
20292                &local_var_str
20293                    .into_iter()
20294                    .map(|p| ("id__gte".to_owned(), p.to_string()))
20295                    .collect::<Vec<(std::string::String, std::string::String)>>(),
20296            ),
20297            _ => local_var_req_builder.query(&[(
20298                "id__gte",
20299                &local_var_str
20300                    .into_iter()
20301                    .map(|p| p.to_string())
20302                    .collect::<Vec<String>>()
20303                    .join(",")
20304                    .to_string(),
20305            )]),
20306        };
20307    }
20308    if let Some(ref local_var_str) = id__lt {
20309        local_var_req_builder = match "multi" {
20310            "multi" => local_var_req_builder.query(
20311                &local_var_str
20312                    .into_iter()
20313                    .map(|p| ("id__lt".to_owned(), p.to_string()))
20314                    .collect::<Vec<(std::string::String, std::string::String)>>(),
20315            ),
20316            _ => local_var_req_builder.query(&[(
20317                "id__lt",
20318                &local_var_str
20319                    .into_iter()
20320                    .map(|p| p.to_string())
20321                    .collect::<Vec<String>>()
20322                    .join(",")
20323                    .to_string(),
20324            )]),
20325        };
20326    }
20327    if let Some(ref local_var_str) = id__lte {
20328        local_var_req_builder = match "multi" {
20329            "multi" => local_var_req_builder.query(
20330                &local_var_str
20331                    .into_iter()
20332                    .map(|p| ("id__lte".to_owned(), p.to_string()))
20333                    .collect::<Vec<(std::string::String, std::string::String)>>(),
20334            ),
20335            _ => local_var_req_builder.query(&[(
20336                "id__lte",
20337                &local_var_str
20338                    .into_iter()
20339                    .map(|p| p.to_string())
20340                    .collect::<Vec<String>>()
20341                    .join(",")
20342                    .to_string(),
20343            )]),
20344        };
20345    }
20346    if let Some(ref local_var_str) = id__n {
20347        local_var_req_builder = match "multi" {
20348            "multi" => local_var_req_builder.query(
20349                &local_var_str
20350                    .into_iter()
20351                    .map(|p| ("id__n".to_owned(), p.to_string()))
20352                    .collect::<Vec<(std::string::String, std::string::String)>>(),
20353            ),
20354            _ => local_var_req_builder.query(&[(
20355                "id__n",
20356                &local_var_str
20357                    .into_iter()
20358                    .map(|p| p.to_string())
20359                    .collect::<Vec<String>>()
20360                    .join(",")
20361                    .to_string(),
20362            )]),
20363        };
20364    }
20365    if let Some(ref local_var_str) = interface_id {
20366        local_var_req_builder = match "multi" {
20367            "multi" => local_var_req_builder.query(
20368                &local_var_str
20369                    .into_iter()
20370                    .map(|p| ("interface_id".to_owned(), p.to_string()))
20371                    .collect::<Vec<(std::string::String, std::string::String)>>(),
20372            ),
20373            _ => local_var_req_builder.query(&[(
20374                "interface_id",
20375                &local_var_str
20376                    .into_iter()
20377                    .map(|p| p.to_string())
20378                    .collect::<Vec<String>>()
20379                    .join(",")
20380                    .to_string(),
20381            )]),
20382        };
20383    }
20384    if let Some(ref local_var_str) = interface_id__n {
20385        local_var_req_builder = match "multi" {
20386            "multi" => local_var_req_builder.query(
20387                &local_var_str
20388                    .into_iter()
20389                    .map(|p| ("interface_id__n".to_owned(), p.to_string()))
20390                    .collect::<Vec<(std::string::String, std::string::String)>>(),
20391            ),
20392            _ => local_var_req_builder.query(&[(
20393                "interface_id__n",
20394                &local_var_str
20395                    .into_iter()
20396                    .map(|p| p.to_string())
20397                    .collect::<Vec<String>>()
20398                    .join(",")
20399                    .to_string(),
20400            )]),
20401        };
20402    }
20403    if let Some(ref local_var_str) = last_updated {
20404        local_var_req_builder = match "multi" {
20405            "multi" => local_var_req_builder.query(
20406                &local_var_str
20407                    .into_iter()
20408                    .map(|p| ("last_updated".to_owned(), p.to_string()))
20409                    .collect::<Vec<(std::string::String, std::string::String)>>(),
20410            ),
20411            _ => local_var_req_builder.query(&[(
20412                "last_updated",
20413                &local_var_str
20414                    .into_iter()
20415                    .map(|p| p.to_string())
20416                    .collect::<Vec<String>>()
20417                    .join(",")
20418                    .to_string(),
20419            )]),
20420        };
20421    }
20422    if let Some(ref local_var_str) = last_updated__empty {
20423        local_var_req_builder = match "multi" {
20424            "multi" => local_var_req_builder.query(
20425                &local_var_str
20426                    .into_iter()
20427                    .map(|p| ("last_updated__empty".to_owned(), p.to_string()))
20428                    .collect::<Vec<(std::string::String, std::string::String)>>(),
20429            ),
20430            _ => local_var_req_builder.query(&[(
20431                "last_updated__empty",
20432                &local_var_str
20433                    .into_iter()
20434                    .map(|p| p.to_string())
20435                    .collect::<Vec<String>>()
20436                    .join(",")
20437                    .to_string(),
20438            )]),
20439        };
20440    }
20441    if let Some(ref local_var_str) = last_updated__gt {
20442        local_var_req_builder = match "multi" {
20443            "multi" => local_var_req_builder.query(
20444                &local_var_str
20445                    .into_iter()
20446                    .map(|p| ("last_updated__gt".to_owned(), p.to_string()))
20447                    .collect::<Vec<(std::string::String, std::string::String)>>(),
20448            ),
20449            _ => local_var_req_builder.query(&[(
20450                "last_updated__gt",
20451                &local_var_str
20452                    .into_iter()
20453                    .map(|p| p.to_string())
20454                    .collect::<Vec<String>>()
20455                    .join(",")
20456                    .to_string(),
20457            )]),
20458        };
20459    }
20460    if let Some(ref local_var_str) = last_updated__gte {
20461        local_var_req_builder = match "multi" {
20462            "multi" => local_var_req_builder.query(
20463                &local_var_str
20464                    .into_iter()
20465                    .map(|p| ("last_updated__gte".to_owned(), p.to_string()))
20466                    .collect::<Vec<(std::string::String, std::string::String)>>(),
20467            ),
20468            _ => local_var_req_builder.query(&[(
20469                "last_updated__gte",
20470                &local_var_str
20471                    .into_iter()
20472                    .map(|p| p.to_string())
20473                    .collect::<Vec<String>>()
20474                    .join(",")
20475                    .to_string(),
20476            )]),
20477        };
20478    }
20479    if let Some(ref local_var_str) = last_updated__lt {
20480        local_var_req_builder = match "multi" {
20481            "multi" => local_var_req_builder.query(
20482                &local_var_str
20483                    .into_iter()
20484                    .map(|p| ("last_updated__lt".to_owned(), p.to_string()))
20485                    .collect::<Vec<(std::string::String, std::string::String)>>(),
20486            ),
20487            _ => local_var_req_builder.query(&[(
20488                "last_updated__lt",
20489                &local_var_str
20490                    .into_iter()
20491                    .map(|p| p.to_string())
20492                    .collect::<Vec<String>>()
20493                    .join(",")
20494                    .to_string(),
20495            )]),
20496        };
20497    }
20498    if let Some(ref local_var_str) = last_updated__lte {
20499        local_var_req_builder = match "multi" {
20500            "multi" => local_var_req_builder.query(
20501                &local_var_str
20502                    .into_iter()
20503                    .map(|p| ("last_updated__lte".to_owned(), p.to_string()))
20504                    .collect::<Vec<(std::string::String, std::string::String)>>(),
20505            ),
20506            _ => local_var_req_builder.query(&[(
20507                "last_updated__lte",
20508                &local_var_str
20509                    .into_iter()
20510                    .map(|p| p.to_string())
20511                    .collect::<Vec<String>>()
20512                    .join(",")
20513                    .to_string(),
20514            )]),
20515        };
20516    }
20517    if let Some(ref local_var_str) = last_updated__n {
20518        local_var_req_builder = match "multi" {
20519            "multi" => local_var_req_builder.query(
20520                &local_var_str
20521                    .into_iter()
20522                    .map(|p| ("last_updated__n".to_owned(), p.to_string()))
20523                    .collect::<Vec<(std::string::String, std::string::String)>>(),
20524            ),
20525            _ => local_var_req_builder.query(&[(
20526                "last_updated__n",
20527                &local_var_str
20528                    .into_iter()
20529                    .map(|p| p.to_string())
20530                    .collect::<Vec<String>>()
20531                    .join(",")
20532                    .to_string(),
20533            )]),
20534        };
20535    }
20536    if let Some(ref local_var_str) = limit {
20537        local_var_req_builder =
20538            local_var_req_builder.query(&[("limit", &local_var_str.to_string())]);
20539    }
20540    if let Some(ref local_var_str) = modified_by_request {
20541        local_var_req_builder =
20542            local_var_req_builder.query(&[("modified_by_request", &local_var_str.to_string())]);
20543    }
20544    if let Some(ref local_var_str) = offset {
20545        local_var_req_builder =
20546            local_var_req_builder.query(&[("offset", &local_var_str.to_string())]);
20547    }
20548    if let Some(ref local_var_str) = ordering {
20549        local_var_req_builder =
20550            local_var_req_builder.query(&[("ordering", &local_var_str.to_string())]);
20551    }
20552    if let Some(ref local_var_str) = provider {
20553        local_var_req_builder = match "multi" {
20554            "multi" => local_var_req_builder.query(
20555                &local_var_str
20556                    .into_iter()
20557                    .map(|p| ("provider".to_owned(), p.to_string()))
20558                    .collect::<Vec<(std::string::String, std::string::String)>>(),
20559            ),
20560            _ => local_var_req_builder.query(&[(
20561                "provider",
20562                &local_var_str
20563                    .into_iter()
20564                    .map(|p| p.to_string())
20565                    .collect::<Vec<String>>()
20566                    .join(",")
20567                    .to_string(),
20568            )]),
20569        };
20570    }
20571    if let Some(ref local_var_str) = provider__n {
20572        local_var_req_builder = match "multi" {
20573            "multi" => local_var_req_builder.query(
20574                &local_var_str
20575                    .into_iter()
20576                    .map(|p| ("provider__n".to_owned(), p.to_string()))
20577                    .collect::<Vec<(std::string::String, std::string::String)>>(),
20578            ),
20579            _ => local_var_req_builder.query(&[(
20580                "provider__n",
20581                &local_var_str
20582                    .into_iter()
20583                    .map(|p| p.to_string())
20584                    .collect::<Vec<String>>()
20585                    .join(",")
20586                    .to_string(),
20587            )]),
20588        };
20589    }
20590    if let Some(ref local_var_str) = provider_account {
20591        local_var_req_builder = match "multi" {
20592            "multi" => local_var_req_builder.query(
20593                &local_var_str
20594                    .into_iter()
20595                    .map(|p| ("provider_account".to_owned(), p.to_string()))
20596                    .collect::<Vec<(std::string::String, std::string::String)>>(),
20597            ),
20598            _ => local_var_req_builder.query(&[(
20599                "provider_account",
20600                &local_var_str
20601                    .into_iter()
20602                    .map(|p| p.to_string())
20603                    .collect::<Vec<String>>()
20604                    .join(",")
20605                    .to_string(),
20606            )]),
20607        };
20608    }
20609    if let Some(ref local_var_str) = provider_account__n {
20610        local_var_req_builder = match "multi" {
20611            "multi" => local_var_req_builder.query(
20612                &local_var_str
20613                    .into_iter()
20614                    .map(|p| ("provider_account__n".to_owned(), p.to_string()))
20615                    .collect::<Vec<(std::string::String, std::string::String)>>(),
20616            ),
20617            _ => local_var_req_builder.query(&[(
20618                "provider_account__n",
20619                &local_var_str
20620                    .into_iter()
20621                    .map(|p| p.to_string())
20622                    .collect::<Vec<String>>()
20623                    .join(",")
20624                    .to_string(),
20625            )]),
20626        };
20627    }
20628    if let Some(ref local_var_str) = provider_account_id {
20629        local_var_req_builder = match "multi" {
20630            "multi" => local_var_req_builder.query(
20631                &local_var_str
20632                    .into_iter()
20633                    .map(|p| ("provider_account_id".to_owned(), p.to_string()))
20634                    .collect::<Vec<(std::string::String, std::string::String)>>(),
20635            ),
20636            _ => local_var_req_builder.query(&[(
20637                "provider_account_id",
20638                &local_var_str
20639                    .into_iter()
20640                    .map(|p| p.to_string())
20641                    .collect::<Vec<String>>()
20642                    .join(",")
20643                    .to_string(),
20644            )]),
20645        };
20646    }
20647    if let Some(ref local_var_str) = provider_account_id__n {
20648        local_var_req_builder = match "multi" {
20649            "multi" => local_var_req_builder.query(
20650                &local_var_str
20651                    .into_iter()
20652                    .map(|p| ("provider_account_id__n".to_owned(), p.to_string()))
20653                    .collect::<Vec<(std::string::String, std::string::String)>>(),
20654            ),
20655            _ => local_var_req_builder.query(&[(
20656                "provider_account_id__n",
20657                &local_var_str
20658                    .into_iter()
20659                    .map(|p| p.to_string())
20660                    .collect::<Vec<String>>()
20661                    .join(",")
20662                    .to_string(),
20663            )]),
20664        };
20665    }
20666    if let Some(ref local_var_str) = provider_id {
20667        local_var_req_builder = match "multi" {
20668            "multi" => local_var_req_builder.query(
20669                &local_var_str
20670                    .into_iter()
20671                    .map(|p| ("provider_id".to_owned(), p.to_string()))
20672                    .collect::<Vec<(std::string::String, std::string::String)>>(),
20673            ),
20674            _ => local_var_req_builder.query(&[(
20675                "provider_id",
20676                &local_var_str
20677                    .into_iter()
20678                    .map(|p| p.to_string())
20679                    .collect::<Vec<String>>()
20680                    .join(",")
20681                    .to_string(),
20682            )]),
20683        };
20684    }
20685    if let Some(ref local_var_str) = provider_id__n {
20686        local_var_req_builder = match "multi" {
20687            "multi" => local_var_req_builder.query(
20688                &local_var_str
20689                    .into_iter()
20690                    .map(|p| ("provider_id__n".to_owned(), p.to_string()))
20691                    .collect::<Vec<(std::string::String, std::string::String)>>(),
20692            ),
20693            _ => local_var_req_builder.query(&[(
20694                "provider_id__n",
20695                &local_var_str
20696                    .into_iter()
20697                    .map(|p| p.to_string())
20698                    .collect::<Vec<String>>()
20699                    .join(",")
20700                    .to_string(),
20701            )]),
20702        };
20703    }
20704    if let Some(ref local_var_str) = provider_network_id {
20705        local_var_req_builder = match "multi" {
20706            "multi" => local_var_req_builder.query(
20707                &local_var_str
20708                    .into_iter()
20709                    .map(|p| ("provider_network_id".to_owned(), p.to_string()))
20710                    .collect::<Vec<(std::string::String, std::string::String)>>(),
20711            ),
20712            _ => local_var_req_builder.query(&[(
20713                "provider_network_id",
20714                &local_var_str
20715                    .into_iter()
20716                    .map(|p| p.to_string())
20717                    .collect::<Vec<String>>()
20718                    .join(",")
20719                    .to_string(),
20720            )]),
20721        };
20722    }
20723    if let Some(ref local_var_str) = provider_network_id__n {
20724        local_var_req_builder = match "multi" {
20725            "multi" => local_var_req_builder.query(
20726                &local_var_str
20727                    .into_iter()
20728                    .map(|p| ("provider_network_id__n".to_owned(), p.to_string()))
20729                    .collect::<Vec<(std::string::String, std::string::String)>>(),
20730            ),
20731            _ => local_var_req_builder.query(&[(
20732                "provider_network_id__n",
20733                &local_var_str
20734                    .into_iter()
20735                    .map(|p| p.to_string())
20736                    .collect::<Vec<String>>()
20737                    .join(",")
20738                    .to_string(),
20739            )]),
20740        };
20741    }
20742    if let Some(ref local_var_str) = q {
20743        local_var_req_builder = local_var_req_builder.query(&[("q", &local_var_str.to_string())]);
20744    }
20745    if let Some(ref local_var_str) = role {
20746        local_var_req_builder = match "multi" {
20747            "multi" => local_var_req_builder.query(
20748                &local_var_str
20749                    .into_iter()
20750                    .map(|p| ("role".to_owned(), p.to_string()))
20751                    .collect::<Vec<(std::string::String, std::string::String)>>(),
20752            ),
20753            _ => local_var_req_builder.query(&[(
20754                "role",
20755                &local_var_str
20756                    .into_iter()
20757                    .map(|p| p.to_string())
20758                    .collect::<Vec<String>>()
20759                    .join(",")
20760                    .to_string(),
20761            )]),
20762        };
20763    }
20764    if let Some(ref local_var_str) = role__empty {
20765        local_var_req_builder =
20766            local_var_req_builder.query(&[("role__empty", &local_var_str.to_string())]);
20767    }
20768    if let Some(ref local_var_str) = role__ic {
20769        local_var_req_builder = match "multi" {
20770            "multi" => local_var_req_builder.query(
20771                &local_var_str
20772                    .into_iter()
20773                    .map(|p| ("role__ic".to_owned(), p.to_string()))
20774                    .collect::<Vec<(std::string::String, std::string::String)>>(),
20775            ),
20776            _ => local_var_req_builder.query(&[(
20777                "role__ic",
20778                &local_var_str
20779                    .into_iter()
20780                    .map(|p| p.to_string())
20781                    .collect::<Vec<String>>()
20782                    .join(",")
20783                    .to_string(),
20784            )]),
20785        };
20786    }
20787    if let Some(ref local_var_str) = role__ie {
20788        local_var_req_builder = match "multi" {
20789            "multi" => local_var_req_builder.query(
20790                &local_var_str
20791                    .into_iter()
20792                    .map(|p| ("role__ie".to_owned(), p.to_string()))
20793                    .collect::<Vec<(std::string::String, std::string::String)>>(),
20794            ),
20795            _ => local_var_req_builder.query(&[(
20796                "role__ie",
20797                &local_var_str
20798                    .into_iter()
20799                    .map(|p| p.to_string())
20800                    .collect::<Vec<String>>()
20801                    .join(",")
20802                    .to_string(),
20803            )]),
20804        };
20805    }
20806    if let Some(ref local_var_str) = role__iew {
20807        local_var_req_builder = match "multi" {
20808            "multi" => local_var_req_builder.query(
20809                &local_var_str
20810                    .into_iter()
20811                    .map(|p| ("role__iew".to_owned(), p.to_string()))
20812                    .collect::<Vec<(std::string::String, std::string::String)>>(),
20813            ),
20814            _ => local_var_req_builder.query(&[(
20815                "role__iew",
20816                &local_var_str
20817                    .into_iter()
20818                    .map(|p| p.to_string())
20819                    .collect::<Vec<String>>()
20820                    .join(",")
20821                    .to_string(),
20822            )]),
20823        };
20824    }
20825    if let Some(ref local_var_str) = role__iregex {
20826        local_var_req_builder = match "multi" {
20827            "multi" => local_var_req_builder.query(
20828                &local_var_str
20829                    .into_iter()
20830                    .map(|p| ("role__iregex".to_owned(), p.to_string()))
20831                    .collect::<Vec<(std::string::String, std::string::String)>>(),
20832            ),
20833            _ => local_var_req_builder.query(&[(
20834                "role__iregex",
20835                &local_var_str
20836                    .into_iter()
20837                    .map(|p| p.to_string())
20838                    .collect::<Vec<String>>()
20839                    .join(",")
20840                    .to_string(),
20841            )]),
20842        };
20843    }
20844    if let Some(ref local_var_str) = role__isw {
20845        local_var_req_builder = match "multi" {
20846            "multi" => local_var_req_builder.query(
20847                &local_var_str
20848                    .into_iter()
20849                    .map(|p| ("role__isw".to_owned(), p.to_string()))
20850                    .collect::<Vec<(std::string::String, std::string::String)>>(),
20851            ),
20852            _ => local_var_req_builder.query(&[(
20853                "role__isw",
20854                &local_var_str
20855                    .into_iter()
20856                    .map(|p| p.to_string())
20857                    .collect::<Vec<String>>()
20858                    .join(",")
20859                    .to_string(),
20860            )]),
20861        };
20862    }
20863    if let Some(ref local_var_str) = role__n {
20864        local_var_req_builder = match "multi" {
20865            "multi" => local_var_req_builder.query(
20866                &local_var_str
20867                    .into_iter()
20868                    .map(|p| ("role__n".to_owned(), p.to_string()))
20869                    .collect::<Vec<(std::string::String, std::string::String)>>(),
20870            ),
20871            _ => local_var_req_builder.query(&[(
20872                "role__n",
20873                &local_var_str
20874                    .into_iter()
20875                    .map(|p| p.to_string())
20876                    .collect::<Vec<String>>()
20877                    .join(",")
20878                    .to_string(),
20879            )]),
20880        };
20881    }
20882    if let Some(ref local_var_str) = role__nic {
20883        local_var_req_builder = match "multi" {
20884            "multi" => local_var_req_builder.query(
20885                &local_var_str
20886                    .into_iter()
20887                    .map(|p| ("role__nic".to_owned(), p.to_string()))
20888                    .collect::<Vec<(std::string::String, std::string::String)>>(),
20889            ),
20890            _ => local_var_req_builder.query(&[(
20891                "role__nic",
20892                &local_var_str
20893                    .into_iter()
20894                    .map(|p| p.to_string())
20895                    .collect::<Vec<String>>()
20896                    .join(",")
20897                    .to_string(),
20898            )]),
20899        };
20900    }
20901    if let Some(ref local_var_str) = role__nie {
20902        local_var_req_builder = match "multi" {
20903            "multi" => local_var_req_builder.query(
20904                &local_var_str
20905                    .into_iter()
20906                    .map(|p| ("role__nie".to_owned(), p.to_string()))
20907                    .collect::<Vec<(std::string::String, std::string::String)>>(),
20908            ),
20909            _ => local_var_req_builder.query(&[(
20910                "role__nie",
20911                &local_var_str
20912                    .into_iter()
20913                    .map(|p| p.to_string())
20914                    .collect::<Vec<String>>()
20915                    .join(",")
20916                    .to_string(),
20917            )]),
20918        };
20919    }
20920    if let Some(ref local_var_str) = role__niew {
20921        local_var_req_builder = match "multi" {
20922            "multi" => local_var_req_builder.query(
20923                &local_var_str
20924                    .into_iter()
20925                    .map(|p| ("role__niew".to_owned(), p.to_string()))
20926                    .collect::<Vec<(std::string::String, std::string::String)>>(),
20927            ),
20928            _ => local_var_req_builder.query(&[(
20929                "role__niew",
20930                &local_var_str
20931                    .into_iter()
20932                    .map(|p| p.to_string())
20933                    .collect::<Vec<String>>()
20934                    .join(",")
20935                    .to_string(),
20936            )]),
20937        };
20938    }
20939    if let Some(ref local_var_str) = role__nisw {
20940        local_var_req_builder = match "multi" {
20941            "multi" => local_var_req_builder.query(
20942                &local_var_str
20943                    .into_iter()
20944                    .map(|p| ("role__nisw".to_owned(), p.to_string()))
20945                    .collect::<Vec<(std::string::String, std::string::String)>>(),
20946            ),
20947            _ => local_var_req_builder.query(&[(
20948                "role__nisw",
20949                &local_var_str
20950                    .into_iter()
20951                    .map(|p| p.to_string())
20952                    .collect::<Vec<String>>()
20953                    .join(",")
20954                    .to_string(),
20955            )]),
20956        };
20957    }
20958    if let Some(ref local_var_str) = role__regex {
20959        local_var_req_builder = match "multi" {
20960            "multi" => local_var_req_builder.query(
20961                &local_var_str
20962                    .into_iter()
20963                    .map(|p| ("role__regex".to_owned(), p.to_string()))
20964                    .collect::<Vec<(std::string::String, std::string::String)>>(),
20965            ),
20966            _ => local_var_req_builder.query(&[(
20967                "role__regex",
20968                &local_var_str
20969                    .into_iter()
20970                    .map(|p| p.to_string())
20971                    .collect::<Vec<String>>()
20972                    .join(",")
20973                    .to_string(),
20974            )]),
20975        };
20976    }
20977    if let Some(ref local_var_str) = tag {
20978        local_var_req_builder = match "multi" {
20979            "multi" => local_var_req_builder.query(
20980                &local_var_str
20981                    .into_iter()
20982                    .map(|p| ("tag".to_owned(), p.to_string()))
20983                    .collect::<Vec<(std::string::String, std::string::String)>>(),
20984            ),
20985            _ => local_var_req_builder.query(&[(
20986                "tag",
20987                &local_var_str
20988                    .into_iter()
20989                    .map(|p| p.to_string())
20990                    .collect::<Vec<String>>()
20991                    .join(",")
20992                    .to_string(),
20993            )]),
20994        };
20995    }
20996    if let Some(ref local_var_str) = tag__n {
20997        local_var_req_builder = match "multi" {
20998            "multi" => local_var_req_builder.query(
20999                &local_var_str
21000                    .into_iter()
21001                    .map(|p| ("tag__n".to_owned(), p.to_string()))
21002                    .collect::<Vec<(std::string::String, std::string::String)>>(),
21003            ),
21004            _ => local_var_req_builder.query(&[(
21005                "tag__n",
21006                &local_var_str
21007                    .into_iter()
21008                    .map(|p| p.to_string())
21009                    .collect::<Vec<String>>()
21010                    .join(",")
21011                    .to_string(),
21012            )]),
21013        };
21014    }
21015    if let Some(ref local_var_str) = tag_id {
21016        local_var_req_builder = match "multi" {
21017            "multi" => local_var_req_builder.query(
21018                &local_var_str
21019                    .into_iter()
21020                    .map(|p| ("tag_id".to_owned(), p.to_string()))
21021                    .collect::<Vec<(std::string::String, std::string::String)>>(),
21022            ),
21023            _ => local_var_req_builder.query(&[(
21024                "tag_id",
21025                &local_var_str
21026                    .into_iter()
21027                    .map(|p| p.to_string())
21028                    .collect::<Vec<String>>()
21029                    .join(",")
21030                    .to_string(),
21031            )]),
21032        };
21033    }
21034    if let Some(ref local_var_str) = tag_id__n {
21035        local_var_req_builder = match "multi" {
21036            "multi" => local_var_req_builder.query(
21037                &local_var_str
21038                    .into_iter()
21039                    .map(|p| ("tag_id__n".to_owned(), p.to_string()))
21040                    .collect::<Vec<(std::string::String, std::string::String)>>(),
21041            ),
21042            _ => local_var_req_builder.query(&[(
21043                "tag_id__n",
21044                &local_var_str
21045                    .into_iter()
21046                    .map(|p| p.to_string())
21047                    .collect::<Vec<String>>()
21048                    .join(",")
21049                    .to_string(),
21050            )]),
21051        };
21052    }
21053    if let Some(ref local_var_str) = updated_by_request {
21054        local_var_req_builder =
21055            local_var_req_builder.query(&[("updated_by_request", &local_var_str.to_string())]);
21056    }
21057    if let Some(ref local_var_str) = virtual_circuit_id {
21058        local_var_req_builder = match "multi" {
21059            "multi" => local_var_req_builder.query(
21060                &local_var_str
21061                    .into_iter()
21062                    .map(|p| ("virtual_circuit_id".to_owned(), p.to_string()))
21063                    .collect::<Vec<(std::string::String, std::string::String)>>(),
21064            ),
21065            _ => local_var_req_builder.query(&[(
21066                "virtual_circuit_id",
21067                &local_var_str
21068                    .into_iter()
21069                    .map(|p| p.to_string())
21070                    .collect::<Vec<String>>()
21071                    .join(",")
21072                    .to_string(),
21073            )]),
21074        };
21075    }
21076    if let Some(ref local_var_str) = virtual_circuit_id__n {
21077        local_var_req_builder = match "multi" {
21078            "multi" => local_var_req_builder.query(
21079                &local_var_str
21080                    .into_iter()
21081                    .map(|p| ("virtual_circuit_id__n".to_owned(), p.to_string()))
21082                    .collect::<Vec<(std::string::String, std::string::String)>>(),
21083            ),
21084            _ => local_var_req_builder.query(&[(
21085                "virtual_circuit_id__n",
21086                &local_var_str
21087                    .into_iter()
21088                    .map(|p| p.to_string())
21089                    .collect::<Vec<String>>()
21090                    .join(",")
21091                    .to_string(),
21092            )]),
21093        };
21094    }
21095    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
21096        local_var_req_builder =
21097            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
21098    }
21099    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
21100        let local_var_key = local_var_apikey.key.clone();
21101        let local_var_value = match local_var_apikey.prefix {
21102            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
21103            None => local_var_key,
21104        };
21105        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
21106    };
21107
21108    let local_var_req = local_var_req_builder.build()?;
21109    let local_var_resp = local_var_client.execute(local_var_req).await?;
21110
21111    let local_var_status = local_var_resp.status();
21112    let local_var_content = local_var_resp.text().await?;
21113
21114    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
21115        serde_json::from_str(&local_var_content).map_err(Error::from)
21116    } else {
21117        let local_var_entity: Option<CircuitsVirtualCircuitTerminationsListError> =
21118            serde_json::from_str(&local_var_content).ok();
21119        let local_var_error = ResponseContent {
21120            status: local_var_status,
21121            content: local_var_content,
21122            entity: local_var_entity,
21123        };
21124        Err(Error::ResponseError(local_var_error))
21125    }
21126}
21127
21128/// Patch a virtual circuit termination object.
21129pub async fn circuits_virtual_circuit_terminations_partial_update(
21130    configuration: &configuration::Configuration,
21131    id: i32,
21132    patched_writable_virtual_circuit_termination_request: Option<
21133        crate::models::PatchedWritableVirtualCircuitTerminationRequest,
21134    >,
21135) -> Result<
21136    crate::models::VirtualCircuitTermination,
21137    Error<CircuitsVirtualCircuitTerminationsPartialUpdateError>,
21138> {
21139    let local_var_configuration = configuration;
21140
21141    let local_var_client = &local_var_configuration.client;
21142
21143    let local_var_uri_str = format!(
21144        "{}/api/circuits/virtual-circuit-terminations/{id}/",
21145        local_var_configuration.base_path,
21146        id = id
21147    );
21148    let mut local_var_req_builder =
21149        local_var_client.request(reqwest::Method::PATCH, local_var_uri_str.as_str());
21150
21151    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
21152        local_var_req_builder =
21153            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
21154    }
21155    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
21156        let local_var_key = local_var_apikey.key.clone();
21157        let local_var_value = match local_var_apikey.prefix {
21158            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
21159            None => local_var_key,
21160        };
21161        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
21162    };
21163    local_var_req_builder =
21164        local_var_req_builder.json(&patched_writable_virtual_circuit_termination_request);
21165
21166    let local_var_req = local_var_req_builder.build()?;
21167    let local_var_resp = local_var_client.execute(local_var_req).await?;
21168
21169    let local_var_status = local_var_resp.status();
21170    let local_var_content = local_var_resp.text().await?;
21171
21172    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
21173        serde_json::from_str(&local_var_content).map_err(Error::from)
21174    } else {
21175        let local_var_entity: Option<CircuitsVirtualCircuitTerminationsPartialUpdateError> =
21176            serde_json::from_str(&local_var_content).ok();
21177        let local_var_error = ResponseContent {
21178            status: local_var_status,
21179            content: local_var_content,
21180            entity: local_var_entity,
21181        };
21182        Err(Error::ResponseError(local_var_error))
21183    }
21184}
21185
21186/// Return all CablePaths which traverse a given pass-through port.
21187pub async fn circuits_virtual_circuit_terminations_paths_retrieve(
21188    configuration: &configuration::Configuration,
21189    id: i32,
21190) -> Result<
21191    crate::models::VirtualCircuitTermination,
21192    Error<CircuitsVirtualCircuitTerminationsPathsRetrieveError>,
21193> {
21194    let local_var_configuration = configuration;
21195
21196    let local_var_client = &local_var_configuration.client;
21197
21198    let local_var_uri_str = format!(
21199        "{}/api/circuits/virtual-circuit-terminations/{id}/paths/",
21200        local_var_configuration.base_path,
21201        id = id
21202    );
21203    let mut local_var_req_builder =
21204        local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
21205
21206    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
21207        local_var_req_builder =
21208            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
21209    }
21210    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
21211        let local_var_key = local_var_apikey.key.clone();
21212        let local_var_value = match local_var_apikey.prefix {
21213            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
21214            None => local_var_key,
21215        };
21216        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
21217    };
21218
21219    let local_var_req = local_var_req_builder.build()?;
21220    let local_var_resp = local_var_client.execute(local_var_req).await?;
21221
21222    let local_var_status = local_var_resp.status();
21223    let local_var_content = local_var_resp.text().await?;
21224
21225    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
21226        serde_json::from_str(&local_var_content).map_err(Error::from)
21227    } else {
21228        let local_var_entity: Option<CircuitsVirtualCircuitTerminationsPathsRetrieveError> =
21229            serde_json::from_str(&local_var_content).ok();
21230        let local_var_error = ResponseContent {
21231            status: local_var_status,
21232            content: local_var_content,
21233            entity: local_var_entity,
21234        };
21235        Err(Error::ResponseError(local_var_error))
21236    }
21237}
21238
21239/// Get a virtual circuit termination object.
21240pub async fn circuits_virtual_circuit_terminations_retrieve(
21241    configuration: &configuration::Configuration,
21242    id: i32,
21243) -> Result<
21244    crate::models::VirtualCircuitTermination,
21245    Error<CircuitsVirtualCircuitTerminationsRetrieveError>,
21246> {
21247    let local_var_configuration = configuration;
21248
21249    let local_var_client = &local_var_configuration.client;
21250
21251    let local_var_uri_str = format!(
21252        "{}/api/circuits/virtual-circuit-terminations/{id}/",
21253        local_var_configuration.base_path,
21254        id = id
21255    );
21256    let mut local_var_req_builder =
21257        local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
21258
21259    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
21260        local_var_req_builder =
21261            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
21262    }
21263    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
21264        let local_var_key = local_var_apikey.key.clone();
21265        let local_var_value = match local_var_apikey.prefix {
21266            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
21267            None => local_var_key,
21268        };
21269        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
21270    };
21271
21272    let local_var_req = local_var_req_builder.build()?;
21273    let local_var_resp = local_var_client.execute(local_var_req).await?;
21274
21275    let local_var_status = local_var_resp.status();
21276    let local_var_content = local_var_resp.text().await?;
21277
21278    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
21279        serde_json::from_str(&local_var_content).map_err(Error::from)
21280    } else {
21281        let local_var_entity: Option<CircuitsVirtualCircuitTerminationsRetrieveError> =
21282            serde_json::from_str(&local_var_content).ok();
21283        let local_var_error = ResponseContent {
21284            status: local_var_status,
21285            content: local_var_content,
21286            entity: local_var_entity,
21287        };
21288        Err(Error::ResponseError(local_var_error))
21289    }
21290}
21291
21292/// Put a virtual circuit termination object.
21293pub async fn circuits_virtual_circuit_terminations_update(
21294    configuration: &configuration::Configuration,
21295    id: i32,
21296    writable_virtual_circuit_termination_request: crate::models::WritableVirtualCircuitTerminationRequest,
21297) -> Result<
21298    crate::models::VirtualCircuitTermination,
21299    Error<CircuitsVirtualCircuitTerminationsUpdateError>,
21300> {
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        "{}/api/circuits/virtual-circuit-terminations/{id}/",
21307        local_var_configuration.base_path,
21308        id = id
21309    );
21310    let mut local_var_req_builder =
21311        local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());
21312
21313    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
21314        local_var_req_builder =
21315            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
21316    }
21317    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
21318        let local_var_key = local_var_apikey.key.clone();
21319        let local_var_value = match local_var_apikey.prefix {
21320            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
21321            None => local_var_key,
21322        };
21323        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
21324    };
21325    local_var_req_builder =
21326        local_var_req_builder.json(&writable_virtual_circuit_termination_request);
21327
21328    let local_var_req = local_var_req_builder.build()?;
21329    let local_var_resp = local_var_client.execute(local_var_req).await?;
21330
21331    let local_var_status = local_var_resp.status();
21332    let local_var_content = local_var_resp.text().await?;
21333
21334    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
21335        serde_json::from_str(&local_var_content).map_err(Error::from)
21336    } else {
21337        let local_var_entity: Option<CircuitsVirtualCircuitTerminationsUpdateError> =
21338            serde_json::from_str(&local_var_content).ok();
21339        let local_var_error = ResponseContent {
21340            status: local_var_status,
21341            content: local_var_content,
21342            entity: local_var_entity,
21343        };
21344        Err(Error::ResponseError(local_var_error))
21345    }
21346}
21347
21348/// Delete a list of virtual circuit type objects.
21349pub async fn circuits_virtual_circuit_types_bulk_destroy(
21350    configuration: &configuration::Configuration,
21351    virtual_circuit_type_request: Vec<crate::models::VirtualCircuitTypeRequest>,
21352) -> Result<(), Error<CircuitsVirtualCircuitTypesBulkDestroyError>> {
21353    let local_var_configuration = configuration;
21354
21355    let local_var_client = &local_var_configuration.client;
21356
21357    let local_var_uri_str = format!(
21358        "{}/api/circuits/virtual-circuit-types/",
21359        local_var_configuration.base_path
21360    );
21361    let mut local_var_req_builder =
21362        local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());
21363
21364    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
21365        local_var_req_builder =
21366            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
21367    }
21368    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
21369        let local_var_key = local_var_apikey.key.clone();
21370        let local_var_value = match local_var_apikey.prefix {
21371            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
21372            None => local_var_key,
21373        };
21374        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
21375    };
21376    local_var_req_builder = local_var_req_builder.json(&virtual_circuit_type_request);
21377
21378    let local_var_req = local_var_req_builder.build()?;
21379    let local_var_resp = local_var_client.execute(local_var_req).await?;
21380
21381    let local_var_status = local_var_resp.status();
21382    let local_var_content = local_var_resp.text().await?;
21383
21384    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
21385        Ok(())
21386    } else {
21387        let local_var_entity: Option<CircuitsVirtualCircuitTypesBulkDestroyError> =
21388            serde_json::from_str(&local_var_content).ok();
21389        let local_var_error = ResponseContent {
21390            status: local_var_status,
21391            content: local_var_content,
21392            entity: local_var_entity,
21393        };
21394        Err(Error::ResponseError(local_var_error))
21395    }
21396}
21397
21398/// Patch a list of virtual circuit type objects.
21399pub async fn circuits_virtual_circuit_types_bulk_partial_update(
21400    configuration: &configuration::Configuration,
21401    virtual_circuit_type_request: Vec<crate::models::VirtualCircuitTypeRequest>,
21402) -> Result<
21403    Vec<crate::models::VirtualCircuitType>,
21404    Error<CircuitsVirtualCircuitTypesBulkPartialUpdateError>,
21405> {
21406    let local_var_configuration = configuration;
21407
21408    let local_var_client = &local_var_configuration.client;
21409
21410    let local_var_uri_str = format!(
21411        "{}/api/circuits/virtual-circuit-types/",
21412        local_var_configuration.base_path
21413    );
21414    let mut local_var_req_builder =
21415        local_var_client.request(reqwest::Method::PATCH, local_var_uri_str.as_str());
21416
21417    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
21418        local_var_req_builder =
21419            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
21420    }
21421    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
21422        let local_var_key = local_var_apikey.key.clone();
21423        let local_var_value = match local_var_apikey.prefix {
21424            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
21425            None => local_var_key,
21426        };
21427        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
21428    };
21429    local_var_req_builder = local_var_req_builder.json(&virtual_circuit_type_request);
21430
21431    let local_var_req = local_var_req_builder.build()?;
21432    let local_var_resp = local_var_client.execute(local_var_req).await?;
21433
21434    let local_var_status = local_var_resp.status();
21435    let local_var_content = local_var_resp.text().await?;
21436
21437    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
21438        serde_json::from_str(&local_var_content).map_err(Error::from)
21439    } else {
21440        let local_var_entity: Option<CircuitsVirtualCircuitTypesBulkPartialUpdateError> =
21441            serde_json::from_str(&local_var_content).ok();
21442        let local_var_error = ResponseContent {
21443            status: local_var_status,
21444            content: local_var_content,
21445            entity: local_var_entity,
21446        };
21447        Err(Error::ResponseError(local_var_error))
21448    }
21449}
21450
21451/// Put a list of virtual circuit type objects.
21452pub async fn circuits_virtual_circuit_types_bulk_update(
21453    configuration: &configuration::Configuration,
21454    virtual_circuit_type_request: Vec<crate::models::VirtualCircuitTypeRequest>,
21455) -> Result<Vec<crate::models::VirtualCircuitType>, Error<CircuitsVirtualCircuitTypesBulkUpdateError>>
21456{
21457    let local_var_configuration = configuration;
21458
21459    let local_var_client = &local_var_configuration.client;
21460
21461    let local_var_uri_str = format!(
21462        "{}/api/circuits/virtual-circuit-types/",
21463        local_var_configuration.base_path
21464    );
21465    let mut local_var_req_builder =
21466        local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());
21467
21468    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
21469        local_var_req_builder =
21470            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
21471    }
21472    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
21473        let local_var_key = local_var_apikey.key.clone();
21474        let local_var_value = match local_var_apikey.prefix {
21475            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
21476            None => local_var_key,
21477        };
21478        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
21479    };
21480    local_var_req_builder = local_var_req_builder.json(&virtual_circuit_type_request);
21481
21482    let local_var_req = local_var_req_builder.build()?;
21483    let local_var_resp = local_var_client.execute(local_var_req).await?;
21484
21485    let local_var_status = local_var_resp.status();
21486    let local_var_content = local_var_resp.text().await?;
21487
21488    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
21489        serde_json::from_str(&local_var_content).map_err(Error::from)
21490    } else {
21491        let local_var_entity: Option<CircuitsVirtualCircuitTypesBulkUpdateError> =
21492            serde_json::from_str(&local_var_content).ok();
21493        let local_var_error = ResponseContent {
21494            status: local_var_status,
21495            content: local_var_content,
21496            entity: local_var_entity,
21497        };
21498        Err(Error::ResponseError(local_var_error))
21499    }
21500}
21501
21502/// Post a list of virtual circuit type objects.
21503pub async fn circuits_virtual_circuit_types_create(
21504    configuration: &configuration::Configuration,
21505    circuits_virtual_circuit_types_create_request: crate::models::CircuitsVirtualCircuitTypesCreateRequest,
21506) -> Result<crate::models::VirtualCircuitType, Error<CircuitsVirtualCircuitTypesCreateError>> {
21507    let local_var_configuration = configuration;
21508
21509    let local_var_client = &local_var_configuration.client;
21510
21511    let local_var_uri_str = format!(
21512        "{}/api/circuits/virtual-circuit-types/",
21513        local_var_configuration.base_path
21514    );
21515    let mut local_var_req_builder =
21516        local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
21517
21518    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
21519        local_var_req_builder =
21520            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
21521    }
21522    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
21523        let local_var_key = local_var_apikey.key.clone();
21524        let local_var_value = match local_var_apikey.prefix {
21525            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
21526            None => local_var_key,
21527        };
21528        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
21529    };
21530    local_var_req_builder =
21531        local_var_req_builder.json(&circuits_virtual_circuit_types_create_request);
21532
21533    let local_var_req = local_var_req_builder.build()?;
21534    let local_var_resp = local_var_client.execute(local_var_req).await?;
21535
21536    let local_var_status = local_var_resp.status();
21537    let local_var_content = local_var_resp.text().await?;
21538
21539    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
21540        serde_json::from_str(&local_var_content).map_err(Error::from)
21541    } else {
21542        let local_var_entity: Option<CircuitsVirtualCircuitTypesCreateError> =
21543            serde_json::from_str(&local_var_content).ok();
21544        let local_var_error = ResponseContent {
21545            status: local_var_status,
21546            content: local_var_content,
21547            entity: local_var_entity,
21548        };
21549        Err(Error::ResponseError(local_var_error))
21550    }
21551}
21552
21553/// Delete a virtual circuit type object.
21554pub async fn circuits_virtual_circuit_types_destroy(
21555    configuration: &configuration::Configuration,
21556    id: i32,
21557) -> Result<(), Error<CircuitsVirtualCircuitTypesDestroyError>> {
21558    let local_var_configuration = configuration;
21559
21560    let local_var_client = &local_var_configuration.client;
21561
21562    let local_var_uri_str = format!(
21563        "{}/api/circuits/virtual-circuit-types/{id}/",
21564        local_var_configuration.base_path,
21565        id = id
21566    );
21567    let mut local_var_req_builder =
21568        local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());
21569
21570    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
21571        local_var_req_builder =
21572            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
21573    }
21574    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
21575        let local_var_key = local_var_apikey.key.clone();
21576        let local_var_value = match local_var_apikey.prefix {
21577            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
21578            None => local_var_key,
21579        };
21580        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
21581    };
21582
21583    let local_var_req = local_var_req_builder.build()?;
21584    let local_var_resp = local_var_client.execute(local_var_req).await?;
21585
21586    let local_var_status = local_var_resp.status();
21587    let local_var_content = local_var_resp.text().await?;
21588
21589    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
21590        Ok(())
21591    } else {
21592        let local_var_entity: Option<CircuitsVirtualCircuitTypesDestroyError> =
21593            serde_json::from_str(&local_var_content).ok();
21594        let local_var_error = ResponseContent {
21595            status: local_var_status,
21596            content: local_var_content,
21597            entity: local_var_entity,
21598        };
21599        Err(Error::ResponseError(local_var_error))
21600    }
21601}
21602
21603/// Get a list of virtual circuit type objects.
21604pub async fn circuits_virtual_circuit_types_list(
21605    configuration: &configuration::Configuration,
21606    color: Option<Vec<String>>,
21607    color__empty: Option<bool>,
21608    color__ic: Option<Vec<String>>,
21609    color__ie: Option<Vec<String>>,
21610    color__iew: Option<Vec<String>>,
21611    color__iregex: Option<Vec<String>>,
21612    color__isw: Option<Vec<String>>,
21613    color__n: Option<Vec<String>>,
21614    color__nic: Option<Vec<String>>,
21615    color__nie: Option<Vec<String>>,
21616    color__niew: Option<Vec<String>>,
21617    color__nisw: Option<Vec<String>>,
21618    color__regex: Option<Vec<String>>,
21619    created: Option<Vec<String>>,
21620    created__empty: Option<Vec<String>>,
21621    created__gt: Option<Vec<String>>,
21622    created__gte: Option<Vec<String>>,
21623    created__lt: Option<Vec<String>>,
21624    created__lte: Option<Vec<String>>,
21625    created__n: Option<Vec<String>>,
21626    created_by_request: Option<&str>,
21627    description: Option<Vec<String>>,
21628    description__empty: Option<bool>,
21629    description__ic: Option<Vec<String>>,
21630    description__ie: Option<Vec<String>>,
21631    description__iew: Option<Vec<String>>,
21632    description__iregex: Option<Vec<String>>,
21633    description__isw: Option<Vec<String>>,
21634    description__n: Option<Vec<String>>,
21635    description__nic: Option<Vec<String>>,
21636    description__nie: Option<Vec<String>>,
21637    description__niew: Option<Vec<String>>,
21638    description__nisw: Option<Vec<String>>,
21639    description__regex: Option<Vec<String>>,
21640    id: Option<Vec<i32>>,
21641    id__empty: Option<bool>,
21642    id__gt: Option<Vec<i32>>,
21643    id__gte: Option<Vec<i32>>,
21644    id__lt: Option<Vec<i32>>,
21645    id__lte: Option<Vec<i32>>,
21646    id__n: Option<Vec<i32>>,
21647    last_updated: Option<Vec<String>>,
21648    last_updated__empty: Option<Vec<String>>,
21649    last_updated__gt: Option<Vec<String>>,
21650    last_updated__gte: Option<Vec<String>>,
21651    last_updated__lt: Option<Vec<String>>,
21652    last_updated__lte: Option<Vec<String>>,
21653    last_updated__n: Option<Vec<String>>,
21654    limit: Option<i32>,
21655    modified_by_request: Option<&str>,
21656    name: Option<Vec<String>>,
21657    name__empty: Option<bool>,
21658    name__ic: Option<Vec<String>>,
21659    name__ie: Option<Vec<String>>,
21660    name__iew: Option<Vec<String>>,
21661    name__iregex: Option<Vec<String>>,
21662    name__isw: Option<Vec<String>>,
21663    name__n: Option<Vec<String>>,
21664    name__nic: Option<Vec<String>>,
21665    name__nie: Option<Vec<String>>,
21666    name__niew: Option<Vec<String>>,
21667    name__nisw: Option<Vec<String>>,
21668    name__regex: Option<Vec<String>>,
21669    offset: Option<i32>,
21670    ordering: Option<&str>,
21671    owner: Option<Vec<String>>,
21672    owner__n: Option<Vec<String>>,
21673    owner_group: Option<Vec<String>>,
21674    owner_group__n: Option<Vec<String>>,
21675    owner_group_id: Option<Vec<i32>>,
21676    owner_group_id__n: Option<Vec<i32>>,
21677    owner_id: Option<Vec<i32>>,
21678    owner_id__n: Option<Vec<i32>>,
21679    q: Option<&str>,
21680    slug: Option<Vec<String>>,
21681    slug__empty: Option<bool>,
21682    slug__ic: Option<Vec<String>>,
21683    slug__ie: Option<Vec<String>>,
21684    slug__iew: Option<Vec<String>>,
21685    slug__iregex: Option<Vec<String>>,
21686    slug__isw: Option<Vec<String>>,
21687    slug__n: Option<Vec<String>>,
21688    slug__nic: Option<Vec<String>>,
21689    slug__nie: Option<Vec<String>>,
21690    slug__niew: Option<Vec<String>>,
21691    slug__nisw: Option<Vec<String>>,
21692    slug__regex: Option<Vec<String>>,
21693    tag: Option<Vec<String>>,
21694    tag__n: Option<Vec<String>>,
21695    tag_id: Option<Vec<i32>>,
21696    tag_id__n: Option<Vec<i32>>,
21697    updated_by_request: Option<&str>,
21698) -> Result<
21699    crate::models::PaginatedVirtualCircuitTypeList,
21700    Error<CircuitsVirtualCircuitTypesListError>,
21701> {
21702    let local_var_configuration = configuration;
21703
21704    let local_var_client = &local_var_configuration.client;
21705
21706    let local_var_uri_str = format!(
21707        "{}/api/circuits/virtual-circuit-types/",
21708        local_var_configuration.base_path
21709    );
21710    let mut local_var_req_builder =
21711        local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
21712
21713    if let Some(ref local_var_str) = color {
21714        local_var_req_builder = match "multi" {
21715            "multi" => local_var_req_builder.query(
21716                &local_var_str
21717                    .into_iter()
21718                    .map(|p| ("color".to_owned(), p.to_string()))
21719                    .collect::<Vec<(std::string::String, std::string::String)>>(),
21720            ),
21721            _ => local_var_req_builder.query(&[(
21722                "color",
21723                &local_var_str
21724                    .into_iter()
21725                    .map(|p| p.to_string())
21726                    .collect::<Vec<String>>()
21727                    .join(",")
21728                    .to_string(),
21729            )]),
21730        };
21731    }
21732    if let Some(ref local_var_str) = color__empty {
21733        local_var_req_builder =
21734            local_var_req_builder.query(&[("color__empty", &local_var_str.to_string())]);
21735    }
21736    if let Some(ref local_var_str) = color__ic {
21737        local_var_req_builder = match "multi" {
21738            "multi" => local_var_req_builder.query(
21739                &local_var_str
21740                    .into_iter()
21741                    .map(|p| ("color__ic".to_owned(), p.to_string()))
21742                    .collect::<Vec<(std::string::String, std::string::String)>>(),
21743            ),
21744            _ => local_var_req_builder.query(&[(
21745                "color__ic",
21746                &local_var_str
21747                    .into_iter()
21748                    .map(|p| p.to_string())
21749                    .collect::<Vec<String>>()
21750                    .join(",")
21751                    .to_string(),
21752            )]),
21753        };
21754    }
21755    if let Some(ref local_var_str) = color__ie {
21756        local_var_req_builder = match "multi" {
21757            "multi" => local_var_req_builder.query(
21758                &local_var_str
21759                    .into_iter()
21760                    .map(|p| ("color__ie".to_owned(), p.to_string()))
21761                    .collect::<Vec<(std::string::String, std::string::String)>>(),
21762            ),
21763            _ => local_var_req_builder.query(&[(
21764                "color__ie",
21765                &local_var_str
21766                    .into_iter()
21767                    .map(|p| p.to_string())
21768                    .collect::<Vec<String>>()
21769                    .join(",")
21770                    .to_string(),
21771            )]),
21772        };
21773    }
21774    if let Some(ref local_var_str) = color__iew {
21775        local_var_req_builder = match "multi" {
21776            "multi" => local_var_req_builder.query(
21777                &local_var_str
21778                    .into_iter()
21779                    .map(|p| ("color__iew".to_owned(), p.to_string()))
21780                    .collect::<Vec<(std::string::String, std::string::String)>>(),
21781            ),
21782            _ => local_var_req_builder.query(&[(
21783                "color__iew",
21784                &local_var_str
21785                    .into_iter()
21786                    .map(|p| p.to_string())
21787                    .collect::<Vec<String>>()
21788                    .join(",")
21789                    .to_string(),
21790            )]),
21791        };
21792    }
21793    if let Some(ref local_var_str) = color__iregex {
21794        local_var_req_builder = match "multi" {
21795            "multi" => local_var_req_builder.query(
21796                &local_var_str
21797                    .into_iter()
21798                    .map(|p| ("color__iregex".to_owned(), p.to_string()))
21799                    .collect::<Vec<(std::string::String, std::string::String)>>(),
21800            ),
21801            _ => local_var_req_builder.query(&[(
21802                "color__iregex",
21803                &local_var_str
21804                    .into_iter()
21805                    .map(|p| p.to_string())
21806                    .collect::<Vec<String>>()
21807                    .join(",")
21808                    .to_string(),
21809            )]),
21810        };
21811    }
21812    if let Some(ref local_var_str) = color__isw {
21813        local_var_req_builder = match "multi" {
21814            "multi" => local_var_req_builder.query(
21815                &local_var_str
21816                    .into_iter()
21817                    .map(|p| ("color__isw".to_owned(), p.to_string()))
21818                    .collect::<Vec<(std::string::String, std::string::String)>>(),
21819            ),
21820            _ => local_var_req_builder.query(&[(
21821                "color__isw",
21822                &local_var_str
21823                    .into_iter()
21824                    .map(|p| p.to_string())
21825                    .collect::<Vec<String>>()
21826                    .join(",")
21827                    .to_string(),
21828            )]),
21829        };
21830    }
21831    if let Some(ref local_var_str) = color__n {
21832        local_var_req_builder = match "multi" {
21833            "multi" => local_var_req_builder.query(
21834                &local_var_str
21835                    .into_iter()
21836                    .map(|p| ("color__n".to_owned(), p.to_string()))
21837                    .collect::<Vec<(std::string::String, std::string::String)>>(),
21838            ),
21839            _ => local_var_req_builder.query(&[(
21840                "color__n",
21841                &local_var_str
21842                    .into_iter()
21843                    .map(|p| p.to_string())
21844                    .collect::<Vec<String>>()
21845                    .join(",")
21846                    .to_string(),
21847            )]),
21848        };
21849    }
21850    if let Some(ref local_var_str) = color__nic {
21851        local_var_req_builder = match "multi" {
21852            "multi" => local_var_req_builder.query(
21853                &local_var_str
21854                    .into_iter()
21855                    .map(|p| ("color__nic".to_owned(), p.to_string()))
21856                    .collect::<Vec<(std::string::String, std::string::String)>>(),
21857            ),
21858            _ => local_var_req_builder.query(&[(
21859                "color__nic",
21860                &local_var_str
21861                    .into_iter()
21862                    .map(|p| p.to_string())
21863                    .collect::<Vec<String>>()
21864                    .join(",")
21865                    .to_string(),
21866            )]),
21867        };
21868    }
21869    if let Some(ref local_var_str) = color__nie {
21870        local_var_req_builder = match "multi" {
21871            "multi" => local_var_req_builder.query(
21872                &local_var_str
21873                    .into_iter()
21874                    .map(|p| ("color__nie".to_owned(), p.to_string()))
21875                    .collect::<Vec<(std::string::String, std::string::String)>>(),
21876            ),
21877            _ => local_var_req_builder.query(&[(
21878                "color__nie",
21879                &local_var_str
21880                    .into_iter()
21881                    .map(|p| p.to_string())
21882                    .collect::<Vec<String>>()
21883                    .join(",")
21884                    .to_string(),
21885            )]),
21886        };
21887    }
21888    if let Some(ref local_var_str) = color__niew {
21889        local_var_req_builder = match "multi" {
21890            "multi" => local_var_req_builder.query(
21891                &local_var_str
21892                    .into_iter()
21893                    .map(|p| ("color__niew".to_owned(), p.to_string()))
21894                    .collect::<Vec<(std::string::String, std::string::String)>>(),
21895            ),
21896            _ => local_var_req_builder.query(&[(
21897                "color__niew",
21898                &local_var_str
21899                    .into_iter()
21900                    .map(|p| p.to_string())
21901                    .collect::<Vec<String>>()
21902                    .join(",")
21903                    .to_string(),
21904            )]),
21905        };
21906    }
21907    if let Some(ref local_var_str) = color__nisw {
21908        local_var_req_builder = match "multi" {
21909            "multi" => local_var_req_builder.query(
21910                &local_var_str
21911                    .into_iter()
21912                    .map(|p| ("color__nisw".to_owned(), p.to_string()))
21913                    .collect::<Vec<(std::string::String, std::string::String)>>(),
21914            ),
21915            _ => local_var_req_builder.query(&[(
21916                "color__nisw",
21917                &local_var_str
21918                    .into_iter()
21919                    .map(|p| p.to_string())
21920                    .collect::<Vec<String>>()
21921                    .join(",")
21922                    .to_string(),
21923            )]),
21924        };
21925    }
21926    if let Some(ref local_var_str) = color__regex {
21927        local_var_req_builder = match "multi" {
21928            "multi" => local_var_req_builder.query(
21929                &local_var_str
21930                    .into_iter()
21931                    .map(|p| ("color__regex".to_owned(), p.to_string()))
21932                    .collect::<Vec<(std::string::String, std::string::String)>>(),
21933            ),
21934            _ => local_var_req_builder.query(&[(
21935                "color__regex",
21936                &local_var_str
21937                    .into_iter()
21938                    .map(|p| p.to_string())
21939                    .collect::<Vec<String>>()
21940                    .join(",")
21941                    .to_string(),
21942            )]),
21943        };
21944    }
21945    if let Some(ref local_var_str) = created {
21946        local_var_req_builder = match "multi" {
21947            "multi" => local_var_req_builder.query(
21948                &local_var_str
21949                    .into_iter()
21950                    .map(|p| ("created".to_owned(), p.to_string()))
21951                    .collect::<Vec<(std::string::String, std::string::String)>>(),
21952            ),
21953            _ => local_var_req_builder.query(&[(
21954                "created",
21955                &local_var_str
21956                    .into_iter()
21957                    .map(|p| p.to_string())
21958                    .collect::<Vec<String>>()
21959                    .join(",")
21960                    .to_string(),
21961            )]),
21962        };
21963    }
21964    if let Some(ref local_var_str) = created__empty {
21965        local_var_req_builder = match "multi" {
21966            "multi" => local_var_req_builder.query(
21967                &local_var_str
21968                    .into_iter()
21969                    .map(|p| ("created__empty".to_owned(), p.to_string()))
21970                    .collect::<Vec<(std::string::String, std::string::String)>>(),
21971            ),
21972            _ => local_var_req_builder.query(&[(
21973                "created__empty",
21974                &local_var_str
21975                    .into_iter()
21976                    .map(|p| p.to_string())
21977                    .collect::<Vec<String>>()
21978                    .join(",")
21979                    .to_string(),
21980            )]),
21981        };
21982    }
21983    if let Some(ref local_var_str) = created__gt {
21984        local_var_req_builder = match "multi" {
21985            "multi" => local_var_req_builder.query(
21986                &local_var_str
21987                    .into_iter()
21988                    .map(|p| ("created__gt".to_owned(), p.to_string()))
21989                    .collect::<Vec<(std::string::String, std::string::String)>>(),
21990            ),
21991            _ => local_var_req_builder.query(&[(
21992                "created__gt",
21993                &local_var_str
21994                    .into_iter()
21995                    .map(|p| p.to_string())
21996                    .collect::<Vec<String>>()
21997                    .join(",")
21998                    .to_string(),
21999            )]),
22000        };
22001    }
22002    if let Some(ref local_var_str) = created__gte {
22003        local_var_req_builder = match "multi" {
22004            "multi" => local_var_req_builder.query(
22005                &local_var_str
22006                    .into_iter()
22007                    .map(|p| ("created__gte".to_owned(), p.to_string()))
22008                    .collect::<Vec<(std::string::String, std::string::String)>>(),
22009            ),
22010            _ => local_var_req_builder.query(&[(
22011                "created__gte",
22012                &local_var_str
22013                    .into_iter()
22014                    .map(|p| p.to_string())
22015                    .collect::<Vec<String>>()
22016                    .join(",")
22017                    .to_string(),
22018            )]),
22019        };
22020    }
22021    if let Some(ref local_var_str) = created__lt {
22022        local_var_req_builder = match "multi" {
22023            "multi" => local_var_req_builder.query(
22024                &local_var_str
22025                    .into_iter()
22026                    .map(|p| ("created__lt".to_owned(), p.to_string()))
22027                    .collect::<Vec<(std::string::String, std::string::String)>>(),
22028            ),
22029            _ => local_var_req_builder.query(&[(
22030                "created__lt",
22031                &local_var_str
22032                    .into_iter()
22033                    .map(|p| p.to_string())
22034                    .collect::<Vec<String>>()
22035                    .join(",")
22036                    .to_string(),
22037            )]),
22038        };
22039    }
22040    if let Some(ref local_var_str) = created__lte {
22041        local_var_req_builder = match "multi" {
22042            "multi" => local_var_req_builder.query(
22043                &local_var_str
22044                    .into_iter()
22045                    .map(|p| ("created__lte".to_owned(), p.to_string()))
22046                    .collect::<Vec<(std::string::String, std::string::String)>>(),
22047            ),
22048            _ => local_var_req_builder.query(&[(
22049                "created__lte",
22050                &local_var_str
22051                    .into_iter()
22052                    .map(|p| p.to_string())
22053                    .collect::<Vec<String>>()
22054                    .join(",")
22055                    .to_string(),
22056            )]),
22057        };
22058    }
22059    if let Some(ref local_var_str) = created__n {
22060        local_var_req_builder = match "multi" {
22061            "multi" => local_var_req_builder.query(
22062                &local_var_str
22063                    .into_iter()
22064                    .map(|p| ("created__n".to_owned(), p.to_string()))
22065                    .collect::<Vec<(std::string::String, std::string::String)>>(),
22066            ),
22067            _ => local_var_req_builder.query(&[(
22068                "created__n",
22069                &local_var_str
22070                    .into_iter()
22071                    .map(|p| p.to_string())
22072                    .collect::<Vec<String>>()
22073                    .join(",")
22074                    .to_string(),
22075            )]),
22076        };
22077    }
22078    if let Some(ref local_var_str) = created_by_request {
22079        local_var_req_builder =
22080            local_var_req_builder.query(&[("created_by_request", &local_var_str.to_string())]);
22081    }
22082    if let Some(ref local_var_str) = description {
22083        local_var_req_builder = match "multi" {
22084            "multi" => local_var_req_builder.query(
22085                &local_var_str
22086                    .into_iter()
22087                    .map(|p| ("description".to_owned(), p.to_string()))
22088                    .collect::<Vec<(std::string::String, std::string::String)>>(),
22089            ),
22090            _ => local_var_req_builder.query(&[(
22091                "description",
22092                &local_var_str
22093                    .into_iter()
22094                    .map(|p| p.to_string())
22095                    .collect::<Vec<String>>()
22096                    .join(",")
22097                    .to_string(),
22098            )]),
22099        };
22100    }
22101    if let Some(ref local_var_str) = description__empty {
22102        local_var_req_builder =
22103            local_var_req_builder.query(&[("description__empty", &local_var_str.to_string())]);
22104    }
22105    if let Some(ref local_var_str) = description__ic {
22106        local_var_req_builder = match "multi" {
22107            "multi" => local_var_req_builder.query(
22108                &local_var_str
22109                    .into_iter()
22110                    .map(|p| ("description__ic".to_owned(), p.to_string()))
22111                    .collect::<Vec<(std::string::String, std::string::String)>>(),
22112            ),
22113            _ => local_var_req_builder.query(&[(
22114                "description__ic",
22115                &local_var_str
22116                    .into_iter()
22117                    .map(|p| p.to_string())
22118                    .collect::<Vec<String>>()
22119                    .join(",")
22120                    .to_string(),
22121            )]),
22122        };
22123    }
22124    if let Some(ref local_var_str) = description__ie {
22125        local_var_req_builder = match "multi" {
22126            "multi" => local_var_req_builder.query(
22127                &local_var_str
22128                    .into_iter()
22129                    .map(|p| ("description__ie".to_owned(), p.to_string()))
22130                    .collect::<Vec<(std::string::String, std::string::String)>>(),
22131            ),
22132            _ => local_var_req_builder.query(&[(
22133                "description__ie",
22134                &local_var_str
22135                    .into_iter()
22136                    .map(|p| p.to_string())
22137                    .collect::<Vec<String>>()
22138                    .join(",")
22139                    .to_string(),
22140            )]),
22141        };
22142    }
22143    if let Some(ref local_var_str) = description__iew {
22144        local_var_req_builder = match "multi" {
22145            "multi" => local_var_req_builder.query(
22146                &local_var_str
22147                    .into_iter()
22148                    .map(|p| ("description__iew".to_owned(), p.to_string()))
22149                    .collect::<Vec<(std::string::String, std::string::String)>>(),
22150            ),
22151            _ => local_var_req_builder.query(&[(
22152                "description__iew",
22153                &local_var_str
22154                    .into_iter()
22155                    .map(|p| p.to_string())
22156                    .collect::<Vec<String>>()
22157                    .join(",")
22158                    .to_string(),
22159            )]),
22160        };
22161    }
22162    if let Some(ref local_var_str) = description__iregex {
22163        local_var_req_builder = match "multi" {
22164            "multi" => local_var_req_builder.query(
22165                &local_var_str
22166                    .into_iter()
22167                    .map(|p| ("description__iregex".to_owned(), p.to_string()))
22168                    .collect::<Vec<(std::string::String, std::string::String)>>(),
22169            ),
22170            _ => local_var_req_builder.query(&[(
22171                "description__iregex",
22172                &local_var_str
22173                    .into_iter()
22174                    .map(|p| p.to_string())
22175                    .collect::<Vec<String>>()
22176                    .join(",")
22177                    .to_string(),
22178            )]),
22179        };
22180    }
22181    if let Some(ref local_var_str) = description__isw {
22182        local_var_req_builder = match "multi" {
22183            "multi" => local_var_req_builder.query(
22184                &local_var_str
22185                    .into_iter()
22186                    .map(|p| ("description__isw".to_owned(), p.to_string()))
22187                    .collect::<Vec<(std::string::String, std::string::String)>>(),
22188            ),
22189            _ => local_var_req_builder.query(&[(
22190                "description__isw",
22191                &local_var_str
22192                    .into_iter()
22193                    .map(|p| p.to_string())
22194                    .collect::<Vec<String>>()
22195                    .join(",")
22196                    .to_string(),
22197            )]),
22198        };
22199    }
22200    if let Some(ref local_var_str) = description__n {
22201        local_var_req_builder = match "multi" {
22202            "multi" => local_var_req_builder.query(
22203                &local_var_str
22204                    .into_iter()
22205                    .map(|p| ("description__n".to_owned(), p.to_string()))
22206                    .collect::<Vec<(std::string::String, std::string::String)>>(),
22207            ),
22208            _ => local_var_req_builder.query(&[(
22209                "description__n",
22210                &local_var_str
22211                    .into_iter()
22212                    .map(|p| p.to_string())
22213                    .collect::<Vec<String>>()
22214                    .join(",")
22215                    .to_string(),
22216            )]),
22217        };
22218    }
22219    if let Some(ref local_var_str) = description__nic {
22220        local_var_req_builder = match "multi" {
22221            "multi" => local_var_req_builder.query(
22222                &local_var_str
22223                    .into_iter()
22224                    .map(|p| ("description__nic".to_owned(), p.to_string()))
22225                    .collect::<Vec<(std::string::String, std::string::String)>>(),
22226            ),
22227            _ => local_var_req_builder.query(&[(
22228                "description__nic",
22229                &local_var_str
22230                    .into_iter()
22231                    .map(|p| p.to_string())
22232                    .collect::<Vec<String>>()
22233                    .join(",")
22234                    .to_string(),
22235            )]),
22236        };
22237    }
22238    if let Some(ref local_var_str) = description__nie {
22239        local_var_req_builder = match "multi" {
22240            "multi" => local_var_req_builder.query(
22241                &local_var_str
22242                    .into_iter()
22243                    .map(|p| ("description__nie".to_owned(), p.to_string()))
22244                    .collect::<Vec<(std::string::String, std::string::String)>>(),
22245            ),
22246            _ => local_var_req_builder.query(&[(
22247                "description__nie",
22248                &local_var_str
22249                    .into_iter()
22250                    .map(|p| p.to_string())
22251                    .collect::<Vec<String>>()
22252                    .join(",")
22253                    .to_string(),
22254            )]),
22255        };
22256    }
22257    if let Some(ref local_var_str) = description__niew {
22258        local_var_req_builder = match "multi" {
22259            "multi" => local_var_req_builder.query(
22260                &local_var_str
22261                    .into_iter()
22262                    .map(|p| ("description__niew".to_owned(), p.to_string()))
22263                    .collect::<Vec<(std::string::String, std::string::String)>>(),
22264            ),
22265            _ => local_var_req_builder.query(&[(
22266                "description__niew",
22267                &local_var_str
22268                    .into_iter()
22269                    .map(|p| p.to_string())
22270                    .collect::<Vec<String>>()
22271                    .join(",")
22272                    .to_string(),
22273            )]),
22274        };
22275    }
22276    if let Some(ref local_var_str) = description__nisw {
22277        local_var_req_builder = match "multi" {
22278            "multi" => local_var_req_builder.query(
22279                &local_var_str
22280                    .into_iter()
22281                    .map(|p| ("description__nisw".to_owned(), p.to_string()))
22282                    .collect::<Vec<(std::string::String, std::string::String)>>(),
22283            ),
22284            _ => local_var_req_builder.query(&[(
22285                "description__nisw",
22286                &local_var_str
22287                    .into_iter()
22288                    .map(|p| p.to_string())
22289                    .collect::<Vec<String>>()
22290                    .join(",")
22291                    .to_string(),
22292            )]),
22293        };
22294    }
22295    if let Some(ref local_var_str) = description__regex {
22296        local_var_req_builder = match "multi" {
22297            "multi" => local_var_req_builder.query(
22298                &local_var_str
22299                    .into_iter()
22300                    .map(|p| ("description__regex".to_owned(), p.to_string()))
22301                    .collect::<Vec<(std::string::String, std::string::String)>>(),
22302            ),
22303            _ => local_var_req_builder.query(&[(
22304                "description__regex",
22305                &local_var_str
22306                    .into_iter()
22307                    .map(|p| p.to_string())
22308                    .collect::<Vec<String>>()
22309                    .join(",")
22310                    .to_string(),
22311            )]),
22312        };
22313    }
22314    if let Some(ref local_var_str) = id {
22315        local_var_req_builder = match "multi" {
22316            "multi" => local_var_req_builder.query(
22317                &local_var_str
22318                    .into_iter()
22319                    .map(|p| ("id".to_owned(), p.to_string()))
22320                    .collect::<Vec<(std::string::String, std::string::String)>>(),
22321            ),
22322            _ => local_var_req_builder.query(&[(
22323                "id",
22324                &local_var_str
22325                    .into_iter()
22326                    .map(|p| p.to_string())
22327                    .collect::<Vec<String>>()
22328                    .join(",")
22329                    .to_string(),
22330            )]),
22331        };
22332    }
22333    if let Some(ref local_var_str) = id__empty {
22334        local_var_req_builder =
22335            local_var_req_builder.query(&[("id__empty", &local_var_str.to_string())]);
22336    }
22337    if let Some(ref local_var_str) = id__gt {
22338        local_var_req_builder = match "multi" {
22339            "multi" => local_var_req_builder.query(
22340                &local_var_str
22341                    .into_iter()
22342                    .map(|p| ("id__gt".to_owned(), p.to_string()))
22343                    .collect::<Vec<(std::string::String, std::string::String)>>(),
22344            ),
22345            _ => local_var_req_builder.query(&[(
22346                "id__gt",
22347                &local_var_str
22348                    .into_iter()
22349                    .map(|p| p.to_string())
22350                    .collect::<Vec<String>>()
22351                    .join(",")
22352                    .to_string(),
22353            )]),
22354        };
22355    }
22356    if let Some(ref local_var_str) = id__gte {
22357        local_var_req_builder = match "multi" {
22358            "multi" => local_var_req_builder.query(
22359                &local_var_str
22360                    .into_iter()
22361                    .map(|p| ("id__gte".to_owned(), p.to_string()))
22362                    .collect::<Vec<(std::string::String, std::string::String)>>(),
22363            ),
22364            _ => local_var_req_builder.query(&[(
22365                "id__gte",
22366                &local_var_str
22367                    .into_iter()
22368                    .map(|p| p.to_string())
22369                    .collect::<Vec<String>>()
22370                    .join(",")
22371                    .to_string(),
22372            )]),
22373        };
22374    }
22375    if let Some(ref local_var_str) = id__lt {
22376        local_var_req_builder = match "multi" {
22377            "multi" => local_var_req_builder.query(
22378                &local_var_str
22379                    .into_iter()
22380                    .map(|p| ("id__lt".to_owned(), p.to_string()))
22381                    .collect::<Vec<(std::string::String, std::string::String)>>(),
22382            ),
22383            _ => local_var_req_builder.query(&[(
22384                "id__lt",
22385                &local_var_str
22386                    .into_iter()
22387                    .map(|p| p.to_string())
22388                    .collect::<Vec<String>>()
22389                    .join(",")
22390                    .to_string(),
22391            )]),
22392        };
22393    }
22394    if let Some(ref local_var_str) = id__lte {
22395        local_var_req_builder = match "multi" {
22396            "multi" => local_var_req_builder.query(
22397                &local_var_str
22398                    .into_iter()
22399                    .map(|p| ("id__lte".to_owned(), p.to_string()))
22400                    .collect::<Vec<(std::string::String, std::string::String)>>(),
22401            ),
22402            _ => local_var_req_builder.query(&[(
22403                "id__lte",
22404                &local_var_str
22405                    .into_iter()
22406                    .map(|p| p.to_string())
22407                    .collect::<Vec<String>>()
22408                    .join(",")
22409                    .to_string(),
22410            )]),
22411        };
22412    }
22413    if let Some(ref local_var_str) = id__n {
22414        local_var_req_builder = match "multi" {
22415            "multi" => local_var_req_builder.query(
22416                &local_var_str
22417                    .into_iter()
22418                    .map(|p| ("id__n".to_owned(), p.to_string()))
22419                    .collect::<Vec<(std::string::String, std::string::String)>>(),
22420            ),
22421            _ => local_var_req_builder.query(&[(
22422                "id__n",
22423                &local_var_str
22424                    .into_iter()
22425                    .map(|p| p.to_string())
22426                    .collect::<Vec<String>>()
22427                    .join(",")
22428                    .to_string(),
22429            )]),
22430        };
22431    }
22432    if let Some(ref local_var_str) = last_updated {
22433        local_var_req_builder = match "multi" {
22434            "multi" => local_var_req_builder.query(
22435                &local_var_str
22436                    .into_iter()
22437                    .map(|p| ("last_updated".to_owned(), p.to_string()))
22438                    .collect::<Vec<(std::string::String, std::string::String)>>(),
22439            ),
22440            _ => local_var_req_builder.query(&[(
22441                "last_updated",
22442                &local_var_str
22443                    .into_iter()
22444                    .map(|p| p.to_string())
22445                    .collect::<Vec<String>>()
22446                    .join(",")
22447                    .to_string(),
22448            )]),
22449        };
22450    }
22451    if let Some(ref local_var_str) = last_updated__empty {
22452        local_var_req_builder = match "multi" {
22453            "multi" => local_var_req_builder.query(
22454                &local_var_str
22455                    .into_iter()
22456                    .map(|p| ("last_updated__empty".to_owned(), p.to_string()))
22457                    .collect::<Vec<(std::string::String, std::string::String)>>(),
22458            ),
22459            _ => local_var_req_builder.query(&[(
22460                "last_updated__empty",
22461                &local_var_str
22462                    .into_iter()
22463                    .map(|p| p.to_string())
22464                    .collect::<Vec<String>>()
22465                    .join(",")
22466                    .to_string(),
22467            )]),
22468        };
22469    }
22470    if let Some(ref local_var_str) = last_updated__gt {
22471        local_var_req_builder = match "multi" {
22472            "multi" => local_var_req_builder.query(
22473                &local_var_str
22474                    .into_iter()
22475                    .map(|p| ("last_updated__gt".to_owned(), p.to_string()))
22476                    .collect::<Vec<(std::string::String, std::string::String)>>(),
22477            ),
22478            _ => local_var_req_builder.query(&[(
22479                "last_updated__gt",
22480                &local_var_str
22481                    .into_iter()
22482                    .map(|p| p.to_string())
22483                    .collect::<Vec<String>>()
22484                    .join(",")
22485                    .to_string(),
22486            )]),
22487        };
22488    }
22489    if let Some(ref local_var_str) = last_updated__gte {
22490        local_var_req_builder = match "multi" {
22491            "multi" => local_var_req_builder.query(
22492                &local_var_str
22493                    .into_iter()
22494                    .map(|p| ("last_updated__gte".to_owned(), p.to_string()))
22495                    .collect::<Vec<(std::string::String, std::string::String)>>(),
22496            ),
22497            _ => local_var_req_builder.query(&[(
22498                "last_updated__gte",
22499                &local_var_str
22500                    .into_iter()
22501                    .map(|p| p.to_string())
22502                    .collect::<Vec<String>>()
22503                    .join(",")
22504                    .to_string(),
22505            )]),
22506        };
22507    }
22508    if let Some(ref local_var_str) = last_updated__lt {
22509        local_var_req_builder = match "multi" {
22510            "multi" => local_var_req_builder.query(
22511                &local_var_str
22512                    .into_iter()
22513                    .map(|p| ("last_updated__lt".to_owned(), p.to_string()))
22514                    .collect::<Vec<(std::string::String, std::string::String)>>(),
22515            ),
22516            _ => local_var_req_builder.query(&[(
22517                "last_updated__lt",
22518                &local_var_str
22519                    .into_iter()
22520                    .map(|p| p.to_string())
22521                    .collect::<Vec<String>>()
22522                    .join(",")
22523                    .to_string(),
22524            )]),
22525        };
22526    }
22527    if let Some(ref local_var_str) = last_updated__lte {
22528        local_var_req_builder = match "multi" {
22529            "multi" => local_var_req_builder.query(
22530                &local_var_str
22531                    .into_iter()
22532                    .map(|p| ("last_updated__lte".to_owned(), p.to_string()))
22533                    .collect::<Vec<(std::string::String, std::string::String)>>(),
22534            ),
22535            _ => local_var_req_builder.query(&[(
22536                "last_updated__lte",
22537                &local_var_str
22538                    .into_iter()
22539                    .map(|p| p.to_string())
22540                    .collect::<Vec<String>>()
22541                    .join(",")
22542                    .to_string(),
22543            )]),
22544        };
22545    }
22546    if let Some(ref local_var_str) = last_updated__n {
22547        local_var_req_builder = match "multi" {
22548            "multi" => local_var_req_builder.query(
22549                &local_var_str
22550                    .into_iter()
22551                    .map(|p| ("last_updated__n".to_owned(), p.to_string()))
22552                    .collect::<Vec<(std::string::String, std::string::String)>>(),
22553            ),
22554            _ => local_var_req_builder.query(&[(
22555                "last_updated__n",
22556                &local_var_str
22557                    .into_iter()
22558                    .map(|p| p.to_string())
22559                    .collect::<Vec<String>>()
22560                    .join(",")
22561                    .to_string(),
22562            )]),
22563        };
22564    }
22565    if let Some(ref local_var_str) = limit {
22566        local_var_req_builder =
22567            local_var_req_builder.query(&[("limit", &local_var_str.to_string())]);
22568    }
22569    if let Some(ref local_var_str) = modified_by_request {
22570        local_var_req_builder =
22571            local_var_req_builder.query(&[("modified_by_request", &local_var_str.to_string())]);
22572    }
22573    if let Some(ref local_var_str) = name {
22574        local_var_req_builder = match "multi" {
22575            "multi" => local_var_req_builder.query(
22576                &local_var_str
22577                    .into_iter()
22578                    .map(|p| ("name".to_owned(), p.to_string()))
22579                    .collect::<Vec<(std::string::String, std::string::String)>>(),
22580            ),
22581            _ => local_var_req_builder.query(&[(
22582                "name",
22583                &local_var_str
22584                    .into_iter()
22585                    .map(|p| p.to_string())
22586                    .collect::<Vec<String>>()
22587                    .join(",")
22588                    .to_string(),
22589            )]),
22590        };
22591    }
22592    if let Some(ref local_var_str) = name__empty {
22593        local_var_req_builder =
22594            local_var_req_builder.query(&[("name__empty", &local_var_str.to_string())]);
22595    }
22596    if let Some(ref local_var_str) = name__ic {
22597        local_var_req_builder = match "multi" {
22598            "multi" => local_var_req_builder.query(
22599                &local_var_str
22600                    .into_iter()
22601                    .map(|p| ("name__ic".to_owned(), p.to_string()))
22602                    .collect::<Vec<(std::string::String, std::string::String)>>(),
22603            ),
22604            _ => local_var_req_builder.query(&[(
22605                "name__ic",
22606                &local_var_str
22607                    .into_iter()
22608                    .map(|p| p.to_string())
22609                    .collect::<Vec<String>>()
22610                    .join(",")
22611                    .to_string(),
22612            )]),
22613        };
22614    }
22615    if let Some(ref local_var_str) = name__ie {
22616        local_var_req_builder = match "multi" {
22617            "multi" => local_var_req_builder.query(
22618                &local_var_str
22619                    .into_iter()
22620                    .map(|p| ("name__ie".to_owned(), p.to_string()))
22621                    .collect::<Vec<(std::string::String, std::string::String)>>(),
22622            ),
22623            _ => local_var_req_builder.query(&[(
22624                "name__ie",
22625                &local_var_str
22626                    .into_iter()
22627                    .map(|p| p.to_string())
22628                    .collect::<Vec<String>>()
22629                    .join(",")
22630                    .to_string(),
22631            )]),
22632        };
22633    }
22634    if let Some(ref local_var_str) = name__iew {
22635        local_var_req_builder = match "multi" {
22636            "multi" => local_var_req_builder.query(
22637                &local_var_str
22638                    .into_iter()
22639                    .map(|p| ("name__iew".to_owned(), p.to_string()))
22640                    .collect::<Vec<(std::string::String, std::string::String)>>(),
22641            ),
22642            _ => local_var_req_builder.query(&[(
22643                "name__iew",
22644                &local_var_str
22645                    .into_iter()
22646                    .map(|p| p.to_string())
22647                    .collect::<Vec<String>>()
22648                    .join(",")
22649                    .to_string(),
22650            )]),
22651        };
22652    }
22653    if let Some(ref local_var_str) = name__iregex {
22654        local_var_req_builder = match "multi" {
22655            "multi" => local_var_req_builder.query(
22656                &local_var_str
22657                    .into_iter()
22658                    .map(|p| ("name__iregex".to_owned(), p.to_string()))
22659                    .collect::<Vec<(std::string::String, std::string::String)>>(),
22660            ),
22661            _ => local_var_req_builder.query(&[(
22662                "name__iregex",
22663                &local_var_str
22664                    .into_iter()
22665                    .map(|p| p.to_string())
22666                    .collect::<Vec<String>>()
22667                    .join(",")
22668                    .to_string(),
22669            )]),
22670        };
22671    }
22672    if let Some(ref local_var_str) = name__isw {
22673        local_var_req_builder = match "multi" {
22674            "multi" => local_var_req_builder.query(
22675                &local_var_str
22676                    .into_iter()
22677                    .map(|p| ("name__isw".to_owned(), p.to_string()))
22678                    .collect::<Vec<(std::string::String, std::string::String)>>(),
22679            ),
22680            _ => local_var_req_builder.query(&[(
22681                "name__isw",
22682                &local_var_str
22683                    .into_iter()
22684                    .map(|p| p.to_string())
22685                    .collect::<Vec<String>>()
22686                    .join(",")
22687                    .to_string(),
22688            )]),
22689        };
22690    }
22691    if let Some(ref local_var_str) = name__n {
22692        local_var_req_builder = match "multi" {
22693            "multi" => local_var_req_builder.query(
22694                &local_var_str
22695                    .into_iter()
22696                    .map(|p| ("name__n".to_owned(), p.to_string()))
22697                    .collect::<Vec<(std::string::String, std::string::String)>>(),
22698            ),
22699            _ => local_var_req_builder.query(&[(
22700                "name__n",
22701                &local_var_str
22702                    .into_iter()
22703                    .map(|p| p.to_string())
22704                    .collect::<Vec<String>>()
22705                    .join(",")
22706                    .to_string(),
22707            )]),
22708        };
22709    }
22710    if let Some(ref local_var_str) = name__nic {
22711        local_var_req_builder = match "multi" {
22712            "multi" => local_var_req_builder.query(
22713                &local_var_str
22714                    .into_iter()
22715                    .map(|p| ("name__nic".to_owned(), p.to_string()))
22716                    .collect::<Vec<(std::string::String, std::string::String)>>(),
22717            ),
22718            _ => local_var_req_builder.query(&[(
22719                "name__nic",
22720                &local_var_str
22721                    .into_iter()
22722                    .map(|p| p.to_string())
22723                    .collect::<Vec<String>>()
22724                    .join(",")
22725                    .to_string(),
22726            )]),
22727        };
22728    }
22729    if let Some(ref local_var_str) = name__nie {
22730        local_var_req_builder = match "multi" {
22731            "multi" => local_var_req_builder.query(
22732                &local_var_str
22733                    .into_iter()
22734                    .map(|p| ("name__nie".to_owned(), p.to_string()))
22735                    .collect::<Vec<(std::string::String, std::string::String)>>(),
22736            ),
22737            _ => local_var_req_builder.query(&[(
22738                "name__nie",
22739                &local_var_str
22740                    .into_iter()
22741                    .map(|p| p.to_string())
22742                    .collect::<Vec<String>>()
22743                    .join(",")
22744                    .to_string(),
22745            )]),
22746        };
22747    }
22748    if let Some(ref local_var_str) = name__niew {
22749        local_var_req_builder = match "multi" {
22750            "multi" => local_var_req_builder.query(
22751                &local_var_str
22752                    .into_iter()
22753                    .map(|p| ("name__niew".to_owned(), p.to_string()))
22754                    .collect::<Vec<(std::string::String, std::string::String)>>(),
22755            ),
22756            _ => local_var_req_builder.query(&[(
22757                "name__niew",
22758                &local_var_str
22759                    .into_iter()
22760                    .map(|p| p.to_string())
22761                    .collect::<Vec<String>>()
22762                    .join(",")
22763                    .to_string(),
22764            )]),
22765        };
22766    }
22767    if let Some(ref local_var_str) = name__nisw {
22768        local_var_req_builder = match "multi" {
22769            "multi" => local_var_req_builder.query(
22770                &local_var_str
22771                    .into_iter()
22772                    .map(|p| ("name__nisw".to_owned(), p.to_string()))
22773                    .collect::<Vec<(std::string::String, std::string::String)>>(),
22774            ),
22775            _ => local_var_req_builder.query(&[(
22776                "name__nisw",
22777                &local_var_str
22778                    .into_iter()
22779                    .map(|p| p.to_string())
22780                    .collect::<Vec<String>>()
22781                    .join(",")
22782                    .to_string(),
22783            )]),
22784        };
22785    }
22786    if let Some(ref local_var_str) = name__regex {
22787        local_var_req_builder = match "multi" {
22788            "multi" => local_var_req_builder.query(
22789                &local_var_str
22790                    .into_iter()
22791                    .map(|p| ("name__regex".to_owned(), p.to_string()))
22792                    .collect::<Vec<(std::string::String, std::string::String)>>(),
22793            ),
22794            _ => local_var_req_builder.query(&[(
22795                "name__regex",
22796                &local_var_str
22797                    .into_iter()
22798                    .map(|p| p.to_string())
22799                    .collect::<Vec<String>>()
22800                    .join(",")
22801                    .to_string(),
22802            )]),
22803        };
22804    }
22805    if let Some(ref local_var_str) = offset {
22806        local_var_req_builder =
22807            local_var_req_builder.query(&[("offset", &local_var_str.to_string())]);
22808    }
22809    if let Some(ref local_var_str) = ordering {
22810        local_var_req_builder =
22811            local_var_req_builder.query(&[("ordering", &local_var_str.to_string())]);
22812    }
22813    if let Some(ref local_var_str) = owner {
22814        local_var_req_builder = match "multi" {
22815            "multi" => local_var_req_builder.query(
22816                &local_var_str
22817                    .into_iter()
22818                    .map(|p| ("owner".to_owned(), p.to_string()))
22819                    .collect::<Vec<(std::string::String, std::string::String)>>(),
22820            ),
22821            _ => local_var_req_builder.query(&[(
22822                "owner",
22823                &local_var_str
22824                    .into_iter()
22825                    .map(|p| p.to_string())
22826                    .collect::<Vec<String>>()
22827                    .join(",")
22828                    .to_string(),
22829            )]),
22830        };
22831    }
22832    if let Some(ref local_var_str) = owner__n {
22833        local_var_req_builder = match "multi" {
22834            "multi" => local_var_req_builder.query(
22835                &local_var_str
22836                    .into_iter()
22837                    .map(|p| ("owner__n".to_owned(), p.to_string()))
22838                    .collect::<Vec<(std::string::String, std::string::String)>>(),
22839            ),
22840            _ => local_var_req_builder.query(&[(
22841                "owner__n",
22842                &local_var_str
22843                    .into_iter()
22844                    .map(|p| p.to_string())
22845                    .collect::<Vec<String>>()
22846                    .join(",")
22847                    .to_string(),
22848            )]),
22849        };
22850    }
22851    if let Some(ref local_var_str) = owner_group {
22852        local_var_req_builder = match "multi" {
22853            "multi" => local_var_req_builder.query(
22854                &local_var_str
22855                    .into_iter()
22856                    .map(|p| ("owner_group".to_owned(), p.to_string()))
22857                    .collect::<Vec<(std::string::String, std::string::String)>>(),
22858            ),
22859            _ => local_var_req_builder.query(&[(
22860                "owner_group",
22861                &local_var_str
22862                    .into_iter()
22863                    .map(|p| p.to_string())
22864                    .collect::<Vec<String>>()
22865                    .join(",")
22866                    .to_string(),
22867            )]),
22868        };
22869    }
22870    if let Some(ref local_var_str) = owner_group__n {
22871        local_var_req_builder = match "multi" {
22872            "multi" => local_var_req_builder.query(
22873                &local_var_str
22874                    .into_iter()
22875                    .map(|p| ("owner_group__n".to_owned(), p.to_string()))
22876                    .collect::<Vec<(std::string::String, std::string::String)>>(),
22877            ),
22878            _ => local_var_req_builder.query(&[(
22879                "owner_group__n",
22880                &local_var_str
22881                    .into_iter()
22882                    .map(|p| p.to_string())
22883                    .collect::<Vec<String>>()
22884                    .join(",")
22885                    .to_string(),
22886            )]),
22887        };
22888    }
22889    if let Some(ref local_var_str) = owner_group_id {
22890        local_var_req_builder = match "multi" {
22891            "multi" => local_var_req_builder.query(
22892                &local_var_str
22893                    .into_iter()
22894                    .map(|p| ("owner_group_id".to_owned(), p.to_string()))
22895                    .collect::<Vec<(std::string::String, std::string::String)>>(),
22896            ),
22897            _ => local_var_req_builder.query(&[(
22898                "owner_group_id",
22899                &local_var_str
22900                    .into_iter()
22901                    .map(|p| p.to_string())
22902                    .collect::<Vec<String>>()
22903                    .join(",")
22904                    .to_string(),
22905            )]),
22906        };
22907    }
22908    if let Some(ref local_var_str) = owner_group_id__n {
22909        local_var_req_builder = match "multi" {
22910            "multi" => local_var_req_builder.query(
22911                &local_var_str
22912                    .into_iter()
22913                    .map(|p| ("owner_group_id__n".to_owned(), p.to_string()))
22914                    .collect::<Vec<(std::string::String, std::string::String)>>(),
22915            ),
22916            _ => local_var_req_builder.query(&[(
22917                "owner_group_id__n",
22918                &local_var_str
22919                    .into_iter()
22920                    .map(|p| p.to_string())
22921                    .collect::<Vec<String>>()
22922                    .join(",")
22923                    .to_string(),
22924            )]),
22925        };
22926    }
22927    if let Some(ref local_var_str) = owner_id {
22928        local_var_req_builder = match "multi" {
22929            "multi" => local_var_req_builder.query(
22930                &local_var_str
22931                    .into_iter()
22932                    .map(|p| ("owner_id".to_owned(), p.to_string()))
22933                    .collect::<Vec<(std::string::String, std::string::String)>>(),
22934            ),
22935            _ => local_var_req_builder.query(&[(
22936                "owner_id",
22937                &local_var_str
22938                    .into_iter()
22939                    .map(|p| p.to_string())
22940                    .collect::<Vec<String>>()
22941                    .join(",")
22942                    .to_string(),
22943            )]),
22944        };
22945    }
22946    if let Some(ref local_var_str) = owner_id__n {
22947        local_var_req_builder = match "multi" {
22948            "multi" => local_var_req_builder.query(
22949                &local_var_str
22950                    .into_iter()
22951                    .map(|p| ("owner_id__n".to_owned(), p.to_string()))
22952                    .collect::<Vec<(std::string::String, std::string::String)>>(),
22953            ),
22954            _ => local_var_req_builder.query(&[(
22955                "owner_id__n",
22956                &local_var_str
22957                    .into_iter()
22958                    .map(|p| p.to_string())
22959                    .collect::<Vec<String>>()
22960                    .join(",")
22961                    .to_string(),
22962            )]),
22963        };
22964    }
22965    if let Some(ref local_var_str) = q {
22966        local_var_req_builder = local_var_req_builder.query(&[("q", &local_var_str.to_string())]);
22967    }
22968    if let Some(ref local_var_str) = slug {
22969        local_var_req_builder = match "multi" {
22970            "multi" => local_var_req_builder.query(
22971                &local_var_str
22972                    .into_iter()
22973                    .map(|p| ("slug".to_owned(), p.to_string()))
22974                    .collect::<Vec<(std::string::String, std::string::String)>>(),
22975            ),
22976            _ => local_var_req_builder.query(&[(
22977                "slug",
22978                &local_var_str
22979                    .into_iter()
22980                    .map(|p| p.to_string())
22981                    .collect::<Vec<String>>()
22982                    .join(",")
22983                    .to_string(),
22984            )]),
22985        };
22986    }
22987    if let Some(ref local_var_str) = slug__empty {
22988        local_var_req_builder =
22989            local_var_req_builder.query(&[("slug__empty", &local_var_str.to_string())]);
22990    }
22991    if let Some(ref local_var_str) = slug__ic {
22992        local_var_req_builder = match "multi" {
22993            "multi" => local_var_req_builder.query(
22994                &local_var_str
22995                    .into_iter()
22996                    .map(|p| ("slug__ic".to_owned(), p.to_string()))
22997                    .collect::<Vec<(std::string::String, std::string::String)>>(),
22998            ),
22999            _ => local_var_req_builder.query(&[(
23000                "slug__ic",
23001                &local_var_str
23002                    .into_iter()
23003                    .map(|p| p.to_string())
23004                    .collect::<Vec<String>>()
23005                    .join(",")
23006                    .to_string(),
23007            )]),
23008        };
23009    }
23010    if let Some(ref local_var_str) = slug__ie {
23011        local_var_req_builder = match "multi" {
23012            "multi" => local_var_req_builder.query(
23013                &local_var_str
23014                    .into_iter()
23015                    .map(|p| ("slug__ie".to_owned(), p.to_string()))
23016                    .collect::<Vec<(std::string::String, std::string::String)>>(),
23017            ),
23018            _ => local_var_req_builder.query(&[(
23019                "slug__ie",
23020                &local_var_str
23021                    .into_iter()
23022                    .map(|p| p.to_string())
23023                    .collect::<Vec<String>>()
23024                    .join(",")
23025                    .to_string(),
23026            )]),
23027        };
23028    }
23029    if let Some(ref local_var_str) = slug__iew {
23030        local_var_req_builder = match "multi" {
23031            "multi" => local_var_req_builder.query(
23032                &local_var_str
23033                    .into_iter()
23034                    .map(|p| ("slug__iew".to_owned(), p.to_string()))
23035                    .collect::<Vec<(std::string::String, std::string::String)>>(),
23036            ),
23037            _ => local_var_req_builder.query(&[(
23038                "slug__iew",
23039                &local_var_str
23040                    .into_iter()
23041                    .map(|p| p.to_string())
23042                    .collect::<Vec<String>>()
23043                    .join(",")
23044                    .to_string(),
23045            )]),
23046        };
23047    }
23048    if let Some(ref local_var_str) = slug__iregex {
23049        local_var_req_builder = match "multi" {
23050            "multi" => local_var_req_builder.query(
23051                &local_var_str
23052                    .into_iter()
23053                    .map(|p| ("slug__iregex".to_owned(), p.to_string()))
23054                    .collect::<Vec<(std::string::String, std::string::String)>>(),
23055            ),
23056            _ => local_var_req_builder.query(&[(
23057                "slug__iregex",
23058                &local_var_str
23059                    .into_iter()
23060                    .map(|p| p.to_string())
23061                    .collect::<Vec<String>>()
23062                    .join(",")
23063                    .to_string(),
23064            )]),
23065        };
23066    }
23067    if let Some(ref local_var_str) = slug__isw {
23068        local_var_req_builder = match "multi" {
23069            "multi" => local_var_req_builder.query(
23070                &local_var_str
23071                    .into_iter()
23072                    .map(|p| ("slug__isw".to_owned(), p.to_string()))
23073                    .collect::<Vec<(std::string::String, std::string::String)>>(),
23074            ),
23075            _ => local_var_req_builder.query(&[(
23076                "slug__isw",
23077                &local_var_str
23078                    .into_iter()
23079                    .map(|p| p.to_string())
23080                    .collect::<Vec<String>>()
23081                    .join(",")
23082                    .to_string(),
23083            )]),
23084        };
23085    }
23086    if let Some(ref local_var_str) = slug__n {
23087        local_var_req_builder = match "multi" {
23088            "multi" => local_var_req_builder.query(
23089                &local_var_str
23090                    .into_iter()
23091                    .map(|p| ("slug__n".to_owned(), p.to_string()))
23092                    .collect::<Vec<(std::string::String, std::string::String)>>(),
23093            ),
23094            _ => local_var_req_builder.query(&[(
23095                "slug__n",
23096                &local_var_str
23097                    .into_iter()
23098                    .map(|p| p.to_string())
23099                    .collect::<Vec<String>>()
23100                    .join(",")
23101                    .to_string(),
23102            )]),
23103        };
23104    }
23105    if let Some(ref local_var_str) = slug__nic {
23106        local_var_req_builder = match "multi" {
23107            "multi" => local_var_req_builder.query(
23108                &local_var_str
23109                    .into_iter()
23110                    .map(|p| ("slug__nic".to_owned(), p.to_string()))
23111                    .collect::<Vec<(std::string::String, std::string::String)>>(),
23112            ),
23113            _ => local_var_req_builder.query(&[(
23114                "slug__nic",
23115                &local_var_str
23116                    .into_iter()
23117                    .map(|p| p.to_string())
23118                    .collect::<Vec<String>>()
23119                    .join(",")
23120                    .to_string(),
23121            )]),
23122        };
23123    }
23124    if let Some(ref local_var_str) = slug__nie {
23125        local_var_req_builder = match "multi" {
23126            "multi" => local_var_req_builder.query(
23127                &local_var_str
23128                    .into_iter()
23129                    .map(|p| ("slug__nie".to_owned(), p.to_string()))
23130                    .collect::<Vec<(std::string::String, std::string::String)>>(),
23131            ),
23132            _ => local_var_req_builder.query(&[(
23133                "slug__nie",
23134                &local_var_str
23135                    .into_iter()
23136                    .map(|p| p.to_string())
23137                    .collect::<Vec<String>>()
23138                    .join(",")
23139                    .to_string(),
23140            )]),
23141        };
23142    }
23143    if let Some(ref local_var_str) = slug__niew {
23144        local_var_req_builder = match "multi" {
23145            "multi" => local_var_req_builder.query(
23146                &local_var_str
23147                    .into_iter()
23148                    .map(|p| ("slug__niew".to_owned(), p.to_string()))
23149                    .collect::<Vec<(std::string::String, std::string::String)>>(),
23150            ),
23151            _ => local_var_req_builder.query(&[(
23152                "slug__niew",
23153                &local_var_str
23154                    .into_iter()
23155                    .map(|p| p.to_string())
23156                    .collect::<Vec<String>>()
23157                    .join(",")
23158                    .to_string(),
23159            )]),
23160        };
23161    }
23162    if let Some(ref local_var_str) = slug__nisw {
23163        local_var_req_builder = match "multi" {
23164            "multi" => local_var_req_builder.query(
23165                &local_var_str
23166                    .into_iter()
23167                    .map(|p| ("slug__nisw".to_owned(), p.to_string()))
23168                    .collect::<Vec<(std::string::String, std::string::String)>>(),
23169            ),
23170            _ => local_var_req_builder.query(&[(
23171                "slug__nisw",
23172                &local_var_str
23173                    .into_iter()
23174                    .map(|p| p.to_string())
23175                    .collect::<Vec<String>>()
23176                    .join(",")
23177                    .to_string(),
23178            )]),
23179        };
23180    }
23181    if let Some(ref local_var_str) = slug__regex {
23182        local_var_req_builder = match "multi" {
23183            "multi" => local_var_req_builder.query(
23184                &local_var_str
23185                    .into_iter()
23186                    .map(|p| ("slug__regex".to_owned(), p.to_string()))
23187                    .collect::<Vec<(std::string::String, std::string::String)>>(),
23188            ),
23189            _ => local_var_req_builder.query(&[(
23190                "slug__regex",
23191                &local_var_str
23192                    .into_iter()
23193                    .map(|p| p.to_string())
23194                    .collect::<Vec<String>>()
23195                    .join(",")
23196                    .to_string(),
23197            )]),
23198        };
23199    }
23200    if let Some(ref local_var_str) = tag {
23201        local_var_req_builder = match "multi" {
23202            "multi" => local_var_req_builder.query(
23203                &local_var_str
23204                    .into_iter()
23205                    .map(|p| ("tag".to_owned(), p.to_string()))
23206                    .collect::<Vec<(std::string::String, std::string::String)>>(),
23207            ),
23208            _ => local_var_req_builder.query(&[(
23209                "tag",
23210                &local_var_str
23211                    .into_iter()
23212                    .map(|p| p.to_string())
23213                    .collect::<Vec<String>>()
23214                    .join(",")
23215                    .to_string(),
23216            )]),
23217        };
23218    }
23219    if let Some(ref local_var_str) = tag__n {
23220        local_var_req_builder = match "multi" {
23221            "multi" => local_var_req_builder.query(
23222                &local_var_str
23223                    .into_iter()
23224                    .map(|p| ("tag__n".to_owned(), p.to_string()))
23225                    .collect::<Vec<(std::string::String, std::string::String)>>(),
23226            ),
23227            _ => local_var_req_builder.query(&[(
23228                "tag__n",
23229                &local_var_str
23230                    .into_iter()
23231                    .map(|p| p.to_string())
23232                    .collect::<Vec<String>>()
23233                    .join(",")
23234                    .to_string(),
23235            )]),
23236        };
23237    }
23238    if let Some(ref local_var_str) = tag_id {
23239        local_var_req_builder = match "multi" {
23240            "multi" => local_var_req_builder.query(
23241                &local_var_str
23242                    .into_iter()
23243                    .map(|p| ("tag_id".to_owned(), p.to_string()))
23244                    .collect::<Vec<(std::string::String, std::string::String)>>(),
23245            ),
23246            _ => local_var_req_builder.query(&[(
23247                "tag_id",
23248                &local_var_str
23249                    .into_iter()
23250                    .map(|p| p.to_string())
23251                    .collect::<Vec<String>>()
23252                    .join(",")
23253                    .to_string(),
23254            )]),
23255        };
23256    }
23257    if let Some(ref local_var_str) = tag_id__n {
23258        local_var_req_builder = match "multi" {
23259            "multi" => local_var_req_builder.query(
23260                &local_var_str
23261                    .into_iter()
23262                    .map(|p| ("tag_id__n".to_owned(), p.to_string()))
23263                    .collect::<Vec<(std::string::String, std::string::String)>>(),
23264            ),
23265            _ => local_var_req_builder.query(&[(
23266                "tag_id__n",
23267                &local_var_str
23268                    .into_iter()
23269                    .map(|p| p.to_string())
23270                    .collect::<Vec<String>>()
23271                    .join(",")
23272                    .to_string(),
23273            )]),
23274        };
23275    }
23276    if let Some(ref local_var_str) = updated_by_request {
23277        local_var_req_builder =
23278            local_var_req_builder.query(&[("updated_by_request", &local_var_str.to_string())]);
23279    }
23280    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
23281        local_var_req_builder =
23282            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
23283    }
23284    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
23285        let local_var_key = local_var_apikey.key.clone();
23286        let local_var_value = match local_var_apikey.prefix {
23287            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
23288            None => local_var_key,
23289        };
23290        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
23291    };
23292
23293    let local_var_req = local_var_req_builder.build()?;
23294    let local_var_resp = local_var_client.execute(local_var_req).await?;
23295
23296    let local_var_status = local_var_resp.status();
23297    let local_var_content = local_var_resp.text().await?;
23298
23299    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
23300        serde_json::from_str(&local_var_content).map_err(Error::from)
23301    } else {
23302        let local_var_entity: Option<CircuitsVirtualCircuitTypesListError> =
23303            serde_json::from_str(&local_var_content).ok();
23304        let local_var_error = ResponseContent {
23305            status: local_var_status,
23306            content: local_var_content,
23307            entity: local_var_entity,
23308        };
23309        Err(Error::ResponseError(local_var_error))
23310    }
23311}
23312
23313/// Patch a virtual circuit type object.
23314pub async fn circuits_virtual_circuit_types_partial_update(
23315    configuration: &configuration::Configuration,
23316    id: i32,
23317    patched_virtual_circuit_type_request: Option<crate::models::PatchedVirtualCircuitTypeRequest>,
23318) -> Result<crate::models::VirtualCircuitType, Error<CircuitsVirtualCircuitTypesPartialUpdateError>>
23319{
23320    let local_var_configuration = configuration;
23321
23322    let local_var_client = &local_var_configuration.client;
23323
23324    let local_var_uri_str = format!(
23325        "{}/api/circuits/virtual-circuit-types/{id}/",
23326        local_var_configuration.base_path,
23327        id = id
23328    );
23329    let mut local_var_req_builder =
23330        local_var_client.request(reqwest::Method::PATCH, local_var_uri_str.as_str());
23331
23332    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
23333        local_var_req_builder =
23334            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
23335    }
23336    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
23337        let local_var_key = local_var_apikey.key.clone();
23338        let local_var_value = match local_var_apikey.prefix {
23339            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
23340            None => local_var_key,
23341        };
23342        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
23343    };
23344    local_var_req_builder = local_var_req_builder.json(&patched_virtual_circuit_type_request);
23345
23346    let local_var_req = local_var_req_builder.build()?;
23347    let local_var_resp = local_var_client.execute(local_var_req).await?;
23348
23349    let local_var_status = local_var_resp.status();
23350    let local_var_content = local_var_resp.text().await?;
23351
23352    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
23353        serde_json::from_str(&local_var_content).map_err(Error::from)
23354    } else {
23355        let local_var_entity: Option<CircuitsVirtualCircuitTypesPartialUpdateError> =
23356            serde_json::from_str(&local_var_content).ok();
23357        let local_var_error = ResponseContent {
23358            status: local_var_status,
23359            content: local_var_content,
23360            entity: local_var_entity,
23361        };
23362        Err(Error::ResponseError(local_var_error))
23363    }
23364}
23365
23366/// Get a virtual circuit type object.
23367pub async fn circuits_virtual_circuit_types_retrieve(
23368    configuration: &configuration::Configuration,
23369    id: i32,
23370) -> Result<crate::models::VirtualCircuitType, Error<CircuitsVirtualCircuitTypesRetrieveError>> {
23371    let local_var_configuration = configuration;
23372
23373    let local_var_client = &local_var_configuration.client;
23374
23375    let local_var_uri_str = format!(
23376        "{}/api/circuits/virtual-circuit-types/{id}/",
23377        local_var_configuration.base_path,
23378        id = id
23379    );
23380    let mut local_var_req_builder =
23381        local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
23382
23383    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
23384        local_var_req_builder =
23385            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
23386    }
23387    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
23388        let local_var_key = local_var_apikey.key.clone();
23389        let local_var_value = match local_var_apikey.prefix {
23390            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
23391            None => local_var_key,
23392        };
23393        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
23394    };
23395
23396    let local_var_req = local_var_req_builder.build()?;
23397    let local_var_resp = local_var_client.execute(local_var_req).await?;
23398
23399    let local_var_status = local_var_resp.status();
23400    let local_var_content = local_var_resp.text().await?;
23401
23402    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
23403        serde_json::from_str(&local_var_content).map_err(Error::from)
23404    } else {
23405        let local_var_entity: Option<CircuitsVirtualCircuitTypesRetrieveError> =
23406            serde_json::from_str(&local_var_content).ok();
23407        let local_var_error = ResponseContent {
23408            status: local_var_status,
23409            content: local_var_content,
23410            entity: local_var_entity,
23411        };
23412        Err(Error::ResponseError(local_var_error))
23413    }
23414}
23415
23416/// Put a virtual circuit type object.
23417pub async fn circuits_virtual_circuit_types_update(
23418    configuration: &configuration::Configuration,
23419    id: i32,
23420    virtual_circuit_type_request: crate::models::VirtualCircuitTypeRequest,
23421) -> Result<crate::models::VirtualCircuitType, Error<CircuitsVirtualCircuitTypesUpdateError>> {
23422    let local_var_configuration = configuration;
23423
23424    let local_var_client = &local_var_configuration.client;
23425
23426    let local_var_uri_str = format!(
23427        "{}/api/circuits/virtual-circuit-types/{id}/",
23428        local_var_configuration.base_path,
23429        id = id
23430    );
23431    let mut local_var_req_builder =
23432        local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());
23433
23434    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
23435        local_var_req_builder =
23436            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
23437    }
23438    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
23439        let local_var_key = local_var_apikey.key.clone();
23440        let local_var_value = match local_var_apikey.prefix {
23441            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
23442            None => local_var_key,
23443        };
23444        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
23445    };
23446    local_var_req_builder = local_var_req_builder.json(&virtual_circuit_type_request);
23447
23448    let local_var_req = local_var_req_builder.build()?;
23449    let local_var_resp = local_var_client.execute(local_var_req).await?;
23450
23451    let local_var_status = local_var_resp.status();
23452    let local_var_content = local_var_resp.text().await?;
23453
23454    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
23455        serde_json::from_str(&local_var_content).map_err(Error::from)
23456    } else {
23457        let local_var_entity: Option<CircuitsVirtualCircuitTypesUpdateError> =
23458            serde_json::from_str(&local_var_content).ok();
23459        let local_var_error = ResponseContent {
23460            status: local_var_status,
23461            content: local_var_content,
23462            entity: local_var_entity,
23463        };
23464        Err(Error::ResponseError(local_var_error))
23465    }
23466}
23467
23468/// Delete a list of virtual circuit objects.
23469pub async fn circuits_virtual_circuits_bulk_destroy(
23470    configuration: &configuration::Configuration,
23471    virtual_circuit_request: Vec<crate::models::VirtualCircuitRequest>,
23472) -> Result<(), Error<CircuitsVirtualCircuitsBulkDestroyError>> {
23473    let local_var_configuration = configuration;
23474
23475    let local_var_client = &local_var_configuration.client;
23476
23477    let local_var_uri_str = format!(
23478        "{}/api/circuits/virtual-circuits/",
23479        local_var_configuration.base_path
23480    );
23481    let mut local_var_req_builder =
23482        local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());
23483
23484    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
23485        local_var_req_builder =
23486            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
23487    }
23488    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
23489        let local_var_key = local_var_apikey.key.clone();
23490        let local_var_value = match local_var_apikey.prefix {
23491            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
23492            None => local_var_key,
23493        };
23494        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
23495    };
23496    local_var_req_builder = local_var_req_builder.json(&virtual_circuit_request);
23497
23498    let local_var_req = local_var_req_builder.build()?;
23499    let local_var_resp = local_var_client.execute(local_var_req).await?;
23500
23501    let local_var_status = local_var_resp.status();
23502    let local_var_content = local_var_resp.text().await?;
23503
23504    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
23505        Ok(())
23506    } else {
23507        let local_var_entity: Option<CircuitsVirtualCircuitsBulkDestroyError> =
23508            serde_json::from_str(&local_var_content).ok();
23509        let local_var_error = ResponseContent {
23510            status: local_var_status,
23511            content: local_var_content,
23512            entity: local_var_entity,
23513        };
23514        Err(Error::ResponseError(local_var_error))
23515    }
23516}
23517
23518/// Patch a list of virtual circuit objects.
23519pub async fn circuits_virtual_circuits_bulk_partial_update(
23520    configuration: &configuration::Configuration,
23521    virtual_circuit_request: Vec<crate::models::VirtualCircuitRequest>,
23522) -> Result<Vec<crate::models::VirtualCircuit>, Error<CircuitsVirtualCircuitsBulkPartialUpdateError>>
23523{
23524    let local_var_configuration = configuration;
23525
23526    let local_var_client = &local_var_configuration.client;
23527
23528    let local_var_uri_str = format!(
23529        "{}/api/circuits/virtual-circuits/",
23530        local_var_configuration.base_path
23531    );
23532    let mut local_var_req_builder =
23533        local_var_client.request(reqwest::Method::PATCH, local_var_uri_str.as_str());
23534
23535    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
23536        local_var_req_builder =
23537            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
23538    }
23539    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
23540        let local_var_key = local_var_apikey.key.clone();
23541        let local_var_value = match local_var_apikey.prefix {
23542            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
23543            None => local_var_key,
23544        };
23545        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
23546    };
23547    local_var_req_builder = local_var_req_builder.json(&virtual_circuit_request);
23548
23549    let local_var_req = local_var_req_builder.build()?;
23550    let local_var_resp = local_var_client.execute(local_var_req).await?;
23551
23552    let local_var_status = local_var_resp.status();
23553    let local_var_content = local_var_resp.text().await?;
23554
23555    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
23556        serde_json::from_str(&local_var_content).map_err(Error::from)
23557    } else {
23558        let local_var_entity: Option<CircuitsVirtualCircuitsBulkPartialUpdateError> =
23559            serde_json::from_str(&local_var_content).ok();
23560        let local_var_error = ResponseContent {
23561            status: local_var_status,
23562            content: local_var_content,
23563            entity: local_var_entity,
23564        };
23565        Err(Error::ResponseError(local_var_error))
23566    }
23567}
23568
23569/// Put a list of virtual circuit objects.
23570pub async fn circuits_virtual_circuits_bulk_update(
23571    configuration: &configuration::Configuration,
23572    virtual_circuit_request: Vec<crate::models::VirtualCircuitRequest>,
23573) -> Result<Vec<crate::models::VirtualCircuit>, Error<CircuitsVirtualCircuitsBulkUpdateError>> {
23574    let local_var_configuration = configuration;
23575
23576    let local_var_client = &local_var_configuration.client;
23577
23578    let local_var_uri_str = format!(
23579        "{}/api/circuits/virtual-circuits/",
23580        local_var_configuration.base_path
23581    );
23582    let mut local_var_req_builder =
23583        local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());
23584
23585    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
23586        local_var_req_builder =
23587            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
23588    }
23589    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
23590        let local_var_key = local_var_apikey.key.clone();
23591        let local_var_value = match local_var_apikey.prefix {
23592            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
23593            None => local_var_key,
23594        };
23595        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
23596    };
23597    local_var_req_builder = local_var_req_builder.json(&virtual_circuit_request);
23598
23599    let local_var_req = local_var_req_builder.build()?;
23600    let local_var_resp = local_var_client.execute(local_var_req).await?;
23601
23602    let local_var_status = local_var_resp.status();
23603    let local_var_content = local_var_resp.text().await?;
23604
23605    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
23606        serde_json::from_str(&local_var_content).map_err(Error::from)
23607    } else {
23608        let local_var_entity: Option<CircuitsVirtualCircuitsBulkUpdateError> =
23609            serde_json::from_str(&local_var_content).ok();
23610        let local_var_error = ResponseContent {
23611            status: local_var_status,
23612            content: local_var_content,
23613            entity: local_var_entity,
23614        };
23615        Err(Error::ResponseError(local_var_error))
23616    }
23617}
23618
23619/// Post a list of virtual circuit objects.
23620pub async fn circuits_virtual_circuits_create(
23621    configuration: &configuration::Configuration,
23622    circuits_virtual_circuits_create_request: crate::models::CircuitsVirtualCircuitsCreateRequest,
23623) -> Result<crate::models::VirtualCircuit, Error<CircuitsVirtualCircuitsCreateError>> {
23624    let local_var_configuration = configuration;
23625
23626    let local_var_client = &local_var_configuration.client;
23627
23628    let local_var_uri_str = format!(
23629        "{}/api/circuits/virtual-circuits/",
23630        local_var_configuration.base_path
23631    );
23632    let mut local_var_req_builder =
23633        local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
23634
23635    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
23636        local_var_req_builder =
23637            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
23638    }
23639    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
23640        let local_var_key = local_var_apikey.key.clone();
23641        let local_var_value = match local_var_apikey.prefix {
23642            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
23643            None => local_var_key,
23644        };
23645        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
23646    };
23647    local_var_req_builder = local_var_req_builder.json(&circuits_virtual_circuits_create_request);
23648
23649    let local_var_req = local_var_req_builder.build()?;
23650    let local_var_resp = local_var_client.execute(local_var_req).await?;
23651
23652    let local_var_status = local_var_resp.status();
23653    let local_var_content = local_var_resp.text().await?;
23654
23655    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
23656        serde_json::from_str(&local_var_content).map_err(Error::from)
23657    } else {
23658        let local_var_entity: Option<CircuitsVirtualCircuitsCreateError> =
23659            serde_json::from_str(&local_var_content).ok();
23660        let local_var_error = ResponseContent {
23661            status: local_var_status,
23662            content: local_var_content,
23663            entity: local_var_entity,
23664        };
23665        Err(Error::ResponseError(local_var_error))
23666    }
23667}
23668
23669/// Delete a virtual circuit object.
23670pub async fn circuits_virtual_circuits_destroy(
23671    configuration: &configuration::Configuration,
23672    id: i32,
23673) -> Result<(), Error<CircuitsVirtualCircuitsDestroyError>> {
23674    let local_var_configuration = configuration;
23675
23676    let local_var_client = &local_var_configuration.client;
23677
23678    let local_var_uri_str = format!(
23679        "{}/api/circuits/virtual-circuits/{id}/",
23680        local_var_configuration.base_path,
23681        id = id
23682    );
23683    let mut local_var_req_builder =
23684        local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());
23685
23686    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
23687        local_var_req_builder =
23688            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
23689    }
23690    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
23691        let local_var_key = local_var_apikey.key.clone();
23692        let local_var_value = match local_var_apikey.prefix {
23693            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
23694            None => local_var_key,
23695        };
23696        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
23697    };
23698
23699    let local_var_req = local_var_req_builder.build()?;
23700    let local_var_resp = local_var_client.execute(local_var_req).await?;
23701
23702    let local_var_status = local_var_resp.status();
23703    let local_var_content = local_var_resp.text().await?;
23704
23705    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
23706        Ok(())
23707    } else {
23708        let local_var_entity: Option<CircuitsVirtualCircuitsDestroyError> =
23709            serde_json::from_str(&local_var_content).ok();
23710        let local_var_error = ResponseContent {
23711            status: local_var_status,
23712            content: local_var_content,
23713            entity: local_var_entity,
23714        };
23715        Err(Error::ResponseError(local_var_error))
23716    }
23717}
23718
23719/// Get a list of virtual circuit objects.
23720pub async fn circuits_virtual_circuits_list(
23721    configuration: &configuration::Configuration,
23722    cid: Option<Vec<String>>,
23723    cid__empty: Option<bool>,
23724    cid__ic: Option<Vec<String>>,
23725    cid__ie: Option<Vec<String>>,
23726    cid__iew: Option<Vec<String>>,
23727    cid__iregex: Option<Vec<String>>,
23728    cid__isw: Option<Vec<String>>,
23729    cid__n: Option<Vec<String>>,
23730    cid__nic: Option<Vec<String>>,
23731    cid__nie: Option<Vec<String>>,
23732    cid__niew: Option<Vec<String>>,
23733    cid__nisw: Option<Vec<String>>,
23734    cid__regex: Option<Vec<String>>,
23735    created: Option<Vec<String>>,
23736    created__empty: Option<Vec<String>>,
23737    created__gt: Option<Vec<String>>,
23738    created__gte: Option<Vec<String>>,
23739    created__lt: Option<Vec<String>>,
23740    created__lte: Option<Vec<String>>,
23741    created__n: Option<Vec<String>>,
23742    created_by_request: Option<&str>,
23743    description: Option<Vec<String>>,
23744    description__empty: Option<bool>,
23745    description__ic: Option<Vec<String>>,
23746    description__ie: Option<Vec<String>>,
23747    description__iew: Option<Vec<String>>,
23748    description__iregex: Option<Vec<String>>,
23749    description__isw: Option<Vec<String>>,
23750    description__n: Option<Vec<String>>,
23751    description__nic: Option<Vec<String>>,
23752    description__nie: Option<Vec<String>>,
23753    description__niew: Option<Vec<String>>,
23754    description__nisw: Option<Vec<String>>,
23755    description__regex: Option<Vec<String>>,
23756    id: Option<Vec<i32>>,
23757    id__empty: Option<bool>,
23758    id__gt: Option<Vec<i32>>,
23759    id__gte: Option<Vec<i32>>,
23760    id__lt: Option<Vec<i32>>,
23761    id__lte: Option<Vec<i32>>,
23762    id__n: Option<Vec<i32>>,
23763    last_updated: Option<Vec<String>>,
23764    last_updated__empty: Option<Vec<String>>,
23765    last_updated__gt: Option<Vec<String>>,
23766    last_updated__gte: Option<Vec<String>>,
23767    last_updated__lt: Option<Vec<String>>,
23768    last_updated__lte: Option<Vec<String>>,
23769    last_updated__n: Option<Vec<String>>,
23770    limit: Option<i32>,
23771    modified_by_request: Option<&str>,
23772    offset: Option<i32>,
23773    ordering: Option<&str>,
23774    owner: Option<Vec<String>>,
23775    owner__n: Option<Vec<String>>,
23776    owner_group: Option<Vec<String>>,
23777    owner_group__n: Option<Vec<String>>,
23778    owner_group_id: Option<Vec<i32>>,
23779    owner_group_id__n: Option<Vec<i32>>,
23780    owner_id: Option<Vec<i32>>,
23781    owner_id__n: Option<Vec<i32>>,
23782    provider: Option<Vec<String>>,
23783    provider__n: Option<Vec<String>>,
23784    provider_account: Option<Vec<String>>,
23785    provider_account__n: Option<Vec<String>>,
23786    provider_account_id: Option<Vec<i32>>,
23787    provider_account_id__n: Option<Vec<i32>>,
23788    provider_id: Option<Vec<i32>>,
23789    provider_id__n: Option<Vec<i32>>,
23790    provider_network_id: Option<Vec<i32>>,
23791    provider_network_id__n: Option<Vec<i32>>,
23792    q: Option<&str>,
23793    status: Option<Vec<String>>,
23794    status__empty: Option<bool>,
23795    status__ic: Option<Vec<String>>,
23796    status__ie: Option<Vec<String>>,
23797    status__iew: Option<Vec<String>>,
23798    status__iregex: Option<Vec<String>>,
23799    status__isw: Option<Vec<String>>,
23800    status__n: Option<Vec<String>>,
23801    status__nic: Option<Vec<String>>,
23802    status__nie: Option<Vec<String>>,
23803    status__niew: Option<Vec<String>>,
23804    status__nisw: Option<Vec<String>>,
23805    status__regex: Option<Vec<String>>,
23806    tag: Option<Vec<String>>,
23807    tag__n: Option<Vec<String>>,
23808    tag_id: Option<Vec<i32>>,
23809    tag_id__n: Option<Vec<i32>>,
23810    tenant: Option<Vec<String>>,
23811    tenant__n: Option<Vec<String>>,
23812    tenant_group: Option<Vec<String>>,
23813    tenant_group__n: Option<Vec<String>>,
23814    tenant_group_id: Option<Vec<String>>,
23815    tenant_group_id__n: Option<Vec<String>>,
23816    tenant_id: Option<Vec<i32>>,
23817    tenant_id__n: Option<Vec<i32>>,
23818    r#type: Option<Vec<String>>,
23819    type__n: Option<Vec<String>>,
23820    type_id: Option<Vec<i32>>,
23821    type_id__n: Option<Vec<i32>>,
23822    updated_by_request: Option<&str>,
23823) -> Result<crate::models::PaginatedVirtualCircuitList, Error<CircuitsVirtualCircuitsListError>> {
23824    let local_var_configuration = configuration;
23825
23826    let local_var_client = &local_var_configuration.client;
23827
23828    let local_var_uri_str = format!(
23829        "{}/api/circuits/virtual-circuits/",
23830        local_var_configuration.base_path
23831    );
23832    let mut local_var_req_builder =
23833        local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
23834
23835    if let Some(ref local_var_str) = cid {
23836        local_var_req_builder = match "multi" {
23837            "multi" => local_var_req_builder.query(
23838                &local_var_str
23839                    .into_iter()
23840                    .map(|p| ("cid".to_owned(), p.to_string()))
23841                    .collect::<Vec<(std::string::String, std::string::String)>>(),
23842            ),
23843            _ => local_var_req_builder.query(&[(
23844                "cid",
23845                &local_var_str
23846                    .into_iter()
23847                    .map(|p| p.to_string())
23848                    .collect::<Vec<String>>()
23849                    .join(",")
23850                    .to_string(),
23851            )]),
23852        };
23853    }
23854    if let Some(ref local_var_str) = cid__empty {
23855        local_var_req_builder =
23856            local_var_req_builder.query(&[("cid__empty", &local_var_str.to_string())]);
23857    }
23858    if let Some(ref local_var_str) = cid__ic {
23859        local_var_req_builder = match "multi" {
23860            "multi" => local_var_req_builder.query(
23861                &local_var_str
23862                    .into_iter()
23863                    .map(|p| ("cid__ic".to_owned(), p.to_string()))
23864                    .collect::<Vec<(std::string::String, std::string::String)>>(),
23865            ),
23866            _ => local_var_req_builder.query(&[(
23867                "cid__ic",
23868                &local_var_str
23869                    .into_iter()
23870                    .map(|p| p.to_string())
23871                    .collect::<Vec<String>>()
23872                    .join(",")
23873                    .to_string(),
23874            )]),
23875        };
23876    }
23877    if let Some(ref local_var_str) = cid__ie {
23878        local_var_req_builder = match "multi" {
23879            "multi" => local_var_req_builder.query(
23880                &local_var_str
23881                    .into_iter()
23882                    .map(|p| ("cid__ie".to_owned(), p.to_string()))
23883                    .collect::<Vec<(std::string::String, std::string::String)>>(),
23884            ),
23885            _ => local_var_req_builder.query(&[(
23886                "cid__ie",
23887                &local_var_str
23888                    .into_iter()
23889                    .map(|p| p.to_string())
23890                    .collect::<Vec<String>>()
23891                    .join(",")
23892                    .to_string(),
23893            )]),
23894        };
23895    }
23896    if let Some(ref local_var_str) = cid__iew {
23897        local_var_req_builder = match "multi" {
23898            "multi" => local_var_req_builder.query(
23899                &local_var_str
23900                    .into_iter()
23901                    .map(|p| ("cid__iew".to_owned(), p.to_string()))
23902                    .collect::<Vec<(std::string::String, std::string::String)>>(),
23903            ),
23904            _ => local_var_req_builder.query(&[(
23905                "cid__iew",
23906                &local_var_str
23907                    .into_iter()
23908                    .map(|p| p.to_string())
23909                    .collect::<Vec<String>>()
23910                    .join(",")
23911                    .to_string(),
23912            )]),
23913        };
23914    }
23915    if let Some(ref local_var_str) = cid__iregex {
23916        local_var_req_builder = match "multi" {
23917            "multi" => local_var_req_builder.query(
23918                &local_var_str
23919                    .into_iter()
23920                    .map(|p| ("cid__iregex".to_owned(), p.to_string()))
23921                    .collect::<Vec<(std::string::String, std::string::String)>>(),
23922            ),
23923            _ => local_var_req_builder.query(&[(
23924                "cid__iregex",
23925                &local_var_str
23926                    .into_iter()
23927                    .map(|p| p.to_string())
23928                    .collect::<Vec<String>>()
23929                    .join(",")
23930                    .to_string(),
23931            )]),
23932        };
23933    }
23934    if let Some(ref local_var_str) = cid__isw {
23935        local_var_req_builder = match "multi" {
23936            "multi" => local_var_req_builder.query(
23937                &local_var_str
23938                    .into_iter()
23939                    .map(|p| ("cid__isw".to_owned(), p.to_string()))
23940                    .collect::<Vec<(std::string::String, std::string::String)>>(),
23941            ),
23942            _ => local_var_req_builder.query(&[(
23943                "cid__isw",
23944                &local_var_str
23945                    .into_iter()
23946                    .map(|p| p.to_string())
23947                    .collect::<Vec<String>>()
23948                    .join(",")
23949                    .to_string(),
23950            )]),
23951        };
23952    }
23953    if let Some(ref local_var_str) = cid__n {
23954        local_var_req_builder = match "multi" {
23955            "multi" => local_var_req_builder.query(
23956                &local_var_str
23957                    .into_iter()
23958                    .map(|p| ("cid__n".to_owned(), p.to_string()))
23959                    .collect::<Vec<(std::string::String, std::string::String)>>(),
23960            ),
23961            _ => local_var_req_builder.query(&[(
23962                "cid__n",
23963                &local_var_str
23964                    .into_iter()
23965                    .map(|p| p.to_string())
23966                    .collect::<Vec<String>>()
23967                    .join(",")
23968                    .to_string(),
23969            )]),
23970        };
23971    }
23972    if let Some(ref local_var_str) = cid__nic {
23973        local_var_req_builder = match "multi" {
23974            "multi" => local_var_req_builder.query(
23975                &local_var_str
23976                    .into_iter()
23977                    .map(|p| ("cid__nic".to_owned(), p.to_string()))
23978                    .collect::<Vec<(std::string::String, std::string::String)>>(),
23979            ),
23980            _ => local_var_req_builder.query(&[(
23981                "cid__nic",
23982                &local_var_str
23983                    .into_iter()
23984                    .map(|p| p.to_string())
23985                    .collect::<Vec<String>>()
23986                    .join(",")
23987                    .to_string(),
23988            )]),
23989        };
23990    }
23991    if let Some(ref local_var_str) = cid__nie {
23992        local_var_req_builder = match "multi" {
23993            "multi" => local_var_req_builder.query(
23994                &local_var_str
23995                    .into_iter()
23996                    .map(|p| ("cid__nie".to_owned(), p.to_string()))
23997                    .collect::<Vec<(std::string::String, std::string::String)>>(),
23998            ),
23999            _ => local_var_req_builder.query(&[(
24000                "cid__nie",
24001                &local_var_str
24002                    .into_iter()
24003                    .map(|p| p.to_string())
24004                    .collect::<Vec<String>>()
24005                    .join(",")
24006                    .to_string(),
24007            )]),
24008        };
24009    }
24010    if let Some(ref local_var_str) = cid__niew {
24011        local_var_req_builder = match "multi" {
24012            "multi" => local_var_req_builder.query(
24013                &local_var_str
24014                    .into_iter()
24015                    .map(|p| ("cid__niew".to_owned(), p.to_string()))
24016                    .collect::<Vec<(std::string::String, std::string::String)>>(),
24017            ),
24018            _ => local_var_req_builder.query(&[(
24019                "cid__niew",
24020                &local_var_str
24021                    .into_iter()
24022                    .map(|p| p.to_string())
24023                    .collect::<Vec<String>>()
24024                    .join(",")
24025                    .to_string(),
24026            )]),
24027        };
24028    }
24029    if let Some(ref local_var_str) = cid__nisw {
24030        local_var_req_builder = match "multi" {
24031            "multi" => local_var_req_builder.query(
24032                &local_var_str
24033                    .into_iter()
24034                    .map(|p| ("cid__nisw".to_owned(), p.to_string()))
24035                    .collect::<Vec<(std::string::String, std::string::String)>>(),
24036            ),
24037            _ => local_var_req_builder.query(&[(
24038                "cid__nisw",
24039                &local_var_str
24040                    .into_iter()
24041                    .map(|p| p.to_string())
24042                    .collect::<Vec<String>>()
24043                    .join(",")
24044                    .to_string(),
24045            )]),
24046        };
24047    }
24048    if let Some(ref local_var_str) = cid__regex {
24049        local_var_req_builder = match "multi" {
24050            "multi" => local_var_req_builder.query(
24051                &local_var_str
24052                    .into_iter()
24053                    .map(|p| ("cid__regex".to_owned(), p.to_string()))
24054                    .collect::<Vec<(std::string::String, std::string::String)>>(),
24055            ),
24056            _ => local_var_req_builder.query(&[(
24057                "cid__regex",
24058                &local_var_str
24059                    .into_iter()
24060                    .map(|p| p.to_string())
24061                    .collect::<Vec<String>>()
24062                    .join(",")
24063                    .to_string(),
24064            )]),
24065        };
24066    }
24067    if let Some(ref local_var_str) = created {
24068        local_var_req_builder = match "multi" {
24069            "multi" => local_var_req_builder.query(
24070                &local_var_str
24071                    .into_iter()
24072                    .map(|p| ("created".to_owned(), p.to_string()))
24073                    .collect::<Vec<(std::string::String, std::string::String)>>(),
24074            ),
24075            _ => local_var_req_builder.query(&[(
24076                "created",
24077                &local_var_str
24078                    .into_iter()
24079                    .map(|p| p.to_string())
24080                    .collect::<Vec<String>>()
24081                    .join(",")
24082                    .to_string(),
24083            )]),
24084        };
24085    }
24086    if let Some(ref local_var_str) = created__empty {
24087        local_var_req_builder = match "multi" {
24088            "multi" => local_var_req_builder.query(
24089                &local_var_str
24090                    .into_iter()
24091                    .map(|p| ("created__empty".to_owned(), p.to_string()))
24092                    .collect::<Vec<(std::string::String, std::string::String)>>(),
24093            ),
24094            _ => local_var_req_builder.query(&[(
24095                "created__empty",
24096                &local_var_str
24097                    .into_iter()
24098                    .map(|p| p.to_string())
24099                    .collect::<Vec<String>>()
24100                    .join(",")
24101                    .to_string(),
24102            )]),
24103        };
24104    }
24105    if let Some(ref local_var_str) = created__gt {
24106        local_var_req_builder = match "multi" {
24107            "multi" => local_var_req_builder.query(
24108                &local_var_str
24109                    .into_iter()
24110                    .map(|p| ("created__gt".to_owned(), p.to_string()))
24111                    .collect::<Vec<(std::string::String, std::string::String)>>(),
24112            ),
24113            _ => local_var_req_builder.query(&[(
24114                "created__gt",
24115                &local_var_str
24116                    .into_iter()
24117                    .map(|p| p.to_string())
24118                    .collect::<Vec<String>>()
24119                    .join(",")
24120                    .to_string(),
24121            )]),
24122        };
24123    }
24124    if let Some(ref local_var_str) = created__gte {
24125        local_var_req_builder = match "multi" {
24126            "multi" => local_var_req_builder.query(
24127                &local_var_str
24128                    .into_iter()
24129                    .map(|p| ("created__gte".to_owned(), p.to_string()))
24130                    .collect::<Vec<(std::string::String, std::string::String)>>(),
24131            ),
24132            _ => local_var_req_builder.query(&[(
24133                "created__gte",
24134                &local_var_str
24135                    .into_iter()
24136                    .map(|p| p.to_string())
24137                    .collect::<Vec<String>>()
24138                    .join(",")
24139                    .to_string(),
24140            )]),
24141        };
24142    }
24143    if let Some(ref local_var_str) = created__lt {
24144        local_var_req_builder = match "multi" {
24145            "multi" => local_var_req_builder.query(
24146                &local_var_str
24147                    .into_iter()
24148                    .map(|p| ("created__lt".to_owned(), p.to_string()))
24149                    .collect::<Vec<(std::string::String, std::string::String)>>(),
24150            ),
24151            _ => local_var_req_builder.query(&[(
24152                "created__lt",
24153                &local_var_str
24154                    .into_iter()
24155                    .map(|p| p.to_string())
24156                    .collect::<Vec<String>>()
24157                    .join(",")
24158                    .to_string(),
24159            )]),
24160        };
24161    }
24162    if let Some(ref local_var_str) = created__lte {
24163        local_var_req_builder = match "multi" {
24164            "multi" => local_var_req_builder.query(
24165                &local_var_str
24166                    .into_iter()
24167                    .map(|p| ("created__lte".to_owned(), p.to_string()))
24168                    .collect::<Vec<(std::string::String, std::string::String)>>(),
24169            ),
24170            _ => local_var_req_builder.query(&[(
24171                "created__lte",
24172                &local_var_str
24173                    .into_iter()
24174                    .map(|p| p.to_string())
24175                    .collect::<Vec<String>>()
24176                    .join(",")
24177                    .to_string(),
24178            )]),
24179        };
24180    }
24181    if let Some(ref local_var_str) = created__n {
24182        local_var_req_builder = match "multi" {
24183            "multi" => local_var_req_builder.query(
24184                &local_var_str
24185                    .into_iter()
24186                    .map(|p| ("created__n".to_owned(), p.to_string()))
24187                    .collect::<Vec<(std::string::String, std::string::String)>>(),
24188            ),
24189            _ => local_var_req_builder.query(&[(
24190                "created__n",
24191                &local_var_str
24192                    .into_iter()
24193                    .map(|p| p.to_string())
24194                    .collect::<Vec<String>>()
24195                    .join(",")
24196                    .to_string(),
24197            )]),
24198        };
24199    }
24200    if let Some(ref local_var_str) = created_by_request {
24201        local_var_req_builder =
24202            local_var_req_builder.query(&[("created_by_request", &local_var_str.to_string())]);
24203    }
24204    if let Some(ref local_var_str) = description {
24205        local_var_req_builder = match "multi" {
24206            "multi" => local_var_req_builder.query(
24207                &local_var_str
24208                    .into_iter()
24209                    .map(|p| ("description".to_owned(), p.to_string()))
24210                    .collect::<Vec<(std::string::String, std::string::String)>>(),
24211            ),
24212            _ => local_var_req_builder.query(&[(
24213                "description",
24214                &local_var_str
24215                    .into_iter()
24216                    .map(|p| p.to_string())
24217                    .collect::<Vec<String>>()
24218                    .join(",")
24219                    .to_string(),
24220            )]),
24221        };
24222    }
24223    if let Some(ref local_var_str) = description__empty {
24224        local_var_req_builder =
24225            local_var_req_builder.query(&[("description__empty", &local_var_str.to_string())]);
24226    }
24227    if let Some(ref local_var_str) = description__ic {
24228        local_var_req_builder = match "multi" {
24229            "multi" => local_var_req_builder.query(
24230                &local_var_str
24231                    .into_iter()
24232                    .map(|p| ("description__ic".to_owned(), p.to_string()))
24233                    .collect::<Vec<(std::string::String, std::string::String)>>(),
24234            ),
24235            _ => local_var_req_builder.query(&[(
24236                "description__ic",
24237                &local_var_str
24238                    .into_iter()
24239                    .map(|p| p.to_string())
24240                    .collect::<Vec<String>>()
24241                    .join(",")
24242                    .to_string(),
24243            )]),
24244        };
24245    }
24246    if let Some(ref local_var_str) = description__ie {
24247        local_var_req_builder = match "multi" {
24248            "multi" => local_var_req_builder.query(
24249                &local_var_str
24250                    .into_iter()
24251                    .map(|p| ("description__ie".to_owned(), p.to_string()))
24252                    .collect::<Vec<(std::string::String, std::string::String)>>(),
24253            ),
24254            _ => local_var_req_builder.query(&[(
24255                "description__ie",
24256                &local_var_str
24257                    .into_iter()
24258                    .map(|p| p.to_string())
24259                    .collect::<Vec<String>>()
24260                    .join(",")
24261                    .to_string(),
24262            )]),
24263        };
24264    }
24265    if let Some(ref local_var_str) = description__iew {
24266        local_var_req_builder = match "multi" {
24267            "multi" => local_var_req_builder.query(
24268                &local_var_str
24269                    .into_iter()
24270                    .map(|p| ("description__iew".to_owned(), p.to_string()))
24271                    .collect::<Vec<(std::string::String, std::string::String)>>(),
24272            ),
24273            _ => local_var_req_builder.query(&[(
24274                "description__iew",
24275                &local_var_str
24276                    .into_iter()
24277                    .map(|p| p.to_string())
24278                    .collect::<Vec<String>>()
24279                    .join(",")
24280                    .to_string(),
24281            )]),
24282        };
24283    }
24284    if let Some(ref local_var_str) = description__iregex {
24285        local_var_req_builder = match "multi" {
24286            "multi" => local_var_req_builder.query(
24287                &local_var_str
24288                    .into_iter()
24289                    .map(|p| ("description__iregex".to_owned(), p.to_string()))
24290                    .collect::<Vec<(std::string::String, std::string::String)>>(),
24291            ),
24292            _ => local_var_req_builder.query(&[(
24293                "description__iregex",
24294                &local_var_str
24295                    .into_iter()
24296                    .map(|p| p.to_string())
24297                    .collect::<Vec<String>>()
24298                    .join(",")
24299                    .to_string(),
24300            )]),
24301        };
24302    }
24303    if let Some(ref local_var_str) = description__isw {
24304        local_var_req_builder = match "multi" {
24305            "multi" => local_var_req_builder.query(
24306                &local_var_str
24307                    .into_iter()
24308                    .map(|p| ("description__isw".to_owned(), p.to_string()))
24309                    .collect::<Vec<(std::string::String, std::string::String)>>(),
24310            ),
24311            _ => local_var_req_builder.query(&[(
24312                "description__isw",
24313                &local_var_str
24314                    .into_iter()
24315                    .map(|p| p.to_string())
24316                    .collect::<Vec<String>>()
24317                    .join(",")
24318                    .to_string(),
24319            )]),
24320        };
24321    }
24322    if let Some(ref local_var_str) = description__n {
24323        local_var_req_builder = match "multi" {
24324            "multi" => local_var_req_builder.query(
24325                &local_var_str
24326                    .into_iter()
24327                    .map(|p| ("description__n".to_owned(), p.to_string()))
24328                    .collect::<Vec<(std::string::String, std::string::String)>>(),
24329            ),
24330            _ => local_var_req_builder.query(&[(
24331                "description__n",
24332                &local_var_str
24333                    .into_iter()
24334                    .map(|p| p.to_string())
24335                    .collect::<Vec<String>>()
24336                    .join(",")
24337                    .to_string(),
24338            )]),
24339        };
24340    }
24341    if let Some(ref local_var_str) = description__nic {
24342        local_var_req_builder = match "multi" {
24343            "multi" => local_var_req_builder.query(
24344                &local_var_str
24345                    .into_iter()
24346                    .map(|p| ("description__nic".to_owned(), p.to_string()))
24347                    .collect::<Vec<(std::string::String, std::string::String)>>(),
24348            ),
24349            _ => local_var_req_builder.query(&[(
24350                "description__nic",
24351                &local_var_str
24352                    .into_iter()
24353                    .map(|p| p.to_string())
24354                    .collect::<Vec<String>>()
24355                    .join(",")
24356                    .to_string(),
24357            )]),
24358        };
24359    }
24360    if let Some(ref local_var_str) = description__nie {
24361        local_var_req_builder = match "multi" {
24362            "multi" => local_var_req_builder.query(
24363                &local_var_str
24364                    .into_iter()
24365                    .map(|p| ("description__nie".to_owned(), p.to_string()))
24366                    .collect::<Vec<(std::string::String, std::string::String)>>(),
24367            ),
24368            _ => local_var_req_builder.query(&[(
24369                "description__nie",
24370                &local_var_str
24371                    .into_iter()
24372                    .map(|p| p.to_string())
24373                    .collect::<Vec<String>>()
24374                    .join(",")
24375                    .to_string(),
24376            )]),
24377        };
24378    }
24379    if let Some(ref local_var_str) = description__niew {
24380        local_var_req_builder = match "multi" {
24381            "multi" => local_var_req_builder.query(
24382                &local_var_str
24383                    .into_iter()
24384                    .map(|p| ("description__niew".to_owned(), p.to_string()))
24385                    .collect::<Vec<(std::string::String, std::string::String)>>(),
24386            ),
24387            _ => local_var_req_builder.query(&[(
24388                "description__niew",
24389                &local_var_str
24390                    .into_iter()
24391                    .map(|p| p.to_string())
24392                    .collect::<Vec<String>>()
24393                    .join(",")
24394                    .to_string(),
24395            )]),
24396        };
24397    }
24398    if let Some(ref local_var_str) = description__nisw {
24399        local_var_req_builder = match "multi" {
24400            "multi" => local_var_req_builder.query(
24401                &local_var_str
24402                    .into_iter()
24403                    .map(|p| ("description__nisw".to_owned(), p.to_string()))
24404                    .collect::<Vec<(std::string::String, std::string::String)>>(),
24405            ),
24406            _ => local_var_req_builder.query(&[(
24407                "description__nisw",
24408                &local_var_str
24409                    .into_iter()
24410                    .map(|p| p.to_string())
24411                    .collect::<Vec<String>>()
24412                    .join(",")
24413                    .to_string(),
24414            )]),
24415        };
24416    }
24417    if let Some(ref local_var_str) = description__regex {
24418        local_var_req_builder = match "multi" {
24419            "multi" => local_var_req_builder.query(
24420                &local_var_str
24421                    .into_iter()
24422                    .map(|p| ("description__regex".to_owned(), p.to_string()))
24423                    .collect::<Vec<(std::string::String, std::string::String)>>(),
24424            ),
24425            _ => local_var_req_builder.query(&[(
24426                "description__regex",
24427                &local_var_str
24428                    .into_iter()
24429                    .map(|p| p.to_string())
24430                    .collect::<Vec<String>>()
24431                    .join(",")
24432                    .to_string(),
24433            )]),
24434        };
24435    }
24436    if let Some(ref local_var_str) = id {
24437        local_var_req_builder = match "multi" {
24438            "multi" => local_var_req_builder.query(
24439                &local_var_str
24440                    .into_iter()
24441                    .map(|p| ("id".to_owned(), p.to_string()))
24442                    .collect::<Vec<(std::string::String, std::string::String)>>(),
24443            ),
24444            _ => local_var_req_builder.query(&[(
24445                "id",
24446                &local_var_str
24447                    .into_iter()
24448                    .map(|p| p.to_string())
24449                    .collect::<Vec<String>>()
24450                    .join(",")
24451                    .to_string(),
24452            )]),
24453        };
24454    }
24455    if let Some(ref local_var_str) = id__empty {
24456        local_var_req_builder =
24457            local_var_req_builder.query(&[("id__empty", &local_var_str.to_string())]);
24458    }
24459    if let Some(ref local_var_str) = id__gt {
24460        local_var_req_builder = match "multi" {
24461            "multi" => local_var_req_builder.query(
24462                &local_var_str
24463                    .into_iter()
24464                    .map(|p| ("id__gt".to_owned(), p.to_string()))
24465                    .collect::<Vec<(std::string::String, std::string::String)>>(),
24466            ),
24467            _ => local_var_req_builder.query(&[(
24468                "id__gt",
24469                &local_var_str
24470                    .into_iter()
24471                    .map(|p| p.to_string())
24472                    .collect::<Vec<String>>()
24473                    .join(",")
24474                    .to_string(),
24475            )]),
24476        };
24477    }
24478    if let Some(ref local_var_str) = id__gte {
24479        local_var_req_builder = match "multi" {
24480            "multi" => local_var_req_builder.query(
24481                &local_var_str
24482                    .into_iter()
24483                    .map(|p| ("id__gte".to_owned(), p.to_string()))
24484                    .collect::<Vec<(std::string::String, std::string::String)>>(),
24485            ),
24486            _ => local_var_req_builder.query(&[(
24487                "id__gte",
24488                &local_var_str
24489                    .into_iter()
24490                    .map(|p| p.to_string())
24491                    .collect::<Vec<String>>()
24492                    .join(",")
24493                    .to_string(),
24494            )]),
24495        };
24496    }
24497    if let Some(ref local_var_str) = id__lt {
24498        local_var_req_builder = match "multi" {
24499            "multi" => local_var_req_builder.query(
24500                &local_var_str
24501                    .into_iter()
24502                    .map(|p| ("id__lt".to_owned(), p.to_string()))
24503                    .collect::<Vec<(std::string::String, std::string::String)>>(),
24504            ),
24505            _ => local_var_req_builder.query(&[(
24506                "id__lt",
24507                &local_var_str
24508                    .into_iter()
24509                    .map(|p| p.to_string())
24510                    .collect::<Vec<String>>()
24511                    .join(",")
24512                    .to_string(),
24513            )]),
24514        };
24515    }
24516    if let Some(ref local_var_str) = id__lte {
24517        local_var_req_builder = match "multi" {
24518            "multi" => local_var_req_builder.query(
24519                &local_var_str
24520                    .into_iter()
24521                    .map(|p| ("id__lte".to_owned(), p.to_string()))
24522                    .collect::<Vec<(std::string::String, std::string::String)>>(),
24523            ),
24524            _ => local_var_req_builder.query(&[(
24525                "id__lte",
24526                &local_var_str
24527                    .into_iter()
24528                    .map(|p| p.to_string())
24529                    .collect::<Vec<String>>()
24530                    .join(",")
24531                    .to_string(),
24532            )]),
24533        };
24534    }
24535    if let Some(ref local_var_str) = id__n {
24536        local_var_req_builder = match "multi" {
24537            "multi" => local_var_req_builder.query(
24538                &local_var_str
24539                    .into_iter()
24540                    .map(|p| ("id__n".to_owned(), p.to_string()))
24541                    .collect::<Vec<(std::string::String, std::string::String)>>(),
24542            ),
24543            _ => local_var_req_builder.query(&[(
24544                "id__n",
24545                &local_var_str
24546                    .into_iter()
24547                    .map(|p| p.to_string())
24548                    .collect::<Vec<String>>()
24549                    .join(",")
24550                    .to_string(),
24551            )]),
24552        };
24553    }
24554    if let Some(ref local_var_str) = last_updated {
24555        local_var_req_builder = match "multi" {
24556            "multi" => local_var_req_builder.query(
24557                &local_var_str
24558                    .into_iter()
24559                    .map(|p| ("last_updated".to_owned(), p.to_string()))
24560                    .collect::<Vec<(std::string::String, std::string::String)>>(),
24561            ),
24562            _ => local_var_req_builder.query(&[(
24563                "last_updated",
24564                &local_var_str
24565                    .into_iter()
24566                    .map(|p| p.to_string())
24567                    .collect::<Vec<String>>()
24568                    .join(",")
24569                    .to_string(),
24570            )]),
24571        };
24572    }
24573    if let Some(ref local_var_str) = last_updated__empty {
24574        local_var_req_builder = match "multi" {
24575            "multi" => local_var_req_builder.query(
24576                &local_var_str
24577                    .into_iter()
24578                    .map(|p| ("last_updated__empty".to_owned(), p.to_string()))
24579                    .collect::<Vec<(std::string::String, std::string::String)>>(),
24580            ),
24581            _ => local_var_req_builder.query(&[(
24582                "last_updated__empty",
24583                &local_var_str
24584                    .into_iter()
24585                    .map(|p| p.to_string())
24586                    .collect::<Vec<String>>()
24587                    .join(",")
24588                    .to_string(),
24589            )]),
24590        };
24591    }
24592    if let Some(ref local_var_str) = last_updated__gt {
24593        local_var_req_builder = match "multi" {
24594            "multi" => local_var_req_builder.query(
24595                &local_var_str
24596                    .into_iter()
24597                    .map(|p| ("last_updated__gt".to_owned(), p.to_string()))
24598                    .collect::<Vec<(std::string::String, std::string::String)>>(),
24599            ),
24600            _ => local_var_req_builder.query(&[(
24601                "last_updated__gt",
24602                &local_var_str
24603                    .into_iter()
24604                    .map(|p| p.to_string())
24605                    .collect::<Vec<String>>()
24606                    .join(",")
24607                    .to_string(),
24608            )]),
24609        };
24610    }
24611    if let Some(ref local_var_str) = last_updated__gte {
24612        local_var_req_builder = match "multi" {
24613            "multi" => local_var_req_builder.query(
24614                &local_var_str
24615                    .into_iter()
24616                    .map(|p| ("last_updated__gte".to_owned(), p.to_string()))
24617                    .collect::<Vec<(std::string::String, std::string::String)>>(),
24618            ),
24619            _ => local_var_req_builder.query(&[(
24620                "last_updated__gte",
24621                &local_var_str
24622                    .into_iter()
24623                    .map(|p| p.to_string())
24624                    .collect::<Vec<String>>()
24625                    .join(",")
24626                    .to_string(),
24627            )]),
24628        };
24629    }
24630    if let Some(ref local_var_str) = last_updated__lt {
24631        local_var_req_builder = match "multi" {
24632            "multi" => local_var_req_builder.query(
24633                &local_var_str
24634                    .into_iter()
24635                    .map(|p| ("last_updated__lt".to_owned(), p.to_string()))
24636                    .collect::<Vec<(std::string::String, std::string::String)>>(),
24637            ),
24638            _ => local_var_req_builder.query(&[(
24639                "last_updated__lt",
24640                &local_var_str
24641                    .into_iter()
24642                    .map(|p| p.to_string())
24643                    .collect::<Vec<String>>()
24644                    .join(",")
24645                    .to_string(),
24646            )]),
24647        };
24648    }
24649    if let Some(ref local_var_str) = last_updated__lte {
24650        local_var_req_builder = match "multi" {
24651            "multi" => local_var_req_builder.query(
24652                &local_var_str
24653                    .into_iter()
24654                    .map(|p| ("last_updated__lte".to_owned(), p.to_string()))
24655                    .collect::<Vec<(std::string::String, std::string::String)>>(),
24656            ),
24657            _ => local_var_req_builder.query(&[(
24658                "last_updated__lte",
24659                &local_var_str
24660                    .into_iter()
24661                    .map(|p| p.to_string())
24662                    .collect::<Vec<String>>()
24663                    .join(",")
24664                    .to_string(),
24665            )]),
24666        };
24667    }
24668    if let Some(ref local_var_str) = last_updated__n {
24669        local_var_req_builder = match "multi" {
24670            "multi" => local_var_req_builder.query(
24671                &local_var_str
24672                    .into_iter()
24673                    .map(|p| ("last_updated__n".to_owned(), p.to_string()))
24674                    .collect::<Vec<(std::string::String, std::string::String)>>(),
24675            ),
24676            _ => local_var_req_builder.query(&[(
24677                "last_updated__n",
24678                &local_var_str
24679                    .into_iter()
24680                    .map(|p| p.to_string())
24681                    .collect::<Vec<String>>()
24682                    .join(",")
24683                    .to_string(),
24684            )]),
24685        };
24686    }
24687    if let Some(ref local_var_str) = limit {
24688        local_var_req_builder =
24689            local_var_req_builder.query(&[("limit", &local_var_str.to_string())]);
24690    }
24691    if let Some(ref local_var_str) = modified_by_request {
24692        local_var_req_builder =
24693            local_var_req_builder.query(&[("modified_by_request", &local_var_str.to_string())]);
24694    }
24695    if let Some(ref local_var_str) = offset {
24696        local_var_req_builder =
24697            local_var_req_builder.query(&[("offset", &local_var_str.to_string())]);
24698    }
24699    if let Some(ref local_var_str) = ordering {
24700        local_var_req_builder =
24701            local_var_req_builder.query(&[("ordering", &local_var_str.to_string())]);
24702    }
24703    if let Some(ref local_var_str) = owner {
24704        local_var_req_builder = match "multi" {
24705            "multi" => local_var_req_builder.query(
24706                &local_var_str
24707                    .into_iter()
24708                    .map(|p| ("owner".to_owned(), p.to_string()))
24709                    .collect::<Vec<(std::string::String, std::string::String)>>(),
24710            ),
24711            _ => local_var_req_builder.query(&[(
24712                "owner",
24713                &local_var_str
24714                    .into_iter()
24715                    .map(|p| p.to_string())
24716                    .collect::<Vec<String>>()
24717                    .join(",")
24718                    .to_string(),
24719            )]),
24720        };
24721    }
24722    if let Some(ref local_var_str) = owner__n {
24723        local_var_req_builder = match "multi" {
24724            "multi" => local_var_req_builder.query(
24725                &local_var_str
24726                    .into_iter()
24727                    .map(|p| ("owner__n".to_owned(), p.to_string()))
24728                    .collect::<Vec<(std::string::String, std::string::String)>>(),
24729            ),
24730            _ => local_var_req_builder.query(&[(
24731                "owner__n",
24732                &local_var_str
24733                    .into_iter()
24734                    .map(|p| p.to_string())
24735                    .collect::<Vec<String>>()
24736                    .join(",")
24737                    .to_string(),
24738            )]),
24739        };
24740    }
24741    if let Some(ref local_var_str) = owner_group {
24742        local_var_req_builder = match "multi" {
24743            "multi" => local_var_req_builder.query(
24744                &local_var_str
24745                    .into_iter()
24746                    .map(|p| ("owner_group".to_owned(), p.to_string()))
24747                    .collect::<Vec<(std::string::String, std::string::String)>>(),
24748            ),
24749            _ => local_var_req_builder.query(&[(
24750                "owner_group",
24751                &local_var_str
24752                    .into_iter()
24753                    .map(|p| p.to_string())
24754                    .collect::<Vec<String>>()
24755                    .join(",")
24756                    .to_string(),
24757            )]),
24758        };
24759    }
24760    if let Some(ref local_var_str) = owner_group__n {
24761        local_var_req_builder = match "multi" {
24762            "multi" => local_var_req_builder.query(
24763                &local_var_str
24764                    .into_iter()
24765                    .map(|p| ("owner_group__n".to_owned(), p.to_string()))
24766                    .collect::<Vec<(std::string::String, std::string::String)>>(),
24767            ),
24768            _ => local_var_req_builder.query(&[(
24769                "owner_group__n",
24770                &local_var_str
24771                    .into_iter()
24772                    .map(|p| p.to_string())
24773                    .collect::<Vec<String>>()
24774                    .join(",")
24775                    .to_string(),
24776            )]),
24777        };
24778    }
24779    if let Some(ref local_var_str) = owner_group_id {
24780        local_var_req_builder = match "multi" {
24781            "multi" => local_var_req_builder.query(
24782                &local_var_str
24783                    .into_iter()
24784                    .map(|p| ("owner_group_id".to_owned(), p.to_string()))
24785                    .collect::<Vec<(std::string::String, std::string::String)>>(),
24786            ),
24787            _ => local_var_req_builder.query(&[(
24788                "owner_group_id",
24789                &local_var_str
24790                    .into_iter()
24791                    .map(|p| p.to_string())
24792                    .collect::<Vec<String>>()
24793                    .join(",")
24794                    .to_string(),
24795            )]),
24796        };
24797    }
24798    if let Some(ref local_var_str) = owner_group_id__n {
24799        local_var_req_builder = match "multi" {
24800            "multi" => local_var_req_builder.query(
24801                &local_var_str
24802                    .into_iter()
24803                    .map(|p| ("owner_group_id__n".to_owned(), p.to_string()))
24804                    .collect::<Vec<(std::string::String, std::string::String)>>(),
24805            ),
24806            _ => local_var_req_builder.query(&[(
24807                "owner_group_id__n",
24808                &local_var_str
24809                    .into_iter()
24810                    .map(|p| p.to_string())
24811                    .collect::<Vec<String>>()
24812                    .join(",")
24813                    .to_string(),
24814            )]),
24815        };
24816    }
24817    if let Some(ref local_var_str) = owner_id {
24818        local_var_req_builder = match "multi" {
24819            "multi" => local_var_req_builder.query(
24820                &local_var_str
24821                    .into_iter()
24822                    .map(|p| ("owner_id".to_owned(), p.to_string()))
24823                    .collect::<Vec<(std::string::String, std::string::String)>>(),
24824            ),
24825            _ => local_var_req_builder.query(&[(
24826                "owner_id",
24827                &local_var_str
24828                    .into_iter()
24829                    .map(|p| p.to_string())
24830                    .collect::<Vec<String>>()
24831                    .join(",")
24832                    .to_string(),
24833            )]),
24834        };
24835    }
24836    if let Some(ref local_var_str) = owner_id__n {
24837        local_var_req_builder = match "multi" {
24838            "multi" => local_var_req_builder.query(
24839                &local_var_str
24840                    .into_iter()
24841                    .map(|p| ("owner_id__n".to_owned(), p.to_string()))
24842                    .collect::<Vec<(std::string::String, std::string::String)>>(),
24843            ),
24844            _ => local_var_req_builder.query(&[(
24845                "owner_id__n",
24846                &local_var_str
24847                    .into_iter()
24848                    .map(|p| p.to_string())
24849                    .collect::<Vec<String>>()
24850                    .join(",")
24851                    .to_string(),
24852            )]),
24853        };
24854    }
24855    if let Some(ref local_var_str) = provider {
24856        local_var_req_builder = match "multi" {
24857            "multi" => local_var_req_builder.query(
24858                &local_var_str
24859                    .into_iter()
24860                    .map(|p| ("provider".to_owned(), p.to_string()))
24861                    .collect::<Vec<(std::string::String, std::string::String)>>(),
24862            ),
24863            _ => local_var_req_builder.query(&[(
24864                "provider",
24865                &local_var_str
24866                    .into_iter()
24867                    .map(|p| p.to_string())
24868                    .collect::<Vec<String>>()
24869                    .join(",")
24870                    .to_string(),
24871            )]),
24872        };
24873    }
24874    if let Some(ref local_var_str) = provider__n {
24875        local_var_req_builder = match "multi" {
24876            "multi" => local_var_req_builder.query(
24877                &local_var_str
24878                    .into_iter()
24879                    .map(|p| ("provider__n".to_owned(), p.to_string()))
24880                    .collect::<Vec<(std::string::String, std::string::String)>>(),
24881            ),
24882            _ => local_var_req_builder.query(&[(
24883                "provider__n",
24884                &local_var_str
24885                    .into_iter()
24886                    .map(|p| p.to_string())
24887                    .collect::<Vec<String>>()
24888                    .join(",")
24889                    .to_string(),
24890            )]),
24891        };
24892    }
24893    if let Some(ref local_var_str) = provider_account {
24894        local_var_req_builder = match "multi" {
24895            "multi" => local_var_req_builder.query(
24896                &local_var_str
24897                    .into_iter()
24898                    .map(|p| ("provider_account".to_owned(), p.to_string()))
24899                    .collect::<Vec<(std::string::String, std::string::String)>>(),
24900            ),
24901            _ => local_var_req_builder.query(&[(
24902                "provider_account",
24903                &local_var_str
24904                    .into_iter()
24905                    .map(|p| p.to_string())
24906                    .collect::<Vec<String>>()
24907                    .join(",")
24908                    .to_string(),
24909            )]),
24910        };
24911    }
24912    if let Some(ref local_var_str) = provider_account__n {
24913        local_var_req_builder = match "multi" {
24914            "multi" => local_var_req_builder.query(
24915                &local_var_str
24916                    .into_iter()
24917                    .map(|p| ("provider_account__n".to_owned(), p.to_string()))
24918                    .collect::<Vec<(std::string::String, std::string::String)>>(),
24919            ),
24920            _ => local_var_req_builder.query(&[(
24921                "provider_account__n",
24922                &local_var_str
24923                    .into_iter()
24924                    .map(|p| p.to_string())
24925                    .collect::<Vec<String>>()
24926                    .join(",")
24927                    .to_string(),
24928            )]),
24929        };
24930    }
24931    if let Some(ref local_var_str) = provider_account_id {
24932        local_var_req_builder = match "multi" {
24933            "multi" => local_var_req_builder.query(
24934                &local_var_str
24935                    .into_iter()
24936                    .map(|p| ("provider_account_id".to_owned(), p.to_string()))
24937                    .collect::<Vec<(std::string::String, std::string::String)>>(),
24938            ),
24939            _ => local_var_req_builder.query(&[(
24940                "provider_account_id",
24941                &local_var_str
24942                    .into_iter()
24943                    .map(|p| p.to_string())
24944                    .collect::<Vec<String>>()
24945                    .join(",")
24946                    .to_string(),
24947            )]),
24948        };
24949    }
24950    if let Some(ref local_var_str) = provider_account_id__n {
24951        local_var_req_builder = match "multi" {
24952            "multi" => local_var_req_builder.query(
24953                &local_var_str
24954                    .into_iter()
24955                    .map(|p| ("provider_account_id__n".to_owned(), p.to_string()))
24956                    .collect::<Vec<(std::string::String, std::string::String)>>(),
24957            ),
24958            _ => local_var_req_builder.query(&[(
24959                "provider_account_id__n",
24960                &local_var_str
24961                    .into_iter()
24962                    .map(|p| p.to_string())
24963                    .collect::<Vec<String>>()
24964                    .join(",")
24965                    .to_string(),
24966            )]),
24967        };
24968    }
24969    if let Some(ref local_var_str) = provider_id {
24970        local_var_req_builder = match "multi" {
24971            "multi" => local_var_req_builder.query(
24972                &local_var_str
24973                    .into_iter()
24974                    .map(|p| ("provider_id".to_owned(), p.to_string()))
24975                    .collect::<Vec<(std::string::String, std::string::String)>>(),
24976            ),
24977            _ => local_var_req_builder.query(&[(
24978                "provider_id",
24979                &local_var_str
24980                    .into_iter()
24981                    .map(|p| p.to_string())
24982                    .collect::<Vec<String>>()
24983                    .join(",")
24984                    .to_string(),
24985            )]),
24986        };
24987    }
24988    if let Some(ref local_var_str) = provider_id__n {
24989        local_var_req_builder = match "multi" {
24990            "multi" => local_var_req_builder.query(
24991                &local_var_str
24992                    .into_iter()
24993                    .map(|p| ("provider_id__n".to_owned(), p.to_string()))
24994                    .collect::<Vec<(std::string::String, std::string::String)>>(),
24995            ),
24996            _ => local_var_req_builder.query(&[(
24997                "provider_id__n",
24998                &local_var_str
24999                    .into_iter()
25000                    .map(|p| p.to_string())
25001                    .collect::<Vec<String>>()
25002                    .join(",")
25003                    .to_string(),
25004            )]),
25005        };
25006    }
25007    if let Some(ref local_var_str) = provider_network_id {
25008        local_var_req_builder = match "multi" {
25009            "multi" => local_var_req_builder.query(
25010                &local_var_str
25011                    .into_iter()
25012                    .map(|p| ("provider_network_id".to_owned(), p.to_string()))
25013                    .collect::<Vec<(std::string::String, std::string::String)>>(),
25014            ),
25015            _ => local_var_req_builder.query(&[(
25016                "provider_network_id",
25017                &local_var_str
25018                    .into_iter()
25019                    .map(|p| p.to_string())
25020                    .collect::<Vec<String>>()
25021                    .join(",")
25022                    .to_string(),
25023            )]),
25024        };
25025    }
25026    if let Some(ref local_var_str) = provider_network_id__n {
25027        local_var_req_builder = match "multi" {
25028            "multi" => local_var_req_builder.query(
25029                &local_var_str
25030                    .into_iter()
25031                    .map(|p| ("provider_network_id__n".to_owned(), p.to_string()))
25032                    .collect::<Vec<(std::string::String, std::string::String)>>(),
25033            ),
25034            _ => local_var_req_builder.query(&[(
25035                "provider_network_id__n",
25036                &local_var_str
25037                    .into_iter()
25038                    .map(|p| p.to_string())
25039                    .collect::<Vec<String>>()
25040                    .join(",")
25041                    .to_string(),
25042            )]),
25043        };
25044    }
25045    if let Some(ref local_var_str) = q {
25046        local_var_req_builder = local_var_req_builder.query(&[("q", &local_var_str.to_string())]);
25047    }
25048    if let Some(ref local_var_str) = status {
25049        local_var_req_builder = match "multi" {
25050            "multi" => local_var_req_builder.query(
25051                &local_var_str
25052                    .into_iter()
25053                    .map(|p| ("status".to_owned(), p.to_string()))
25054                    .collect::<Vec<(std::string::String, std::string::String)>>(),
25055            ),
25056            _ => local_var_req_builder.query(&[(
25057                "status",
25058                &local_var_str
25059                    .into_iter()
25060                    .map(|p| p.to_string())
25061                    .collect::<Vec<String>>()
25062                    .join(",")
25063                    .to_string(),
25064            )]),
25065        };
25066    }
25067    if let Some(ref local_var_str) = status__empty {
25068        local_var_req_builder =
25069            local_var_req_builder.query(&[("status__empty", &local_var_str.to_string())]);
25070    }
25071    if let Some(ref local_var_str) = status__ic {
25072        local_var_req_builder = match "multi" {
25073            "multi" => local_var_req_builder.query(
25074                &local_var_str
25075                    .into_iter()
25076                    .map(|p| ("status__ic".to_owned(), p.to_string()))
25077                    .collect::<Vec<(std::string::String, std::string::String)>>(),
25078            ),
25079            _ => local_var_req_builder.query(&[(
25080                "status__ic",
25081                &local_var_str
25082                    .into_iter()
25083                    .map(|p| p.to_string())
25084                    .collect::<Vec<String>>()
25085                    .join(",")
25086                    .to_string(),
25087            )]),
25088        };
25089    }
25090    if let Some(ref local_var_str) = status__ie {
25091        local_var_req_builder = match "multi" {
25092            "multi" => local_var_req_builder.query(
25093                &local_var_str
25094                    .into_iter()
25095                    .map(|p| ("status__ie".to_owned(), p.to_string()))
25096                    .collect::<Vec<(std::string::String, std::string::String)>>(),
25097            ),
25098            _ => local_var_req_builder.query(&[(
25099                "status__ie",
25100                &local_var_str
25101                    .into_iter()
25102                    .map(|p| p.to_string())
25103                    .collect::<Vec<String>>()
25104                    .join(",")
25105                    .to_string(),
25106            )]),
25107        };
25108    }
25109    if let Some(ref local_var_str) = status__iew {
25110        local_var_req_builder = match "multi" {
25111            "multi" => local_var_req_builder.query(
25112                &local_var_str
25113                    .into_iter()
25114                    .map(|p| ("status__iew".to_owned(), p.to_string()))
25115                    .collect::<Vec<(std::string::String, std::string::String)>>(),
25116            ),
25117            _ => local_var_req_builder.query(&[(
25118                "status__iew",
25119                &local_var_str
25120                    .into_iter()
25121                    .map(|p| p.to_string())
25122                    .collect::<Vec<String>>()
25123                    .join(",")
25124                    .to_string(),
25125            )]),
25126        };
25127    }
25128    if let Some(ref local_var_str) = status__iregex {
25129        local_var_req_builder = match "multi" {
25130            "multi" => local_var_req_builder.query(
25131                &local_var_str
25132                    .into_iter()
25133                    .map(|p| ("status__iregex".to_owned(), p.to_string()))
25134                    .collect::<Vec<(std::string::String, std::string::String)>>(),
25135            ),
25136            _ => local_var_req_builder.query(&[(
25137                "status__iregex",
25138                &local_var_str
25139                    .into_iter()
25140                    .map(|p| p.to_string())
25141                    .collect::<Vec<String>>()
25142                    .join(",")
25143                    .to_string(),
25144            )]),
25145        };
25146    }
25147    if let Some(ref local_var_str) = status__isw {
25148        local_var_req_builder = match "multi" {
25149            "multi" => local_var_req_builder.query(
25150                &local_var_str
25151                    .into_iter()
25152                    .map(|p| ("status__isw".to_owned(), p.to_string()))
25153                    .collect::<Vec<(std::string::String, std::string::String)>>(),
25154            ),
25155            _ => local_var_req_builder.query(&[(
25156                "status__isw",
25157                &local_var_str
25158                    .into_iter()
25159                    .map(|p| p.to_string())
25160                    .collect::<Vec<String>>()
25161                    .join(",")
25162                    .to_string(),
25163            )]),
25164        };
25165    }
25166    if let Some(ref local_var_str) = status__n {
25167        local_var_req_builder = match "multi" {
25168            "multi" => local_var_req_builder.query(
25169                &local_var_str
25170                    .into_iter()
25171                    .map(|p| ("status__n".to_owned(), p.to_string()))
25172                    .collect::<Vec<(std::string::String, std::string::String)>>(),
25173            ),
25174            _ => local_var_req_builder.query(&[(
25175                "status__n",
25176                &local_var_str
25177                    .into_iter()
25178                    .map(|p| p.to_string())
25179                    .collect::<Vec<String>>()
25180                    .join(",")
25181                    .to_string(),
25182            )]),
25183        };
25184    }
25185    if let Some(ref local_var_str) = status__nic {
25186        local_var_req_builder = match "multi" {
25187            "multi" => local_var_req_builder.query(
25188                &local_var_str
25189                    .into_iter()
25190                    .map(|p| ("status__nic".to_owned(), p.to_string()))
25191                    .collect::<Vec<(std::string::String, std::string::String)>>(),
25192            ),
25193            _ => local_var_req_builder.query(&[(
25194                "status__nic",
25195                &local_var_str
25196                    .into_iter()
25197                    .map(|p| p.to_string())
25198                    .collect::<Vec<String>>()
25199                    .join(",")
25200                    .to_string(),
25201            )]),
25202        };
25203    }
25204    if let Some(ref local_var_str) = status__nie {
25205        local_var_req_builder = match "multi" {
25206            "multi" => local_var_req_builder.query(
25207                &local_var_str
25208                    .into_iter()
25209                    .map(|p| ("status__nie".to_owned(), p.to_string()))
25210                    .collect::<Vec<(std::string::String, std::string::String)>>(),
25211            ),
25212            _ => local_var_req_builder.query(&[(
25213                "status__nie",
25214                &local_var_str
25215                    .into_iter()
25216                    .map(|p| p.to_string())
25217                    .collect::<Vec<String>>()
25218                    .join(",")
25219                    .to_string(),
25220            )]),
25221        };
25222    }
25223    if let Some(ref local_var_str) = status__niew {
25224        local_var_req_builder = match "multi" {
25225            "multi" => local_var_req_builder.query(
25226                &local_var_str
25227                    .into_iter()
25228                    .map(|p| ("status__niew".to_owned(), p.to_string()))
25229                    .collect::<Vec<(std::string::String, std::string::String)>>(),
25230            ),
25231            _ => local_var_req_builder.query(&[(
25232                "status__niew",
25233                &local_var_str
25234                    .into_iter()
25235                    .map(|p| p.to_string())
25236                    .collect::<Vec<String>>()
25237                    .join(",")
25238                    .to_string(),
25239            )]),
25240        };
25241    }
25242    if let Some(ref local_var_str) = status__nisw {
25243        local_var_req_builder = match "multi" {
25244            "multi" => local_var_req_builder.query(
25245                &local_var_str
25246                    .into_iter()
25247                    .map(|p| ("status__nisw".to_owned(), p.to_string()))
25248                    .collect::<Vec<(std::string::String, std::string::String)>>(),
25249            ),
25250            _ => local_var_req_builder.query(&[(
25251                "status__nisw",
25252                &local_var_str
25253                    .into_iter()
25254                    .map(|p| p.to_string())
25255                    .collect::<Vec<String>>()
25256                    .join(",")
25257                    .to_string(),
25258            )]),
25259        };
25260    }
25261    if let Some(ref local_var_str) = status__regex {
25262        local_var_req_builder = match "multi" {
25263            "multi" => local_var_req_builder.query(
25264                &local_var_str
25265                    .into_iter()
25266                    .map(|p| ("status__regex".to_owned(), p.to_string()))
25267                    .collect::<Vec<(std::string::String, std::string::String)>>(),
25268            ),
25269            _ => local_var_req_builder.query(&[(
25270                "status__regex",
25271                &local_var_str
25272                    .into_iter()
25273                    .map(|p| p.to_string())
25274                    .collect::<Vec<String>>()
25275                    .join(",")
25276                    .to_string(),
25277            )]),
25278        };
25279    }
25280    if let Some(ref local_var_str) = tag {
25281        local_var_req_builder = match "multi" {
25282            "multi" => local_var_req_builder.query(
25283                &local_var_str
25284                    .into_iter()
25285                    .map(|p| ("tag".to_owned(), p.to_string()))
25286                    .collect::<Vec<(std::string::String, std::string::String)>>(),
25287            ),
25288            _ => local_var_req_builder.query(&[(
25289                "tag",
25290                &local_var_str
25291                    .into_iter()
25292                    .map(|p| p.to_string())
25293                    .collect::<Vec<String>>()
25294                    .join(",")
25295                    .to_string(),
25296            )]),
25297        };
25298    }
25299    if let Some(ref local_var_str) = tag__n {
25300        local_var_req_builder = match "multi" {
25301            "multi" => local_var_req_builder.query(
25302                &local_var_str
25303                    .into_iter()
25304                    .map(|p| ("tag__n".to_owned(), p.to_string()))
25305                    .collect::<Vec<(std::string::String, std::string::String)>>(),
25306            ),
25307            _ => local_var_req_builder.query(&[(
25308                "tag__n",
25309                &local_var_str
25310                    .into_iter()
25311                    .map(|p| p.to_string())
25312                    .collect::<Vec<String>>()
25313                    .join(",")
25314                    .to_string(),
25315            )]),
25316        };
25317    }
25318    if let Some(ref local_var_str) = tag_id {
25319        local_var_req_builder = match "multi" {
25320            "multi" => local_var_req_builder.query(
25321                &local_var_str
25322                    .into_iter()
25323                    .map(|p| ("tag_id".to_owned(), p.to_string()))
25324                    .collect::<Vec<(std::string::String, std::string::String)>>(),
25325            ),
25326            _ => local_var_req_builder.query(&[(
25327                "tag_id",
25328                &local_var_str
25329                    .into_iter()
25330                    .map(|p| p.to_string())
25331                    .collect::<Vec<String>>()
25332                    .join(",")
25333                    .to_string(),
25334            )]),
25335        };
25336    }
25337    if let Some(ref local_var_str) = tag_id__n {
25338        local_var_req_builder = match "multi" {
25339            "multi" => local_var_req_builder.query(
25340                &local_var_str
25341                    .into_iter()
25342                    .map(|p| ("tag_id__n".to_owned(), p.to_string()))
25343                    .collect::<Vec<(std::string::String, std::string::String)>>(),
25344            ),
25345            _ => local_var_req_builder.query(&[(
25346                "tag_id__n",
25347                &local_var_str
25348                    .into_iter()
25349                    .map(|p| p.to_string())
25350                    .collect::<Vec<String>>()
25351                    .join(",")
25352                    .to_string(),
25353            )]),
25354        };
25355    }
25356    if let Some(ref local_var_str) = tenant {
25357        local_var_req_builder = match "multi" {
25358            "multi" => local_var_req_builder.query(
25359                &local_var_str
25360                    .into_iter()
25361                    .map(|p| ("tenant".to_owned(), p.to_string()))
25362                    .collect::<Vec<(std::string::String, std::string::String)>>(),
25363            ),
25364            _ => local_var_req_builder.query(&[(
25365                "tenant",
25366                &local_var_str
25367                    .into_iter()
25368                    .map(|p| p.to_string())
25369                    .collect::<Vec<String>>()
25370                    .join(",")
25371                    .to_string(),
25372            )]),
25373        };
25374    }
25375    if let Some(ref local_var_str) = tenant__n {
25376        local_var_req_builder = match "multi" {
25377            "multi" => local_var_req_builder.query(
25378                &local_var_str
25379                    .into_iter()
25380                    .map(|p| ("tenant__n".to_owned(), p.to_string()))
25381                    .collect::<Vec<(std::string::String, std::string::String)>>(),
25382            ),
25383            _ => local_var_req_builder.query(&[(
25384                "tenant__n",
25385                &local_var_str
25386                    .into_iter()
25387                    .map(|p| p.to_string())
25388                    .collect::<Vec<String>>()
25389                    .join(",")
25390                    .to_string(),
25391            )]),
25392        };
25393    }
25394    if let Some(ref local_var_str) = tenant_group {
25395        local_var_req_builder = match "multi" {
25396            "multi" => local_var_req_builder.query(
25397                &local_var_str
25398                    .into_iter()
25399                    .map(|p| ("tenant_group".to_owned(), p.to_string()))
25400                    .collect::<Vec<(std::string::String, std::string::String)>>(),
25401            ),
25402            _ => local_var_req_builder.query(&[(
25403                "tenant_group",
25404                &local_var_str
25405                    .into_iter()
25406                    .map(|p| p.to_string())
25407                    .collect::<Vec<String>>()
25408                    .join(",")
25409                    .to_string(),
25410            )]),
25411        };
25412    }
25413    if let Some(ref local_var_str) = tenant_group__n {
25414        local_var_req_builder = match "multi" {
25415            "multi" => local_var_req_builder.query(
25416                &local_var_str
25417                    .into_iter()
25418                    .map(|p| ("tenant_group__n".to_owned(), p.to_string()))
25419                    .collect::<Vec<(std::string::String, std::string::String)>>(),
25420            ),
25421            _ => local_var_req_builder.query(&[(
25422                "tenant_group__n",
25423                &local_var_str
25424                    .into_iter()
25425                    .map(|p| p.to_string())
25426                    .collect::<Vec<String>>()
25427                    .join(",")
25428                    .to_string(),
25429            )]),
25430        };
25431    }
25432    if let Some(ref local_var_str) = tenant_group_id {
25433        local_var_req_builder = match "multi" {
25434            "multi" => local_var_req_builder.query(
25435                &local_var_str
25436                    .into_iter()
25437                    .map(|p| ("tenant_group_id".to_owned(), p.to_string()))
25438                    .collect::<Vec<(std::string::String, std::string::String)>>(),
25439            ),
25440            _ => local_var_req_builder.query(&[(
25441                "tenant_group_id",
25442                &local_var_str
25443                    .into_iter()
25444                    .map(|p| p.to_string())
25445                    .collect::<Vec<String>>()
25446                    .join(",")
25447                    .to_string(),
25448            )]),
25449        };
25450    }
25451    if let Some(ref local_var_str) = tenant_group_id__n {
25452        local_var_req_builder = match "multi" {
25453            "multi" => local_var_req_builder.query(
25454                &local_var_str
25455                    .into_iter()
25456                    .map(|p| ("tenant_group_id__n".to_owned(), p.to_string()))
25457                    .collect::<Vec<(std::string::String, std::string::String)>>(),
25458            ),
25459            _ => local_var_req_builder.query(&[(
25460                "tenant_group_id__n",
25461                &local_var_str
25462                    .into_iter()
25463                    .map(|p| p.to_string())
25464                    .collect::<Vec<String>>()
25465                    .join(",")
25466                    .to_string(),
25467            )]),
25468        };
25469    }
25470    if let Some(ref local_var_str) = tenant_id {
25471        local_var_req_builder = match "multi" {
25472            "multi" => local_var_req_builder.query(
25473                &local_var_str
25474                    .into_iter()
25475                    .map(|p| ("tenant_id".to_owned(), p.to_string()))
25476                    .collect::<Vec<(std::string::String, std::string::String)>>(),
25477            ),
25478            _ => local_var_req_builder.query(&[(
25479                "tenant_id",
25480                &local_var_str
25481                    .into_iter()
25482                    .map(|p| p.to_string())
25483                    .collect::<Vec<String>>()
25484                    .join(",")
25485                    .to_string(),
25486            )]),
25487        };
25488    }
25489    if let Some(ref local_var_str) = tenant_id__n {
25490        local_var_req_builder = match "multi" {
25491            "multi" => local_var_req_builder.query(
25492                &local_var_str
25493                    .into_iter()
25494                    .map(|p| ("tenant_id__n".to_owned(), p.to_string()))
25495                    .collect::<Vec<(std::string::String, std::string::String)>>(),
25496            ),
25497            _ => local_var_req_builder.query(&[(
25498                "tenant_id__n",
25499                &local_var_str
25500                    .into_iter()
25501                    .map(|p| p.to_string())
25502                    .collect::<Vec<String>>()
25503                    .join(",")
25504                    .to_string(),
25505            )]),
25506        };
25507    }
25508    if let Some(ref local_var_str) = r#type {
25509        local_var_req_builder = match "multi" {
25510            "multi" => local_var_req_builder.query(
25511                &local_var_str
25512                    .into_iter()
25513                    .map(|p| ("type".to_owned(), p.to_string()))
25514                    .collect::<Vec<(std::string::String, std::string::String)>>(),
25515            ),
25516            _ => local_var_req_builder.query(&[(
25517                "type",
25518                &local_var_str
25519                    .into_iter()
25520                    .map(|p| p.to_string())
25521                    .collect::<Vec<String>>()
25522                    .join(",")
25523                    .to_string(),
25524            )]),
25525        };
25526    }
25527    if let Some(ref local_var_str) = type__n {
25528        local_var_req_builder = match "multi" {
25529            "multi" => local_var_req_builder.query(
25530                &local_var_str
25531                    .into_iter()
25532                    .map(|p| ("type__n".to_owned(), p.to_string()))
25533                    .collect::<Vec<(std::string::String, std::string::String)>>(),
25534            ),
25535            _ => local_var_req_builder.query(&[(
25536                "type__n",
25537                &local_var_str
25538                    .into_iter()
25539                    .map(|p| p.to_string())
25540                    .collect::<Vec<String>>()
25541                    .join(",")
25542                    .to_string(),
25543            )]),
25544        };
25545    }
25546    if let Some(ref local_var_str) = type_id {
25547        local_var_req_builder = match "multi" {
25548            "multi" => local_var_req_builder.query(
25549                &local_var_str
25550                    .into_iter()
25551                    .map(|p| ("type_id".to_owned(), p.to_string()))
25552                    .collect::<Vec<(std::string::String, std::string::String)>>(),
25553            ),
25554            _ => local_var_req_builder.query(&[(
25555                "type_id",
25556                &local_var_str
25557                    .into_iter()
25558                    .map(|p| p.to_string())
25559                    .collect::<Vec<String>>()
25560                    .join(",")
25561                    .to_string(),
25562            )]),
25563        };
25564    }
25565    if let Some(ref local_var_str) = type_id__n {
25566        local_var_req_builder = match "multi" {
25567            "multi" => local_var_req_builder.query(
25568                &local_var_str
25569                    .into_iter()
25570                    .map(|p| ("type_id__n".to_owned(), p.to_string()))
25571                    .collect::<Vec<(std::string::String, std::string::String)>>(),
25572            ),
25573            _ => local_var_req_builder.query(&[(
25574                "type_id__n",
25575                &local_var_str
25576                    .into_iter()
25577                    .map(|p| p.to_string())
25578                    .collect::<Vec<String>>()
25579                    .join(",")
25580                    .to_string(),
25581            )]),
25582        };
25583    }
25584    if let Some(ref local_var_str) = updated_by_request {
25585        local_var_req_builder =
25586            local_var_req_builder.query(&[("updated_by_request", &local_var_str.to_string())]);
25587    }
25588    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
25589        local_var_req_builder =
25590            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
25591    }
25592    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
25593        let local_var_key = local_var_apikey.key.clone();
25594        let local_var_value = match local_var_apikey.prefix {
25595            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
25596            None => local_var_key,
25597        };
25598        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
25599    };
25600
25601    let local_var_req = local_var_req_builder.build()?;
25602    let local_var_resp = local_var_client.execute(local_var_req).await?;
25603
25604    let local_var_status = local_var_resp.status();
25605    let local_var_content = local_var_resp.text().await?;
25606
25607    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
25608        serde_json::from_str(&local_var_content).map_err(Error::from)
25609    } else {
25610        let local_var_entity: Option<CircuitsVirtualCircuitsListError> =
25611            serde_json::from_str(&local_var_content).ok();
25612        let local_var_error = ResponseContent {
25613            status: local_var_status,
25614            content: local_var_content,
25615            entity: local_var_entity,
25616        };
25617        Err(Error::ResponseError(local_var_error))
25618    }
25619}
25620
25621/// Patch a virtual circuit object.
25622pub async fn circuits_virtual_circuits_partial_update(
25623    configuration: &configuration::Configuration,
25624    id: i32,
25625    patched_writable_virtual_circuit_request: Option<
25626        crate::models::PatchedWritableVirtualCircuitRequest,
25627    >,
25628) -> Result<crate::models::VirtualCircuit, Error<CircuitsVirtualCircuitsPartialUpdateError>> {
25629    let local_var_configuration = configuration;
25630
25631    let local_var_client = &local_var_configuration.client;
25632
25633    let local_var_uri_str = format!(
25634        "{}/api/circuits/virtual-circuits/{id}/",
25635        local_var_configuration.base_path,
25636        id = id
25637    );
25638    let mut local_var_req_builder =
25639        local_var_client.request(reqwest::Method::PATCH, local_var_uri_str.as_str());
25640
25641    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
25642        local_var_req_builder =
25643            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
25644    }
25645    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
25646        let local_var_key = local_var_apikey.key.clone();
25647        let local_var_value = match local_var_apikey.prefix {
25648            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
25649            None => local_var_key,
25650        };
25651        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
25652    };
25653    local_var_req_builder = local_var_req_builder.json(&patched_writable_virtual_circuit_request);
25654
25655    let local_var_req = local_var_req_builder.build()?;
25656    let local_var_resp = local_var_client.execute(local_var_req).await?;
25657
25658    let local_var_status = local_var_resp.status();
25659    let local_var_content = local_var_resp.text().await?;
25660
25661    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
25662        serde_json::from_str(&local_var_content).map_err(Error::from)
25663    } else {
25664        let local_var_entity: Option<CircuitsVirtualCircuitsPartialUpdateError> =
25665            serde_json::from_str(&local_var_content).ok();
25666        let local_var_error = ResponseContent {
25667            status: local_var_status,
25668            content: local_var_content,
25669            entity: local_var_entity,
25670        };
25671        Err(Error::ResponseError(local_var_error))
25672    }
25673}
25674
25675/// Get a virtual circuit object.
25676pub async fn circuits_virtual_circuits_retrieve(
25677    configuration: &configuration::Configuration,
25678    id: i32,
25679) -> Result<crate::models::VirtualCircuit, Error<CircuitsVirtualCircuitsRetrieveError>> {
25680    let local_var_configuration = configuration;
25681
25682    let local_var_client = &local_var_configuration.client;
25683
25684    let local_var_uri_str = format!(
25685        "{}/api/circuits/virtual-circuits/{id}/",
25686        local_var_configuration.base_path,
25687        id = id
25688    );
25689    let mut local_var_req_builder =
25690        local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
25691
25692    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
25693        local_var_req_builder =
25694            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
25695    }
25696    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
25697        let local_var_key = local_var_apikey.key.clone();
25698        let local_var_value = match local_var_apikey.prefix {
25699            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
25700            None => local_var_key,
25701        };
25702        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
25703    };
25704
25705    let local_var_req = local_var_req_builder.build()?;
25706    let local_var_resp = local_var_client.execute(local_var_req).await?;
25707
25708    let local_var_status = local_var_resp.status();
25709    let local_var_content = local_var_resp.text().await?;
25710
25711    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
25712        serde_json::from_str(&local_var_content).map_err(Error::from)
25713    } else {
25714        let local_var_entity: Option<CircuitsVirtualCircuitsRetrieveError> =
25715            serde_json::from_str(&local_var_content).ok();
25716        let local_var_error = ResponseContent {
25717            status: local_var_status,
25718            content: local_var_content,
25719            entity: local_var_entity,
25720        };
25721        Err(Error::ResponseError(local_var_error))
25722    }
25723}
25724
25725/// Put a virtual circuit object.
25726pub async fn circuits_virtual_circuits_update(
25727    configuration: &configuration::Configuration,
25728    id: i32,
25729    writable_virtual_circuit_request: crate::models::WritableVirtualCircuitRequest,
25730) -> Result<crate::models::VirtualCircuit, Error<CircuitsVirtualCircuitsUpdateError>> {
25731    let local_var_configuration = configuration;
25732
25733    let local_var_client = &local_var_configuration.client;
25734
25735    let local_var_uri_str = format!(
25736        "{}/api/circuits/virtual-circuits/{id}/",
25737        local_var_configuration.base_path,
25738        id = id
25739    );
25740    let mut local_var_req_builder =
25741        local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());
25742
25743    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
25744        local_var_req_builder =
25745            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
25746    }
25747    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
25748        let local_var_key = local_var_apikey.key.clone();
25749        let local_var_value = match local_var_apikey.prefix {
25750            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
25751            None => local_var_key,
25752        };
25753        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
25754    };
25755    local_var_req_builder = local_var_req_builder.json(&writable_virtual_circuit_request);
25756
25757    let local_var_req = local_var_req_builder.build()?;
25758    let local_var_resp = local_var_client.execute(local_var_req).await?;
25759
25760    let local_var_status = local_var_resp.status();
25761    let local_var_content = local_var_resp.text().await?;
25762
25763    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
25764        serde_json::from_str(&local_var_content).map_err(Error::from)
25765    } else {
25766        let local_var_entity: Option<CircuitsVirtualCircuitsUpdateError> =
25767            serde_json::from_str(&local_var_content).ok();
25768        let local_var_error = ResponseContent {
25769            status: local_var_status,
25770            content: local_var_content,
25771            entity: local_var_entity,
25772        };
25773        Err(Error::ResponseError(local_var_error))
25774    }
25775}
netbox_openapi/apis/circuits_api.rs

netbox_openapi/apis/
circuits_api.rs
