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.6.0 (4.6)
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    start: Option<i32>,
1042    tag: Option<Vec<String>>,
1043    tag__n: Option<Vec<String>>,
1044    tag_id: Option<Vec<i32>>,
1045    tag_id__n: Option<Vec<i32>>,
1046    updated_by_request: Option<&str>,
1047    virtual_circuit: Option<Vec<String>>,
1048    virtual_circuit_id: Option<Vec<i32>>,
1049) -> Result<
1050    crate::models::PaginatedCircuitGroupAssignmentList,
1051    Error<CircuitsCircuitGroupAssignmentsListError>,
1052> {
1053    let local_var_configuration = configuration;
1054
1055    let local_var_client = &local_var_configuration.client;
1056
1057    let local_var_uri_str = format!(
1058        "{}/api/circuits/circuit-group-assignments/",
1059        local_var_configuration.base_path
1060    );
1061    let mut local_var_req_builder =
1062        local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
1063
1064    if let Some(ref local_var_str) = circuit {
1065        local_var_req_builder = match "multi" {
1066            "multi" => local_var_req_builder.query(
1067                &local_var_str
1068                    .into_iter()
1069                    .map(|p| ("circuit".to_owned(), p.to_string()))
1070                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1071            ),
1072            _ => local_var_req_builder.query(&[(
1073                "circuit",
1074                &local_var_str
1075                    .into_iter()
1076                    .map(|p| p.to_string())
1077                    .collect::<Vec<String>>()
1078                    .join(",")
1079                    .to_string(),
1080            )]),
1081        };
1082    }
1083    if let Some(ref local_var_str) = circuit_id {
1084        local_var_req_builder = match "multi" {
1085            "multi" => local_var_req_builder.query(
1086                &local_var_str
1087                    .into_iter()
1088                    .map(|p| ("circuit_id".to_owned(), p.to_string()))
1089                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1090            ),
1091            _ => local_var_req_builder.query(&[(
1092                "circuit_id",
1093                &local_var_str
1094                    .into_iter()
1095                    .map(|p| p.to_string())
1096                    .collect::<Vec<String>>()
1097                    .join(",")
1098                    .to_string(),
1099            )]),
1100        };
1101    }
1102    if let Some(ref local_var_str) = created {
1103        local_var_req_builder = match "multi" {
1104            "multi" => local_var_req_builder.query(
1105                &local_var_str
1106                    .into_iter()
1107                    .map(|p| ("created".to_owned(), p.to_string()))
1108                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1109            ),
1110            _ => local_var_req_builder.query(&[(
1111                "created",
1112                &local_var_str
1113                    .into_iter()
1114                    .map(|p| p.to_string())
1115                    .collect::<Vec<String>>()
1116                    .join(",")
1117                    .to_string(),
1118            )]),
1119        };
1120    }
1121    if let Some(ref local_var_str) = created__empty {
1122        local_var_req_builder = match "multi" {
1123            "multi" => local_var_req_builder.query(
1124                &local_var_str
1125                    .into_iter()
1126                    .map(|p| ("created__empty".to_owned(), p.to_string()))
1127                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1128            ),
1129            _ => local_var_req_builder.query(&[(
1130                "created__empty",
1131                &local_var_str
1132                    .into_iter()
1133                    .map(|p| p.to_string())
1134                    .collect::<Vec<String>>()
1135                    .join(",")
1136                    .to_string(),
1137            )]),
1138        };
1139    }
1140    if let Some(ref local_var_str) = created__gt {
1141        local_var_req_builder = match "multi" {
1142            "multi" => local_var_req_builder.query(
1143                &local_var_str
1144                    .into_iter()
1145                    .map(|p| ("created__gt".to_owned(), p.to_string()))
1146                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1147            ),
1148            _ => local_var_req_builder.query(&[(
1149                "created__gt",
1150                &local_var_str
1151                    .into_iter()
1152                    .map(|p| p.to_string())
1153                    .collect::<Vec<String>>()
1154                    .join(",")
1155                    .to_string(),
1156            )]),
1157        };
1158    }
1159    if let Some(ref local_var_str) = created__gte {
1160        local_var_req_builder = match "multi" {
1161            "multi" => local_var_req_builder.query(
1162                &local_var_str
1163                    .into_iter()
1164                    .map(|p| ("created__gte".to_owned(), p.to_string()))
1165                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1166            ),
1167            _ => local_var_req_builder.query(&[(
1168                "created__gte",
1169                &local_var_str
1170                    .into_iter()
1171                    .map(|p| p.to_string())
1172                    .collect::<Vec<String>>()
1173                    .join(",")
1174                    .to_string(),
1175            )]),
1176        };
1177    }
1178    if let Some(ref local_var_str) = created__lt {
1179        local_var_req_builder = match "multi" {
1180            "multi" => local_var_req_builder.query(
1181                &local_var_str
1182                    .into_iter()
1183                    .map(|p| ("created__lt".to_owned(), p.to_string()))
1184                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1185            ),
1186            _ => local_var_req_builder.query(&[(
1187                "created__lt",
1188                &local_var_str
1189                    .into_iter()
1190                    .map(|p| p.to_string())
1191                    .collect::<Vec<String>>()
1192                    .join(",")
1193                    .to_string(),
1194            )]),
1195        };
1196    }
1197    if let Some(ref local_var_str) = created__lte {
1198        local_var_req_builder = match "multi" {
1199            "multi" => local_var_req_builder.query(
1200                &local_var_str
1201                    .into_iter()
1202                    .map(|p| ("created__lte".to_owned(), p.to_string()))
1203                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1204            ),
1205            _ => local_var_req_builder.query(&[(
1206                "created__lte",
1207                &local_var_str
1208                    .into_iter()
1209                    .map(|p| p.to_string())
1210                    .collect::<Vec<String>>()
1211                    .join(",")
1212                    .to_string(),
1213            )]),
1214        };
1215    }
1216    if let Some(ref local_var_str) = created__n {
1217        local_var_req_builder = match "multi" {
1218            "multi" => local_var_req_builder.query(
1219                &local_var_str
1220                    .into_iter()
1221                    .map(|p| ("created__n".to_owned(), p.to_string()))
1222                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1223            ),
1224            _ => local_var_req_builder.query(&[(
1225                "created__n",
1226                &local_var_str
1227                    .into_iter()
1228                    .map(|p| p.to_string())
1229                    .collect::<Vec<String>>()
1230                    .join(",")
1231                    .to_string(),
1232            )]),
1233        };
1234    }
1235    if let Some(ref local_var_str) = created_by_request {
1236        local_var_req_builder =
1237            local_var_req_builder.query(&[("created_by_request", &local_var_str.to_string())]);
1238    }
1239    if let Some(ref local_var_str) = group {
1240        local_var_req_builder = match "multi" {
1241            "multi" => local_var_req_builder.query(
1242                &local_var_str
1243                    .into_iter()
1244                    .map(|p| ("group".to_owned(), p.to_string()))
1245                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1246            ),
1247            _ => local_var_req_builder.query(&[(
1248                "group",
1249                &local_var_str
1250                    .into_iter()
1251                    .map(|p| p.to_string())
1252                    .collect::<Vec<String>>()
1253                    .join(",")
1254                    .to_string(),
1255            )]),
1256        };
1257    }
1258    if let Some(ref local_var_str) = group__n {
1259        local_var_req_builder = match "multi" {
1260            "multi" => local_var_req_builder.query(
1261                &local_var_str
1262                    .into_iter()
1263                    .map(|p| ("group__n".to_owned(), p.to_string()))
1264                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1265            ),
1266            _ => local_var_req_builder.query(&[(
1267                "group__n",
1268                &local_var_str
1269                    .into_iter()
1270                    .map(|p| p.to_string())
1271                    .collect::<Vec<String>>()
1272                    .join(",")
1273                    .to_string(),
1274            )]),
1275        };
1276    }
1277    if let Some(ref local_var_str) = group_id {
1278        local_var_req_builder = match "multi" {
1279            "multi" => local_var_req_builder.query(
1280                &local_var_str
1281                    .into_iter()
1282                    .map(|p| ("group_id".to_owned(), p.to_string()))
1283                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1284            ),
1285            _ => local_var_req_builder.query(&[(
1286                "group_id",
1287                &local_var_str
1288                    .into_iter()
1289                    .map(|p| p.to_string())
1290                    .collect::<Vec<String>>()
1291                    .join(",")
1292                    .to_string(),
1293            )]),
1294        };
1295    }
1296    if let Some(ref local_var_str) = group_id__n {
1297        local_var_req_builder = match "multi" {
1298            "multi" => local_var_req_builder.query(
1299                &local_var_str
1300                    .into_iter()
1301                    .map(|p| ("group_id__n".to_owned(), p.to_string()))
1302                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1303            ),
1304            _ => local_var_req_builder.query(&[(
1305                "group_id__n",
1306                &local_var_str
1307                    .into_iter()
1308                    .map(|p| p.to_string())
1309                    .collect::<Vec<String>>()
1310                    .join(",")
1311                    .to_string(),
1312            )]),
1313        };
1314    }
1315    if let Some(ref local_var_str) = id {
1316        local_var_req_builder = match "multi" {
1317            "multi" => local_var_req_builder.query(
1318                &local_var_str
1319                    .into_iter()
1320                    .map(|p| ("id".to_owned(), p.to_string()))
1321                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1322            ),
1323            _ => local_var_req_builder.query(&[(
1324                "id",
1325                &local_var_str
1326                    .into_iter()
1327                    .map(|p| p.to_string())
1328                    .collect::<Vec<String>>()
1329                    .join(",")
1330                    .to_string(),
1331            )]),
1332        };
1333    }
1334    if let Some(ref local_var_str) = id__empty {
1335        local_var_req_builder =
1336            local_var_req_builder.query(&[("id__empty", &local_var_str.to_string())]);
1337    }
1338    if let Some(ref local_var_str) = id__gt {
1339        local_var_req_builder = match "multi" {
1340            "multi" => local_var_req_builder.query(
1341                &local_var_str
1342                    .into_iter()
1343                    .map(|p| ("id__gt".to_owned(), p.to_string()))
1344                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1345            ),
1346            _ => local_var_req_builder.query(&[(
1347                "id__gt",
1348                &local_var_str
1349                    .into_iter()
1350                    .map(|p| p.to_string())
1351                    .collect::<Vec<String>>()
1352                    .join(",")
1353                    .to_string(),
1354            )]),
1355        };
1356    }
1357    if let Some(ref local_var_str) = id__gte {
1358        local_var_req_builder = match "multi" {
1359            "multi" => local_var_req_builder.query(
1360                &local_var_str
1361                    .into_iter()
1362                    .map(|p| ("id__gte".to_owned(), p.to_string()))
1363                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1364            ),
1365            _ => local_var_req_builder.query(&[(
1366                "id__gte",
1367                &local_var_str
1368                    .into_iter()
1369                    .map(|p| p.to_string())
1370                    .collect::<Vec<String>>()
1371                    .join(",")
1372                    .to_string(),
1373            )]),
1374        };
1375    }
1376    if let Some(ref local_var_str) = id__lt {
1377        local_var_req_builder = match "multi" {
1378            "multi" => local_var_req_builder.query(
1379                &local_var_str
1380                    .into_iter()
1381                    .map(|p| ("id__lt".to_owned(), p.to_string()))
1382                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1383            ),
1384            _ => local_var_req_builder.query(&[(
1385                "id__lt",
1386                &local_var_str
1387                    .into_iter()
1388                    .map(|p| p.to_string())
1389                    .collect::<Vec<String>>()
1390                    .join(",")
1391                    .to_string(),
1392            )]),
1393        };
1394    }
1395    if let Some(ref local_var_str) = id__lte {
1396        local_var_req_builder = match "multi" {
1397            "multi" => local_var_req_builder.query(
1398                &local_var_str
1399                    .into_iter()
1400                    .map(|p| ("id__lte".to_owned(), p.to_string()))
1401                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1402            ),
1403            _ => local_var_req_builder.query(&[(
1404                "id__lte",
1405                &local_var_str
1406                    .into_iter()
1407                    .map(|p| p.to_string())
1408                    .collect::<Vec<String>>()
1409                    .join(",")
1410                    .to_string(),
1411            )]),
1412        };
1413    }
1414    if let Some(ref local_var_str) = id__n {
1415        local_var_req_builder = match "multi" {
1416            "multi" => local_var_req_builder.query(
1417                &local_var_str
1418                    .into_iter()
1419                    .map(|p| ("id__n".to_owned(), p.to_string()))
1420                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1421            ),
1422            _ => local_var_req_builder.query(&[(
1423                "id__n",
1424                &local_var_str
1425                    .into_iter()
1426                    .map(|p| p.to_string())
1427                    .collect::<Vec<String>>()
1428                    .join(",")
1429                    .to_string(),
1430            )]),
1431        };
1432    }
1433    if let Some(ref local_var_str) = last_updated {
1434        local_var_req_builder = match "multi" {
1435            "multi" => local_var_req_builder.query(
1436                &local_var_str
1437                    .into_iter()
1438                    .map(|p| ("last_updated".to_owned(), p.to_string()))
1439                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1440            ),
1441            _ => local_var_req_builder.query(&[(
1442                "last_updated",
1443                &local_var_str
1444                    .into_iter()
1445                    .map(|p| p.to_string())
1446                    .collect::<Vec<String>>()
1447                    .join(",")
1448                    .to_string(),
1449            )]),
1450        };
1451    }
1452    if let Some(ref local_var_str) = last_updated__empty {
1453        local_var_req_builder = match "multi" {
1454            "multi" => local_var_req_builder.query(
1455                &local_var_str
1456                    .into_iter()
1457                    .map(|p| ("last_updated__empty".to_owned(), p.to_string()))
1458                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1459            ),
1460            _ => local_var_req_builder.query(&[(
1461                "last_updated__empty",
1462                &local_var_str
1463                    .into_iter()
1464                    .map(|p| p.to_string())
1465                    .collect::<Vec<String>>()
1466                    .join(",")
1467                    .to_string(),
1468            )]),
1469        };
1470    }
1471    if let Some(ref local_var_str) = last_updated__gt {
1472        local_var_req_builder = match "multi" {
1473            "multi" => local_var_req_builder.query(
1474                &local_var_str
1475                    .into_iter()
1476                    .map(|p| ("last_updated__gt".to_owned(), p.to_string()))
1477                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1478            ),
1479            _ => local_var_req_builder.query(&[(
1480                "last_updated__gt",
1481                &local_var_str
1482                    .into_iter()
1483                    .map(|p| p.to_string())
1484                    .collect::<Vec<String>>()
1485                    .join(",")
1486                    .to_string(),
1487            )]),
1488        };
1489    }
1490    if let Some(ref local_var_str) = last_updated__gte {
1491        local_var_req_builder = match "multi" {
1492            "multi" => local_var_req_builder.query(
1493                &local_var_str
1494                    .into_iter()
1495                    .map(|p| ("last_updated__gte".to_owned(), p.to_string()))
1496                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1497            ),
1498            _ => local_var_req_builder.query(&[(
1499                "last_updated__gte",
1500                &local_var_str
1501                    .into_iter()
1502                    .map(|p| p.to_string())
1503                    .collect::<Vec<String>>()
1504                    .join(",")
1505                    .to_string(),
1506            )]),
1507        };
1508    }
1509    if let Some(ref local_var_str) = last_updated__lt {
1510        local_var_req_builder = match "multi" {
1511            "multi" => local_var_req_builder.query(
1512                &local_var_str
1513                    .into_iter()
1514                    .map(|p| ("last_updated__lt".to_owned(), p.to_string()))
1515                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1516            ),
1517            _ => local_var_req_builder.query(&[(
1518                "last_updated__lt",
1519                &local_var_str
1520                    .into_iter()
1521                    .map(|p| p.to_string())
1522                    .collect::<Vec<String>>()
1523                    .join(",")
1524                    .to_string(),
1525            )]),
1526        };
1527    }
1528    if let Some(ref local_var_str) = last_updated__lte {
1529        local_var_req_builder = match "multi" {
1530            "multi" => local_var_req_builder.query(
1531                &local_var_str
1532                    .into_iter()
1533                    .map(|p| ("last_updated__lte".to_owned(), p.to_string()))
1534                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1535            ),
1536            _ => local_var_req_builder.query(&[(
1537                "last_updated__lte",
1538                &local_var_str
1539                    .into_iter()
1540                    .map(|p| p.to_string())
1541                    .collect::<Vec<String>>()
1542                    .join(",")
1543                    .to_string(),
1544            )]),
1545        };
1546    }
1547    if let Some(ref local_var_str) = last_updated__n {
1548        local_var_req_builder = match "multi" {
1549            "multi" => local_var_req_builder.query(
1550                &local_var_str
1551                    .into_iter()
1552                    .map(|p| ("last_updated__n".to_owned(), p.to_string()))
1553                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1554            ),
1555            _ => local_var_req_builder.query(&[(
1556                "last_updated__n",
1557                &local_var_str
1558                    .into_iter()
1559                    .map(|p| p.to_string())
1560                    .collect::<Vec<String>>()
1561                    .join(",")
1562                    .to_string(),
1563            )]),
1564        };
1565    }
1566    if let Some(ref local_var_str) = limit {
1567        local_var_req_builder =
1568            local_var_req_builder.query(&[("limit", &local_var_str.to_string())]);
1569    }
1570    if let Some(ref local_var_str) = member_id {
1571        local_var_req_builder = match "multi" {
1572            "multi" => local_var_req_builder.query(
1573                &local_var_str
1574                    .into_iter()
1575                    .map(|p| ("member_id".to_owned(), p.to_string()))
1576                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1577            ),
1578            _ => local_var_req_builder.query(&[(
1579                "member_id",
1580                &local_var_str
1581                    .into_iter()
1582                    .map(|p| p.to_string())
1583                    .collect::<Vec<String>>()
1584                    .join(",")
1585                    .to_string(),
1586            )]),
1587        };
1588    }
1589    if let Some(ref local_var_str) = member_id__empty {
1590        local_var_req_builder =
1591            local_var_req_builder.query(&[("member_id__empty", &local_var_str.to_string())]);
1592    }
1593    if let Some(ref local_var_str) = member_id__gt {
1594        local_var_req_builder = match "multi" {
1595            "multi" => local_var_req_builder.query(
1596                &local_var_str
1597                    .into_iter()
1598                    .map(|p| ("member_id__gt".to_owned(), p.to_string()))
1599                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1600            ),
1601            _ => local_var_req_builder.query(&[(
1602                "member_id__gt",
1603                &local_var_str
1604                    .into_iter()
1605                    .map(|p| p.to_string())
1606                    .collect::<Vec<String>>()
1607                    .join(",")
1608                    .to_string(),
1609            )]),
1610        };
1611    }
1612    if let Some(ref local_var_str) = member_id__gte {
1613        local_var_req_builder = match "multi" {
1614            "multi" => local_var_req_builder.query(
1615                &local_var_str
1616                    .into_iter()
1617                    .map(|p| ("member_id__gte".to_owned(), p.to_string()))
1618                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1619            ),
1620            _ => local_var_req_builder.query(&[(
1621                "member_id__gte",
1622                &local_var_str
1623                    .into_iter()
1624                    .map(|p| p.to_string())
1625                    .collect::<Vec<String>>()
1626                    .join(",")
1627                    .to_string(),
1628            )]),
1629        };
1630    }
1631    if let Some(ref local_var_str) = member_id__lt {
1632        local_var_req_builder = match "multi" {
1633            "multi" => local_var_req_builder.query(
1634                &local_var_str
1635                    .into_iter()
1636                    .map(|p| ("member_id__lt".to_owned(), p.to_string()))
1637                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1638            ),
1639            _ => local_var_req_builder.query(&[(
1640                "member_id__lt",
1641                &local_var_str
1642                    .into_iter()
1643                    .map(|p| p.to_string())
1644                    .collect::<Vec<String>>()
1645                    .join(",")
1646                    .to_string(),
1647            )]),
1648        };
1649    }
1650    if let Some(ref local_var_str) = member_id__lte {
1651        local_var_req_builder = match "multi" {
1652            "multi" => local_var_req_builder.query(
1653                &local_var_str
1654                    .into_iter()
1655                    .map(|p| ("member_id__lte".to_owned(), p.to_string()))
1656                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1657            ),
1658            _ => local_var_req_builder.query(&[(
1659                "member_id__lte",
1660                &local_var_str
1661                    .into_iter()
1662                    .map(|p| p.to_string())
1663                    .collect::<Vec<String>>()
1664                    .join(",")
1665                    .to_string(),
1666            )]),
1667        };
1668    }
1669    if let Some(ref local_var_str) = member_id__n {
1670        local_var_req_builder = match "multi" {
1671            "multi" => local_var_req_builder.query(
1672                &local_var_str
1673                    .into_iter()
1674                    .map(|p| ("member_id__n".to_owned(), p.to_string()))
1675                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1676            ),
1677            _ => local_var_req_builder.query(&[(
1678                "member_id__n",
1679                &local_var_str
1680                    .into_iter()
1681                    .map(|p| p.to_string())
1682                    .collect::<Vec<String>>()
1683                    .join(",")
1684                    .to_string(),
1685            )]),
1686        };
1687    }
1688    if let Some(ref local_var_str) = member_type {
1689        local_var_req_builder = match "multi" {
1690            "multi" => local_var_req_builder.query(
1691                &local_var_str
1692                    .into_iter()
1693                    .map(|p| ("member_type".to_owned(), p.to_string()))
1694                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1695            ),
1696            _ => local_var_req_builder.query(&[(
1697                "member_type",
1698                &local_var_str
1699                    .into_iter()
1700                    .map(|p| p.to_string())
1701                    .collect::<Vec<String>>()
1702                    .join(",")
1703                    .to_string(),
1704            )]),
1705        };
1706    }
1707    if let Some(ref local_var_str) = member_type__n {
1708        local_var_req_builder = match "multi" {
1709            "multi" => local_var_req_builder.query(
1710                &local_var_str
1711                    .into_iter()
1712                    .map(|p| ("member_type__n".to_owned(), p.to_string()))
1713                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1714            ),
1715            _ => local_var_req_builder.query(&[(
1716                "member_type__n",
1717                &local_var_str
1718                    .into_iter()
1719                    .map(|p| p.to_string())
1720                    .collect::<Vec<String>>()
1721                    .join(",")
1722                    .to_string(),
1723            )]),
1724        };
1725    }
1726    if let Some(ref local_var_str) = modified_by_request {
1727        local_var_req_builder =
1728            local_var_req_builder.query(&[("modified_by_request", &local_var_str.to_string())]);
1729    }
1730    if let Some(ref local_var_str) = offset {
1731        local_var_req_builder =
1732            local_var_req_builder.query(&[("offset", &local_var_str.to_string())]);
1733    }
1734    if let Some(ref local_var_str) = ordering {
1735        local_var_req_builder =
1736            local_var_req_builder.query(&[("ordering", &local_var_str.to_string())]);
1737    }
1738    if let Some(ref local_var_str) = priority {
1739        local_var_req_builder =
1740            local_var_req_builder.query(&[("priority", &local_var_str.to_string())]);
1741    }
1742    if let Some(ref local_var_str) = priority__empty {
1743        local_var_req_builder =
1744            local_var_req_builder.query(&[("priority__empty", &local_var_str.to_string())]);
1745    }
1746    if let Some(ref local_var_str) = priority__ic {
1747        local_var_req_builder = match "multi" {
1748            "multi" => local_var_req_builder.query(
1749                &local_var_str
1750                    .into_iter()
1751                    .map(|p| ("priority__ic".to_owned(), p.to_string()))
1752                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1753            ),
1754            _ => local_var_req_builder.query(&[(
1755                "priority__ic",
1756                &local_var_str
1757                    .into_iter()
1758                    .map(|p| p.to_string())
1759                    .collect::<Vec<String>>()
1760                    .join(",")
1761                    .to_string(),
1762            )]),
1763        };
1764    }
1765    if let Some(ref local_var_str) = priority__ie {
1766        local_var_req_builder = match "multi" {
1767            "multi" => local_var_req_builder.query(
1768                &local_var_str
1769                    .into_iter()
1770                    .map(|p| ("priority__ie".to_owned(), p.to_string()))
1771                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1772            ),
1773            _ => local_var_req_builder.query(&[(
1774                "priority__ie",
1775                &local_var_str
1776                    .into_iter()
1777                    .map(|p| p.to_string())
1778                    .collect::<Vec<String>>()
1779                    .join(",")
1780                    .to_string(),
1781            )]),
1782        };
1783    }
1784    if let Some(ref local_var_str) = priority__iew {
1785        local_var_req_builder = match "multi" {
1786            "multi" => local_var_req_builder.query(
1787                &local_var_str
1788                    .into_iter()
1789                    .map(|p| ("priority__iew".to_owned(), p.to_string()))
1790                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1791            ),
1792            _ => local_var_req_builder.query(&[(
1793                "priority__iew",
1794                &local_var_str
1795                    .into_iter()
1796                    .map(|p| p.to_string())
1797                    .collect::<Vec<String>>()
1798                    .join(",")
1799                    .to_string(),
1800            )]),
1801        };
1802    }
1803    if let Some(ref local_var_str) = priority__iregex {
1804        local_var_req_builder = match "multi" {
1805            "multi" => local_var_req_builder.query(
1806                &local_var_str
1807                    .into_iter()
1808                    .map(|p| ("priority__iregex".to_owned(), p.to_string()))
1809                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1810            ),
1811            _ => local_var_req_builder.query(&[(
1812                "priority__iregex",
1813                &local_var_str
1814                    .into_iter()
1815                    .map(|p| p.to_string())
1816                    .collect::<Vec<String>>()
1817                    .join(",")
1818                    .to_string(),
1819            )]),
1820        };
1821    }
1822    if let Some(ref local_var_str) = priority__isw {
1823        local_var_req_builder = match "multi" {
1824            "multi" => local_var_req_builder.query(
1825                &local_var_str
1826                    .into_iter()
1827                    .map(|p| ("priority__isw".to_owned(), p.to_string()))
1828                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1829            ),
1830            _ => local_var_req_builder.query(&[(
1831                "priority__isw",
1832                &local_var_str
1833                    .into_iter()
1834                    .map(|p| p.to_string())
1835                    .collect::<Vec<String>>()
1836                    .join(",")
1837                    .to_string(),
1838            )]),
1839        };
1840    }
1841    if let Some(ref local_var_str) = priority__n {
1842        local_var_req_builder =
1843            local_var_req_builder.query(&[("priority__n", &local_var_str.to_string())]);
1844    }
1845    if let Some(ref local_var_str) = priority__nic {
1846        local_var_req_builder = match "multi" {
1847            "multi" => local_var_req_builder.query(
1848                &local_var_str
1849                    .into_iter()
1850                    .map(|p| ("priority__nic".to_owned(), p.to_string()))
1851                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1852            ),
1853            _ => local_var_req_builder.query(&[(
1854                "priority__nic",
1855                &local_var_str
1856                    .into_iter()
1857                    .map(|p| p.to_string())
1858                    .collect::<Vec<String>>()
1859                    .join(",")
1860                    .to_string(),
1861            )]),
1862        };
1863    }
1864    if let Some(ref local_var_str) = priority__nie {
1865        local_var_req_builder = match "multi" {
1866            "multi" => local_var_req_builder.query(
1867                &local_var_str
1868                    .into_iter()
1869                    .map(|p| ("priority__nie".to_owned(), p.to_string()))
1870                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1871            ),
1872            _ => local_var_req_builder.query(&[(
1873                "priority__nie",
1874                &local_var_str
1875                    .into_iter()
1876                    .map(|p| p.to_string())
1877                    .collect::<Vec<String>>()
1878                    .join(",")
1879                    .to_string(),
1880            )]),
1881        };
1882    }
1883    if let Some(ref local_var_str) = priority__niew {
1884        local_var_req_builder = match "multi" {
1885            "multi" => local_var_req_builder.query(
1886                &local_var_str
1887                    .into_iter()
1888                    .map(|p| ("priority__niew".to_owned(), p.to_string()))
1889                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1890            ),
1891            _ => local_var_req_builder.query(&[(
1892                "priority__niew",
1893                &local_var_str
1894                    .into_iter()
1895                    .map(|p| p.to_string())
1896                    .collect::<Vec<String>>()
1897                    .join(",")
1898                    .to_string(),
1899            )]),
1900        };
1901    }
1902    if let Some(ref local_var_str) = priority__nisw {
1903        local_var_req_builder = match "multi" {
1904            "multi" => local_var_req_builder.query(
1905                &local_var_str
1906                    .into_iter()
1907                    .map(|p| ("priority__nisw".to_owned(), p.to_string()))
1908                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1909            ),
1910            _ => local_var_req_builder.query(&[(
1911                "priority__nisw",
1912                &local_var_str
1913                    .into_iter()
1914                    .map(|p| p.to_string())
1915                    .collect::<Vec<String>>()
1916                    .join(",")
1917                    .to_string(),
1918            )]),
1919        };
1920    }
1921    if let Some(ref local_var_str) = priority__regex {
1922        local_var_req_builder = match "multi" {
1923            "multi" => local_var_req_builder.query(
1924                &local_var_str
1925                    .into_iter()
1926                    .map(|p| ("priority__regex".to_owned(), p.to_string()))
1927                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1928            ),
1929            _ => local_var_req_builder.query(&[(
1930                "priority__regex",
1931                &local_var_str
1932                    .into_iter()
1933                    .map(|p| p.to_string())
1934                    .collect::<Vec<String>>()
1935                    .join(",")
1936                    .to_string(),
1937            )]),
1938        };
1939    }
1940    if let Some(ref local_var_str) = provider {
1941        local_var_req_builder = match "multi" {
1942            "multi" => local_var_req_builder.query(
1943                &local_var_str
1944                    .into_iter()
1945                    .map(|p| ("provider".to_owned(), p.to_string()))
1946                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1947            ),
1948            _ => local_var_req_builder.query(&[(
1949                "provider",
1950                &local_var_str
1951                    .into_iter()
1952                    .map(|p| p.to_string())
1953                    .collect::<Vec<String>>()
1954                    .join(",")
1955                    .to_string(),
1956            )]),
1957        };
1958    }
1959    if let Some(ref local_var_str) = provider_id {
1960        local_var_req_builder = match "multi" {
1961            "multi" => local_var_req_builder.query(
1962                &local_var_str
1963                    .into_iter()
1964                    .map(|p| ("provider_id".to_owned(), p.to_string()))
1965                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1966            ),
1967            _ => local_var_req_builder.query(&[(
1968                "provider_id",
1969                &local_var_str
1970                    .into_iter()
1971                    .map(|p| p.to_string())
1972                    .collect::<Vec<String>>()
1973                    .join(",")
1974                    .to_string(),
1975            )]),
1976        };
1977    }
1978    if let Some(ref local_var_str) = q {
1979        local_var_req_builder = local_var_req_builder.query(&[("q", &local_var_str.to_string())]);
1980    }
1981    if let Some(ref local_var_str) = start {
1982        local_var_req_builder =
1983            local_var_req_builder.query(&[("start", &local_var_str.to_string())]);
1984    }
1985    if let Some(ref local_var_str) = tag {
1986        local_var_req_builder = match "multi" {
1987            "multi" => local_var_req_builder.query(
1988                &local_var_str
1989                    .into_iter()
1990                    .map(|p| ("tag".to_owned(), p.to_string()))
1991                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1992            ),
1993            _ => local_var_req_builder.query(&[(
1994                "tag",
1995                &local_var_str
1996                    .into_iter()
1997                    .map(|p| p.to_string())
1998                    .collect::<Vec<String>>()
1999                    .join(",")
2000                    .to_string(),
2001            )]),
2002        };
2003    }
2004    if let Some(ref local_var_str) = tag__n {
2005        local_var_req_builder = match "multi" {
2006            "multi" => local_var_req_builder.query(
2007                &local_var_str
2008                    .into_iter()
2009                    .map(|p| ("tag__n".to_owned(), p.to_string()))
2010                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2011            ),
2012            _ => local_var_req_builder.query(&[(
2013                "tag__n",
2014                &local_var_str
2015                    .into_iter()
2016                    .map(|p| p.to_string())
2017                    .collect::<Vec<String>>()
2018                    .join(",")
2019                    .to_string(),
2020            )]),
2021        };
2022    }
2023    if let Some(ref local_var_str) = tag_id {
2024        local_var_req_builder = match "multi" {
2025            "multi" => local_var_req_builder.query(
2026                &local_var_str
2027                    .into_iter()
2028                    .map(|p| ("tag_id".to_owned(), p.to_string()))
2029                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2030            ),
2031            _ => local_var_req_builder.query(&[(
2032                "tag_id",
2033                &local_var_str
2034                    .into_iter()
2035                    .map(|p| p.to_string())
2036                    .collect::<Vec<String>>()
2037                    .join(",")
2038                    .to_string(),
2039            )]),
2040        };
2041    }
2042    if let Some(ref local_var_str) = tag_id__n {
2043        local_var_req_builder = match "multi" {
2044            "multi" => local_var_req_builder.query(
2045                &local_var_str
2046                    .into_iter()
2047                    .map(|p| ("tag_id__n".to_owned(), p.to_string()))
2048                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2049            ),
2050            _ => local_var_req_builder.query(&[(
2051                "tag_id__n",
2052                &local_var_str
2053                    .into_iter()
2054                    .map(|p| p.to_string())
2055                    .collect::<Vec<String>>()
2056                    .join(",")
2057                    .to_string(),
2058            )]),
2059        };
2060    }
2061    if let Some(ref local_var_str) = updated_by_request {
2062        local_var_req_builder =
2063            local_var_req_builder.query(&[("updated_by_request", &local_var_str.to_string())]);
2064    }
2065    if let Some(ref local_var_str) = virtual_circuit {
2066        local_var_req_builder = match "multi" {
2067            "multi" => local_var_req_builder.query(
2068                &local_var_str
2069                    .into_iter()
2070                    .map(|p| ("virtual_circuit".to_owned(), p.to_string()))
2071                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2072            ),
2073            _ => local_var_req_builder.query(&[(
2074                "virtual_circuit",
2075                &local_var_str
2076                    .into_iter()
2077                    .map(|p| p.to_string())
2078                    .collect::<Vec<String>>()
2079                    .join(",")
2080                    .to_string(),
2081            )]),
2082        };
2083    }
2084    if let Some(ref local_var_str) = virtual_circuit_id {
2085        local_var_req_builder = match "multi" {
2086            "multi" => local_var_req_builder.query(
2087                &local_var_str
2088                    .into_iter()
2089                    .map(|p| ("virtual_circuit_id".to_owned(), p.to_string()))
2090                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2091            ),
2092            _ => local_var_req_builder.query(&[(
2093                "virtual_circuit_id",
2094                &local_var_str
2095                    .into_iter()
2096                    .map(|p| p.to_string())
2097                    .collect::<Vec<String>>()
2098                    .join(",")
2099                    .to_string(),
2100            )]),
2101        };
2102    }
2103    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
2104        local_var_req_builder =
2105            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
2106    }
2107    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
2108        let local_var_key = local_var_apikey.key.clone();
2109        let local_var_value = match local_var_apikey.prefix {
2110            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
2111            None => local_var_key,
2112        };
2113        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
2114    };
2115
2116    let local_var_req = local_var_req_builder.build()?;
2117    let local_var_resp = local_var_client.execute(local_var_req).await?;
2118
2119    let local_var_status = local_var_resp.status();
2120    let local_var_content = local_var_resp.text().await?;
2121
2122    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
2123        serde_json::from_str(&local_var_content).map_err(Error::from)
2124    } else {
2125        let local_var_entity: Option<CircuitsCircuitGroupAssignmentsListError> =
2126            serde_json::from_str(&local_var_content).ok();
2127        let local_var_error = ResponseContent {
2128            status: local_var_status,
2129            content: local_var_content,
2130            entity: local_var_entity,
2131        };
2132        Err(Error::ResponseError(local_var_error))
2133    }
2134}
2135
2136/// Patch a Circuit group assignment object.
2137pub async fn circuits_circuit_group_assignments_partial_update(
2138    configuration: &configuration::Configuration,
2139    id: i32,
2140    patched_writable_circuit_group_assignment_request: Option<
2141        crate::models::PatchedWritableCircuitGroupAssignmentRequest,
2142    >,
2143) -> Result<
2144    crate::models::CircuitGroupAssignment,
2145    Error<CircuitsCircuitGroupAssignmentsPartialUpdateError>,
2146> {
2147    let local_var_configuration = configuration;
2148
2149    let local_var_client = &local_var_configuration.client;
2150
2151    let local_var_uri_str = format!(
2152        "{}/api/circuits/circuit-group-assignments/{id}/",
2153        local_var_configuration.base_path,
2154        id = id
2155    );
2156    let mut local_var_req_builder =
2157        local_var_client.request(reqwest::Method::PATCH, local_var_uri_str.as_str());
2158
2159    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
2160        local_var_req_builder =
2161            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
2162    }
2163    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
2164        let local_var_key = local_var_apikey.key.clone();
2165        let local_var_value = match local_var_apikey.prefix {
2166            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
2167            None => local_var_key,
2168        };
2169        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
2170    };
2171    local_var_req_builder =
2172        local_var_req_builder.json(&patched_writable_circuit_group_assignment_request);
2173
2174    let local_var_req = local_var_req_builder.build()?;
2175    let local_var_resp = local_var_client.execute(local_var_req).await?;
2176
2177    let local_var_status = local_var_resp.status();
2178    let local_var_content = local_var_resp.text().await?;
2179
2180    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
2181        serde_json::from_str(&local_var_content).map_err(Error::from)
2182    } else {
2183        let local_var_entity: Option<CircuitsCircuitGroupAssignmentsPartialUpdateError> =
2184            serde_json::from_str(&local_var_content).ok();
2185        let local_var_error = ResponseContent {
2186            status: local_var_status,
2187            content: local_var_content,
2188            entity: local_var_entity,
2189        };
2190        Err(Error::ResponseError(local_var_error))
2191    }
2192}
2193
2194/// Get a Circuit group assignment object.
2195pub async fn circuits_circuit_group_assignments_retrieve(
2196    configuration: &configuration::Configuration,
2197    id: i32,
2198) -> Result<
2199    crate::models::CircuitGroupAssignment,
2200    Error<CircuitsCircuitGroupAssignmentsRetrieveError>,
2201> {
2202    let local_var_configuration = configuration;
2203
2204    let local_var_client = &local_var_configuration.client;
2205
2206    let local_var_uri_str = format!(
2207        "{}/api/circuits/circuit-group-assignments/{id}/",
2208        local_var_configuration.base_path,
2209        id = id
2210    );
2211    let mut local_var_req_builder =
2212        local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
2213
2214    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
2215        local_var_req_builder =
2216            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
2217    }
2218    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
2219        let local_var_key = local_var_apikey.key.clone();
2220        let local_var_value = match local_var_apikey.prefix {
2221            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
2222            None => local_var_key,
2223        };
2224        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
2225    };
2226
2227    let local_var_req = local_var_req_builder.build()?;
2228    let local_var_resp = local_var_client.execute(local_var_req).await?;
2229
2230    let local_var_status = local_var_resp.status();
2231    let local_var_content = local_var_resp.text().await?;
2232
2233    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
2234        serde_json::from_str(&local_var_content).map_err(Error::from)
2235    } else {
2236        let local_var_entity: Option<CircuitsCircuitGroupAssignmentsRetrieveError> =
2237            serde_json::from_str(&local_var_content).ok();
2238        let local_var_error = ResponseContent {
2239            status: local_var_status,
2240            content: local_var_content,
2241            entity: local_var_entity,
2242        };
2243        Err(Error::ResponseError(local_var_error))
2244    }
2245}
2246
2247/// Put a Circuit group assignment object.
2248pub async fn circuits_circuit_group_assignments_update(
2249    configuration: &configuration::Configuration,
2250    id: i32,
2251    writable_circuit_group_assignment_request: crate::models::WritableCircuitGroupAssignmentRequest,
2252) -> Result<crate::models::CircuitGroupAssignment, Error<CircuitsCircuitGroupAssignmentsUpdateError>>
2253{
2254    let local_var_configuration = configuration;
2255
2256    let local_var_client = &local_var_configuration.client;
2257
2258    let local_var_uri_str = format!(
2259        "{}/api/circuits/circuit-group-assignments/{id}/",
2260        local_var_configuration.base_path,
2261        id = id
2262    );
2263    let mut local_var_req_builder =
2264        local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());
2265
2266    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
2267        local_var_req_builder =
2268            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
2269    }
2270    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
2271        let local_var_key = local_var_apikey.key.clone();
2272        let local_var_value = match local_var_apikey.prefix {
2273            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
2274            None => local_var_key,
2275        };
2276        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
2277    };
2278    local_var_req_builder = local_var_req_builder.json(&writable_circuit_group_assignment_request);
2279
2280    let local_var_req = local_var_req_builder.build()?;
2281    let local_var_resp = local_var_client.execute(local_var_req).await?;
2282
2283    let local_var_status = local_var_resp.status();
2284    let local_var_content = local_var_resp.text().await?;
2285
2286    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
2287        serde_json::from_str(&local_var_content).map_err(Error::from)
2288    } else {
2289        let local_var_entity: Option<CircuitsCircuitGroupAssignmentsUpdateError> =
2290            serde_json::from_str(&local_var_content).ok();
2291        let local_var_error = ResponseContent {
2292            status: local_var_status,
2293            content: local_var_content,
2294            entity: local_var_entity,
2295        };
2296        Err(Error::ResponseError(local_var_error))
2297    }
2298}
2299
2300/// Delete a list of circuit group objects.
2301pub async fn circuits_circuit_groups_bulk_destroy(
2302    configuration: &configuration::Configuration,
2303    circuit_group_request: Vec<crate::models::CircuitGroupRequest>,
2304) -> Result<(), Error<CircuitsCircuitGroupsBulkDestroyError>> {
2305    let local_var_configuration = configuration;
2306
2307    let local_var_client = &local_var_configuration.client;
2308
2309    let local_var_uri_str = format!(
2310        "{}/api/circuits/circuit-groups/",
2311        local_var_configuration.base_path
2312    );
2313    let mut local_var_req_builder =
2314        local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());
2315
2316    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
2317        local_var_req_builder =
2318            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
2319    }
2320    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
2321        let local_var_key = local_var_apikey.key.clone();
2322        let local_var_value = match local_var_apikey.prefix {
2323            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
2324            None => local_var_key,
2325        };
2326        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
2327    };
2328    local_var_req_builder = local_var_req_builder.json(&circuit_group_request);
2329
2330    let local_var_req = local_var_req_builder.build()?;
2331    let local_var_resp = local_var_client.execute(local_var_req).await?;
2332
2333    let local_var_status = local_var_resp.status();
2334    let local_var_content = local_var_resp.text().await?;
2335
2336    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
2337        Ok(())
2338    } else {
2339        let local_var_entity: Option<CircuitsCircuitGroupsBulkDestroyError> =
2340            serde_json::from_str(&local_var_content).ok();
2341        let local_var_error = ResponseContent {
2342            status: local_var_status,
2343            content: local_var_content,
2344            entity: local_var_entity,
2345        };
2346        Err(Error::ResponseError(local_var_error))
2347    }
2348}
2349
2350/// Patch a list of circuit group objects.
2351pub async fn circuits_circuit_groups_bulk_partial_update(
2352    configuration: &configuration::Configuration,
2353    circuit_group_request: Vec<crate::models::CircuitGroupRequest>,
2354) -> Result<Vec<crate::models::CircuitGroup>, Error<CircuitsCircuitGroupsBulkPartialUpdateError>> {
2355    let local_var_configuration = configuration;
2356
2357    let local_var_client = &local_var_configuration.client;
2358
2359    let local_var_uri_str = format!(
2360        "{}/api/circuits/circuit-groups/",
2361        local_var_configuration.base_path
2362    );
2363    let mut local_var_req_builder =
2364        local_var_client.request(reqwest::Method::PATCH, local_var_uri_str.as_str());
2365
2366    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
2367        local_var_req_builder =
2368            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
2369    }
2370    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
2371        let local_var_key = local_var_apikey.key.clone();
2372        let local_var_value = match local_var_apikey.prefix {
2373            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
2374            None => local_var_key,
2375        };
2376        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
2377    };
2378    local_var_req_builder = local_var_req_builder.json(&circuit_group_request);
2379
2380    let local_var_req = local_var_req_builder.build()?;
2381    let local_var_resp = local_var_client.execute(local_var_req).await?;
2382
2383    let local_var_status = local_var_resp.status();
2384    let local_var_content = local_var_resp.text().await?;
2385
2386    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
2387        serde_json::from_str(&local_var_content).map_err(Error::from)
2388    } else {
2389        let local_var_entity: Option<CircuitsCircuitGroupsBulkPartialUpdateError> =
2390            serde_json::from_str(&local_var_content).ok();
2391        let local_var_error = ResponseContent {
2392            status: local_var_status,
2393            content: local_var_content,
2394            entity: local_var_entity,
2395        };
2396        Err(Error::ResponseError(local_var_error))
2397    }
2398}
2399
2400/// Put a list of circuit group objects.
2401pub async fn circuits_circuit_groups_bulk_update(
2402    configuration: &configuration::Configuration,
2403    circuit_group_request: Vec<crate::models::CircuitGroupRequest>,
2404) -> Result<Vec<crate::models::CircuitGroup>, Error<CircuitsCircuitGroupsBulkUpdateError>> {
2405    let local_var_configuration = configuration;
2406
2407    let local_var_client = &local_var_configuration.client;
2408
2409    let local_var_uri_str = format!(
2410        "{}/api/circuits/circuit-groups/",
2411        local_var_configuration.base_path
2412    );
2413    let mut local_var_req_builder =
2414        local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());
2415
2416    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
2417        local_var_req_builder =
2418            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
2419    }
2420    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
2421        let local_var_key = local_var_apikey.key.clone();
2422        let local_var_value = match local_var_apikey.prefix {
2423            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
2424            None => local_var_key,
2425        };
2426        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
2427    };
2428    local_var_req_builder = local_var_req_builder.json(&circuit_group_request);
2429
2430    let local_var_req = local_var_req_builder.build()?;
2431    let local_var_resp = local_var_client.execute(local_var_req).await?;
2432
2433    let local_var_status = local_var_resp.status();
2434    let local_var_content = local_var_resp.text().await?;
2435
2436    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
2437        serde_json::from_str(&local_var_content).map_err(Error::from)
2438    } else {
2439        let local_var_entity: Option<CircuitsCircuitGroupsBulkUpdateError> =
2440            serde_json::from_str(&local_var_content).ok();
2441        let local_var_error = ResponseContent {
2442            status: local_var_status,
2443            content: local_var_content,
2444            entity: local_var_entity,
2445        };
2446        Err(Error::ResponseError(local_var_error))
2447    }
2448}
2449
2450/// Post a list of circuit group objects.
2451pub async fn circuits_circuit_groups_create(
2452    configuration: &configuration::Configuration,
2453    circuits_circuit_groups_create_request: crate::models::CircuitsCircuitGroupsCreateRequest,
2454) -> Result<crate::models::CircuitGroup, Error<CircuitsCircuitGroupsCreateError>> {
2455    let local_var_configuration = configuration;
2456
2457    let local_var_client = &local_var_configuration.client;
2458
2459    let local_var_uri_str = format!(
2460        "{}/api/circuits/circuit-groups/",
2461        local_var_configuration.base_path
2462    );
2463    let mut local_var_req_builder =
2464        local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
2465
2466    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
2467        local_var_req_builder =
2468            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
2469    }
2470    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
2471        let local_var_key = local_var_apikey.key.clone();
2472        let local_var_value = match local_var_apikey.prefix {
2473            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
2474            None => local_var_key,
2475        };
2476        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
2477    };
2478    local_var_req_builder = local_var_req_builder.json(&circuits_circuit_groups_create_request);
2479
2480    let local_var_req = local_var_req_builder.build()?;
2481    let local_var_resp = local_var_client.execute(local_var_req).await?;
2482
2483    let local_var_status = local_var_resp.status();
2484    let local_var_content = local_var_resp.text().await?;
2485
2486    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
2487        serde_json::from_str(&local_var_content).map_err(Error::from)
2488    } else {
2489        let local_var_entity: Option<CircuitsCircuitGroupsCreateError> =
2490            serde_json::from_str(&local_var_content).ok();
2491        let local_var_error = ResponseContent {
2492            status: local_var_status,
2493            content: local_var_content,
2494            entity: local_var_entity,
2495        };
2496        Err(Error::ResponseError(local_var_error))
2497    }
2498}
2499
2500/// Delete a circuit group object.
2501pub async fn circuits_circuit_groups_destroy(
2502    configuration: &configuration::Configuration,
2503    id: i32,
2504) -> Result<(), Error<CircuitsCircuitGroupsDestroyError>> {
2505    let local_var_configuration = configuration;
2506
2507    let local_var_client = &local_var_configuration.client;
2508
2509    let local_var_uri_str = format!(
2510        "{}/api/circuits/circuit-groups/{id}/",
2511        local_var_configuration.base_path,
2512        id = id
2513    );
2514    let mut local_var_req_builder =
2515        local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());
2516
2517    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
2518        local_var_req_builder =
2519            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
2520    }
2521    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
2522        let local_var_key = local_var_apikey.key.clone();
2523        let local_var_value = match local_var_apikey.prefix {
2524            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
2525            None => local_var_key,
2526        };
2527        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
2528    };
2529
2530    let local_var_req = local_var_req_builder.build()?;
2531    let local_var_resp = local_var_client.execute(local_var_req).await?;
2532
2533    let local_var_status = local_var_resp.status();
2534    let local_var_content = local_var_resp.text().await?;
2535
2536    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
2537        Ok(())
2538    } else {
2539        let local_var_entity: Option<CircuitsCircuitGroupsDestroyError> =
2540            serde_json::from_str(&local_var_content).ok();
2541        let local_var_error = ResponseContent {
2542            status: local_var_status,
2543            content: local_var_content,
2544            entity: local_var_entity,
2545        };
2546        Err(Error::ResponseError(local_var_error))
2547    }
2548}
2549
2550/// Get a list of circuit group objects.
2551pub async fn circuits_circuit_groups_list(
2552    configuration: &configuration::Configuration,
2553    created: Option<Vec<String>>,
2554    created__empty: Option<Vec<String>>,
2555    created__gt: Option<Vec<String>>,
2556    created__gte: Option<Vec<String>>,
2557    created__lt: Option<Vec<String>>,
2558    created__lte: Option<Vec<String>>,
2559    created__n: Option<Vec<String>>,
2560    created_by_request: Option<&str>,
2561    description: Option<Vec<String>>,
2562    description__empty: Option<bool>,
2563    description__ic: Option<Vec<String>>,
2564    description__ie: Option<Vec<String>>,
2565    description__iew: Option<Vec<String>>,
2566    description__iregex: Option<Vec<String>>,
2567    description__isw: Option<Vec<String>>,
2568    description__n: Option<Vec<String>>,
2569    description__nic: Option<Vec<String>>,
2570    description__nie: Option<Vec<String>>,
2571    description__niew: Option<Vec<String>>,
2572    description__nisw: Option<Vec<String>>,
2573    description__regex: Option<Vec<String>>,
2574    id: Option<Vec<i32>>,
2575    id__empty: Option<bool>,
2576    id__gt: Option<Vec<i32>>,
2577    id__gte: Option<Vec<i32>>,
2578    id__lt: Option<Vec<i32>>,
2579    id__lte: Option<Vec<i32>>,
2580    id__n: Option<Vec<i32>>,
2581    last_updated: Option<Vec<String>>,
2582    last_updated__empty: Option<Vec<String>>,
2583    last_updated__gt: Option<Vec<String>>,
2584    last_updated__gte: Option<Vec<String>>,
2585    last_updated__lt: Option<Vec<String>>,
2586    last_updated__lte: Option<Vec<String>>,
2587    last_updated__n: Option<Vec<String>>,
2588    limit: Option<i32>,
2589    modified_by_request: Option<&str>,
2590    name: Option<Vec<String>>,
2591    name__empty: Option<bool>,
2592    name__ic: Option<Vec<String>>,
2593    name__ie: Option<Vec<String>>,
2594    name__iew: Option<Vec<String>>,
2595    name__iregex: Option<Vec<String>>,
2596    name__isw: Option<Vec<String>>,
2597    name__n: Option<Vec<String>>,
2598    name__nic: Option<Vec<String>>,
2599    name__nie: Option<Vec<String>>,
2600    name__niew: Option<Vec<String>>,
2601    name__nisw: Option<Vec<String>>,
2602    name__regex: Option<Vec<String>>,
2603    offset: Option<i32>,
2604    ordering: Option<&str>,
2605    owner: Option<Vec<String>>,
2606    owner__n: Option<Vec<String>>,
2607    owner_group: Option<Vec<String>>,
2608    owner_group__n: Option<Vec<String>>,
2609    owner_group_id: Option<Vec<i32>>,
2610    owner_group_id__n: Option<Vec<i32>>,
2611    owner_id: Option<Vec<i32>>,
2612    owner_id__n: Option<Vec<i32>>,
2613    q: Option<&str>,
2614    slug: Option<Vec<String>>,
2615    slug__empty: Option<bool>,
2616    slug__ic: Option<Vec<String>>,
2617    slug__ie: Option<Vec<String>>,
2618    slug__iew: Option<Vec<String>>,
2619    slug__iregex: Option<Vec<String>>,
2620    slug__isw: Option<Vec<String>>,
2621    slug__n: Option<Vec<String>>,
2622    slug__nic: Option<Vec<String>>,
2623    slug__nie: Option<Vec<String>>,
2624    slug__niew: Option<Vec<String>>,
2625    slug__nisw: Option<Vec<String>>,
2626    slug__regex: Option<Vec<String>>,
2627    start: Option<i32>,
2628    tag: Option<Vec<String>>,
2629    tag__n: Option<Vec<String>>,
2630    tag_id: Option<Vec<i32>>,
2631    tag_id__n: Option<Vec<i32>>,
2632    tenant: Option<Vec<String>>,
2633    tenant__n: Option<Vec<String>>,
2634    tenant_group: Option<Vec<String>>,
2635    tenant_group__n: Option<Vec<String>>,
2636    tenant_group_id: Option<Vec<String>>,
2637    tenant_group_id__n: Option<Vec<String>>,
2638    tenant_id: Option<Vec<i32>>,
2639    tenant_id__n: Option<Vec<i32>>,
2640    updated_by_request: Option<&str>,
2641) -> Result<crate::models::PaginatedCircuitGroupList, Error<CircuitsCircuitGroupsListError>> {
2642    let local_var_configuration = configuration;
2643
2644    let local_var_client = &local_var_configuration.client;
2645
2646    let local_var_uri_str = format!(
2647        "{}/api/circuits/circuit-groups/",
2648        local_var_configuration.base_path
2649    );
2650    let mut local_var_req_builder =
2651        local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
2652
2653    if let Some(ref local_var_str) = created {
2654        local_var_req_builder = match "multi" {
2655            "multi" => local_var_req_builder.query(
2656                &local_var_str
2657                    .into_iter()
2658                    .map(|p| ("created".to_owned(), p.to_string()))
2659                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2660            ),
2661            _ => local_var_req_builder.query(&[(
2662                "created",
2663                &local_var_str
2664                    .into_iter()
2665                    .map(|p| p.to_string())
2666                    .collect::<Vec<String>>()
2667                    .join(",")
2668                    .to_string(),
2669            )]),
2670        };
2671    }
2672    if let Some(ref local_var_str) = created__empty {
2673        local_var_req_builder = match "multi" {
2674            "multi" => local_var_req_builder.query(
2675                &local_var_str
2676                    .into_iter()
2677                    .map(|p| ("created__empty".to_owned(), p.to_string()))
2678                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2679            ),
2680            _ => local_var_req_builder.query(&[(
2681                "created__empty",
2682                &local_var_str
2683                    .into_iter()
2684                    .map(|p| p.to_string())
2685                    .collect::<Vec<String>>()
2686                    .join(",")
2687                    .to_string(),
2688            )]),
2689        };
2690    }
2691    if let Some(ref local_var_str) = created__gt {
2692        local_var_req_builder = match "multi" {
2693            "multi" => local_var_req_builder.query(
2694                &local_var_str
2695                    .into_iter()
2696                    .map(|p| ("created__gt".to_owned(), p.to_string()))
2697                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2698            ),
2699            _ => local_var_req_builder.query(&[(
2700                "created__gt",
2701                &local_var_str
2702                    .into_iter()
2703                    .map(|p| p.to_string())
2704                    .collect::<Vec<String>>()
2705                    .join(",")
2706                    .to_string(),
2707            )]),
2708        };
2709    }
2710    if let Some(ref local_var_str) = created__gte {
2711        local_var_req_builder = match "multi" {
2712            "multi" => local_var_req_builder.query(
2713                &local_var_str
2714                    .into_iter()
2715                    .map(|p| ("created__gte".to_owned(), p.to_string()))
2716                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2717            ),
2718            _ => local_var_req_builder.query(&[(
2719                "created__gte",
2720                &local_var_str
2721                    .into_iter()
2722                    .map(|p| p.to_string())
2723                    .collect::<Vec<String>>()
2724                    .join(",")
2725                    .to_string(),
2726            )]),
2727        };
2728    }
2729    if let Some(ref local_var_str) = created__lt {
2730        local_var_req_builder = match "multi" {
2731            "multi" => local_var_req_builder.query(
2732                &local_var_str
2733                    .into_iter()
2734                    .map(|p| ("created__lt".to_owned(), p.to_string()))
2735                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2736            ),
2737            _ => local_var_req_builder.query(&[(
2738                "created__lt",
2739                &local_var_str
2740                    .into_iter()
2741                    .map(|p| p.to_string())
2742                    .collect::<Vec<String>>()
2743                    .join(",")
2744                    .to_string(),
2745            )]),
2746        };
2747    }
2748    if let Some(ref local_var_str) = created__lte {
2749        local_var_req_builder = match "multi" {
2750            "multi" => local_var_req_builder.query(
2751                &local_var_str
2752                    .into_iter()
2753                    .map(|p| ("created__lte".to_owned(), p.to_string()))
2754                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2755            ),
2756            _ => local_var_req_builder.query(&[(
2757                "created__lte",
2758                &local_var_str
2759                    .into_iter()
2760                    .map(|p| p.to_string())
2761                    .collect::<Vec<String>>()
2762                    .join(",")
2763                    .to_string(),
2764            )]),
2765        };
2766    }
2767    if let Some(ref local_var_str) = created__n {
2768        local_var_req_builder = match "multi" {
2769            "multi" => local_var_req_builder.query(
2770                &local_var_str
2771                    .into_iter()
2772                    .map(|p| ("created__n".to_owned(), p.to_string()))
2773                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2774            ),
2775            _ => local_var_req_builder.query(&[(
2776                "created__n",
2777                &local_var_str
2778                    .into_iter()
2779                    .map(|p| p.to_string())
2780                    .collect::<Vec<String>>()
2781                    .join(",")
2782                    .to_string(),
2783            )]),
2784        };
2785    }
2786    if let Some(ref local_var_str) = created_by_request {
2787        local_var_req_builder =
2788            local_var_req_builder.query(&[("created_by_request", &local_var_str.to_string())]);
2789    }
2790    if let Some(ref local_var_str) = description {
2791        local_var_req_builder = match "multi" {
2792            "multi" => local_var_req_builder.query(
2793                &local_var_str
2794                    .into_iter()
2795                    .map(|p| ("description".to_owned(), p.to_string()))
2796                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2797            ),
2798            _ => local_var_req_builder.query(&[(
2799                "description",
2800                &local_var_str
2801                    .into_iter()
2802                    .map(|p| p.to_string())
2803                    .collect::<Vec<String>>()
2804                    .join(",")
2805                    .to_string(),
2806            )]),
2807        };
2808    }
2809    if let Some(ref local_var_str) = description__empty {
2810        local_var_req_builder =
2811            local_var_req_builder.query(&[("description__empty", &local_var_str.to_string())]);
2812    }
2813    if let Some(ref local_var_str) = description__ic {
2814        local_var_req_builder = match "multi" {
2815            "multi" => local_var_req_builder.query(
2816                &local_var_str
2817                    .into_iter()
2818                    .map(|p| ("description__ic".to_owned(), p.to_string()))
2819                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2820            ),
2821            _ => local_var_req_builder.query(&[(
2822                "description__ic",
2823                &local_var_str
2824                    .into_iter()
2825                    .map(|p| p.to_string())
2826                    .collect::<Vec<String>>()
2827                    .join(",")
2828                    .to_string(),
2829            )]),
2830        };
2831    }
2832    if let Some(ref local_var_str) = description__ie {
2833        local_var_req_builder = match "multi" {
2834            "multi" => local_var_req_builder.query(
2835                &local_var_str
2836                    .into_iter()
2837                    .map(|p| ("description__ie".to_owned(), p.to_string()))
2838                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2839            ),
2840            _ => local_var_req_builder.query(&[(
2841                "description__ie",
2842                &local_var_str
2843                    .into_iter()
2844                    .map(|p| p.to_string())
2845                    .collect::<Vec<String>>()
2846                    .join(",")
2847                    .to_string(),
2848            )]),
2849        };
2850    }
2851    if let Some(ref local_var_str) = description__iew {
2852        local_var_req_builder = match "multi" {
2853            "multi" => local_var_req_builder.query(
2854                &local_var_str
2855                    .into_iter()
2856                    .map(|p| ("description__iew".to_owned(), p.to_string()))
2857                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2858            ),
2859            _ => local_var_req_builder.query(&[(
2860                "description__iew",
2861                &local_var_str
2862                    .into_iter()
2863                    .map(|p| p.to_string())
2864                    .collect::<Vec<String>>()
2865                    .join(",")
2866                    .to_string(),
2867            )]),
2868        };
2869    }
2870    if let Some(ref local_var_str) = description__iregex {
2871        local_var_req_builder = match "multi" {
2872            "multi" => local_var_req_builder.query(
2873                &local_var_str
2874                    .into_iter()
2875                    .map(|p| ("description__iregex".to_owned(), p.to_string()))
2876                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2877            ),
2878            _ => local_var_req_builder.query(&[(
2879                "description__iregex",
2880                &local_var_str
2881                    .into_iter()
2882                    .map(|p| p.to_string())
2883                    .collect::<Vec<String>>()
2884                    .join(",")
2885                    .to_string(),
2886            )]),
2887        };
2888    }
2889    if let Some(ref local_var_str) = description__isw {
2890        local_var_req_builder = match "multi" {
2891            "multi" => local_var_req_builder.query(
2892                &local_var_str
2893                    .into_iter()
2894                    .map(|p| ("description__isw".to_owned(), p.to_string()))
2895                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2896            ),
2897            _ => local_var_req_builder.query(&[(
2898                "description__isw",
2899                &local_var_str
2900                    .into_iter()
2901                    .map(|p| p.to_string())
2902                    .collect::<Vec<String>>()
2903                    .join(",")
2904                    .to_string(),
2905            )]),
2906        };
2907    }
2908    if let Some(ref local_var_str) = description__n {
2909        local_var_req_builder = match "multi" {
2910            "multi" => local_var_req_builder.query(
2911                &local_var_str
2912                    .into_iter()
2913                    .map(|p| ("description__n".to_owned(), p.to_string()))
2914                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2915            ),
2916            _ => local_var_req_builder.query(&[(
2917                "description__n",
2918                &local_var_str
2919                    .into_iter()
2920                    .map(|p| p.to_string())
2921                    .collect::<Vec<String>>()
2922                    .join(",")
2923                    .to_string(),
2924            )]),
2925        };
2926    }
2927    if let Some(ref local_var_str) = description__nic {
2928        local_var_req_builder = match "multi" {
2929            "multi" => local_var_req_builder.query(
2930                &local_var_str
2931                    .into_iter()
2932                    .map(|p| ("description__nic".to_owned(), p.to_string()))
2933                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2934            ),
2935            _ => local_var_req_builder.query(&[(
2936                "description__nic",
2937                &local_var_str
2938                    .into_iter()
2939                    .map(|p| p.to_string())
2940                    .collect::<Vec<String>>()
2941                    .join(",")
2942                    .to_string(),
2943            )]),
2944        };
2945    }
2946    if let Some(ref local_var_str) = description__nie {
2947        local_var_req_builder = match "multi" {
2948            "multi" => local_var_req_builder.query(
2949                &local_var_str
2950                    .into_iter()
2951                    .map(|p| ("description__nie".to_owned(), p.to_string()))
2952                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2953            ),
2954            _ => local_var_req_builder.query(&[(
2955                "description__nie",
2956                &local_var_str
2957                    .into_iter()
2958                    .map(|p| p.to_string())
2959                    .collect::<Vec<String>>()
2960                    .join(",")
2961                    .to_string(),
2962            )]),
2963        };
2964    }
2965    if let Some(ref local_var_str) = description__niew {
2966        local_var_req_builder = match "multi" {
2967            "multi" => local_var_req_builder.query(
2968                &local_var_str
2969                    .into_iter()
2970                    .map(|p| ("description__niew".to_owned(), p.to_string()))
2971                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2972            ),
2973            _ => local_var_req_builder.query(&[(
2974                "description__niew",
2975                &local_var_str
2976                    .into_iter()
2977                    .map(|p| p.to_string())
2978                    .collect::<Vec<String>>()
2979                    .join(",")
2980                    .to_string(),
2981            )]),
2982        };
2983    }
2984    if let Some(ref local_var_str) = description__nisw {
2985        local_var_req_builder = match "multi" {
2986            "multi" => local_var_req_builder.query(
2987                &local_var_str
2988                    .into_iter()
2989                    .map(|p| ("description__nisw".to_owned(), p.to_string()))
2990                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2991            ),
2992            _ => local_var_req_builder.query(&[(
2993                "description__nisw",
2994                &local_var_str
2995                    .into_iter()
2996                    .map(|p| p.to_string())
2997                    .collect::<Vec<String>>()
2998                    .join(",")
2999                    .to_string(),
3000            )]),
3001        };
3002    }
3003    if let Some(ref local_var_str) = description__regex {
3004        local_var_req_builder = match "multi" {
3005            "multi" => local_var_req_builder.query(
3006                &local_var_str
3007                    .into_iter()
3008                    .map(|p| ("description__regex".to_owned(), p.to_string()))
3009                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3010            ),
3011            _ => local_var_req_builder.query(&[(
3012                "description__regex",
3013                &local_var_str
3014                    .into_iter()
3015                    .map(|p| p.to_string())
3016                    .collect::<Vec<String>>()
3017                    .join(",")
3018                    .to_string(),
3019            )]),
3020        };
3021    }
3022    if let Some(ref local_var_str) = id {
3023        local_var_req_builder = match "multi" {
3024            "multi" => local_var_req_builder.query(
3025                &local_var_str
3026                    .into_iter()
3027                    .map(|p| ("id".to_owned(), p.to_string()))
3028                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3029            ),
3030            _ => local_var_req_builder.query(&[(
3031                "id",
3032                &local_var_str
3033                    .into_iter()
3034                    .map(|p| p.to_string())
3035                    .collect::<Vec<String>>()
3036                    .join(",")
3037                    .to_string(),
3038            )]),
3039        };
3040    }
3041    if let Some(ref local_var_str) = id__empty {
3042        local_var_req_builder =
3043            local_var_req_builder.query(&[("id__empty", &local_var_str.to_string())]);
3044    }
3045    if let Some(ref local_var_str) = id__gt {
3046        local_var_req_builder = match "multi" {
3047            "multi" => local_var_req_builder.query(
3048                &local_var_str
3049                    .into_iter()
3050                    .map(|p| ("id__gt".to_owned(), p.to_string()))
3051                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3052            ),
3053            _ => local_var_req_builder.query(&[(
3054                "id__gt",
3055                &local_var_str
3056                    .into_iter()
3057                    .map(|p| p.to_string())
3058                    .collect::<Vec<String>>()
3059                    .join(",")
3060                    .to_string(),
3061            )]),
3062        };
3063    }
3064    if let Some(ref local_var_str) = id__gte {
3065        local_var_req_builder = match "multi" {
3066            "multi" => local_var_req_builder.query(
3067                &local_var_str
3068                    .into_iter()
3069                    .map(|p| ("id__gte".to_owned(), p.to_string()))
3070                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3071            ),
3072            _ => local_var_req_builder.query(&[(
3073                "id__gte",
3074                &local_var_str
3075                    .into_iter()
3076                    .map(|p| p.to_string())
3077                    .collect::<Vec<String>>()
3078                    .join(",")
3079                    .to_string(),
3080            )]),
3081        };
3082    }
3083    if let Some(ref local_var_str) = id__lt {
3084        local_var_req_builder = match "multi" {
3085            "multi" => local_var_req_builder.query(
3086                &local_var_str
3087                    .into_iter()
3088                    .map(|p| ("id__lt".to_owned(), p.to_string()))
3089                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3090            ),
3091            _ => local_var_req_builder.query(&[(
3092                "id__lt",
3093                &local_var_str
3094                    .into_iter()
3095                    .map(|p| p.to_string())
3096                    .collect::<Vec<String>>()
3097                    .join(",")
3098                    .to_string(),
3099            )]),
3100        };
3101    }
3102    if let Some(ref local_var_str) = id__lte {
3103        local_var_req_builder = match "multi" {
3104            "multi" => local_var_req_builder.query(
3105                &local_var_str
3106                    .into_iter()
3107                    .map(|p| ("id__lte".to_owned(), p.to_string()))
3108                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3109            ),
3110            _ => local_var_req_builder.query(&[(
3111                "id__lte",
3112                &local_var_str
3113                    .into_iter()
3114                    .map(|p| p.to_string())
3115                    .collect::<Vec<String>>()
3116                    .join(",")
3117                    .to_string(),
3118            )]),
3119        };
3120    }
3121    if let Some(ref local_var_str) = id__n {
3122        local_var_req_builder = match "multi" {
3123            "multi" => local_var_req_builder.query(
3124                &local_var_str
3125                    .into_iter()
3126                    .map(|p| ("id__n".to_owned(), p.to_string()))
3127                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3128            ),
3129            _ => local_var_req_builder.query(&[(
3130                "id__n",
3131                &local_var_str
3132                    .into_iter()
3133                    .map(|p| p.to_string())
3134                    .collect::<Vec<String>>()
3135                    .join(",")
3136                    .to_string(),
3137            )]),
3138        };
3139    }
3140    if let Some(ref local_var_str) = last_updated {
3141        local_var_req_builder = match "multi" {
3142            "multi" => local_var_req_builder.query(
3143                &local_var_str
3144                    .into_iter()
3145                    .map(|p| ("last_updated".to_owned(), p.to_string()))
3146                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3147            ),
3148            _ => local_var_req_builder.query(&[(
3149                "last_updated",
3150                &local_var_str
3151                    .into_iter()
3152                    .map(|p| p.to_string())
3153                    .collect::<Vec<String>>()
3154                    .join(",")
3155                    .to_string(),
3156            )]),
3157        };
3158    }
3159    if let Some(ref local_var_str) = last_updated__empty {
3160        local_var_req_builder = match "multi" {
3161            "multi" => local_var_req_builder.query(
3162                &local_var_str
3163                    .into_iter()
3164                    .map(|p| ("last_updated__empty".to_owned(), p.to_string()))
3165                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3166            ),
3167            _ => local_var_req_builder.query(&[(
3168                "last_updated__empty",
3169                &local_var_str
3170                    .into_iter()
3171                    .map(|p| p.to_string())
3172                    .collect::<Vec<String>>()
3173                    .join(",")
3174                    .to_string(),
3175            )]),
3176        };
3177    }
3178    if let Some(ref local_var_str) = last_updated__gt {
3179        local_var_req_builder = match "multi" {
3180            "multi" => local_var_req_builder.query(
3181                &local_var_str
3182                    .into_iter()
3183                    .map(|p| ("last_updated__gt".to_owned(), p.to_string()))
3184                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3185            ),
3186            _ => local_var_req_builder.query(&[(
3187                "last_updated__gt",
3188                &local_var_str
3189                    .into_iter()
3190                    .map(|p| p.to_string())
3191                    .collect::<Vec<String>>()
3192                    .join(",")
3193                    .to_string(),
3194            )]),
3195        };
3196    }
3197    if let Some(ref local_var_str) = last_updated__gte {
3198        local_var_req_builder = match "multi" {
3199            "multi" => local_var_req_builder.query(
3200                &local_var_str
3201                    .into_iter()
3202                    .map(|p| ("last_updated__gte".to_owned(), p.to_string()))
3203                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3204            ),
3205            _ => local_var_req_builder.query(&[(
3206                "last_updated__gte",
3207                &local_var_str
3208                    .into_iter()
3209                    .map(|p| p.to_string())
3210                    .collect::<Vec<String>>()
3211                    .join(",")
3212                    .to_string(),
3213            )]),
3214        };
3215    }
3216    if let Some(ref local_var_str) = last_updated__lt {
3217        local_var_req_builder = match "multi" {
3218            "multi" => local_var_req_builder.query(
3219                &local_var_str
3220                    .into_iter()
3221                    .map(|p| ("last_updated__lt".to_owned(), p.to_string()))
3222                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3223            ),
3224            _ => local_var_req_builder.query(&[(
3225                "last_updated__lt",
3226                &local_var_str
3227                    .into_iter()
3228                    .map(|p| p.to_string())
3229                    .collect::<Vec<String>>()
3230                    .join(",")
3231                    .to_string(),
3232            )]),
3233        };
3234    }
3235    if let Some(ref local_var_str) = last_updated__lte {
3236        local_var_req_builder = match "multi" {
3237            "multi" => local_var_req_builder.query(
3238                &local_var_str
3239                    .into_iter()
3240                    .map(|p| ("last_updated__lte".to_owned(), p.to_string()))
3241                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3242            ),
3243            _ => local_var_req_builder.query(&[(
3244                "last_updated__lte",
3245                &local_var_str
3246                    .into_iter()
3247                    .map(|p| p.to_string())
3248                    .collect::<Vec<String>>()
3249                    .join(",")
3250                    .to_string(),
3251            )]),
3252        };
3253    }
3254    if let Some(ref local_var_str) = last_updated__n {
3255        local_var_req_builder = match "multi" {
3256            "multi" => local_var_req_builder.query(
3257                &local_var_str
3258                    .into_iter()
3259                    .map(|p| ("last_updated__n".to_owned(), p.to_string()))
3260                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3261            ),
3262            _ => local_var_req_builder.query(&[(
3263                "last_updated__n",
3264                &local_var_str
3265                    .into_iter()
3266                    .map(|p| p.to_string())
3267                    .collect::<Vec<String>>()
3268                    .join(",")
3269                    .to_string(),
3270            )]),
3271        };
3272    }
3273    if let Some(ref local_var_str) = limit {
3274        local_var_req_builder =
3275            local_var_req_builder.query(&[("limit", &local_var_str.to_string())]);
3276    }
3277    if let Some(ref local_var_str) = modified_by_request {
3278        local_var_req_builder =
3279            local_var_req_builder.query(&[("modified_by_request", &local_var_str.to_string())]);
3280    }
3281    if let Some(ref local_var_str) = name {
3282        local_var_req_builder = match "multi" {
3283            "multi" => local_var_req_builder.query(
3284                &local_var_str
3285                    .into_iter()
3286                    .map(|p| ("name".to_owned(), p.to_string()))
3287                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3288            ),
3289            _ => local_var_req_builder.query(&[(
3290                "name",
3291                &local_var_str
3292                    .into_iter()
3293                    .map(|p| p.to_string())
3294                    .collect::<Vec<String>>()
3295                    .join(",")
3296                    .to_string(),
3297            )]),
3298        };
3299    }
3300    if let Some(ref local_var_str) = name__empty {
3301        local_var_req_builder =
3302            local_var_req_builder.query(&[("name__empty", &local_var_str.to_string())]);
3303    }
3304    if let Some(ref local_var_str) = name__ic {
3305        local_var_req_builder = match "multi" {
3306            "multi" => local_var_req_builder.query(
3307                &local_var_str
3308                    .into_iter()
3309                    .map(|p| ("name__ic".to_owned(), p.to_string()))
3310                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3311            ),
3312            _ => local_var_req_builder.query(&[(
3313                "name__ic",
3314                &local_var_str
3315                    .into_iter()
3316                    .map(|p| p.to_string())
3317                    .collect::<Vec<String>>()
3318                    .join(",")
3319                    .to_string(),
3320            )]),
3321        };
3322    }
3323    if let Some(ref local_var_str) = name__ie {
3324        local_var_req_builder = match "multi" {
3325            "multi" => local_var_req_builder.query(
3326                &local_var_str
3327                    .into_iter()
3328                    .map(|p| ("name__ie".to_owned(), p.to_string()))
3329                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3330            ),
3331            _ => local_var_req_builder.query(&[(
3332                "name__ie",
3333                &local_var_str
3334                    .into_iter()
3335                    .map(|p| p.to_string())
3336                    .collect::<Vec<String>>()
3337                    .join(",")
3338                    .to_string(),
3339            )]),
3340        };
3341    }
3342    if let Some(ref local_var_str) = name__iew {
3343        local_var_req_builder = match "multi" {
3344            "multi" => local_var_req_builder.query(
3345                &local_var_str
3346                    .into_iter()
3347                    .map(|p| ("name__iew".to_owned(), p.to_string()))
3348                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3349            ),
3350            _ => local_var_req_builder.query(&[(
3351                "name__iew",
3352                &local_var_str
3353                    .into_iter()
3354                    .map(|p| p.to_string())
3355                    .collect::<Vec<String>>()
3356                    .join(",")
3357                    .to_string(),
3358            )]),
3359        };
3360    }
3361    if let Some(ref local_var_str) = name__iregex {
3362        local_var_req_builder = match "multi" {
3363            "multi" => local_var_req_builder.query(
3364                &local_var_str
3365                    .into_iter()
3366                    .map(|p| ("name__iregex".to_owned(), p.to_string()))
3367                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3368            ),
3369            _ => local_var_req_builder.query(&[(
3370                "name__iregex",
3371                &local_var_str
3372                    .into_iter()
3373                    .map(|p| p.to_string())
3374                    .collect::<Vec<String>>()
3375                    .join(",")
3376                    .to_string(),
3377            )]),
3378        };
3379    }
3380    if let Some(ref local_var_str) = name__isw {
3381        local_var_req_builder = match "multi" {
3382            "multi" => local_var_req_builder.query(
3383                &local_var_str
3384                    .into_iter()
3385                    .map(|p| ("name__isw".to_owned(), p.to_string()))
3386                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3387            ),
3388            _ => local_var_req_builder.query(&[(
3389                "name__isw",
3390                &local_var_str
3391                    .into_iter()
3392                    .map(|p| p.to_string())
3393                    .collect::<Vec<String>>()
3394                    .join(",")
3395                    .to_string(),
3396            )]),
3397        };
3398    }
3399    if let Some(ref local_var_str) = name__n {
3400        local_var_req_builder = match "multi" {
3401            "multi" => local_var_req_builder.query(
3402                &local_var_str
3403                    .into_iter()
3404                    .map(|p| ("name__n".to_owned(), p.to_string()))
3405                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3406            ),
3407            _ => local_var_req_builder.query(&[(
3408                "name__n",
3409                &local_var_str
3410                    .into_iter()
3411                    .map(|p| p.to_string())
3412                    .collect::<Vec<String>>()
3413                    .join(",")
3414                    .to_string(),
3415            )]),
3416        };
3417    }
3418    if let Some(ref local_var_str) = name__nic {
3419        local_var_req_builder = match "multi" {
3420            "multi" => local_var_req_builder.query(
3421                &local_var_str
3422                    .into_iter()
3423                    .map(|p| ("name__nic".to_owned(), p.to_string()))
3424                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3425            ),
3426            _ => local_var_req_builder.query(&[(
3427                "name__nic",
3428                &local_var_str
3429                    .into_iter()
3430                    .map(|p| p.to_string())
3431                    .collect::<Vec<String>>()
3432                    .join(",")
3433                    .to_string(),
3434            )]),
3435        };
3436    }
3437    if let Some(ref local_var_str) = name__nie {
3438        local_var_req_builder = match "multi" {
3439            "multi" => local_var_req_builder.query(
3440                &local_var_str
3441                    .into_iter()
3442                    .map(|p| ("name__nie".to_owned(), p.to_string()))
3443                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3444            ),
3445            _ => local_var_req_builder.query(&[(
3446                "name__nie",
3447                &local_var_str
3448                    .into_iter()
3449                    .map(|p| p.to_string())
3450                    .collect::<Vec<String>>()
3451                    .join(",")
3452                    .to_string(),
3453            )]),
3454        };
3455    }
3456    if let Some(ref local_var_str) = name__niew {
3457        local_var_req_builder = match "multi" {
3458            "multi" => local_var_req_builder.query(
3459                &local_var_str
3460                    .into_iter()
3461                    .map(|p| ("name__niew".to_owned(), p.to_string()))
3462                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3463            ),
3464            _ => local_var_req_builder.query(&[(
3465                "name__niew",
3466                &local_var_str
3467                    .into_iter()
3468                    .map(|p| p.to_string())
3469                    .collect::<Vec<String>>()
3470                    .join(",")
3471                    .to_string(),
3472            )]),
3473        };
3474    }
3475    if let Some(ref local_var_str) = name__nisw {
3476        local_var_req_builder = match "multi" {
3477            "multi" => local_var_req_builder.query(
3478                &local_var_str
3479                    .into_iter()
3480                    .map(|p| ("name__nisw".to_owned(), p.to_string()))
3481                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3482            ),
3483            _ => local_var_req_builder.query(&[(
3484                "name__nisw",
3485                &local_var_str
3486                    .into_iter()
3487                    .map(|p| p.to_string())
3488                    .collect::<Vec<String>>()
3489                    .join(",")
3490                    .to_string(),
3491            )]),
3492        };
3493    }
3494    if let Some(ref local_var_str) = name__regex {
3495        local_var_req_builder = match "multi" {
3496            "multi" => local_var_req_builder.query(
3497                &local_var_str
3498                    .into_iter()
3499                    .map(|p| ("name__regex".to_owned(), p.to_string()))
3500                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3501            ),
3502            _ => local_var_req_builder.query(&[(
3503                "name__regex",
3504                &local_var_str
3505                    .into_iter()
3506                    .map(|p| p.to_string())
3507                    .collect::<Vec<String>>()
3508                    .join(",")
3509                    .to_string(),
3510            )]),
3511        };
3512    }
3513    if let Some(ref local_var_str) = offset {
3514        local_var_req_builder =
3515            local_var_req_builder.query(&[("offset", &local_var_str.to_string())]);
3516    }
3517    if let Some(ref local_var_str) = ordering {
3518        local_var_req_builder =
3519            local_var_req_builder.query(&[("ordering", &local_var_str.to_string())]);
3520    }
3521    if let Some(ref local_var_str) = owner {
3522        local_var_req_builder = match "multi" {
3523            "multi" => local_var_req_builder.query(
3524                &local_var_str
3525                    .into_iter()
3526                    .map(|p| ("owner".to_owned(), p.to_string()))
3527                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3528            ),
3529            _ => local_var_req_builder.query(&[(
3530                "owner",
3531                &local_var_str
3532                    .into_iter()
3533                    .map(|p| p.to_string())
3534                    .collect::<Vec<String>>()
3535                    .join(",")
3536                    .to_string(),
3537            )]),
3538        };
3539    }
3540    if let Some(ref local_var_str) = owner__n {
3541        local_var_req_builder = match "multi" {
3542            "multi" => local_var_req_builder.query(
3543                &local_var_str
3544                    .into_iter()
3545                    .map(|p| ("owner__n".to_owned(), p.to_string()))
3546                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3547            ),
3548            _ => local_var_req_builder.query(&[(
3549                "owner__n",
3550                &local_var_str
3551                    .into_iter()
3552                    .map(|p| p.to_string())
3553                    .collect::<Vec<String>>()
3554                    .join(",")
3555                    .to_string(),
3556            )]),
3557        };
3558    }
3559    if let Some(ref local_var_str) = owner_group {
3560        local_var_req_builder = match "multi" {
3561            "multi" => local_var_req_builder.query(
3562                &local_var_str
3563                    .into_iter()
3564                    .map(|p| ("owner_group".to_owned(), p.to_string()))
3565                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3566            ),
3567            _ => local_var_req_builder.query(&[(
3568                "owner_group",
3569                &local_var_str
3570                    .into_iter()
3571                    .map(|p| p.to_string())
3572                    .collect::<Vec<String>>()
3573                    .join(",")
3574                    .to_string(),
3575            )]),
3576        };
3577    }
3578    if let Some(ref local_var_str) = owner_group__n {
3579        local_var_req_builder = match "multi" {
3580            "multi" => local_var_req_builder.query(
3581                &local_var_str
3582                    .into_iter()
3583                    .map(|p| ("owner_group__n".to_owned(), p.to_string()))
3584                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3585            ),
3586            _ => local_var_req_builder.query(&[(
3587                "owner_group__n",
3588                &local_var_str
3589                    .into_iter()
3590                    .map(|p| p.to_string())
3591                    .collect::<Vec<String>>()
3592                    .join(",")
3593                    .to_string(),
3594            )]),
3595        };
3596    }
3597    if let Some(ref local_var_str) = owner_group_id {
3598        local_var_req_builder = match "multi" {
3599            "multi" => local_var_req_builder.query(
3600                &local_var_str
3601                    .into_iter()
3602                    .map(|p| ("owner_group_id".to_owned(), p.to_string()))
3603                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3604            ),
3605            _ => local_var_req_builder.query(&[(
3606                "owner_group_id",
3607                &local_var_str
3608                    .into_iter()
3609                    .map(|p| p.to_string())
3610                    .collect::<Vec<String>>()
3611                    .join(",")
3612                    .to_string(),
3613            )]),
3614        };
3615    }
3616    if let Some(ref local_var_str) = owner_group_id__n {
3617        local_var_req_builder = match "multi" {
3618            "multi" => local_var_req_builder.query(
3619                &local_var_str
3620                    .into_iter()
3621                    .map(|p| ("owner_group_id__n".to_owned(), p.to_string()))
3622                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3623            ),
3624            _ => local_var_req_builder.query(&[(
3625                "owner_group_id__n",
3626                &local_var_str
3627                    .into_iter()
3628                    .map(|p| p.to_string())
3629                    .collect::<Vec<String>>()
3630                    .join(",")
3631                    .to_string(),
3632            )]),
3633        };
3634    }
3635    if let Some(ref local_var_str) = owner_id {
3636        local_var_req_builder = match "multi" {
3637            "multi" => local_var_req_builder.query(
3638                &local_var_str
3639                    .into_iter()
3640                    .map(|p| ("owner_id".to_owned(), p.to_string()))
3641                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3642            ),
3643            _ => local_var_req_builder.query(&[(
3644                "owner_id",
3645                &local_var_str
3646                    .into_iter()
3647                    .map(|p| p.to_string())
3648                    .collect::<Vec<String>>()
3649                    .join(",")
3650                    .to_string(),
3651            )]),
3652        };
3653    }
3654    if let Some(ref local_var_str) = owner_id__n {
3655        local_var_req_builder = match "multi" {
3656            "multi" => local_var_req_builder.query(
3657                &local_var_str
3658                    .into_iter()
3659                    .map(|p| ("owner_id__n".to_owned(), p.to_string()))
3660                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3661            ),
3662            _ => local_var_req_builder.query(&[(
3663                "owner_id__n",
3664                &local_var_str
3665                    .into_iter()
3666                    .map(|p| p.to_string())
3667                    .collect::<Vec<String>>()
3668                    .join(",")
3669                    .to_string(),
3670            )]),
3671        };
3672    }
3673    if let Some(ref local_var_str) = q {
3674        local_var_req_builder = local_var_req_builder.query(&[("q", &local_var_str.to_string())]);
3675    }
3676    if let Some(ref local_var_str) = slug {
3677        local_var_req_builder = match "multi" {
3678            "multi" => local_var_req_builder.query(
3679                &local_var_str
3680                    .into_iter()
3681                    .map(|p| ("slug".to_owned(), p.to_string()))
3682                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3683            ),
3684            _ => local_var_req_builder.query(&[(
3685                "slug",
3686                &local_var_str
3687                    .into_iter()
3688                    .map(|p| p.to_string())
3689                    .collect::<Vec<String>>()
3690                    .join(",")
3691                    .to_string(),
3692            )]),
3693        };
3694    }
3695    if let Some(ref local_var_str) = slug__empty {
3696        local_var_req_builder =
3697            local_var_req_builder.query(&[("slug__empty", &local_var_str.to_string())]);
3698    }
3699    if let Some(ref local_var_str) = slug__ic {
3700        local_var_req_builder = match "multi" {
3701            "multi" => local_var_req_builder.query(
3702                &local_var_str
3703                    .into_iter()
3704                    .map(|p| ("slug__ic".to_owned(), p.to_string()))
3705                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3706            ),
3707            _ => local_var_req_builder.query(&[(
3708                "slug__ic",
3709                &local_var_str
3710                    .into_iter()
3711                    .map(|p| p.to_string())
3712                    .collect::<Vec<String>>()
3713                    .join(",")
3714                    .to_string(),
3715            )]),
3716        };
3717    }
3718    if let Some(ref local_var_str) = slug__ie {
3719        local_var_req_builder = match "multi" {
3720            "multi" => local_var_req_builder.query(
3721                &local_var_str
3722                    .into_iter()
3723                    .map(|p| ("slug__ie".to_owned(), p.to_string()))
3724                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3725            ),
3726            _ => local_var_req_builder.query(&[(
3727                "slug__ie",
3728                &local_var_str
3729                    .into_iter()
3730                    .map(|p| p.to_string())
3731                    .collect::<Vec<String>>()
3732                    .join(",")
3733                    .to_string(),
3734            )]),
3735        };
3736    }
3737    if let Some(ref local_var_str) = slug__iew {
3738        local_var_req_builder = match "multi" {
3739            "multi" => local_var_req_builder.query(
3740                &local_var_str
3741                    .into_iter()
3742                    .map(|p| ("slug__iew".to_owned(), p.to_string()))
3743                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3744            ),
3745            _ => local_var_req_builder.query(&[(
3746                "slug__iew",
3747                &local_var_str
3748                    .into_iter()
3749                    .map(|p| p.to_string())
3750                    .collect::<Vec<String>>()
3751                    .join(",")
3752                    .to_string(),
3753            )]),
3754        };
3755    }
3756    if let Some(ref local_var_str) = slug__iregex {
3757        local_var_req_builder = match "multi" {
3758            "multi" => local_var_req_builder.query(
3759                &local_var_str
3760                    .into_iter()
3761                    .map(|p| ("slug__iregex".to_owned(), p.to_string()))
3762                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3763            ),
3764            _ => local_var_req_builder.query(&[(
3765                "slug__iregex",
3766                &local_var_str
3767                    .into_iter()
3768                    .map(|p| p.to_string())
3769                    .collect::<Vec<String>>()
3770                    .join(",")
3771                    .to_string(),
3772            )]),
3773        };
3774    }
3775    if let Some(ref local_var_str) = slug__isw {
3776        local_var_req_builder = match "multi" {
3777            "multi" => local_var_req_builder.query(
3778                &local_var_str
3779                    .into_iter()
3780                    .map(|p| ("slug__isw".to_owned(), p.to_string()))
3781                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3782            ),
3783            _ => local_var_req_builder.query(&[(
3784                "slug__isw",
3785                &local_var_str
3786                    .into_iter()
3787                    .map(|p| p.to_string())
3788                    .collect::<Vec<String>>()
3789                    .join(",")
3790                    .to_string(),
3791            )]),
3792        };
3793    }
3794    if let Some(ref local_var_str) = slug__n {
3795        local_var_req_builder = match "multi" {
3796            "multi" => local_var_req_builder.query(
3797                &local_var_str
3798                    .into_iter()
3799                    .map(|p| ("slug__n".to_owned(), p.to_string()))
3800                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3801            ),
3802            _ => local_var_req_builder.query(&[(
3803                "slug__n",
3804                &local_var_str
3805                    .into_iter()
3806                    .map(|p| p.to_string())
3807                    .collect::<Vec<String>>()
3808                    .join(",")
3809                    .to_string(),
3810            )]),
3811        };
3812    }
3813    if let Some(ref local_var_str) = slug__nic {
3814        local_var_req_builder = match "multi" {
3815            "multi" => local_var_req_builder.query(
3816                &local_var_str
3817                    .into_iter()
3818                    .map(|p| ("slug__nic".to_owned(), p.to_string()))
3819                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3820            ),
3821            _ => local_var_req_builder.query(&[(
3822                "slug__nic",
3823                &local_var_str
3824                    .into_iter()
3825                    .map(|p| p.to_string())
3826                    .collect::<Vec<String>>()
3827                    .join(",")
3828                    .to_string(),
3829            )]),
3830        };
3831    }
3832    if let Some(ref local_var_str) = slug__nie {
3833        local_var_req_builder = match "multi" {
3834            "multi" => local_var_req_builder.query(
3835                &local_var_str
3836                    .into_iter()
3837                    .map(|p| ("slug__nie".to_owned(), p.to_string()))
3838                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3839            ),
3840            _ => local_var_req_builder.query(&[(
3841                "slug__nie",
3842                &local_var_str
3843                    .into_iter()
3844                    .map(|p| p.to_string())
3845                    .collect::<Vec<String>>()
3846                    .join(",")
3847                    .to_string(),
3848            )]),
3849        };
3850    }
3851    if let Some(ref local_var_str) = slug__niew {
3852        local_var_req_builder = match "multi" {
3853            "multi" => local_var_req_builder.query(
3854                &local_var_str
3855                    .into_iter()
3856                    .map(|p| ("slug__niew".to_owned(), p.to_string()))
3857                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3858            ),
3859            _ => local_var_req_builder.query(&[(
3860                "slug__niew",
3861                &local_var_str
3862                    .into_iter()
3863                    .map(|p| p.to_string())
3864                    .collect::<Vec<String>>()
3865                    .join(",")
3866                    .to_string(),
3867            )]),
3868        };
3869    }
3870    if let Some(ref local_var_str) = slug__nisw {
3871        local_var_req_builder = match "multi" {
3872            "multi" => local_var_req_builder.query(
3873                &local_var_str
3874                    .into_iter()
3875                    .map(|p| ("slug__nisw".to_owned(), p.to_string()))
3876                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3877            ),
3878            _ => local_var_req_builder.query(&[(
3879                "slug__nisw",
3880                &local_var_str
3881                    .into_iter()
3882                    .map(|p| p.to_string())
3883                    .collect::<Vec<String>>()
3884                    .join(",")
3885                    .to_string(),
3886            )]),
3887        };
3888    }
3889    if let Some(ref local_var_str) = slug__regex {
3890        local_var_req_builder = match "multi" {
3891            "multi" => local_var_req_builder.query(
3892                &local_var_str
3893                    .into_iter()
3894                    .map(|p| ("slug__regex".to_owned(), p.to_string()))
3895                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3896            ),
3897            _ => local_var_req_builder.query(&[(
3898                "slug__regex",
3899                &local_var_str
3900                    .into_iter()
3901                    .map(|p| p.to_string())
3902                    .collect::<Vec<String>>()
3903                    .join(",")
3904                    .to_string(),
3905            )]),
3906        };
3907    }
3908    if let Some(ref local_var_str) = start {
3909        local_var_req_builder =
3910            local_var_req_builder.query(&[("start", &local_var_str.to_string())]);
3911    }
3912    if let Some(ref local_var_str) = tag {
3913        local_var_req_builder = match "multi" {
3914            "multi" => local_var_req_builder.query(
3915                &local_var_str
3916                    .into_iter()
3917                    .map(|p| ("tag".to_owned(), p.to_string()))
3918                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3919            ),
3920            _ => local_var_req_builder.query(&[(
3921                "tag",
3922                &local_var_str
3923                    .into_iter()
3924                    .map(|p| p.to_string())
3925                    .collect::<Vec<String>>()
3926                    .join(",")
3927                    .to_string(),
3928            )]),
3929        };
3930    }
3931    if let Some(ref local_var_str) = tag__n {
3932        local_var_req_builder = match "multi" {
3933            "multi" => local_var_req_builder.query(
3934                &local_var_str
3935                    .into_iter()
3936                    .map(|p| ("tag__n".to_owned(), p.to_string()))
3937                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3938            ),
3939            _ => local_var_req_builder.query(&[(
3940                "tag__n",
3941                &local_var_str
3942                    .into_iter()
3943                    .map(|p| p.to_string())
3944                    .collect::<Vec<String>>()
3945                    .join(",")
3946                    .to_string(),
3947            )]),
3948        };
3949    }
3950    if let Some(ref local_var_str) = tag_id {
3951        local_var_req_builder = match "multi" {
3952            "multi" => local_var_req_builder.query(
3953                &local_var_str
3954                    .into_iter()
3955                    .map(|p| ("tag_id".to_owned(), p.to_string()))
3956                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3957            ),
3958            _ => local_var_req_builder.query(&[(
3959                "tag_id",
3960                &local_var_str
3961                    .into_iter()
3962                    .map(|p| p.to_string())
3963                    .collect::<Vec<String>>()
3964                    .join(",")
3965                    .to_string(),
3966            )]),
3967        };
3968    }
3969    if let Some(ref local_var_str) = tag_id__n {
3970        local_var_req_builder = match "multi" {
3971            "multi" => local_var_req_builder.query(
3972                &local_var_str
3973                    .into_iter()
3974                    .map(|p| ("tag_id__n".to_owned(), p.to_string()))
3975                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3976            ),
3977            _ => local_var_req_builder.query(&[(
3978                "tag_id__n",
3979                &local_var_str
3980                    .into_iter()
3981                    .map(|p| p.to_string())
3982                    .collect::<Vec<String>>()
3983                    .join(",")
3984                    .to_string(),
3985            )]),
3986        };
3987    }
3988    if let Some(ref local_var_str) = tenant {
3989        local_var_req_builder = match "multi" {
3990            "multi" => local_var_req_builder.query(
3991                &local_var_str
3992                    .into_iter()
3993                    .map(|p| ("tenant".to_owned(), p.to_string()))
3994                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3995            ),
3996            _ => local_var_req_builder.query(&[(
3997                "tenant",
3998                &local_var_str
3999                    .into_iter()
4000                    .map(|p| p.to_string())
4001                    .collect::<Vec<String>>()
4002                    .join(",")
4003                    .to_string(),
4004            )]),
4005        };
4006    }
4007    if let Some(ref local_var_str) = tenant__n {
4008        local_var_req_builder = match "multi" {
4009            "multi" => local_var_req_builder.query(
4010                &local_var_str
4011                    .into_iter()
4012                    .map(|p| ("tenant__n".to_owned(), p.to_string()))
4013                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4014            ),
4015            _ => local_var_req_builder.query(&[(
4016                "tenant__n",
4017                &local_var_str
4018                    .into_iter()
4019                    .map(|p| p.to_string())
4020                    .collect::<Vec<String>>()
4021                    .join(",")
4022                    .to_string(),
4023            )]),
4024        };
4025    }
4026    if let Some(ref local_var_str) = tenant_group {
4027        local_var_req_builder = match "multi" {
4028            "multi" => local_var_req_builder.query(
4029                &local_var_str
4030                    .into_iter()
4031                    .map(|p| ("tenant_group".to_owned(), p.to_string()))
4032                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4033            ),
4034            _ => local_var_req_builder.query(&[(
4035                "tenant_group",
4036                &local_var_str
4037                    .into_iter()
4038                    .map(|p| p.to_string())
4039                    .collect::<Vec<String>>()
4040                    .join(",")
4041                    .to_string(),
4042            )]),
4043        };
4044    }
4045    if let Some(ref local_var_str) = tenant_group__n {
4046        local_var_req_builder = match "multi" {
4047            "multi" => local_var_req_builder.query(
4048                &local_var_str
4049                    .into_iter()
4050                    .map(|p| ("tenant_group__n".to_owned(), p.to_string()))
4051                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4052            ),
4053            _ => local_var_req_builder.query(&[(
4054                "tenant_group__n",
4055                &local_var_str
4056                    .into_iter()
4057                    .map(|p| p.to_string())
4058                    .collect::<Vec<String>>()
4059                    .join(",")
4060                    .to_string(),
4061            )]),
4062        };
4063    }
4064    if let Some(ref local_var_str) = tenant_group_id {
4065        local_var_req_builder = match "multi" {
4066            "multi" => local_var_req_builder.query(
4067                &local_var_str
4068                    .into_iter()
4069                    .map(|p| ("tenant_group_id".to_owned(), p.to_string()))
4070                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4071            ),
4072            _ => local_var_req_builder.query(&[(
4073                "tenant_group_id",
4074                &local_var_str
4075                    .into_iter()
4076                    .map(|p| p.to_string())
4077                    .collect::<Vec<String>>()
4078                    .join(",")
4079                    .to_string(),
4080            )]),
4081        };
4082    }
4083    if let Some(ref local_var_str) = tenant_group_id__n {
4084        local_var_req_builder = match "multi" {
4085            "multi" => local_var_req_builder.query(
4086                &local_var_str
4087                    .into_iter()
4088                    .map(|p| ("tenant_group_id__n".to_owned(), p.to_string()))
4089                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4090            ),
4091            _ => local_var_req_builder.query(&[(
4092                "tenant_group_id__n",
4093                &local_var_str
4094                    .into_iter()
4095                    .map(|p| p.to_string())
4096                    .collect::<Vec<String>>()
4097                    .join(",")
4098                    .to_string(),
4099            )]),
4100        };
4101    }
4102    if let Some(ref local_var_str) = tenant_id {
4103        local_var_req_builder = match "multi" {
4104            "multi" => local_var_req_builder.query(
4105                &local_var_str
4106                    .into_iter()
4107                    .map(|p| ("tenant_id".to_owned(), p.to_string()))
4108                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4109            ),
4110            _ => local_var_req_builder.query(&[(
4111                "tenant_id",
4112                &local_var_str
4113                    .into_iter()
4114                    .map(|p| p.to_string())
4115                    .collect::<Vec<String>>()
4116                    .join(",")
4117                    .to_string(),
4118            )]),
4119        };
4120    }
4121    if let Some(ref local_var_str) = tenant_id__n {
4122        local_var_req_builder = match "multi" {
4123            "multi" => local_var_req_builder.query(
4124                &local_var_str
4125                    .into_iter()
4126                    .map(|p| ("tenant_id__n".to_owned(), p.to_string()))
4127                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4128            ),
4129            _ => local_var_req_builder.query(&[(
4130                "tenant_id__n",
4131                &local_var_str
4132                    .into_iter()
4133                    .map(|p| p.to_string())
4134                    .collect::<Vec<String>>()
4135                    .join(",")
4136                    .to_string(),
4137            )]),
4138        };
4139    }
4140    if let Some(ref local_var_str) = updated_by_request {
4141        local_var_req_builder =
4142            local_var_req_builder.query(&[("updated_by_request", &local_var_str.to_string())]);
4143    }
4144    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
4145        local_var_req_builder =
4146            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
4147    }
4148    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
4149        let local_var_key = local_var_apikey.key.clone();
4150        let local_var_value = match local_var_apikey.prefix {
4151            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
4152            None => local_var_key,
4153        };
4154        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
4155    };
4156
4157    let local_var_req = local_var_req_builder.build()?;
4158    let local_var_resp = local_var_client.execute(local_var_req).await?;
4159
4160    let local_var_status = local_var_resp.status();
4161    let local_var_content = local_var_resp.text().await?;
4162
4163    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
4164        serde_json::from_str(&local_var_content).map_err(Error::from)
4165    } else {
4166        let local_var_entity: Option<CircuitsCircuitGroupsListError> =
4167            serde_json::from_str(&local_var_content).ok();
4168        let local_var_error = ResponseContent {
4169            status: local_var_status,
4170            content: local_var_content,
4171            entity: local_var_entity,
4172        };
4173        Err(Error::ResponseError(local_var_error))
4174    }
4175}
4176
4177/// Patch a circuit group object.
4178pub async fn circuits_circuit_groups_partial_update(
4179    configuration: &configuration::Configuration,
4180    id: i32,
4181    patched_circuit_group_request: Option<crate::models::PatchedCircuitGroupRequest>,
4182) -> Result<crate::models::CircuitGroup, Error<CircuitsCircuitGroupsPartialUpdateError>> {
4183    let local_var_configuration = configuration;
4184
4185    let local_var_client = &local_var_configuration.client;
4186
4187    let local_var_uri_str = format!(
4188        "{}/api/circuits/circuit-groups/{id}/",
4189        local_var_configuration.base_path,
4190        id = id
4191    );
4192    let mut local_var_req_builder =
4193        local_var_client.request(reqwest::Method::PATCH, local_var_uri_str.as_str());
4194
4195    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
4196        local_var_req_builder =
4197            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
4198    }
4199    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
4200        let local_var_key = local_var_apikey.key.clone();
4201        let local_var_value = match local_var_apikey.prefix {
4202            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
4203            None => local_var_key,
4204        };
4205        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
4206    };
4207    local_var_req_builder = local_var_req_builder.json(&patched_circuit_group_request);
4208
4209    let local_var_req = local_var_req_builder.build()?;
4210    let local_var_resp = local_var_client.execute(local_var_req).await?;
4211
4212    let local_var_status = local_var_resp.status();
4213    let local_var_content = local_var_resp.text().await?;
4214
4215    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
4216        serde_json::from_str(&local_var_content).map_err(Error::from)
4217    } else {
4218        let local_var_entity: Option<CircuitsCircuitGroupsPartialUpdateError> =
4219            serde_json::from_str(&local_var_content).ok();
4220        let local_var_error = ResponseContent {
4221            status: local_var_status,
4222            content: local_var_content,
4223            entity: local_var_entity,
4224        };
4225        Err(Error::ResponseError(local_var_error))
4226    }
4227}
4228
4229/// Get a circuit group object.
4230pub async fn circuits_circuit_groups_retrieve(
4231    configuration: &configuration::Configuration,
4232    id: i32,
4233) -> Result<crate::models::CircuitGroup, Error<CircuitsCircuitGroupsRetrieveError>> {
4234    let local_var_configuration = configuration;
4235
4236    let local_var_client = &local_var_configuration.client;
4237
4238    let local_var_uri_str = format!(
4239        "{}/api/circuits/circuit-groups/{id}/",
4240        local_var_configuration.base_path,
4241        id = id
4242    );
4243    let mut local_var_req_builder =
4244        local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
4245
4246    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
4247        local_var_req_builder =
4248            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
4249    }
4250    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
4251        let local_var_key = local_var_apikey.key.clone();
4252        let local_var_value = match local_var_apikey.prefix {
4253            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
4254            None => local_var_key,
4255        };
4256        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
4257    };
4258
4259    let local_var_req = local_var_req_builder.build()?;
4260    let local_var_resp = local_var_client.execute(local_var_req).await?;
4261
4262    let local_var_status = local_var_resp.status();
4263    let local_var_content = local_var_resp.text().await?;
4264
4265    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
4266        serde_json::from_str(&local_var_content).map_err(Error::from)
4267    } else {
4268        let local_var_entity: Option<CircuitsCircuitGroupsRetrieveError> =
4269            serde_json::from_str(&local_var_content).ok();
4270        let local_var_error = ResponseContent {
4271            status: local_var_status,
4272            content: local_var_content,
4273            entity: local_var_entity,
4274        };
4275        Err(Error::ResponseError(local_var_error))
4276    }
4277}
4278
4279/// Put a circuit group object.
4280pub async fn circuits_circuit_groups_update(
4281    configuration: &configuration::Configuration,
4282    id: i32,
4283    circuit_group_request: crate::models::CircuitGroupRequest,
4284) -> Result<crate::models::CircuitGroup, Error<CircuitsCircuitGroupsUpdateError>> {
4285    let local_var_configuration = configuration;
4286
4287    let local_var_client = &local_var_configuration.client;
4288
4289    let local_var_uri_str = format!(
4290        "{}/api/circuits/circuit-groups/{id}/",
4291        local_var_configuration.base_path,
4292        id = id
4293    );
4294    let mut local_var_req_builder =
4295        local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());
4296
4297    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
4298        local_var_req_builder =
4299            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
4300    }
4301    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
4302        let local_var_key = local_var_apikey.key.clone();
4303        let local_var_value = match local_var_apikey.prefix {
4304            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
4305            None => local_var_key,
4306        };
4307        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
4308    };
4309    local_var_req_builder = local_var_req_builder.json(&circuit_group_request);
4310
4311    let local_var_req = local_var_req_builder.build()?;
4312    let local_var_resp = local_var_client.execute(local_var_req).await?;
4313
4314    let local_var_status = local_var_resp.status();
4315    let local_var_content = local_var_resp.text().await?;
4316
4317    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
4318        serde_json::from_str(&local_var_content).map_err(Error::from)
4319    } else {
4320        let local_var_entity: Option<CircuitsCircuitGroupsUpdateError> =
4321            serde_json::from_str(&local_var_content).ok();
4322        let local_var_error = ResponseContent {
4323            status: local_var_status,
4324            content: local_var_content,
4325            entity: local_var_entity,
4326        };
4327        Err(Error::ResponseError(local_var_error))
4328    }
4329}
4330
4331/// Delete a list of circuit termination objects.
4332pub async fn circuits_circuit_terminations_bulk_destroy(
4333    configuration: &configuration::Configuration,
4334    circuit_termination_request: Vec<crate::models::CircuitTerminationRequest>,
4335) -> Result<(), Error<CircuitsCircuitTerminationsBulkDestroyError>> {
4336    let local_var_configuration = configuration;
4337
4338    let local_var_client = &local_var_configuration.client;
4339
4340    let local_var_uri_str = format!(
4341        "{}/api/circuits/circuit-terminations/",
4342        local_var_configuration.base_path
4343    );
4344    let mut local_var_req_builder =
4345        local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());
4346
4347    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
4348        local_var_req_builder =
4349            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
4350    }
4351    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
4352        let local_var_key = local_var_apikey.key.clone();
4353        let local_var_value = match local_var_apikey.prefix {
4354            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
4355            None => local_var_key,
4356        };
4357        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
4358    };
4359    local_var_req_builder = local_var_req_builder.json(&circuit_termination_request);
4360
4361    let local_var_req = local_var_req_builder.build()?;
4362    let local_var_resp = local_var_client.execute(local_var_req).await?;
4363
4364    let local_var_status = local_var_resp.status();
4365    let local_var_content = local_var_resp.text().await?;
4366
4367    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
4368        Ok(())
4369    } else {
4370        let local_var_entity: Option<CircuitsCircuitTerminationsBulkDestroyError> =
4371            serde_json::from_str(&local_var_content).ok();
4372        let local_var_error = ResponseContent {
4373            status: local_var_status,
4374            content: local_var_content,
4375            entity: local_var_entity,
4376        };
4377        Err(Error::ResponseError(local_var_error))
4378    }
4379}
4380
4381/// Patch a list of circuit termination objects.
4382pub async fn circuits_circuit_terminations_bulk_partial_update(
4383    configuration: &configuration::Configuration,
4384    circuit_termination_request: Vec<crate::models::CircuitTerminationRequest>,
4385) -> Result<
4386    Vec<crate::models::CircuitTermination>,
4387    Error<CircuitsCircuitTerminationsBulkPartialUpdateError>,
4388> {
4389    let local_var_configuration = configuration;
4390
4391    let local_var_client = &local_var_configuration.client;
4392
4393    let local_var_uri_str = format!(
4394        "{}/api/circuits/circuit-terminations/",
4395        local_var_configuration.base_path
4396    );
4397    let mut local_var_req_builder =
4398        local_var_client.request(reqwest::Method::PATCH, local_var_uri_str.as_str());
4399
4400    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
4401        local_var_req_builder =
4402            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
4403    }
4404    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
4405        let local_var_key = local_var_apikey.key.clone();
4406        let local_var_value = match local_var_apikey.prefix {
4407            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
4408            None => local_var_key,
4409        };
4410        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
4411    };
4412    local_var_req_builder = local_var_req_builder.json(&circuit_termination_request);
4413
4414    let local_var_req = local_var_req_builder.build()?;
4415    let local_var_resp = local_var_client.execute(local_var_req).await?;
4416
4417    let local_var_status = local_var_resp.status();
4418    let local_var_content = local_var_resp.text().await?;
4419
4420    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
4421        serde_json::from_str(&local_var_content).map_err(Error::from)
4422    } else {
4423        let local_var_entity: Option<CircuitsCircuitTerminationsBulkPartialUpdateError> =
4424            serde_json::from_str(&local_var_content).ok();
4425        let local_var_error = ResponseContent {
4426            status: local_var_status,
4427            content: local_var_content,
4428            entity: local_var_entity,
4429        };
4430        Err(Error::ResponseError(local_var_error))
4431    }
4432}
4433
4434/// Put a list of circuit termination objects.
4435pub async fn circuits_circuit_terminations_bulk_update(
4436    configuration: &configuration::Configuration,
4437    circuit_termination_request: Vec<crate::models::CircuitTerminationRequest>,
4438) -> Result<Vec<crate::models::CircuitTermination>, Error<CircuitsCircuitTerminationsBulkUpdateError>>
4439{
4440    let local_var_configuration = configuration;
4441
4442    let local_var_client = &local_var_configuration.client;
4443
4444    let local_var_uri_str = format!(
4445        "{}/api/circuits/circuit-terminations/",
4446        local_var_configuration.base_path
4447    );
4448    let mut local_var_req_builder =
4449        local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());
4450
4451    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
4452        local_var_req_builder =
4453            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
4454    }
4455    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
4456        let local_var_key = local_var_apikey.key.clone();
4457        let local_var_value = match local_var_apikey.prefix {
4458            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
4459            None => local_var_key,
4460        };
4461        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
4462    };
4463    local_var_req_builder = local_var_req_builder.json(&circuit_termination_request);
4464
4465    let local_var_req = local_var_req_builder.build()?;
4466    let local_var_resp = local_var_client.execute(local_var_req).await?;
4467
4468    let local_var_status = local_var_resp.status();
4469    let local_var_content = local_var_resp.text().await?;
4470
4471    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
4472        serde_json::from_str(&local_var_content).map_err(Error::from)
4473    } else {
4474        let local_var_entity: Option<CircuitsCircuitTerminationsBulkUpdateError> =
4475            serde_json::from_str(&local_var_content).ok();
4476        let local_var_error = ResponseContent {
4477            status: local_var_status,
4478            content: local_var_content,
4479            entity: local_var_entity,
4480        };
4481        Err(Error::ResponseError(local_var_error))
4482    }
4483}
4484
4485/// Post a list of circuit termination objects.
4486pub async fn circuits_circuit_terminations_create(
4487    configuration: &configuration::Configuration,
4488    circuits_circuit_terminations_create_request: crate::models::CircuitsCircuitTerminationsCreateRequest,
4489) -> Result<crate::models::CircuitTermination, Error<CircuitsCircuitTerminationsCreateError>> {
4490    let local_var_configuration = configuration;
4491
4492    let local_var_client = &local_var_configuration.client;
4493
4494    let local_var_uri_str = format!(
4495        "{}/api/circuits/circuit-terminations/",
4496        local_var_configuration.base_path
4497    );
4498    let mut local_var_req_builder =
4499        local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
4500
4501    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
4502        local_var_req_builder =
4503            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
4504    }
4505    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
4506        let local_var_key = local_var_apikey.key.clone();
4507        let local_var_value = match local_var_apikey.prefix {
4508            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
4509            None => local_var_key,
4510        };
4511        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
4512    };
4513    local_var_req_builder =
4514        local_var_req_builder.json(&circuits_circuit_terminations_create_request);
4515
4516    let local_var_req = local_var_req_builder.build()?;
4517    let local_var_resp = local_var_client.execute(local_var_req).await?;
4518
4519    let local_var_status = local_var_resp.status();
4520    let local_var_content = local_var_resp.text().await?;
4521
4522    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
4523        serde_json::from_str(&local_var_content).map_err(Error::from)
4524    } else {
4525        let local_var_entity: Option<CircuitsCircuitTerminationsCreateError> =
4526            serde_json::from_str(&local_var_content).ok();
4527        let local_var_error = ResponseContent {
4528            status: local_var_status,
4529            content: local_var_content,
4530            entity: local_var_entity,
4531        };
4532        Err(Error::ResponseError(local_var_error))
4533    }
4534}
4535
4536/// Delete a circuit termination object.
4537pub async fn circuits_circuit_terminations_destroy(
4538    configuration: &configuration::Configuration,
4539    id: i32,
4540) -> Result<(), Error<CircuitsCircuitTerminationsDestroyError>> {
4541    let local_var_configuration = configuration;
4542
4543    let local_var_client = &local_var_configuration.client;
4544
4545    let local_var_uri_str = format!(
4546        "{}/api/circuits/circuit-terminations/{id}/",
4547        local_var_configuration.base_path,
4548        id = id
4549    );
4550    let mut local_var_req_builder =
4551        local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());
4552
4553    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
4554        local_var_req_builder =
4555            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
4556    }
4557    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
4558        let local_var_key = local_var_apikey.key.clone();
4559        let local_var_value = match local_var_apikey.prefix {
4560            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
4561            None => local_var_key,
4562        };
4563        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
4564    };
4565
4566    let local_var_req = local_var_req_builder.build()?;
4567    let local_var_resp = local_var_client.execute(local_var_req).await?;
4568
4569    let local_var_status = local_var_resp.status();
4570    let local_var_content = local_var_resp.text().await?;
4571
4572    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
4573        Ok(())
4574    } else {
4575        let local_var_entity: Option<CircuitsCircuitTerminationsDestroyError> =
4576            serde_json::from_str(&local_var_content).ok();
4577        let local_var_error = ResponseContent {
4578            status: local_var_status,
4579            content: local_var_content,
4580            entity: local_var_entity,
4581        };
4582        Err(Error::ResponseError(local_var_error))
4583    }
4584}
4585
4586/// Get a list of circuit termination objects.
4587pub async fn circuits_circuit_terminations_list(
4588    configuration: &configuration::Configuration,
4589    cable_connector: Option<Vec<i32>>,
4590    cable_connector__empty: Option<bool>,
4591    cable_connector__gt: Option<Vec<i32>>,
4592    cable_connector__gte: Option<Vec<i32>>,
4593    cable_connector__lt: Option<Vec<i32>>,
4594    cable_connector__lte: Option<Vec<i32>>,
4595    cable_connector__n: Option<Vec<i32>>,
4596    cable_end: Option<&str>,
4597    cable_end__empty: Option<bool>,
4598    cable_end__ic: Option<Vec<String>>,
4599    cable_end__ie: Option<Vec<String>>,
4600    cable_end__iew: Option<Vec<String>>,
4601    cable_end__iregex: Option<Vec<String>>,
4602    cable_end__isw: Option<Vec<String>>,
4603    cable_end__n: Option<&str>,
4604    cable_end__nic: Option<Vec<String>>,
4605    cable_end__nie: Option<Vec<String>>,
4606    cable_end__niew: Option<Vec<String>>,
4607    cable_end__nisw: Option<Vec<String>>,
4608    cable_end__regex: Option<Vec<String>>,
4609    cable_id: Option<Vec<i32>>,
4610    cable_id__n: Option<Vec<i32>>,
4611    cabled: Option<bool>,
4612    circuit_id: Option<Vec<i32>>,
4613    circuit_id__n: Option<Vec<i32>>,
4614    created: Option<Vec<String>>,
4615    created__empty: Option<Vec<String>>,
4616    created__gt: Option<Vec<String>>,
4617    created__gte: Option<Vec<String>>,
4618    created__lt: Option<Vec<String>>,
4619    created__lte: Option<Vec<String>>,
4620    created__n: Option<Vec<String>>,
4621    created_by_request: Option<&str>,
4622    description: Option<Vec<String>>,
4623    description__empty: Option<bool>,
4624    description__ic: Option<Vec<String>>,
4625    description__ie: Option<Vec<String>>,
4626    description__iew: Option<Vec<String>>,
4627    description__iregex: Option<Vec<String>>,
4628    description__isw: Option<Vec<String>>,
4629    description__n: Option<Vec<String>>,
4630    description__nic: Option<Vec<String>>,
4631    description__nie: Option<Vec<String>>,
4632    description__niew: Option<Vec<String>>,
4633    description__nisw: Option<Vec<String>>,
4634    description__regex: Option<Vec<String>>,
4635    id: Option<Vec<i32>>,
4636    id__empty: Option<bool>,
4637    id__gt: Option<Vec<i32>>,
4638    id__gte: Option<Vec<i32>>,
4639    id__lt: Option<Vec<i32>>,
4640    id__lte: Option<Vec<i32>>,
4641    id__n: Option<Vec<i32>>,
4642    last_updated: Option<Vec<String>>,
4643    last_updated__empty: Option<Vec<String>>,
4644    last_updated__gt: Option<Vec<String>>,
4645    last_updated__gte: Option<Vec<String>>,
4646    last_updated__lt: Option<Vec<String>>,
4647    last_updated__lte: Option<Vec<String>>,
4648    last_updated__n: Option<Vec<String>>,
4649    limit: Option<i32>,
4650    location: Option<Vec<String>>,
4651    location__n: Option<Vec<String>>,
4652    location_id: Option<Vec<String>>,
4653    location_id__n: Option<Vec<String>>,
4654    mark_connected: Option<bool>,
4655    modified_by_request: Option<&str>,
4656    occupied: Option<bool>,
4657    offset: Option<i32>,
4658    ordering: Option<&str>,
4659    port_speed: Option<Vec<i32>>,
4660    port_speed__empty: Option<bool>,
4661    port_speed__gt: Option<Vec<i32>>,
4662    port_speed__gte: Option<Vec<i32>>,
4663    port_speed__lt: Option<Vec<i32>>,
4664    port_speed__lte: Option<Vec<i32>>,
4665    port_speed__n: Option<Vec<i32>>,
4666    pp_info: Option<Vec<String>>,
4667    pp_info__empty: Option<bool>,
4668    pp_info__ic: Option<Vec<String>>,
4669    pp_info__ie: Option<Vec<String>>,
4670    pp_info__iew: Option<Vec<String>>,
4671    pp_info__iregex: Option<Vec<String>>,
4672    pp_info__isw: Option<Vec<String>>,
4673    pp_info__n: Option<Vec<String>>,
4674    pp_info__nic: Option<Vec<String>>,
4675    pp_info__nie: Option<Vec<String>>,
4676    pp_info__niew: Option<Vec<String>>,
4677    pp_info__nisw: Option<Vec<String>>,
4678    pp_info__regex: Option<Vec<String>>,
4679    provider: Option<Vec<String>>,
4680    provider__n: Option<Vec<String>>,
4681    provider_id: Option<Vec<i32>>,
4682    provider_id__n: Option<Vec<i32>>,
4683    provider_network_id: Option<Vec<i32>>,
4684    provider_network_id__n: Option<Vec<i32>>,
4685    q: Option<&str>,
4686    region: Option<Vec<String>>,
4687    region__n: Option<Vec<String>>,
4688    region_id: Option<Vec<String>>,
4689    region_id__n: Option<Vec<String>>,
4690    site: Option<Vec<String>>,
4691    site__n: Option<Vec<String>>,
4692    site_group: Option<Vec<String>>,
4693    site_group__n: Option<Vec<String>>,
4694    site_group_id: Option<Vec<String>>,
4695    site_group_id__n: Option<Vec<String>>,
4696    site_id: Option<Vec<i32>>,
4697    site_id__n: Option<Vec<i32>>,
4698    start: Option<i32>,
4699    tag: Option<Vec<String>>,
4700    tag__n: Option<Vec<String>>,
4701    tag_id: Option<Vec<i32>>,
4702    tag_id__n: Option<Vec<i32>>,
4703    term_side: Option<&str>,
4704    term_side__empty: Option<bool>,
4705    term_side__ic: Option<Vec<String>>,
4706    term_side__ie: Option<Vec<String>>,
4707    term_side__iew: Option<Vec<String>>,
4708    term_side__iregex: Option<Vec<String>>,
4709    term_side__isw: Option<Vec<String>>,
4710    term_side__n: Option<&str>,
4711    term_side__nic: Option<Vec<String>>,
4712    term_side__nie: Option<Vec<String>>,
4713    term_side__niew: Option<Vec<String>>,
4714    term_side__nisw: Option<Vec<String>>,
4715    term_side__regex: Option<Vec<String>>,
4716    termination_id: Option<Vec<i32>>,
4717    termination_id__empty: Option<bool>,
4718    termination_id__gt: Option<Vec<i32>>,
4719    termination_id__gte: Option<Vec<i32>>,
4720    termination_id__lt: Option<Vec<i32>>,
4721    termination_id__lte: Option<Vec<i32>>,
4722    termination_id__n: Option<Vec<i32>>,
4723    termination_type: Option<Vec<String>>,
4724    termination_type__n: Option<Vec<String>>,
4725    updated_by_request: Option<&str>,
4726    upstream_speed: Option<Vec<i32>>,
4727    upstream_speed__empty: Option<bool>,
4728    upstream_speed__gt: Option<Vec<i32>>,
4729    upstream_speed__gte: Option<Vec<i32>>,
4730    upstream_speed__lt: Option<Vec<i32>>,
4731    upstream_speed__lte: Option<Vec<i32>>,
4732    upstream_speed__n: Option<Vec<i32>>,
4733    xconnect_id: Option<Vec<String>>,
4734    xconnect_id__empty: Option<bool>,
4735    xconnect_id__ic: Option<Vec<String>>,
4736    xconnect_id__ie: Option<Vec<String>>,
4737    xconnect_id__iew: Option<Vec<String>>,
4738    xconnect_id__iregex: Option<Vec<String>>,
4739    xconnect_id__isw: Option<Vec<String>>,
4740    xconnect_id__n: Option<Vec<String>>,
4741    xconnect_id__nic: Option<Vec<String>>,
4742    xconnect_id__nie: Option<Vec<String>>,
4743    xconnect_id__niew: Option<Vec<String>>,
4744    xconnect_id__nisw: Option<Vec<String>>,
4745    xconnect_id__regex: Option<Vec<String>>,
4746) -> Result<
4747    crate::models::PaginatedCircuitTerminationList,
4748    Error<CircuitsCircuitTerminationsListError>,
4749> {
4750    let local_var_configuration = configuration;
4751
4752    let local_var_client = &local_var_configuration.client;
4753
4754    let local_var_uri_str = format!(
4755        "{}/api/circuits/circuit-terminations/",
4756        local_var_configuration.base_path
4757    );
4758    let mut local_var_req_builder =
4759        local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
4760
4761    if let Some(ref local_var_str) = cable_connector {
4762        local_var_req_builder = match "multi" {
4763            "multi" => local_var_req_builder.query(
4764                &local_var_str
4765                    .into_iter()
4766                    .map(|p| ("cable_connector".to_owned(), p.to_string()))
4767                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4768            ),
4769            _ => local_var_req_builder.query(&[(
4770                "cable_connector",
4771                &local_var_str
4772                    .into_iter()
4773                    .map(|p| p.to_string())
4774                    .collect::<Vec<String>>()
4775                    .join(",")
4776                    .to_string(),
4777            )]),
4778        };
4779    }
4780    if let Some(ref local_var_str) = cable_connector__empty {
4781        local_var_req_builder =
4782            local_var_req_builder.query(&[("cable_connector__empty", &local_var_str.to_string())]);
4783    }
4784    if let Some(ref local_var_str) = cable_connector__gt {
4785        local_var_req_builder = match "multi" {
4786            "multi" => local_var_req_builder.query(
4787                &local_var_str
4788                    .into_iter()
4789                    .map(|p| ("cable_connector__gt".to_owned(), p.to_string()))
4790                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4791            ),
4792            _ => local_var_req_builder.query(&[(
4793                "cable_connector__gt",
4794                &local_var_str
4795                    .into_iter()
4796                    .map(|p| p.to_string())
4797                    .collect::<Vec<String>>()
4798                    .join(",")
4799                    .to_string(),
4800            )]),
4801        };
4802    }
4803    if let Some(ref local_var_str) = cable_connector__gte {
4804        local_var_req_builder = match "multi" {
4805            "multi" => local_var_req_builder.query(
4806                &local_var_str
4807                    .into_iter()
4808                    .map(|p| ("cable_connector__gte".to_owned(), p.to_string()))
4809                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4810            ),
4811            _ => local_var_req_builder.query(&[(
4812                "cable_connector__gte",
4813                &local_var_str
4814                    .into_iter()
4815                    .map(|p| p.to_string())
4816                    .collect::<Vec<String>>()
4817                    .join(",")
4818                    .to_string(),
4819            )]),
4820        };
4821    }
4822    if let Some(ref local_var_str) = cable_connector__lt {
4823        local_var_req_builder = match "multi" {
4824            "multi" => local_var_req_builder.query(
4825                &local_var_str
4826                    .into_iter()
4827                    .map(|p| ("cable_connector__lt".to_owned(), p.to_string()))
4828                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4829            ),
4830            _ => local_var_req_builder.query(&[(
4831                "cable_connector__lt",
4832                &local_var_str
4833                    .into_iter()
4834                    .map(|p| p.to_string())
4835                    .collect::<Vec<String>>()
4836                    .join(",")
4837                    .to_string(),
4838            )]),
4839        };
4840    }
4841    if let Some(ref local_var_str) = cable_connector__lte {
4842        local_var_req_builder = match "multi" {
4843            "multi" => local_var_req_builder.query(
4844                &local_var_str
4845                    .into_iter()
4846                    .map(|p| ("cable_connector__lte".to_owned(), p.to_string()))
4847                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4848            ),
4849            _ => local_var_req_builder.query(&[(
4850                "cable_connector__lte",
4851                &local_var_str
4852                    .into_iter()
4853                    .map(|p| p.to_string())
4854                    .collect::<Vec<String>>()
4855                    .join(",")
4856                    .to_string(),
4857            )]),
4858        };
4859    }
4860    if let Some(ref local_var_str) = cable_connector__n {
4861        local_var_req_builder = match "multi" {
4862            "multi" => local_var_req_builder.query(
4863                &local_var_str
4864                    .into_iter()
4865                    .map(|p| ("cable_connector__n".to_owned(), p.to_string()))
4866                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4867            ),
4868            _ => local_var_req_builder.query(&[(
4869                "cable_connector__n",
4870                &local_var_str
4871                    .into_iter()
4872                    .map(|p| p.to_string())
4873                    .collect::<Vec<String>>()
4874                    .join(",")
4875                    .to_string(),
4876            )]),
4877        };
4878    }
4879    if let Some(ref local_var_str) = cable_end {
4880        local_var_req_builder =
4881            local_var_req_builder.query(&[("cable_end", &local_var_str.to_string())]);
4882    }
4883    if let Some(ref local_var_str) = cable_end__empty {
4884        local_var_req_builder =
4885            local_var_req_builder.query(&[("cable_end__empty", &local_var_str.to_string())]);
4886    }
4887    if let Some(ref local_var_str) = cable_end__ic {
4888        local_var_req_builder = match "multi" {
4889            "multi" => local_var_req_builder.query(
4890                &local_var_str
4891                    .into_iter()
4892                    .map(|p| ("cable_end__ic".to_owned(), p.to_string()))
4893                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4894            ),
4895            _ => local_var_req_builder.query(&[(
4896                "cable_end__ic",
4897                &local_var_str
4898                    .into_iter()
4899                    .map(|p| p.to_string())
4900                    .collect::<Vec<String>>()
4901                    .join(",")
4902                    .to_string(),
4903            )]),
4904        };
4905    }
4906    if let Some(ref local_var_str) = cable_end__ie {
4907        local_var_req_builder = match "multi" {
4908            "multi" => local_var_req_builder.query(
4909                &local_var_str
4910                    .into_iter()
4911                    .map(|p| ("cable_end__ie".to_owned(), p.to_string()))
4912                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4913            ),
4914            _ => local_var_req_builder.query(&[(
4915                "cable_end__ie",
4916                &local_var_str
4917                    .into_iter()
4918                    .map(|p| p.to_string())
4919                    .collect::<Vec<String>>()
4920                    .join(",")
4921                    .to_string(),
4922            )]),
4923        };
4924    }
4925    if let Some(ref local_var_str) = cable_end__iew {
4926        local_var_req_builder = match "multi" {
4927            "multi" => local_var_req_builder.query(
4928                &local_var_str
4929                    .into_iter()
4930                    .map(|p| ("cable_end__iew".to_owned(), p.to_string()))
4931                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4932            ),
4933            _ => local_var_req_builder.query(&[(
4934                "cable_end__iew",
4935                &local_var_str
4936                    .into_iter()
4937                    .map(|p| p.to_string())
4938                    .collect::<Vec<String>>()
4939                    .join(",")
4940                    .to_string(),
4941            )]),
4942        };
4943    }
4944    if let Some(ref local_var_str) = cable_end__iregex {
4945        local_var_req_builder = match "multi" {
4946            "multi" => local_var_req_builder.query(
4947                &local_var_str
4948                    .into_iter()
4949                    .map(|p| ("cable_end__iregex".to_owned(), p.to_string()))
4950                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4951            ),
4952            _ => local_var_req_builder.query(&[(
4953                "cable_end__iregex",
4954                &local_var_str
4955                    .into_iter()
4956                    .map(|p| p.to_string())
4957                    .collect::<Vec<String>>()
4958                    .join(",")
4959                    .to_string(),
4960            )]),
4961        };
4962    }
4963    if let Some(ref local_var_str) = cable_end__isw {
4964        local_var_req_builder = match "multi" {
4965            "multi" => local_var_req_builder.query(
4966                &local_var_str
4967                    .into_iter()
4968                    .map(|p| ("cable_end__isw".to_owned(), p.to_string()))
4969                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4970            ),
4971            _ => local_var_req_builder.query(&[(
4972                "cable_end__isw",
4973                &local_var_str
4974                    .into_iter()
4975                    .map(|p| p.to_string())
4976                    .collect::<Vec<String>>()
4977                    .join(",")
4978                    .to_string(),
4979            )]),
4980        };
4981    }
4982    if let Some(ref local_var_str) = cable_end__n {
4983        local_var_req_builder =
4984            local_var_req_builder.query(&[("cable_end__n", &local_var_str.to_string())]);
4985    }
4986    if let Some(ref local_var_str) = cable_end__nic {
4987        local_var_req_builder = match "multi" {
4988            "multi" => local_var_req_builder.query(
4989                &local_var_str
4990                    .into_iter()
4991                    .map(|p| ("cable_end__nic".to_owned(), p.to_string()))
4992                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4993            ),
4994            _ => local_var_req_builder.query(&[(
4995                "cable_end__nic",
4996                &local_var_str
4997                    .into_iter()
4998                    .map(|p| p.to_string())
4999                    .collect::<Vec<String>>()
5000                    .join(",")
5001                    .to_string(),
5002            )]),
5003        };
5004    }
5005    if let Some(ref local_var_str) = cable_end__nie {
5006        local_var_req_builder = match "multi" {
5007            "multi" => local_var_req_builder.query(
5008                &local_var_str
5009                    .into_iter()
5010                    .map(|p| ("cable_end__nie".to_owned(), p.to_string()))
5011                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5012            ),
5013            _ => local_var_req_builder.query(&[(
5014                "cable_end__nie",
5015                &local_var_str
5016                    .into_iter()
5017                    .map(|p| p.to_string())
5018                    .collect::<Vec<String>>()
5019                    .join(",")
5020                    .to_string(),
5021            )]),
5022        };
5023    }
5024    if let Some(ref local_var_str) = cable_end__niew {
5025        local_var_req_builder = match "multi" {
5026            "multi" => local_var_req_builder.query(
5027                &local_var_str
5028                    .into_iter()
5029                    .map(|p| ("cable_end__niew".to_owned(), p.to_string()))
5030                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5031            ),
5032            _ => local_var_req_builder.query(&[(
5033                "cable_end__niew",
5034                &local_var_str
5035                    .into_iter()
5036                    .map(|p| p.to_string())
5037                    .collect::<Vec<String>>()
5038                    .join(",")
5039                    .to_string(),
5040            )]),
5041        };
5042    }
5043    if let Some(ref local_var_str) = cable_end__nisw {
5044        local_var_req_builder = match "multi" {
5045            "multi" => local_var_req_builder.query(
5046                &local_var_str
5047                    .into_iter()
5048                    .map(|p| ("cable_end__nisw".to_owned(), p.to_string()))
5049                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5050            ),
5051            _ => local_var_req_builder.query(&[(
5052                "cable_end__nisw",
5053                &local_var_str
5054                    .into_iter()
5055                    .map(|p| p.to_string())
5056                    .collect::<Vec<String>>()
5057                    .join(",")
5058                    .to_string(),
5059            )]),
5060        };
5061    }
5062    if let Some(ref local_var_str) = cable_end__regex {
5063        local_var_req_builder = match "multi" {
5064            "multi" => local_var_req_builder.query(
5065                &local_var_str
5066                    .into_iter()
5067                    .map(|p| ("cable_end__regex".to_owned(), p.to_string()))
5068                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5069            ),
5070            _ => local_var_req_builder.query(&[(
5071                "cable_end__regex",
5072                &local_var_str
5073                    .into_iter()
5074                    .map(|p| p.to_string())
5075                    .collect::<Vec<String>>()
5076                    .join(",")
5077                    .to_string(),
5078            )]),
5079        };
5080    }
5081    if let Some(ref local_var_str) = cable_id {
5082        local_var_req_builder = match "multi" {
5083            "multi" => local_var_req_builder.query(
5084                &local_var_str
5085                    .into_iter()
5086                    .map(|p| ("cable_id".to_owned(), p.to_string()))
5087                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5088            ),
5089            _ => local_var_req_builder.query(&[(
5090                "cable_id",
5091                &local_var_str
5092                    .into_iter()
5093                    .map(|p| p.to_string())
5094                    .collect::<Vec<String>>()
5095                    .join(",")
5096                    .to_string(),
5097            )]),
5098        };
5099    }
5100    if let Some(ref local_var_str) = cable_id__n {
5101        local_var_req_builder = match "multi" {
5102            "multi" => local_var_req_builder.query(
5103                &local_var_str
5104                    .into_iter()
5105                    .map(|p| ("cable_id__n".to_owned(), p.to_string()))
5106                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5107            ),
5108            _ => local_var_req_builder.query(&[(
5109                "cable_id__n",
5110                &local_var_str
5111                    .into_iter()
5112                    .map(|p| p.to_string())
5113                    .collect::<Vec<String>>()
5114                    .join(",")
5115                    .to_string(),
5116            )]),
5117        };
5118    }
5119    if let Some(ref local_var_str) = cabled {
5120        local_var_req_builder =
5121            local_var_req_builder.query(&[("cabled", &local_var_str.to_string())]);
5122    }
5123    if let Some(ref local_var_str) = circuit_id {
5124        local_var_req_builder = match "multi" {
5125            "multi" => local_var_req_builder.query(
5126                &local_var_str
5127                    .into_iter()
5128                    .map(|p| ("circuit_id".to_owned(), p.to_string()))
5129                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5130            ),
5131            _ => local_var_req_builder.query(&[(
5132                "circuit_id",
5133                &local_var_str
5134                    .into_iter()
5135                    .map(|p| p.to_string())
5136                    .collect::<Vec<String>>()
5137                    .join(",")
5138                    .to_string(),
5139            )]),
5140        };
5141    }
5142    if let Some(ref local_var_str) = circuit_id__n {
5143        local_var_req_builder = match "multi" {
5144            "multi" => local_var_req_builder.query(
5145                &local_var_str
5146                    .into_iter()
5147                    .map(|p| ("circuit_id__n".to_owned(), p.to_string()))
5148                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5149            ),
5150            _ => local_var_req_builder.query(&[(
5151                "circuit_id__n",
5152                &local_var_str
5153                    .into_iter()
5154                    .map(|p| p.to_string())
5155                    .collect::<Vec<String>>()
5156                    .join(",")
5157                    .to_string(),
5158            )]),
5159        };
5160    }
5161    if let Some(ref local_var_str) = created {
5162        local_var_req_builder = match "multi" {
5163            "multi" => local_var_req_builder.query(
5164                &local_var_str
5165                    .into_iter()
5166                    .map(|p| ("created".to_owned(), p.to_string()))
5167                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5168            ),
5169            _ => local_var_req_builder.query(&[(
5170                "created",
5171                &local_var_str
5172                    .into_iter()
5173                    .map(|p| p.to_string())
5174                    .collect::<Vec<String>>()
5175                    .join(",")
5176                    .to_string(),
5177            )]),
5178        };
5179    }
5180    if let Some(ref local_var_str) = created__empty {
5181        local_var_req_builder = match "multi" {
5182            "multi" => local_var_req_builder.query(
5183                &local_var_str
5184                    .into_iter()
5185                    .map(|p| ("created__empty".to_owned(), p.to_string()))
5186                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5187            ),
5188            _ => local_var_req_builder.query(&[(
5189                "created__empty",
5190                &local_var_str
5191                    .into_iter()
5192                    .map(|p| p.to_string())
5193                    .collect::<Vec<String>>()
5194                    .join(",")
5195                    .to_string(),
5196            )]),
5197        };
5198    }
5199    if let Some(ref local_var_str) = created__gt {
5200        local_var_req_builder = match "multi" {
5201            "multi" => local_var_req_builder.query(
5202                &local_var_str
5203                    .into_iter()
5204                    .map(|p| ("created__gt".to_owned(), p.to_string()))
5205                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5206            ),
5207            _ => local_var_req_builder.query(&[(
5208                "created__gt",
5209                &local_var_str
5210                    .into_iter()
5211                    .map(|p| p.to_string())
5212                    .collect::<Vec<String>>()
5213                    .join(",")
5214                    .to_string(),
5215            )]),
5216        };
5217    }
5218    if let Some(ref local_var_str) = created__gte {
5219        local_var_req_builder = match "multi" {
5220            "multi" => local_var_req_builder.query(
5221                &local_var_str
5222                    .into_iter()
5223                    .map(|p| ("created__gte".to_owned(), p.to_string()))
5224                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5225            ),
5226            _ => local_var_req_builder.query(&[(
5227                "created__gte",
5228                &local_var_str
5229                    .into_iter()
5230                    .map(|p| p.to_string())
5231                    .collect::<Vec<String>>()
5232                    .join(",")
5233                    .to_string(),
5234            )]),
5235        };
5236    }
5237    if let Some(ref local_var_str) = created__lt {
5238        local_var_req_builder = match "multi" {
5239            "multi" => local_var_req_builder.query(
5240                &local_var_str
5241                    .into_iter()
5242                    .map(|p| ("created__lt".to_owned(), p.to_string()))
5243                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5244            ),
5245            _ => local_var_req_builder.query(&[(
5246                "created__lt",
5247                &local_var_str
5248                    .into_iter()
5249                    .map(|p| p.to_string())
5250                    .collect::<Vec<String>>()
5251                    .join(",")
5252                    .to_string(),
5253            )]),
5254        };
5255    }
5256    if let Some(ref local_var_str) = created__lte {
5257        local_var_req_builder = match "multi" {
5258            "multi" => local_var_req_builder.query(
5259                &local_var_str
5260                    .into_iter()
5261                    .map(|p| ("created__lte".to_owned(), p.to_string()))
5262                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5263            ),
5264            _ => local_var_req_builder.query(&[(
5265                "created__lte",
5266                &local_var_str
5267                    .into_iter()
5268                    .map(|p| p.to_string())
5269                    .collect::<Vec<String>>()
5270                    .join(",")
5271                    .to_string(),
5272            )]),
5273        };
5274    }
5275    if let Some(ref local_var_str) = created__n {
5276        local_var_req_builder = match "multi" {
5277            "multi" => local_var_req_builder.query(
5278                &local_var_str
5279                    .into_iter()
5280                    .map(|p| ("created__n".to_owned(), p.to_string()))
5281                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5282            ),
5283            _ => local_var_req_builder.query(&[(
5284                "created__n",
5285                &local_var_str
5286                    .into_iter()
5287                    .map(|p| p.to_string())
5288                    .collect::<Vec<String>>()
5289                    .join(",")
5290                    .to_string(),
5291            )]),
5292        };
5293    }
5294    if let Some(ref local_var_str) = created_by_request {
5295        local_var_req_builder =
5296            local_var_req_builder.query(&[("created_by_request", &local_var_str.to_string())]);
5297    }
5298    if let Some(ref local_var_str) = description {
5299        local_var_req_builder = match "multi" {
5300            "multi" => local_var_req_builder.query(
5301                &local_var_str
5302                    .into_iter()
5303                    .map(|p| ("description".to_owned(), p.to_string()))
5304                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5305            ),
5306            _ => local_var_req_builder.query(&[(
5307                "description",
5308                &local_var_str
5309                    .into_iter()
5310                    .map(|p| p.to_string())
5311                    .collect::<Vec<String>>()
5312                    .join(",")
5313                    .to_string(),
5314            )]),
5315        };
5316    }
5317    if let Some(ref local_var_str) = description__empty {
5318        local_var_req_builder =
5319            local_var_req_builder.query(&[("description__empty", &local_var_str.to_string())]);
5320    }
5321    if let Some(ref local_var_str) = description__ic {
5322        local_var_req_builder = match "multi" {
5323            "multi" => local_var_req_builder.query(
5324                &local_var_str
5325                    .into_iter()
5326                    .map(|p| ("description__ic".to_owned(), p.to_string()))
5327                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5328            ),
5329            _ => local_var_req_builder.query(&[(
5330                "description__ic",
5331                &local_var_str
5332                    .into_iter()
5333                    .map(|p| p.to_string())
5334                    .collect::<Vec<String>>()
5335                    .join(",")
5336                    .to_string(),
5337            )]),
5338        };
5339    }
5340    if let Some(ref local_var_str) = description__ie {
5341        local_var_req_builder = match "multi" {
5342            "multi" => local_var_req_builder.query(
5343                &local_var_str
5344                    .into_iter()
5345                    .map(|p| ("description__ie".to_owned(), p.to_string()))
5346                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5347            ),
5348            _ => local_var_req_builder.query(&[(
5349                "description__ie",
5350                &local_var_str
5351                    .into_iter()
5352                    .map(|p| p.to_string())
5353                    .collect::<Vec<String>>()
5354                    .join(",")
5355                    .to_string(),
5356            )]),
5357        };
5358    }
5359    if let Some(ref local_var_str) = description__iew {
5360        local_var_req_builder = match "multi" {
5361            "multi" => local_var_req_builder.query(
5362                &local_var_str
5363                    .into_iter()
5364                    .map(|p| ("description__iew".to_owned(), p.to_string()))
5365                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5366            ),
5367            _ => local_var_req_builder.query(&[(
5368                "description__iew",
5369                &local_var_str
5370                    .into_iter()
5371                    .map(|p| p.to_string())
5372                    .collect::<Vec<String>>()
5373                    .join(",")
5374                    .to_string(),
5375            )]),
5376        };
5377    }
5378    if let Some(ref local_var_str) = description__iregex {
5379        local_var_req_builder = match "multi" {
5380            "multi" => local_var_req_builder.query(
5381                &local_var_str
5382                    .into_iter()
5383                    .map(|p| ("description__iregex".to_owned(), p.to_string()))
5384                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5385            ),
5386            _ => local_var_req_builder.query(&[(
5387                "description__iregex",
5388                &local_var_str
5389                    .into_iter()
5390                    .map(|p| p.to_string())
5391                    .collect::<Vec<String>>()
5392                    .join(",")
5393                    .to_string(),
5394            )]),
5395        };
5396    }
5397    if let Some(ref local_var_str) = description__isw {
5398        local_var_req_builder = match "multi" {
5399            "multi" => local_var_req_builder.query(
5400                &local_var_str
5401                    .into_iter()
5402                    .map(|p| ("description__isw".to_owned(), p.to_string()))
5403                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5404            ),
5405            _ => local_var_req_builder.query(&[(
5406                "description__isw",
5407                &local_var_str
5408                    .into_iter()
5409                    .map(|p| p.to_string())
5410                    .collect::<Vec<String>>()
5411                    .join(",")
5412                    .to_string(),
5413            )]),
5414        };
5415    }
5416    if let Some(ref local_var_str) = description__n {
5417        local_var_req_builder = match "multi" {
5418            "multi" => local_var_req_builder.query(
5419                &local_var_str
5420                    .into_iter()
5421                    .map(|p| ("description__n".to_owned(), p.to_string()))
5422                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5423            ),
5424            _ => local_var_req_builder.query(&[(
5425                "description__n",
5426                &local_var_str
5427                    .into_iter()
5428                    .map(|p| p.to_string())
5429                    .collect::<Vec<String>>()
5430                    .join(",")
5431                    .to_string(),
5432            )]),
5433        };
5434    }
5435    if let Some(ref local_var_str) = description__nic {
5436        local_var_req_builder = match "multi" {
5437            "multi" => local_var_req_builder.query(
5438                &local_var_str
5439                    .into_iter()
5440                    .map(|p| ("description__nic".to_owned(), p.to_string()))
5441                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5442            ),
5443            _ => local_var_req_builder.query(&[(
5444                "description__nic",
5445                &local_var_str
5446                    .into_iter()
5447                    .map(|p| p.to_string())
5448                    .collect::<Vec<String>>()
5449                    .join(",")
5450                    .to_string(),
5451            )]),
5452        };
5453    }
5454    if let Some(ref local_var_str) = description__nie {
5455        local_var_req_builder = match "multi" {
5456            "multi" => local_var_req_builder.query(
5457                &local_var_str
5458                    .into_iter()
5459                    .map(|p| ("description__nie".to_owned(), p.to_string()))
5460                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5461            ),
5462            _ => local_var_req_builder.query(&[(
5463                "description__nie",
5464                &local_var_str
5465                    .into_iter()
5466                    .map(|p| p.to_string())
5467                    .collect::<Vec<String>>()
5468                    .join(",")
5469                    .to_string(),
5470            )]),
5471        };
5472    }
5473    if let Some(ref local_var_str) = description__niew {
5474        local_var_req_builder = match "multi" {
5475            "multi" => local_var_req_builder.query(
5476                &local_var_str
5477                    .into_iter()
5478                    .map(|p| ("description__niew".to_owned(), p.to_string()))
5479                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5480            ),
5481            _ => local_var_req_builder.query(&[(
5482                "description__niew",
5483                &local_var_str
5484                    .into_iter()
5485                    .map(|p| p.to_string())
5486                    .collect::<Vec<String>>()
5487                    .join(",")
5488                    .to_string(),
5489            )]),
5490        };
5491    }
5492    if let Some(ref local_var_str) = description__nisw {
5493        local_var_req_builder = match "multi" {
5494            "multi" => local_var_req_builder.query(
5495                &local_var_str
5496                    .into_iter()
5497                    .map(|p| ("description__nisw".to_owned(), p.to_string()))
5498                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5499            ),
5500            _ => local_var_req_builder.query(&[(
5501                "description__nisw",
5502                &local_var_str
5503                    .into_iter()
5504                    .map(|p| p.to_string())
5505                    .collect::<Vec<String>>()
5506                    .join(",")
5507                    .to_string(),
5508            )]),
5509        };
5510    }
5511    if let Some(ref local_var_str) = description__regex {
5512        local_var_req_builder = match "multi" {
5513            "multi" => local_var_req_builder.query(
5514                &local_var_str
5515                    .into_iter()
5516                    .map(|p| ("description__regex".to_owned(), p.to_string()))
5517                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5518            ),
5519            _ => local_var_req_builder.query(&[(
5520                "description__regex",
5521                &local_var_str
5522                    .into_iter()
5523                    .map(|p| p.to_string())
5524                    .collect::<Vec<String>>()
5525                    .join(",")
5526                    .to_string(),
5527            )]),
5528        };
5529    }
5530    if let Some(ref local_var_str) = id {
5531        local_var_req_builder = match "multi" {
5532            "multi" => local_var_req_builder.query(
5533                &local_var_str
5534                    .into_iter()
5535                    .map(|p| ("id".to_owned(), p.to_string()))
5536                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5537            ),
5538            _ => local_var_req_builder.query(&[(
5539                "id",
5540                &local_var_str
5541                    .into_iter()
5542                    .map(|p| p.to_string())
5543                    .collect::<Vec<String>>()
5544                    .join(",")
5545                    .to_string(),
5546            )]),
5547        };
5548    }
5549    if let Some(ref local_var_str) = id__empty {
5550        local_var_req_builder =
5551            local_var_req_builder.query(&[("id__empty", &local_var_str.to_string())]);
5552    }
5553    if let Some(ref local_var_str) = id__gt {
5554        local_var_req_builder = match "multi" {
5555            "multi" => local_var_req_builder.query(
5556                &local_var_str
5557                    .into_iter()
5558                    .map(|p| ("id__gt".to_owned(), p.to_string()))
5559                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5560            ),
5561            _ => local_var_req_builder.query(&[(
5562                "id__gt",
5563                &local_var_str
5564                    .into_iter()
5565                    .map(|p| p.to_string())
5566                    .collect::<Vec<String>>()
5567                    .join(",")
5568                    .to_string(),
5569            )]),
5570        };
5571    }
5572    if let Some(ref local_var_str) = id__gte {
5573        local_var_req_builder = match "multi" {
5574            "multi" => local_var_req_builder.query(
5575                &local_var_str
5576                    .into_iter()
5577                    .map(|p| ("id__gte".to_owned(), p.to_string()))
5578                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5579            ),
5580            _ => local_var_req_builder.query(&[(
5581                "id__gte",
5582                &local_var_str
5583                    .into_iter()
5584                    .map(|p| p.to_string())
5585                    .collect::<Vec<String>>()
5586                    .join(",")
5587                    .to_string(),
5588            )]),
5589        };
5590    }
5591    if let Some(ref local_var_str) = id__lt {
5592        local_var_req_builder = match "multi" {
5593            "multi" => local_var_req_builder.query(
5594                &local_var_str
5595                    .into_iter()
5596                    .map(|p| ("id__lt".to_owned(), p.to_string()))
5597                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5598            ),
5599            _ => local_var_req_builder.query(&[(
5600                "id__lt",
5601                &local_var_str
5602                    .into_iter()
5603                    .map(|p| p.to_string())
5604                    .collect::<Vec<String>>()
5605                    .join(",")
5606                    .to_string(),
5607            )]),
5608        };
5609    }
5610    if let Some(ref local_var_str) = id__lte {
5611        local_var_req_builder = match "multi" {
5612            "multi" => local_var_req_builder.query(
5613                &local_var_str
5614                    .into_iter()
5615                    .map(|p| ("id__lte".to_owned(), p.to_string()))
5616                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5617            ),
5618            _ => local_var_req_builder.query(&[(
5619                "id__lte",
5620                &local_var_str
5621                    .into_iter()
5622                    .map(|p| p.to_string())
5623                    .collect::<Vec<String>>()
5624                    .join(",")
5625                    .to_string(),
5626            )]),
5627        };
5628    }
5629    if let Some(ref local_var_str) = id__n {
5630        local_var_req_builder = match "multi" {
5631            "multi" => local_var_req_builder.query(
5632                &local_var_str
5633                    .into_iter()
5634                    .map(|p| ("id__n".to_owned(), p.to_string()))
5635                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5636            ),
5637            _ => local_var_req_builder.query(&[(
5638                "id__n",
5639                &local_var_str
5640                    .into_iter()
5641                    .map(|p| p.to_string())
5642                    .collect::<Vec<String>>()
5643                    .join(",")
5644                    .to_string(),
5645            )]),
5646        };
5647    }
5648    if let Some(ref local_var_str) = last_updated {
5649        local_var_req_builder = match "multi" {
5650            "multi" => local_var_req_builder.query(
5651                &local_var_str
5652                    .into_iter()
5653                    .map(|p| ("last_updated".to_owned(), p.to_string()))
5654                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5655            ),
5656            _ => local_var_req_builder.query(&[(
5657                "last_updated",
5658                &local_var_str
5659                    .into_iter()
5660                    .map(|p| p.to_string())
5661                    .collect::<Vec<String>>()
5662                    .join(",")
5663                    .to_string(),
5664            )]),
5665        };
5666    }
5667    if let Some(ref local_var_str) = last_updated__empty {
5668        local_var_req_builder = match "multi" {
5669            "multi" => local_var_req_builder.query(
5670                &local_var_str
5671                    .into_iter()
5672                    .map(|p| ("last_updated__empty".to_owned(), p.to_string()))
5673                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5674            ),
5675            _ => local_var_req_builder.query(&[(
5676                "last_updated__empty",
5677                &local_var_str
5678                    .into_iter()
5679                    .map(|p| p.to_string())
5680                    .collect::<Vec<String>>()
5681                    .join(",")
5682                    .to_string(),
5683            )]),
5684        };
5685    }
5686    if let Some(ref local_var_str) = last_updated__gt {
5687        local_var_req_builder = match "multi" {
5688            "multi" => local_var_req_builder.query(
5689                &local_var_str
5690                    .into_iter()
5691                    .map(|p| ("last_updated__gt".to_owned(), p.to_string()))
5692                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5693            ),
5694            _ => local_var_req_builder.query(&[(
5695                "last_updated__gt",
5696                &local_var_str
5697                    .into_iter()
5698                    .map(|p| p.to_string())
5699                    .collect::<Vec<String>>()
5700                    .join(",")
5701                    .to_string(),
5702            )]),
5703        };
5704    }
5705    if let Some(ref local_var_str) = last_updated__gte {
5706        local_var_req_builder = match "multi" {
5707            "multi" => local_var_req_builder.query(
5708                &local_var_str
5709                    .into_iter()
5710                    .map(|p| ("last_updated__gte".to_owned(), p.to_string()))
5711                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5712            ),
5713            _ => local_var_req_builder.query(&[(
5714                "last_updated__gte",
5715                &local_var_str
5716                    .into_iter()
5717                    .map(|p| p.to_string())
5718                    .collect::<Vec<String>>()
5719                    .join(",")
5720                    .to_string(),
5721            )]),
5722        };
5723    }
5724    if let Some(ref local_var_str) = last_updated__lt {
5725        local_var_req_builder = match "multi" {
5726            "multi" => local_var_req_builder.query(
5727                &local_var_str
5728                    .into_iter()
5729                    .map(|p| ("last_updated__lt".to_owned(), p.to_string()))
5730                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5731            ),
5732            _ => local_var_req_builder.query(&[(
5733                "last_updated__lt",
5734                &local_var_str
5735                    .into_iter()
5736                    .map(|p| p.to_string())
5737                    .collect::<Vec<String>>()
5738                    .join(",")
5739                    .to_string(),
5740            )]),
5741        };
5742    }
5743    if let Some(ref local_var_str) = last_updated__lte {
5744        local_var_req_builder = match "multi" {
5745            "multi" => local_var_req_builder.query(
5746                &local_var_str
5747                    .into_iter()
5748                    .map(|p| ("last_updated__lte".to_owned(), p.to_string()))
5749                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5750            ),
5751            _ => local_var_req_builder.query(&[(
5752                "last_updated__lte",
5753                &local_var_str
5754                    .into_iter()
5755                    .map(|p| p.to_string())
5756                    .collect::<Vec<String>>()
5757                    .join(",")
5758                    .to_string(),
5759            )]),
5760        };
5761    }
5762    if let Some(ref local_var_str) = last_updated__n {
5763        local_var_req_builder = match "multi" {
5764            "multi" => local_var_req_builder.query(
5765                &local_var_str
5766                    .into_iter()
5767                    .map(|p| ("last_updated__n".to_owned(), p.to_string()))
5768                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5769            ),
5770            _ => local_var_req_builder.query(&[(
5771                "last_updated__n",
5772                &local_var_str
5773                    .into_iter()
5774                    .map(|p| p.to_string())
5775                    .collect::<Vec<String>>()
5776                    .join(",")
5777                    .to_string(),
5778            )]),
5779        };
5780    }
5781    if let Some(ref local_var_str) = limit {
5782        local_var_req_builder =
5783            local_var_req_builder.query(&[("limit", &local_var_str.to_string())]);
5784    }
5785    if let Some(ref local_var_str) = location {
5786        local_var_req_builder = match "multi" {
5787            "multi" => local_var_req_builder.query(
5788                &local_var_str
5789                    .into_iter()
5790                    .map(|p| ("location".to_owned(), p.to_string()))
5791                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5792            ),
5793            _ => local_var_req_builder.query(&[(
5794                "location",
5795                &local_var_str
5796                    .into_iter()
5797                    .map(|p| p.to_string())
5798                    .collect::<Vec<String>>()
5799                    .join(",")
5800                    .to_string(),
5801            )]),
5802        };
5803    }
5804    if let Some(ref local_var_str) = location__n {
5805        local_var_req_builder = match "multi" {
5806            "multi" => local_var_req_builder.query(
5807                &local_var_str
5808                    .into_iter()
5809                    .map(|p| ("location__n".to_owned(), p.to_string()))
5810                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5811            ),
5812            _ => local_var_req_builder.query(&[(
5813                "location__n",
5814                &local_var_str
5815                    .into_iter()
5816                    .map(|p| p.to_string())
5817                    .collect::<Vec<String>>()
5818                    .join(",")
5819                    .to_string(),
5820            )]),
5821        };
5822    }
5823    if let Some(ref local_var_str) = location_id {
5824        local_var_req_builder = match "multi" {
5825            "multi" => local_var_req_builder.query(
5826                &local_var_str
5827                    .into_iter()
5828                    .map(|p| ("location_id".to_owned(), p.to_string()))
5829                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5830            ),
5831            _ => local_var_req_builder.query(&[(
5832                "location_id",
5833                &local_var_str
5834                    .into_iter()
5835                    .map(|p| p.to_string())
5836                    .collect::<Vec<String>>()
5837                    .join(",")
5838                    .to_string(),
5839            )]),
5840        };
5841    }
5842    if let Some(ref local_var_str) = location_id__n {
5843        local_var_req_builder = match "multi" {
5844            "multi" => local_var_req_builder.query(
5845                &local_var_str
5846                    .into_iter()
5847                    .map(|p| ("location_id__n".to_owned(), p.to_string()))
5848                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5849            ),
5850            _ => local_var_req_builder.query(&[(
5851                "location_id__n",
5852                &local_var_str
5853                    .into_iter()
5854                    .map(|p| p.to_string())
5855                    .collect::<Vec<String>>()
5856                    .join(",")
5857                    .to_string(),
5858            )]),
5859        };
5860    }
5861    if let Some(ref local_var_str) = mark_connected {
5862        local_var_req_builder =
5863            local_var_req_builder.query(&[("mark_connected", &local_var_str.to_string())]);
5864    }
5865    if let Some(ref local_var_str) = modified_by_request {
5866        local_var_req_builder =
5867            local_var_req_builder.query(&[("modified_by_request", &local_var_str.to_string())]);
5868    }
5869    if let Some(ref local_var_str) = occupied {
5870        local_var_req_builder =
5871            local_var_req_builder.query(&[("occupied", &local_var_str.to_string())]);
5872    }
5873    if let Some(ref local_var_str) = offset {
5874        local_var_req_builder =
5875            local_var_req_builder.query(&[("offset", &local_var_str.to_string())]);
5876    }
5877    if let Some(ref local_var_str) = ordering {
5878        local_var_req_builder =
5879            local_var_req_builder.query(&[("ordering", &local_var_str.to_string())]);
5880    }
5881    if let Some(ref local_var_str) = port_speed {
5882        local_var_req_builder = match "multi" {
5883            "multi" => local_var_req_builder.query(
5884                &local_var_str
5885                    .into_iter()
5886                    .map(|p| ("port_speed".to_owned(), p.to_string()))
5887                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5888            ),
5889            _ => local_var_req_builder.query(&[(
5890                "port_speed",
5891                &local_var_str
5892                    .into_iter()
5893                    .map(|p| p.to_string())
5894                    .collect::<Vec<String>>()
5895                    .join(",")
5896                    .to_string(),
5897            )]),
5898        };
5899    }
5900    if let Some(ref local_var_str) = port_speed__empty {
5901        local_var_req_builder =
5902            local_var_req_builder.query(&[("port_speed__empty", &local_var_str.to_string())]);
5903    }
5904    if let Some(ref local_var_str) = port_speed__gt {
5905        local_var_req_builder = match "multi" {
5906            "multi" => local_var_req_builder.query(
5907                &local_var_str
5908                    .into_iter()
5909                    .map(|p| ("port_speed__gt".to_owned(), p.to_string()))
5910                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5911            ),
5912            _ => local_var_req_builder.query(&[(
5913                "port_speed__gt",
5914                &local_var_str
5915                    .into_iter()
5916                    .map(|p| p.to_string())
5917                    .collect::<Vec<String>>()
5918                    .join(",")
5919                    .to_string(),
5920            )]),
5921        };
5922    }
5923    if let Some(ref local_var_str) = port_speed__gte {
5924        local_var_req_builder = match "multi" {
5925            "multi" => local_var_req_builder.query(
5926                &local_var_str
5927                    .into_iter()
5928                    .map(|p| ("port_speed__gte".to_owned(), p.to_string()))
5929                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5930            ),
5931            _ => local_var_req_builder.query(&[(
5932                "port_speed__gte",
5933                &local_var_str
5934                    .into_iter()
5935                    .map(|p| p.to_string())
5936                    .collect::<Vec<String>>()
5937                    .join(",")
5938                    .to_string(),
5939            )]),
5940        };
5941    }
5942    if let Some(ref local_var_str) = port_speed__lt {
5943        local_var_req_builder = match "multi" {
5944            "multi" => local_var_req_builder.query(
5945                &local_var_str
5946                    .into_iter()
5947                    .map(|p| ("port_speed__lt".to_owned(), p.to_string()))
5948                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5949            ),
5950            _ => local_var_req_builder.query(&[(
5951                "port_speed__lt",
5952                &local_var_str
5953                    .into_iter()
5954                    .map(|p| p.to_string())
5955                    .collect::<Vec<String>>()
5956                    .join(",")
5957                    .to_string(),
5958            )]),
5959        };
5960    }
5961    if let Some(ref local_var_str) = port_speed__lte {
5962        local_var_req_builder = match "multi" {
5963            "multi" => local_var_req_builder.query(
5964                &local_var_str
5965                    .into_iter()
5966                    .map(|p| ("port_speed__lte".to_owned(), p.to_string()))
5967                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5968            ),
5969            _ => local_var_req_builder.query(&[(
5970                "port_speed__lte",
5971                &local_var_str
5972                    .into_iter()
5973                    .map(|p| p.to_string())
5974                    .collect::<Vec<String>>()
5975                    .join(",")
5976                    .to_string(),
5977            )]),
5978        };
5979    }
5980    if let Some(ref local_var_str) = port_speed__n {
5981        local_var_req_builder = match "multi" {
5982            "multi" => local_var_req_builder.query(
5983                &local_var_str
5984                    .into_iter()
5985                    .map(|p| ("port_speed__n".to_owned(), p.to_string()))
5986                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5987            ),
5988            _ => local_var_req_builder.query(&[(
5989                "port_speed__n",
5990                &local_var_str
5991                    .into_iter()
5992                    .map(|p| p.to_string())
5993                    .collect::<Vec<String>>()
5994                    .join(",")
5995                    .to_string(),
5996            )]),
5997        };
5998    }
5999    if let Some(ref local_var_str) = pp_info {
6000        local_var_req_builder = match "multi" {
6001            "multi" => local_var_req_builder.query(
6002                &local_var_str
6003                    .into_iter()
6004                    .map(|p| ("pp_info".to_owned(), p.to_string()))
6005                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6006            ),
6007            _ => local_var_req_builder.query(&[(
6008                "pp_info",
6009                &local_var_str
6010                    .into_iter()
6011                    .map(|p| p.to_string())
6012                    .collect::<Vec<String>>()
6013                    .join(",")
6014                    .to_string(),
6015            )]),
6016        };
6017    }
6018    if let Some(ref local_var_str) = pp_info__empty {
6019        local_var_req_builder =
6020            local_var_req_builder.query(&[("pp_info__empty", &local_var_str.to_string())]);
6021    }
6022    if let Some(ref local_var_str) = pp_info__ic {
6023        local_var_req_builder = match "multi" {
6024            "multi" => local_var_req_builder.query(
6025                &local_var_str
6026                    .into_iter()
6027                    .map(|p| ("pp_info__ic".to_owned(), p.to_string()))
6028                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6029            ),
6030            _ => local_var_req_builder.query(&[(
6031                "pp_info__ic",
6032                &local_var_str
6033                    .into_iter()
6034                    .map(|p| p.to_string())
6035                    .collect::<Vec<String>>()
6036                    .join(",")
6037                    .to_string(),
6038            )]),
6039        };
6040    }
6041    if let Some(ref local_var_str) = pp_info__ie {
6042        local_var_req_builder = match "multi" {
6043            "multi" => local_var_req_builder.query(
6044                &local_var_str
6045                    .into_iter()
6046                    .map(|p| ("pp_info__ie".to_owned(), p.to_string()))
6047                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6048            ),
6049            _ => local_var_req_builder.query(&[(
6050                "pp_info__ie",
6051                &local_var_str
6052                    .into_iter()
6053                    .map(|p| p.to_string())
6054                    .collect::<Vec<String>>()
6055                    .join(",")
6056                    .to_string(),
6057            )]),
6058        };
6059    }
6060    if let Some(ref local_var_str) = pp_info__iew {
6061        local_var_req_builder = match "multi" {
6062            "multi" => local_var_req_builder.query(
6063                &local_var_str
6064                    .into_iter()
6065                    .map(|p| ("pp_info__iew".to_owned(), p.to_string()))
6066                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6067            ),
6068            _ => local_var_req_builder.query(&[(
6069                "pp_info__iew",
6070                &local_var_str
6071                    .into_iter()
6072                    .map(|p| p.to_string())
6073                    .collect::<Vec<String>>()
6074                    .join(",")
6075                    .to_string(),
6076            )]),
6077        };
6078    }
6079    if let Some(ref local_var_str) = pp_info__iregex {
6080        local_var_req_builder = match "multi" {
6081            "multi" => local_var_req_builder.query(
6082                &local_var_str
6083                    .into_iter()
6084                    .map(|p| ("pp_info__iregex".to_owned(), p.to_string()))
6085                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6086            ),
6087            _ => local_var_req_builder.query(&[(
6088                "pp_info__iregex",
6089                &local_var_str
6090                    .into_iter()
6091                    .map(|p| p.to_string())
6092                    .collect::<Vec<String>>()
6093                    .join(",")
6094                    .to_string(),
6095            )]),
6096        };
6097    }
6098    if let Some(ref local_var_str) = pp_info__isw {
6099        local_var_req_builder = match "multi" {
6100            "multi" => local_var_req_builder.query(
6101                &local_var_str
6102                    .into_iter()
6103                    .map(|p| ("pp_info__isw".to_owned(), p.to_string()))
6104                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6105            ),
6106            _ => local_var_req_builder.query(&[(
6107                "pp_info__isw",
6108                &local_var_str
6109                    .into_iter()
6110                    .map(|p| p.to_string())
6111                    .collect::<Vec<String>>()
6112                    .join(",")
6113                    .to_string(),
6114            )]),
6115        };
6116    }
6117    if let Some(ref local_var_str) = pp_info__n {
6118        local_var_req_builder = match "multi" {
6119            "multi" => local_var_req_builder.query(
6120                &local_var_str
6121                    .into_iter()
6122                    .map(|p| ("pp_info__n".to_owned(), p.to_string()))
6123                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6124            ),
6125            _ => local_var_req_builder.query(&[(
6126                "pp_info__n",
6127                &local_var_str
6128                    .into_iter()
6129                    .map(|p| p.to_string())
6130                    .collect::<Vec<String>>()
6131                    .join(",")
6132                    .to_string(),
6133            )]),
6134        };
6135    }
6136    if let Some(ref local_var_str) = pp_info__nic {
6137        local_var_req_builder = match "multi" {
6138            "multi" => local_var_req_builder.query(
6139                &local_var_str
6140                    .into_iter()
6141                    .map(|p| ("pp_info__nic".to_owned(), p.to_string()))
6142                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6143            ),
6144            _ => local_var_req_builder.query(&[(
6145                "pp_info__nic",
6146                &local_var_str
6147                    .into_iter()
6148                    .map(|p| p.to_string())
6149                    .collect::<Vec<String>>()
6150                    .join(",")
6151                    .to_string(),
6152            )]),
6153        };
6154    }
6155    if let Some(ref local_var_str) = pp_info__nie {
6156        local_var_req_builder = match "multi" {
6157            "multi" => local_var_req_builder.query(
6158                &local_var_str
6159                    .into_iter()
6160                    .map(|p| ("pp_info__nie".to_owned(), p.to_string()))
6161                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6162            ),
6163            _ => local_var_req_builder.query(&[(
6164                "pp_info__nie",
6165                &local_var_str
6166                    .into_iter()
6167                    .map(|p| p.to_string())
6168                    .collect::<Vec<String>>()
6169                    .join(",")
6170                    .to_string(),
6171            )]),
6172        };
6173    }
6174    if let Some(ref local_var_str) = pp_info__niew {
6175        local_var_req_builder = match "multi" {
6176            "multi" => local_var_req_builder.query(
6177                &local_var_str
6178                    .into_iter()
6179                    .map(|p| ("pp_info__niew".to_owned(), p.to_string()))
6180                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6181            ),
6182            _ => local_var_req_builder.query(&[(
6183                "pp_info__niew",
6184                &local_var_str
6185                    .into_iter()
6186                    .map(|p| p.to_string())
6187                    .collect::<Vec<String>>()
6188                    .join(",")
6189                    .to_string(),
6190            )]),
6191        };
6192    }
6193    if let Some(ref local_var_str) = pp_info__nisw {
6194        local_var_req_builder = match "multi" {
6195            "multi" => local_var_req_builder.query(
6196                &local_var_str
6197                    .into_iter()
6198                    .map(|p| ("pp_info__nisw".to_owned(), p.to_string()))
6199                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6200            ),
6201            _ => local_var_req_builder.query(&[(
6202                "pp_info__nisw",
6203                &local_var_str
6204                    .into_iter()
6205                    .map(|p| p.to_string())
6206                    .collect::<Vec<String>>()
6207                    .join(",")
6208                    .to_string(),
6209            )]),
6210        };
6211    }
6212    if let Some(ref local_var_str) = pp_info__regex {
6213        local_var_req_builder = match "multi" {
6214            "multi" => local_var_req_builder.query(
6215                &local_var_str
6216                    .into_iter()
6217                    .map(|p| ("pp_info__regex".to_owned(), p.to_string()))
6218                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6219            ),
6220            _ => local_var_req_builder.query(&[(
6221                "pp_info__regex",
6222                &local_var_str
6223                    .into_iter()
6224                    .map(|p| p.to_string())
6225                    .collect::<Vec<String>>()
6226                    .join(",")
6227                    .to_string(),
6228            )]),
6229        };
6230    }
6231    if let Some(ref local_var_str) = provider {
6232        local_var_req_builder = match "multi" {
6233            "multi" => local_var_req_builder.query(
6234                &local_var_str
6235                    .into_iter()
6236                    .map(|p| ("provider".to_owned(), p.to_string()))
6237                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6238            ),
6239            _ => local_var_req_builder.query(&[(
6240                "provider",
6241                &local_var_str
6242                    .into_iter()
6243                    .map(|p| p.to_string())
6244                    .collect::<Vec<String>>()
6245                    .join(",")
6246                    .to_string(),
6247            )]),
6248        };
6249    }
6250    if let Some(ref local_var_str) = provider__n {
6251        local_var_req_builder = match "multi" {
6252            "multi" => local_var_req_builder.query(
6253                &local_var_str
6254                    .into_iter()
6255                    .map(|p| ("provider__n".to_owned(), p.to_string()))
6256                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6257            ),
6258            _ => local_var_req_builder.query(&[(
6259                "provider__n",
6260                &local_var_str
6261                    .into_iter()
6262                    .map(|p| p.to_string())
6263                    .collect::<Vec<String>>()
6264                    .join(",")
6265                    .to_string(),
6266            )]),
6267        };
6268    }
6269    if let Some(ref local_var_str) = provider_id {
6270        local_var_req_builder = match "multi" {
6271            "multi" => local_var_req_builder.query(
6272                &local_var_str
6273                    .into_iter()
6274                    .map(|p| ("provider_id".to_owned(), p.to_string()))
6275                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6276            ),
6277            _ => local_var_req_builder.query(&[(
6278                "provider_id",
6279                &local_var_str
6280                    .into_iter()
6281                    .map(|p| p.to_string())
6282                    .collect::<Vec<String>>()
6283                    .join(",")
6284                    .to_string(),
6285            )]),
6286        };
6287    }
6288    if let Some(ref local_var_str) = provider_id__n {
6289        local_var_req_builder = match "multi" {
6290            "multi" => local_var_req_builder.query(
6291                &local_var_str
6292                    .into_iter()
6293                    .map(|p| ("provider_id__n".to_owned(), p.to_string()))
6294                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6295            ),
6296            _ => local_var_req_builder.query(&[(
6297                "provider_id__n",
6298                &local_var_str
6299                    .into_iter()
6300                    .map(|p| p.to_string())
6301                    .collect::<Vec<String>>()
6302                    .join(",")
6303                    .to_string(),
6304            )]),
6305        };
6306    }
6307    if let Some(ref local_var_str) = provider_network_id {
6308        local_var_req_builder = match "multi" {
6309            "multi" => local_var_req_builder.query(
6310                &local_var_str
6311                    .into_iter()
6312                    .map(|p| ("provider_network_id".to_owned(), p.to_string()))
6313                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6314            ),
6315            _ => local_var_req_builder.query(&[(
6316                "provider_network_id",
6317                &local_var_str
6318                    .into_iter()
6319                    .map(|p| p.to_string())
6320                    .collect::<Vec<String>>()
6321                    .join(",")
6322                    .to_string(),
6323            )]),
6324        };
6325    }
6326    if let Some(ref local_var_str) = provider_network_id__n {
6327        local_var_req_builder = match "multi" {
6328            "multi" => local_var_req_builder.query(
6329                &local_var_str
6330                    .into_iter()
6331                    .map(|p| ("provider_network_id__n".to_owned(), p.to_string()))
6332                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6333            ),
6334            _ => local_var_req_builder.query(&[(
6335                "provider_network_id__n",
6336                &local_var_str
6337                    .into_iter()
6338                    .map(|p| p.to_string())
6339                    .collect::<Vec<String>>()
6340                    .join(",")
6341                    .to_string(),
6342            )]),
6343        };
6344    }
6345    if let Some(ref local_var_str) = q {
6346        local_var_req_builder = local_var_req_builder.query(&[("q", &local_var_str.to_string())]);
6347    }
6348    if let Some(ref local_var_str) = region {
6349        local_var_req_builder = match "multi" {
6350            "multi" => local_var_req_builder.query(
6351                &local_var_str
6352                    .into_iter()
6353                    .map(|p| ("region".to_owned(), p.to_string()))
6354                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6355            ),
6356            _ => local_var_req_builder.query(&[(
6357                "region",
6358                &local_var_str
6359                    .into_iter()
6360                    .map(|p| p.to_string())
6361                    .collect::<Vec<String>>()
6362                    .join(",")
6363                    .to_string(),
6364            )]),
6365        };
6366    }
6367    if let Some(ref local_var_str) = region__n {
6368        local_var_req_builder = match "multi" {
6369            "multi" => local_var_req_builder.query(
6370                &local_var_str
6371                    .into_iter()
6372                    .map(|p| ("region__n".to_owned(), p.to_string()))
6373                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6374            ),
6375            _ => local_var_req_builder.query(&[(
6376                "region__n",
6377                &local_var_str
6378                    .into_iter()
6379                    .map(|p| p.to_string())
6380                    .collect::<Vec<String>>()
6381                    .join(",")
6382                    .to_string(),
6383            )]),
6384        };
6385    }
6386    if let Some(ref local_var_str) = region_id {
6387        local_var_req_builder = match "multi" {
6388            "multi" => local_var_req_builder.query(
6389                &local_var_str
6390                    .into_iter()
6391                    .map(|p| ("region_id".to_owned(), p.to_string()))
6392                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6393            ),
6394            _ => local_var_req_builder.query(&[(
6395                "region_id",
6396                &local_var_str
6397                    .into_iter()
6398                    .map(|p| p.to_string())
6399                    .collect::<Vec<String>>()
6400                    .join(",")
6401                    .to_string(),
6402            )]),
6403        };
6404    }
6405    if let Some(ref local_var_str) = region_id__n {
6406        local_var_req_builder = match "multi" {
6407            "multi" => local_var_req_builder.query(
6408                &local_var_str
6409                    .into_iter()
6410                    .map(|p| ("region_id__n".to_owned(), p.to_string()))
6411                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6412            ),
6413            _ => local_var_req_builder.query(&[(
6414                "region_id__n",
6415                &local_var_str
6416                    .into_iter()
6417                    .map(|p| p.to_string())
6418                    .collect::<Vec<String>>()
6419                    .join(",")
6420                    .to_string(),
6421            )]),
6422        };
6423    }
6424    if let Some(ref local_var_str) = site {
6425        local_var_req_builder = match "multi" {
6426            "multi" => local_var_req_builder.query(
6427                &local_var_str
6428                    .into_iter()
6429                    .map(|p| ("site".to_owned(), p.to_string()))
6430                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6431            ),
6432            _ => local_var_req_builder.query(&[(
6433                "site",
6434                &local_var_str
6435                    .into_iter()
6436                    .map(|p| p.to_string())
6437                    .collect::<Vec<String>>()
6438                    .join(",")
6439                    .to_string(),
6440            )]),
6441        };
6442    }
6443    if let Some(ref local_var_str) = site__n {
6444        local_var_req_builder = match "multi" {
6445            "multi" => local_var_req_builder.query(
6446                &local_var_str
6447                    .into_iter()
6448                    .map(|p| ("site__n".to_owned(), p.to_string()))
6449                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6450            ),
6451            _ => local_var_req_builder.query(&[(
6452                "site__n",
6453                &local_var_str
6454                    .into_iter()
6455                    .map(|p| p.to_string())
6456                    .collect::<Vec<String>>()
6457                    .join(",")
6458                    .to_string(),
6459            )]),
6460        };
6461    }
6462    if let Some(ref local_var_str) = site_group {
6463        local_var_req_builder = match "multi" {
6464            "multi" => local_var_req_builder.query(
6465                &local_var_str
6466                    .into_iter()
6467                    .map(|p| ("site_group".to_owned(), p.to_string()))
6468                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6469            ),
6470            _ => local_var_req_builder.query(&[(
6471                "site_group",
6472                &local_var_str
6473                    .into_iter()
6474                    .map(|p| p.to_string())
6475                    .collect::<Vec<String>>()
6476                    .join(",")
6477                    .to_string(),
6478            )]),
6479        };
6480    }
6481    if let Some(ref local_var_str) = site_group__n {
6482        local_var_req_builder = match "multi" {
6483            "multi" => local_var_req_builder.query(
6484                &local_var_str
6485                    .into_iter()
6486                    .map(|p| ("site_group__n".to_owned(), p.to_string()))
6487                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6488            ),
6489            _ => local_var_req_builder.query(&[(
6490                "site_group__n",
6491                &local_var_str
6492                    .into_iter()
6493                    .map(|p| p.to_string())
6494                    .collect::<Vec<String>>()
6495                    .join(",")
6496                    .to_string(),
6497            )]),
6498        };
6499    }
6500    if let Some(ref local_var_str) = site_group_id {
6501        local_var_req_builder = match "multi" {
6502            "multi" => local_var_req_builder.query(
6503                &local_var_str
6504                    .into_iter()
6505                    .map(|p| ("site_group_id".to_owned(), p.to_string()))
6506                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6507            ),
6508            _ => local_var_req_builder.query(&[(
6509                "site_group_id",
6510                &local_var_str
6511                    .into_iter()
6512                    .map(|p| p.to_string())
6513                    .collect::<Vec<String>>()
6514                    .join(",")
6515                    .to_string(),
6516            )]),
6517        };
6518    }
6519    if let Some(ref local_var_str) = site_group_id__n {
6520        local_var_req_builder = match "multi" {
6521            "multi" => local_var_req_builder.query(
6522                &local_var_str
6523                    .into_iter()
6524                    .map(|p| ("site_group_id__n".to_owned(), p.to_string()))
6525                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6526            ),
6527            _ => local_var_req_builder.query(&[(
6528                "site_group_id__n",
6529                &local_var_str
6530                    .into_iter()
6531                    .map(|p| p.to_string())
6532                    .collect::<Vec<String>>()
6533                    .join(",")
6534                    .to_string(),
6535            )]),
6536        };
6537    }
6538    if let Some(ref local_var_str) = site_id {
6539        local_var_req_builder = match "multi" {
6540            "multi" => local_var_req_builder.query(
6541                &local_var_str
6542                    .into_iter()
6543                    .map(|p| ("site_id".to_owned(), p.to_string()))
6544                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6545            ),
6546            _ => local_var_req_builder.query(&[(
6547                "site_id",
6548                &local_var_str
6549                    .into_iter()
6550                    .map(|p| p.to_string())
6551                    .collect::<Vec<String>>()
6552                    .join(",")
6553                    .to_string(),
6554            )]),
6555        };
6556    }
6557    if let Some(ref local_var_str) = site_id__n {
6558        local_var_req_builder = match "multi" {
6559            "multi" => local_var_req_builder.query(
6560                &local_var_str
6561                    .into_iter()
6562                    .map(|p| ("site_id__n".to_owned(), p.to_string()))
6563                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6564            ),
6565            _ => local_var_req_builder.query(&[(
6566                "site_id__n",
6567                &local_var_str
6568                    .into_iter()
6569                    .map(|p| p.to_string())
6570                    .collect::<Vec<String>>()
6571                    .join(",")
6572                    .to_string(),
6573            )]),
6574        };
6575    }
6576    if let Some(ref local_var_str) = start {
6577        local_var_req_builder =
6578            local_var_req_builder.query(&[("start", &local_var_str.to_string())]);
6579    }
6580    if let Some(ref local_var_str) = tag {
6581        local_var_req_builder = match "multi" {
6582            "multi" => local_var_req_builder.query(
6583                &local_var_str
6584                    .into_iter()
6585                    .map(|p| ("tag".to_owned(), p.to_string()))
6586                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6587            ),
6588            _ => local_var_req_builder.query(&[(
6589                "tag",
6590                &local_var_str
6591                    .into_iter()
6592                    .map(|p| p.to_string())
6593                    .collect::<Vec<String>>()
6594                    .join(",")
6595                    .to_string(),
6596            )]),
6597        };
6598    }
6599    if let Some(ref local_var_str) = tag__n {
6600        local_var_req_builder = match "multi" {
6601            "multi" => local_var_req_builder.query(
6602                &local_var_str
6603                    .into_iter()
6604                    .map(|p| ("tag__n".to_owned(), p.to_string()))
6605                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6606            ),
6607            _ => local_var_req_builder.query(&[(
6608                "tag__n",
6609                &local_var_str
6610                    .into_iter()
6611                    .map(|p| p.to_string())
6612                    .collect::<Vec<String>>()
6613                    .join(",")
6614                    .to_string(),
6615            )]),
6616        };
6617    }
6618    if let Some(ref local_var_str) = tag_id {
6619        local_var_req_builder = match "multi" {
6620            "multi" => local_var_req_builder.query(
6621                &local_var_str
6622                    .into_iter()
6623                    .map(|p| ("tag_id".to_owned(), p.to_string()))
6624                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6625            ),
6626            _ => local_var_req_builder.query(&[(
6627                "tag_id",
6628                &local_var_str
6629                    .into_iter()
6630                    .map(|p| p.to_string())
6631                    .collect::<Vec<String>>()
6632                    .join(",")
6633                    .to_string(),
6634            )]),
6635        };
6636    }
6637    if let Some(ref local_var_str) = tag_id__n {
6638        local_var_req_builder = match "multi" {
6639            "multi" => local_var_req_builder.query(
6640                &local_var_str
6641                    .into_iter()
6642                    .map(|p| ("tag_id__n".to_owned(), p.to_string()))
6643                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6644            ),
6645            _ => local_var_req_builder.query(&[(
6646                "tag_id__n",
6647                &local_var_str
6648                    .into_iter()
6649                    .map(|p| p.to_string())
6650                    .collect::<Vec<String>>()
6651                    .join(",")
6652                    .to_string(),
6653            )]),
6654        };
6655    }
6656    if let Some(ref local_var_str) = term_side {
6657        local_var_req_builder =
6658            local_var_req_builder.query(&[("term_side", &local_var_str.to_string())]);
6659    }
6660    if let Some(ref local_var_str) = term_side__empty {
6661        local_var_req_builder =
6662            local_var_req_builder.query(&[("term_side__empty", &local_var_str.to_string())]);
6663    }
6664    if let Some(ref local_var_str) = term_side__ic {
6665        local_var_req_builder = match "multi" {
6666            "multi" => local_var_req_builder.query(
6667                &local_var_str
6668                    .into_iter()
6669                    .map(|p| ("term_side__ic".to_owned(), p.to_string()))
6670                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6671            ),
6672            _ => local_var_req_builder.query(&[(
6673                "term_side__ic",
6674                &local_var_str
6675                    .into_iter()
6676                    .map(|p| p.to_string())
6677                    .collect::<Vec<String>>()
6678                    .join(",")
6679                    .to_string(),
6680            )]),
6681        };
6682    }
6683    if let Some(ref local_var_str) = term_side__ie {
6684        local_var_req_builder = match "multi" {
6685            "multi" => local_var_req_builder.query(
6686                &local_var_str
6687                    .into_iter()
6688                    .map(|p| ("term_side__ie".to_owned(), p.to_string()))
6689                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6690            ),
6691            _ => local_var_req_builder.query(&[(
6692                "term_side__ie",
6693                &local_var_str
6694                    .into_iter()
6695                    .map(|p| p.to_string())
6696                    .collect::<Vec<String>>()
6697                    .join(",")
6698                    .to_string(),
6699            )]),
6700        };
6701    }
6702    if let Some(ref local_var_str) = term_side__iew {
6703        local_var_req_builder = match "multi" {
6704            "multi" => local_var_req_builder.query(
6705                &local_var_str
6706                    .into_iter()
6707                    .map(|p| ("term_side__iew".to_owned(), p.to_string()))
6708                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6709            ),
6710            _ => local_var_req_builder.query(&[(
6711                "term_side__iew",
6712                &local_var_str
6713                    .into_iter()
6714                    .map(|p| p.to_string())
6715                    .collect::<Vec<String>>()
6716                    .join(",")
6717                    .to_string(),
6718            )]),
6719        };
6720    }
6721    if let Some(ref local_var_str) = term_side__iregex {
6722        local_var_req_builder = match "multi" {
6723            "multi" => local_var_req_builder.query(
6724                &local_var_str
6725                    .into_iter()
6726                    .map(|p| ("term_side__iregex".to_owned(), p.to_string()))
6727                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6728            ),
6729            _ => local_var_req_builder.query(&[(
6730                "term_side__iregex",
6731                &local_var_str
6732                    .into_iter()
6733                    .map(|p| p.to_string())
6734                    .collect::<Vec<String>>()
6735                    .join(",")
6736                    .to_string(),
6737            )]),
6738        };
6739    }
6740    if let Some(ref local_var_str) = term_side__isw {
6741        local_var_req_builder = match "multi" {
6742            "multi" => local_var_req_builder.query(
6743                &local_var_str
6744                    .into_iter()
6745                    .map(|p| ("term_side__isw".to_owned(), p.to_string()))
6746                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6747            ),
6748            _ => local_var_req_builder.query(&[(
6749                "term_side__isw",
6750                &local_var_str
6751                    .into_iter()
6752                    .map(|p| p.to_string())
6753                    .collect::<Vec<String>>()
6754                    .join(",")
6755                    .to_string(),
6756            )]),
6757        };
6758    }
6759    if let Some(ref local_var_str) = term_side__n {
6760        local_var_req_builder =
6761            local_var_req_builder.query(&[("term_side__n", &local_var_str.to_string())]);
6762    }
6763    if let Some(ref local_var_str) = term_side__nic {
6764        local_var_req_builder = match "multi" {
6765            "multi" => local_var_req_builder.query(
6766                &local_var_str
6767                    .into_iter()
6768                    .map(|p| ("term_side__nic".to_owned(), p.to_string()))
6769                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6770            ),
6771            _ => local_var_req_builder.query(&[(
6772                "term_side__nic",
6773                &local_var_str
6774                    .into_iter()
6775                    .map(|p| p.to_string())
6776                    .collect::<Vec<String>>()
6777                    .join(",")
6778                    .to_string(),
6779            )]),
6780        };
6781    }
6782    if let Some(ref local_var_str) = term_side__nie {
6783        local_var_req_builder = match "multi" {
6784            "multi" => local_var_req_builder.query(
6785                &local_var_str
6786                    .into_iter()
6787                    .map(|p| ("term_side__nie".to_owned(), p.to_string()))
6788                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6789            ),
6790            _ => local_var_req_builder.query(&[(
6791                "term_side__nie",
6792                &local_var_str
6793                    .into_iter()
6794                    .map(|p| p.to_string())
6795                    .collect::<Vec<String>>()
6796                    .join(",")
6797                    .to_string(),
6798            )]),
6799        };
6800    }
6801    if let Some(ref local_var_str) = term_side__niew {
6802        local_var_req_builder = match "multi" {
6803            "multi" => local_var_req_builder.query(
6804                &local_var_str
6805                    .into_iter()
6806                    .map(|p| ("term_side__niew".to_owned(), p.to_string()))
6807                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6808            ),
6809            _ => local_var_req_builder.query(&[(
6810                "term_side__niew",
6811                &local_var_str
6812                    .into_iter()
6813                    .map(|p| p.to_string())
6814                    .collect::<Vec<String>>()
6815                    .join(",")
6816                    .to_string(),
6817            )]),
6818        };
6819    }
6820    if let Some(ref local_var_str) = term_side__nisw {
6821        local_var_req_builder = match "multi" {
6822            "multi" => local_var_req_builder.query(
6823                &local_var_str
6824                    .into_iter()
6825                    .map(|p| ("term_side__nisw".to_owned(), p.to_string()))
6826                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6827            ),
6828            _ => local_var_req_builder.query(&[(
6829                "term_side__nisw",
6830                &local_var_str
6831                    .into_iter()
6832                    .map(|p| p.to_string())
6833                    .collect::<Vec<String>>()
6834                    .join(",")
6835                    .to_string(),
6836            )]),
6837        };
6838    }
6839    if let Some(ref local_var_str) = term_side__regex {
6840        local_var_req_builder = match "multi" {
6841            "multi" => local_var_req_builder.query(
6842                &local_var_str
6843                    .into_iter()
6844                    .map(|p| ("term_side__regex".to_owned(), p.to_string()))
6845                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6846            ),
6847            _ => local_var_req_builder.query(&[(
6848                "term_side__regex",
6849                &local_var_str
6850                    .into_iter()
6851                    .map(|p| p.to_string())
6852                    .collect::<Vec<String>>()
6853                    .join(",")
6854                    .to_string(),
6855            )]),
6856        };
6857    }
6858    if let Some(ref local_var_str) = termination_id {
6859        local_var_req_builder = match "multi" {
6860            "multi" => local_var_req_builder.query(
6861                &local_var_str
6862                    .into_iter()
6863                    .map(|p| ("termination_id".to_owned(), p.to_string()))
6864                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6865            ),
6866            _ => local_var_req_builder.query(&[(
6867                "termination_id",
6868                &local_var_str
6869                    .into_iter()
6870                    .map(|p| p.to_string())
6871                    .collect::<Vec<String>>()
6872                    .join(",")
6873                    .to_string(),
6874            )]),
6875        };
6876    }
6877    if let Some(ref local_var_str) = termination_id__empty {
6878        local_var_req_builder =
6879            local_var_req_builder.query(&[("termination_id__empty", &local_var_str.to_string())]);
6880    }
6881    if let Some(ref local_var_str) = termination_id__gt {
6882        local_var_req_builder = match "multi" {
6883            "multi" => local_var_req_builder.query(
6884                &local_var_str
6885                    .into_iter()
6886                    .map(|p| ("termination_id__gt".to_owned(), p.to_string()))
6887                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6888            ),
6889            _ => local_var_req_builder.query(&[(
6890                "termination_id__gt",
6891                &local_var_str
6892                    .into_iter()
6893                    .map(|p| p.to_string())
6894                    .collect::<Vec<String>>()
6895                    .join(",")
6896                    .to_string(),
6897            )]),
6898        };
6899    }
6900    if let Some(ref local_var_str) = termination_id__gte {
6901        local_var_req_builder = match "multi" {
6902            "multi" => local_var_req_builder.query(
6903                &local_var_str
6904                    .into_iter()
6905                    .map(|p| ("termination_id__gte".to_owned(), p.to_string()))
6906                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6907            ),
6908            _ => local_var_req_builder.query(&[(
6909                "termination_id__gte",
6910                &local_var_str
6911                    .into_iter()
6912                    .map(|p| p.to_string())
6913                    .collect::<Vec<String>>()
6914                    .join(",")
6915                    .to_string(),
6916            )]),
6917        };
6918    }
6919    if let Some(ref local_var_str) = termination_id__lt {
6920        local_var_req_builder = match "multi" {
6921            "multi" => local_var_req_builder.query(
6922                &local_var_str
6923                    .into_iter()
6924                    .map(|p| ("termination_id__lt".to_owned(), p.to_string()))
6925                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6926            ),
6927            _ => local_var_req_builder.query(&[(
6928                "termination_id__lt",
6929                &local_var_str
6930                    .into_iter()
6931                    .map(|p| p.to_string())
6932                    .collect::<Vec<String>>()
6933                    .join(",")
6934                    .to_string(),
6935            )]),
6936        };
6937    }
6938    if let Some(ref local_var_str) = termination_id__lte {
6939        local_var_req_builder = match "multi" {
6940            "multi" => local_var_req_builder.query(
6941                &local_var_str
6942                    .into_iter()
6943                    .map(|p| ("termination_id__lte".to_owned(), p.to_string()))
6944                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6945            ),
6946            _ => local_var_req_builder.query(&[(
6947                "termination_id__lte",
6948                &local_var_str
6949                    .into_iter()
6950                    .map(|p| p.to_string())
6951                    .collect::<Vec<String>>()
6952                    .join(",")
6953                    .to_string(),
6954            )]),
6955        };
6956    }
6957    if let Some(ref local_var_str) = termination_id__n {
6958        local_var_req_builder = match "multi" {
6959            "multi" => local_var_req_builder.query(
6960                &local_var_str
6961                    .into_iter()
6962                    .map(|p| ("termination_id__n".to_owned(), p.to_string()))
6963                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6964            ),
6965            _ => local_var_req_builder.query(&[(
6966                "termination_id__n",
6967                &local_var_str
6968                    .into_iter()
6969                    .map(|p| p.to_string())
6970                    .collect::<Vec<String>>()
6971                    .join(",")
6972                    .to_string(),
6973            )]),
6974        };
6975    }
6976    if let Some(ref local_var_str) = termination_type {
6977        local_var_req_builder = match "multi" {
6978            "multi" => local_var_req_builder.query(
6979                &local_var_str
6980                    .into_iter()
6981                    .map(|p| ("termination_type".to_owned(), p.to_string()))
6982                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6983            ),
6984            _ => local_var_req_builder.query(&[(
6985                "termination_type",
6986                &local_var_str
6987                    .into_iter()
6988                    .map(|p| p.to_string())
6989                    .collect::<Vec<String>>()
6990                    .join(",")
6991                    .to_string(),
6992            )]),
6993        };
6994    }
6995    if let Some(ref local_var_str) = termination_type__n {
6996        local_var_req_builder = match "multi" {
6997            "multi" => local_var_req_builder.query(
6998                &local_var_str
6999                    .into_iter()
7000                    .map(|p| ("termination_type__n".to_owned(), p.to_string()))
7001                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7002            ),
7003            _ => local_var_req_builder.query(&[(
7004                "termination_type__n",
7005                &local_var_str
7006                    .into_iter()
7007                    .map(|p| p.to_string())
7008                    .collect::<Vec<String>>()
7009                    .join(",")
7010                    .to_string(),
7011            )]),
7012        };
7013    }
7014    if let Some(ref local_var_str) = updated_by_request {
7015        local_var_req_builder =
7016            local_var_req_builder.query(&[("updated_by_request", &local_var_str.to_string())]);
7017    }
7018    if let Some(ref local_var_str) = upstream_speed {
7019        local_var_req_builder = match "multi" {
7020            "multi" => local_var_req_builder.query(
7021                &local_var_str
7022                    .into_iter()
7023                    .map(|p| ("upstream_speed".to_owned(), p.to_string()))
7024                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7025            ),
7026            _ => local_var_req_builder.query(&[(
7027                "upstream_speed",
7028                &local_var_str
7029                    .into_iter()
7030                    .map(|p| p.to_string())
7031                    .collect::<Vec<String>>()
7032                    .join(",")
7033                    .to_string(),
7034            )]),
7035        };
7036    }
7037    if let Some(ref local_var_str) = upstream_speed__empty {
7038        local_var_req_builder =
7039            local_var_req_builder.query(&[("upstream_speed__empty", &local_var_str.to_string())]);
7040    }
7041    if let Some(ref local_var_str) = upstream_speed__gt {
7042        local_var_req_builder = match "multi" {
7043            "multi" => local_var_req_builder.query(
7044                &local_var_str
7045                    .into_iter()
7046                    .map(|p| ("upstream_speed__gt".to_owned(), p.to_string()))
7047                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7048            ),
7049            _ => local_var_req_builder.query(&[(
7050                "upstream_speed__gt",
7051                &local_var_str
7052                    .into_iter()
7053                    .map(|p| p.to_string())
7054                    .collect::<Vec<String>>()
7055                    .join(",")
7056                    .to_string(),
7057            )]),
7058        };
7059    }
7060    if let Some(ref local_var_str) = upstream_speed__gte {
7061        local_var_req_builder = match "multi" {
7062            "multi" => local_var_req_builder.query(
7063                &local_var_str
7064                    .into_iter()
7065                    .map(|p| ("upstream_speed__gte".to_owned(), p.to_string()))
7066                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7067            ),
7068            _ => local_var_req_builder.query(&[(
7069                "upstream_speed__gte",
7070                &local_var_str
7071                    .into_iter()
7072                    .map(|p| p.to_string())
7073                    .collect::<Vec<String>>()
7074                    .join(",")
7075                    .to_string(),
7076            )]),
7077        };
7078    }
7079    if let Some(ref local_var_str) = upstream_speed__lt {
7080        local_var_req_builder = match "multi" {
7081            "multi" => local_var_req_builder.query(
7082                &local_var_str
7083                    .into_iter()
7084                    .map(|p| ("upstream_speed__lt".to_owned(), p.to_string()))
7085                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7086            ),
7087            _ => local_var_req_builder.query(&[(
7088                "upstream_speed__lt",
7089                &local_var_str
7090                    .into_iter()
7091                    .map(|p| p.to_string())
7092                    .collect::<Vec<String>>()
7093                    .join(",")
7094                    .to_string(),
7095            )]),
7096        };
7097    }
7098    if let Some(ref local_var_str) = upstream_speed__lte {
7099        local_var_req_builder = match "multi" {
7100            "multi" => local_var_req_builder.query(
7101                &local_var_str
7102                    .into_iter()
7103                    .map(|p| ("upstream_speed__lte".to_owned(), p.to_string()))
7104                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7105            ),
7106            _ => local_var_req_builder.query(&[(
7107                "upstream_speed__lte",
7108                &local_var_str
7109                    .into_iter()
7110                    .map(|p| p.to_string())
7111                    .collect::<Vec<String>>()
7112                    .join(",")
7113                    .to_string(),
7114            )]),
7115        };
7116    }
7117    if let Some(ref local_var_str) = upstream_speed__n {
7118        local_var_req_builder = match "multi" {
7119            "multi" => local_var_req_builder.query(
7120                &local_var_str
7121                    .into_iter()
7122                    .map(|p| ("upstream_speed__n".to_owned(), p.to_string()))
7123                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7124            ),
7125            _ => local_var_req_builder.query(&[(
7126                "upstream_speed__n",
7127                &local_var_str
7128                    .into_iter()
7129                    .map(|p| p.to_string())
7130                    .collect::<Vec<String>>()
7131                    .join(",")
7132                    .to_string(),
7133            )]),
7134        };
7135    }
7136    if let Some(ref local_var_str) = xconnect_id {
7137        local_var_req_builder = match "multi" {
7138            "multi" => local_var_req_builder.query(
7139                &local_var_str
7140                    .into_iter()
7141                    .map(|p| ("xconnect_id".to_owned(), p.to_string()))
7142                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7143            ),
7144            _ => local_var_req_builder.query(&[(
7145                "xconnect_id",
7146                &local_var_str
7147                    .into_iter()
7148                    .map(|p| p.to_string())
7149                    .collect::<Vec<String>>()
7150                    .join(",")
7151                    .to_string(),
7152            )]),
7153        };
7154    }
7155    if let Some(ref local_var_str) = xconnect_id__empty {
7156        local_var_req_builder =
7157            local_var_req_builder.query(&[("xconnect_id__empty", &local_var_str.to_string())]);
7158    }
7159    if let Some(ref local_var_str) = xconnect_id__ic {
7160        local_var_req_builder = match "multi" {
7161            "multi" => local_var_req_builder.query(
7162                &local_var_str
7163                    .into_iter()
7164                    .map(|p| ("xconnect_id__ic".to_owned(), p.to_string()))
7165                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7166            ),
7167            _ => local_var_req_builder.query(&[(
7168                "xconnect_id__ic",
7169                &local_var_str
7170                    .into_iter()
7171                    .map(|p| p.to_string())
7172                    .collect::<Vec<String>>()
7173                    .join(",")
7174                    .to_string(),
7175            )]),
7176        };
7177    }
7178    if let Some(ref local_var_str) = xconnect_id__ie {
7179        local_var_req_builder = match "multi" {
7180            "multi" => local_var_req_builder.query(
7181                &local_var_str
7182                    .into_iter()
7183                    .map(|p| ("xconnect_id__ie".to_owned(), p.to_string()))
7184                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7185            ),
7186            _ => local_var_req_builder.query(&[(
7187                "xconnect_id__ie",
7188                &local_var_str
7189                    .into_iter()
7190                    .map(|p| p.to_string())
7191                    .collect::<Vec<String>>()
7192                    .join(",")
7193                    .to_string(),
7194            )]),
7195        };
7196    }
7197    if let Some(ref local_var_str) = xconnect_id__iew {
7198        local_var_req_builder = match "multi" {
7199            "multi" => local_var_req_builder.query(
7200                &local_var_str
7201                    .into_iter()
7202                    .map(|p| ("xconnect_id__iew".to_owned(), p.to_string()))
7203                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7204            ),
7205            _ => local_var_req_builder.query(&[(
7206                "xconnect_id__iew",
7207                &local_var_str
7208                    .into_iter()
7209                    .map(|p| p.to_string())
7210                    .collect::<Vec<String>>()
7211                    .join(",")
7212                    .to_string(),
7213            )]),
7214        };
7215    }
7216    if let Some(ref local_var_str) = xconnect_id__iregex {
7217        local_var_req_builder = match "multi" {
7218            "multi" => local_var_req_builder.query(
7219                &local_var_str
7220                    .into_iter()
7221                    .map(|p| ("xconnect_id__iregex".to_owned(), p.to_string()))
7222                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7223            ),
7224            _ => local_var_req_builder.query(&[(
7225                "xconnect_id__iregex",
7226                &local_var_str
7227                    .into_iter()
7228                    .map(|p| p.to_string())
7229                    .collect::<Vec<String>>()
7230                    .join(",")
7231                    .to_string(),
7232            )]),
7233        };
7234    }
7235    if let Some(ref local_var_str) = xconnect_id__isw {
7236        local_var_req_builder = match "multi" {
7237            "multi" => local_var_req_builder.query(
7238                &local_var_str
7239                    .into_iter()
7240                    .map(|p| ("xconnect_id__isw".to_owned(), p.to_string()))
7241                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7242            ),
7243            _ => local_var_req_builder.query(&[(
7244                "xconnect_id__isw",
7245                &local_var_str
7246                    .into_iter()
7247                    .map(|p| p.to_string())
7248                    .collect::<Vec<String>>()
7249                    .join(",")
7250                    .to_string(),
7251            )]),
7252        };
7253    }
7254    if let Some(ref local_var_str) = xconnect_id__n {
7255        local_var_req_builder = match "multi" {
7256            "multi" => local_var_req_builder.query(
7257                &local_var_str
7258                    .into_iter()
7259                    .map(|p| ("xconnect_id__n".to_owned(), p.to_string()))
7260                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7261            ),
7262            _ => local_var_req_builder.query(&[(
7263                "xconnect_id__n",
7264                &local_var_str
7265                    .into_iter()
7266                    .map(|p| p.to_string())
7267                    .collect::<Vec<String>>()
7268                    .join(",")
7269                    .to_string(),
7270            )]),
7271        };
7272    }
7273    if let Some(ref local_var_str) = xconnect_id__nic {
7274        local_var_req_builder = match "multi" {
7275            "multi" => local_var_req_builder.query(
7276                &local_var_str
7277                    .into_iter()
7278                    .map(|p| ("xconnect_id__nic".to_owned(), p.to_string()))
7279                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7280            ),
7281            _ => local_var_req_builder.query(&[(
7282                "xconnect_id__nic",
7283                &local_var_str
7284                    .into_iter()
7285                    .map(|p| p.to_string())
7286                    .collect::<Vec<String>>()
7287                    .join(",")
7288                    .to_string(),
7289            )]),
7290        };
7291    }
7292    if let Some(ref local_var_str) = xconnect_id__nie {
7293        local_var_req_builder = match "multi" {
7294            "multi" => local_var_req_builder.query(
7295                &local_var_str
7296                    .into_iter()
7297                    .map(|p| ("xconnect_id__nie".to_owned(), p.to_string()))
7298                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7299            ),
7300            _ => local_var_req_builder.query(&[(
7301                "xconnect_id__nie",
7302                &local_var_str
7303                    .into_iter()
7304                    .map(|p| p.to_string())
7305                    .collect::<Vec<String>>()
7306                    .join(",")
7307                    .to_string(),
7308            )]),
7309        };
7310    }
7311    if let Some(ref local_var_str) = xconnect_id__niew {
7312        local_var_req_builder = match "multi" {
7313            "multi" => local_var_req_builder.query(
7314                &local_var_str
7315                    .into_iter()
7316                    .map(|p| ("xconnect_id__niew".to_owned(), p.to_string()))
7317                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7318            ),
7319            _ => local_var_req_builder.query(&[(
7320                "xconnect_id__niew",
7321                &local_var_str
7322                    .into_iter()
7323                    .map(|p| p.to_string())
7324                    .collect::<Vec<String>>()
7325                    .join(",")
7326                    .to_string(),
7327            )]),
7328        };
7329    }
7330    if let Some(ref local_var_str) = xconnect_id__nisw {
7331        local_var_req_builder = match "multi" {
7332            "multi" => local_var_req_builder.query(
7333                &local_var_str
7334                    .into_iter()
7335                    .map(|p| ("xconnect_id__nisw".to_owned(), p.to_string()))
7336                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7337            ),
7338            _ => local_var_req_builder.query(&[(
7339                "xconnect_id__nisw",
7340                &local_var_str
7341                    .into_iter()
7342                    .map(|p| p.to_string())
7343                    .collect::<Vec<String>>()
7344                    .join(",")
7345                    .to_string(),
7346            )]),
7347        };
7348    }
7349    if let Some(ref local_var_str) = xconnect_id__regex {
7350        local_var_req_builder = match "multi" {
7351            "multi" => local_var_req_builder.query(
7352                &local_var_str
7353                    .into_iter()
7354                    .map(|p| ("xconnect_id__regex".to_owned(), p.to_string()))
7355                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7356            ),
7357            _ => local_var_req_builder.query(&[(
7358                "xconnect_id__regex",
7359                &local_var_str
7360                    .into_iter()
7361                    .map(|p| p.to_string())
7362                    .collect::<Vec<String>>()
7363                    .join(",")
7364                    .to_string(),
7365            )]),
7366        };
7367    }
7368    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
7369        local_var_req_builder =
7370            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
7371    }
7372    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
7373        let local_var_key = local_var_apikey.key.clone();
7374        let local_var_value = match local_var_apikey.prefix {
7375            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
7376            None => local_var_key,
7377        };
7378        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
7379    };
7380
7381    let local_var_req = local_var_req_builder.build()?;
7382    let local_var_resp = local_var_client.execute(local_var_req).await?;
7383
7384    let local_var_status = local_var_resp.status();
7385    let local_var_content = local_var_resp.text().await?;
7386
7387    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
7388        serde_json::from_str(&local_var_content).map_err(Error::from)
7389    } else {
7390        let local_var_entity: Option<CircuitsCircuitTerminationsListError> =
7391            serde_json::from_str(&local_var_content).ok();
7392        let local_var_error = ResponseContent {
7393            status: local_var_status,
7394            content: local_var_content,
7395            entity: local_var_entity,
7396        };
7397        Err(Error::ResponseError(local_var_error))
7398    }
7399}
7400
7401/// Patch a circuit termination object.
7402pub async fn circuits_circuit_terminations_partial_update(
7403    configuration: &configuration::Configuration,
7404    id: i32,
7405    patched_circuit_termination_request: Option<crate::models::PatchedCircuitTerminationRequest>,
7406) -> Result<crate::models::CircuitTermination, Error<CircuitsCircuitTerminationsPartialUpdateError>>
7407{
7408    let local_var_configuration = configuration;
7409
7410    let local_var_client = &local_var_configuration.client;
7411
7412    let local_var_uri_str = format!(
7413        "{}/api/circuits/circuit-terminations/{id}/",
7414        local_var_configuration.base_path,
7415        id = id
7416    );
7417    let mut local_var_req_builder =
7418        local_var_client.request(reqwest::Method::PATCH, local_var_uri_str.as_str());
7419
7420    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
7421        local_var_req_builder =
7422            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
7423    }
7424    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
7425        let local_var_key = local_var_apikey.key.clone();
7426        let local_var_value = match local_var_apikey.prefix {
7427            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
7428            None => local_var_key,
7429        };
7430        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
7431    };
7432    local_var_req_builder = local_var_req_builder.json(&patched_circuit_termination_request);
7433
7434    let local_var_req = local_var_req_builder.build()?;
7435    let local_var_resp = local_var_client.execute(local_var_req).await?;
7436
7437    let local_var_status = local_var_resp.status();
7438    let local_var_content = local_var_resp.text().await?;
7439
7440    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
7441        serde_json::from_str(&local_var_content).map_err(Error::from)
7442    } else {
7443        let local_var_entity: Option<CircuitsCircuitTerminationsPartialUpdateError> =
7444            serde_json::from_str(&local_var_content).ok();
7445        let local_var_error = ResponseContent {
7446            status: local_var_status,
7447            content: local_var_content,
7448            entity: local_var_entity,
7449        };
7450        Err(Error::ResponseError(local_var_error))
7451    }
7452}
7453
7454/// Return all CablePaths which traverse a given pass-through port.
7455pub async fn circuits_circuit_terminations_paths_retrieve(
7456    configuration: &configuration::Configuration,
7457    id: i32,
7458) -> Result<crate::models::CircuitTermination, Error<CircuitsCircuitTerminationsPathsRetrieveError>>
7459{
7460    let local_var_configuration = configuration;
7461
7462    let local_var_client = &local_var_configuration.client;
7463
7464    let local_var_uri_str = format!(
7465        "{}/api/circuits/circuit-terminations/{id}/paths/",
7466        local_var_configuration.base_path,
7467        id = id
7468    );
7469    let mut local_var_req_builder =
7470        local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
7471
7472    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
7473        local_var_req_builder =
7474            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
7475    }
7476    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
7477        let local_var_key = local_var_apikey.key.clone();
7478        let local_var_value = match local_var_apikey.prefix {
7479            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
7480            None => local_var_key,
7481        };
7482        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
7483    };
7484
7485    let local_var_req = local_var_req_builder.build()?;
7486    let local_var_resp = local_var_client.execute(local_var_req).await?;
7487
7488    let local_var_status = local_var_resp.status();
7489    let local_var_content = local_var_resp.text().await?;
7490
7491    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
7492        serde_json::from_str(&local_var_content).map_err(Error::from)
7493    } else {
7494        let local_var_entity: Option<CircuitsCircuitTerminationsPathsRetrieveError> =
7495            serde_json::from_str(&local_var_content).ok();
7496        let local_var_error = ResponseContent {
7497            status: local_var_status,
7498            content: local_var_content,
7499            entity: local_var_entity,
7500        };
7501        Err(Error::ResponseError(local_var_error))
7502    }
7503}
7504
7505/// Get a circuit termination object.
7506pub async fn circuits_circuit_terminations_retrieve(
7507    configuration: &configuration::Configuration,
7508    id: i32,
7509) -> Result<crate::models::CircuitTermination, Error<CircuitsCircuitTerminationsRetrieveError>> {
7510    let local_var_configuration = configuration;
7511
7512    let local_var_client = &local_var_configuration.client;
7513
7514    let local_var_uri_str = format!(
7515        "{}/api/circuits/circuit-terminations/{id}/",
7516        local_var_configuration.base_path,
7517        id = id
7518    );
7519    let mut local_var_req_builder =
7520        local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
7521
7522    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
7523        local_var_req_builder =
7524            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
7525    }
7526    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
7527        let local_var_key = local_var_apikey.key.clone();
7528        let local_var_value = match local_var_apikey.prefix {
7529            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
7530            None => local_var_key,
7531        };
7532        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
7533    };
7534
7535    let local_var_req = local_var_req_builder.build()?;
7536    let local_var_resp = local_var_client.execute(local_var_req).await?;
7537
7538    let local_var_status = local_var_resp.status();
7539    let local_var_content = local_var_resp.text().await?;
7540
7541    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
7542        serde_json::from_str(&local_var_content).map_err(Error::from)
7543    } else {
7544        let local_var_entity: Option<CircuitsCircuitTerminationsRetrieveError> =
7545            serde_json::from_str(&local_var_content).ok();
7546        let local_var_error = ResponseContent {
7547            status: local_var_status,
7548            content: local_var_content,
7549            entity: local_var_entity,
7550        };
7551        Err(Error::ResponseError(local_var_error))
7552    }
7553}
7554
7555/// Put a circuit termination object.
7556pub async fn circuits_circuit_terminations_update(
7557    configuration: &configuration::Configuration,
7558    id: i32,
7559    circuit_termination_request: crate::models::CircuitTerminationRequest,
7560) -> Result<crate::models::CircuitTermination, Error<CircuitsCircuitTerminationsUpdateError>> {
7561    let local_var_configuration = configuration;
7562
7563    let local_var_client = &local_var_configuration.client;
7564
7565    let local_var_uri_str = format!(
7566        "{}/api/circuits/circuit-terminations/{id}/",
7567        local_var_configuration.base_path,
7568        id = id
7569    );
7570    let mut local_var_req_builder =
7571        local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());
7572
7573    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
7574        local_var_req_builder =
7575            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
7576    }
7577    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
7578        let local_var_key = local_var_apikey.key.clone();
7579        let local_var_value = match local_var_apikey.prefix {
7580            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
7581            None => local_var_key,
7582        };
7583        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
7584    };
7585    local_var_req_builder = local_var_req_builder.json(&circuit_termination_request);
7586
7587    let local_var_req = local_var_req_builder.build()?;
7588    let local_var_resp = local_var_client.execute(local_var_req).await?;
7589
7590    let local_var_status = local_var_resp.status();
7591    let local_var_content = local_var_resp.text().await?;
7592
7593    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
7594        serde_json::from_str(&local_var_content).map_err(Error::from)
7595    } else {
7596        let local_var_entity: Option<CircuitsCircuitTerminationsUpdateError> =
7597            serde_json::from_str(&local_var_content).ok();
7598        let local_var_error = ResponseContent {
7599            status: local_var_status,
7600            content: local_var_content,
7601            entity: local_var_entity,
7602        };
7603        Err(Error::ResponseError(local_var_error))
7604    }
7605}
7606
7607/// Delete a list of circuit type objects.
7608pub async fn circuits_circuit_types_bulk_destroy(
7609    configuration: &configuration::Configuration,
7610    circuit_type_request: Vec<crate::models::CircuitTypeRequest>,
7611) -> Result<(), Error<CircuitsCircuitTypesBulkDestroyError>> {
7612    let local_var_configuration = configuration;
7613
7614    let local_var_client = &local_var_configuration.client;
7615
7616    let local_var_uri_str = format!(
7617        "{}/api/circuits/circuit-types/",
7618        local_var_configuration.base_path
7619    );
7620    let mut local_var_req_builder =
7621        local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());
7622
7623    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
7624        local_var_req_builder =
7625            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
7626    }
7627    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
7628        let local_var_key = local_var_apikey.key.clone();
7629        let local_var_value = match local_var_apikey.prefix {
7630            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
7631            None => local_var_key,
7632        };
7633        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
7634    };
7635    local_var_req_builder = local_var_req_builder.json(&circuit_type_request);
7636
7637    let local_var_req = local_var_req_builder.build()?;
7638    let local_var_resp = local_var_client.execute(local_var_req).await?;
7639
7640    let local_var_status = local_var_resp.status();
7641    let local_var_content = local_var_resp.text().await?;
7642
7643    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
7644        Ok(())
7645    } else {
7646        let local_var_entity: Option<CircuitsCircuitTypesBulkDestroyError> =
7647            serde_json::from_str(&local_var_content).ok();
7648        let local_var_error = ResponseContent {
7649            status: local_var_status,
7650            content: local_var_content,
7651            entity: local_var_entity,
7652        };
7653        Err(Error::ResponseError(local_var_error))
7654    }
7655}
7656
7657/// Patch a list of circuit type objects.
7658pub async fn circuits_circuit_types_bulk_partial_update(
7659    configuration: &configuration::Configuration,
7660    circuit_type_request: Vec<crate::models::CircuitTypeRequest>,
7661) -> Result<Vec<crate::models::CircuitType>, Error<CircuitsCircuitTypesBulkPartialUpdateError>> {
7662    let local_var_configuration = configuration;
7663
7664    let local_var_client = &local_var_configuration.client;
7665
7666    let local_var_uri_str = format!(
7667        "{}/api/circuits/circuit-types/",
7668        local_var_configuration.base_path
7669    );
7670    let mut local_var_req_builder =
7671        local_var_client.request(reqwest::Method::PATCH, local_var_uri_str.as_str());
7672
7673    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
7674        local_var_req_builder =
7675            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
7676    }
7677    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
7678        let local_var_key = local_var_apikey.key.clone();
7679        let local_var_value = match local_var_apikey.prefix {
7680            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
7681            None => local_var_key,
7682        };
7683        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
7684    };
7685    local_var_req_builder = local_var_req_builder.json(&circuit_type_request);
7686
7687    let local_var_req = local_var_req_builder.build()?;
7688    let local_var_resp = local_var_client.execute(local_var_req).await?;
7689
7690    let local_var_status = local_var_resp.status();
7691    let local_var_content = local_var_resp.text().await?;
7692
7693    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
7694        serde_json::from_str(&local_var_content).map_err(Error::from)
7695    } else {
7696        let local_var_entity: Option<CircuitsCircuitTypesBulkPartialUpdateError> =
7697            serde_json::from_str(&local_var_content).ok();
7698        let local_var_error = ResponseContent {
7699            status: local_var_status,
7700            content: local_var_content,
7701            entity: local_var_entity,
7702        };
7703        Err(Error::ResponseError(local_var_error))
7704    }
7705}
7706
7707/// Put a list of circuit type objects.
7708pub async fn circuits_circuit_types_bulk_update(
7709    configuration: &configuration::Configuration,
7710    circuit_type_request: Vec<crate::models::CircuitTypeRequest>,
7711) -> Result<Vec<crate::models::CircuitType>, Error<CircuitsCircuitTypesBulkUpdateError>> {
7712    let local_var_configuration = configuration;
7713
7714    let local_var_client = &local_var_configuration.client;
7715
7716    let local_var_uri_str = format!(
7717        "{}/api/circuits/circuit-types/",
7718        local_var_configuration.base_path
7719    );
7720    let mut local_var_req_builder =
7721        local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());
7722
7723    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
7724        local_var_req_builder =
7725            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
7726    }
7727    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
7728        let local_var_key = local_var_apikey.key.clone();
7729        let local_var_value = match local_var_apikey.prefix {
7730            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
7731            None => local_var_key,
7732        };
7733        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
7734    };
7735    local_var_req_builder = local_var_req_builder.json(&circuit_type_request);
7736
7737    let local_var_req = local_var_req_builder.build()?;
7738    let local_var_resp = local_var_client.execute(local_var_req).await?;
7739
7740    let local_var_status = local_var_resp.status();
7741    let local_var_content = local_var_resp.text().await?;
7742
7743    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
7744        serde_json::from_str(&local_var_content).map_err(Error::from)
7745    } else {
7746        let local_var_entity: Option<CircuitsCircuitTypesBulkUpdateError> =
7747            serde_json::from_str(&local_var_content).ok();
7748        let local_var_error = ResponseContent {
7749            status: local_var_status,
7750            content: local_var_content,
7751            entity: local_var_entity,
7752        };
7753        Err(Error::ResponseError(local_var_error))
7754    }
7755}
7756
7757/// Post a list of circuit type objects.
7758pub async fn circuits_circuit_types_create(
7759    configuration: &configuration::Configuration,
7760    circuits_circuit_types_create_request: crate::models::CircuitsCircuitTypesCreateRequest,
7761) -> Result<crate::models::CircuitType, Error<CircuitsCircuitTypesCreateError>> {
7762    let local_var_configuration = configuration;
7763
7764    let local_var_client = &local_var_configuration.client;
7765
7766    let local_var_uri_str = format!(
7767        "{}/api/circuits/circuit-types/",
7768        local_var_configuration.base_path
7769    );
7770    let mut local_var_req_builder =
7771        local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
7772
7773    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
7774        local_var_req_builder =
7775            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
7776    }
7777    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
7778        let local_var_key = local_var_apikey.key.clone();
7779        let local_var_value = match local_var_apikey.prefix {
7780            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
7781            None => local_var_key,
7782        };
7783        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
7784    };
7785    local_var_req_builder = local_var_req_builder.json(&circuits_circuit_types_create_request);
7786
7787    let local_var_req = local_var_req_builder.build()?;
7788    let local_var_resp = local_var_client.execute(local_var_req).await?;
7789
7790    let local_var_status = local_var_resp.status();
7791    let local_var_content = local_var_resp.text().await?;
7792
7793    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
7794        serde_json::from_str(&local_var_content).map_err(Error::from)
7795    } else {
7796        let local_var_entity: Option<CircuitsCircuitTypesCreateError> =
7797            serde_json::from_str(&local_var_content).ok();
7798        let local_var_error = ResponseContent {
7799            status: local_var_status,
7800            content: local_var_content,
7801            entity: local_var_entity,
7802        };
7803        Err(Error::ResponseError(local_var_error))
7804    }
7805}
7806
7807/// Delete a circuit type object.
7808pub async fn circuits_circuit_types_destroy(
7809    configuration: &configuration::Configuration,
7810    id: i32,
7811) -> Result<(), Error<CircuitsCircuitTypesDestroyError>> {
7812    let local_var_configuration = configuration;
7813
7814    let local_var_client = &local_var_configuration.client;
7815
7816    let local_var_uri_str = format!(
7817        "{}/api/circuits/circuit-types/{id}/",
7818        local_var_configuration.base_path,
7819        id = id
7820    );
7821    let mut local_var_req_builder =
7822        local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());
7823
7824    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
7825        local_var_req_builder =
7826            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
7827    }
7828    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
7829        let local_var_key = local_var_apikey.key.clone();
7830        let local_var_value = match local_var_apikey.prefix {
7831            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
7832            None => local_var_key,
7833        };
7834        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
7835    };
7836
7837    let local_var_req = local_var_req_builder.build()?;
7838    let local_var_resp = local_var_client.execute(local_var_req).await?;
7839
7840    let local_var_status = local_var_resp.status();
7841    let local_var_content = local_var_resp.text().await?;
7842
7843    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
7844        Ok(())
7845    } else {
7846        let local_var_entity: Option<CircuitsCircuitTypesDestroyError> =
7847            serde_json::from_str(&local_var_content).ok();
7848        let local_var_error = ResponseContent {
7849            status: local_var_status,
7850            content: local_var_content,
7851            entity: local_var_entity,
7852        };
7853        Err(Error::ResponseError(local_var_error))
7854    }
7855}
7856
7857/// Get a list of circuit type objects.
7858pub async fn circuits_circuit_types_list(
7859    configuration: &configuration::Configuration,
7860    color: Option<Vec<String>>,
7861    color__empty: Option<bool>,
7862    color__ic: Option<Vec<String>>,
7863    color__ie: Option<Vec<String>>,
7864    color__iew: Option<Vec<String>>,
7865    color__iregex: Option<Vec<String>>,
7866    color__isw: Option<Vec<String>>,
7867    color__n: Option<Vec<String>>,
7868    color__nic: Option<Vec<String>>,
7869    color__nie: Option<Vec<String>>,
7870    color__niew: Option<Vec<String>>,
7871    color__nisw: Option<Vec<String>>,
7872    color__regex: Option<Vec<String>>,
7873    created: Option<Vec<String>>,
7874    created__empty: Option<Vec<String>>,
7875    created__gt: Option<Vec<String>>,
7876    created__gte: Option<Vec<String>>,
7877    created__lt: Option<Vec<String>>,
7878    created__lte: Option<Vec<String>>,
7879    created__n: Option<Vec<String>>,
7880    created_by_request: Option<&str>,
7881    description: Option<Vec<String>>,
7882    description__empty: Option<bool>,
7883    description__ic: Option<Vec<String>>,
7884    description__ie: Option<Vec<String>>,
7885    description__iew: Option<Vec<String>>,
7886    description__iregex: Option<Vec<String>>,
7887    description__isw: Option<Vec<String>>,
7888    description__n: Option<Vec<String>>,
7889    description__nic: Option<Vec<String>>,
7890    description__nie: Option<Vec<String>>,
7891    description__niew: Option<Vec<String>>,
7892    description__nisw: Option<Vec<String>>,
7893    description__regex: Option<Vec<String>>,
7894    id: Option<Vec<i32>>,
7895    id__empty: Option<bool>,
7896    id__gt: Option<Vec<i32>>,
7897    id__gte: Option<Vec<i32>>,
7898    id__lt: Option<Vec<i32>>,
7899    id__lte: Option<Vec<i32>>,
7900    id__n: Option<Vec<i32>>,
7901    last_updated: Option<Vec<String>>,
7902    last_updated__empty: Option<Vec<String>>,
7903    last_updated__gt: Option<Vec<String>>,
7904    last_updated__gte: Option<Vec<String>>,
7905    last_updated__lt: Option<Vec<String>>,
7906    last_updated__lte: Option<Vec<String>>,
7907    last_updated__n: Option<Vec<String>>,
7908    limit: Option<i32>,
7909    modified_by_request: Option<&str>,
7910    name: Option<Vec<String>>,
7911    name__empty: Option<bool>,
7912    name__ic: Option<Vec<String>>,
7913    name__ie: Option<Vec<String>>,
7914    name__iew: Option<Vec<String>>,
7915    name__iregex: Option<Vec<String>>,
7916    name__isw: Option<Vec<String>>,
7917    name__n: Option<Vec<String>>,
7918    name__nic: Option<Vec<String>>,
7919    name__nie: Option<Vec<String>>,
7920    name__niew: Option<Vec<String>>,
7921    name__nisw: Option<Vec<String>>,
7922    name__regex: Option<Vec<String>>,
7923    offset: Option<i32>,
7924    ordering: Option<&str>,
7925    owner: Option<Vec<String>>,
7926    owner__n: Option<Vec<String>>,
7927    owner_group: Option<Vec<String>>,
7928    owner_group__n: Option<Vec<String>>,
7929    owner_group_id: Option<Vec<i32>>,
7930    owner_group_id__n: Option<Vec<i32>>,
7931    owner_id: Option<Vec<i32>>,
7932    owner_id__n: Option<Vec<i32>>,
7933    q: Option<&str>,
7934    slug: Option<Vec<String>>,
7935    slug__empty: Option<bool>,
7936    slug__ic: Option<Vec<String>>,
7937    slug__ie: Option<Vec<String>>,
7938    slug__iew: Option<Vec<String>>,
7939    slug__iregex: Option<Vec<String>>,
7940    slug__isw: Option<Vec<String>>,
7941    slug__n: Option<Vec<String>>,
7942    slug__nic: Option<Vec<String>>,
7943    slug__nie: Option<Vec<String>>,
7944    slug__niew: Option<Vec<String>>,
7945    slug__nisw: Option<Vec<String>>,
7946    slug__regex: Option<Vec<String>>,
7947    start: Option<i32>,
7948    tag: Option<Vec<String>>,
7949    tag__n: Option<Vec<String>>,
7950    tag_id: Option<Vec<i32>>,
7951    tag_id__n: Option<Vec<i32>>,
7952    updated_by_request: Option<&str>,
7953) -> Result<crate::models::PaginatedCircuitTypeList, Error<CircuitsCircuitTypesListError>> {
7954    let local_var_configuration = configuration;
7955
7956    let local_var_client = &local_var_configuration.client;
7957
7958    let local_var_uri_str = format!(
7959        "{}/api/circuits/circuit-types/",
7960        local_var_configuration.base_path
7961    );
7962    let mut local_var_req_builder =
7963        local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
7964
7965    if let Some(ref local_var_str) = color {
7966        local_var_req_builder = match "multi" {
7967            "multi" => local_var_req_builder.query(
7968                &local_var_str
7969                    .into_iter()
7970                    .map(|p| ("color".to_owned(), p.to_string()))
7971                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7972            ),
7973            _ => local_var_req_builder.query(&[(
7974                "color",
7975                &local_var_str
7976                    .into_iter()
7977                    .map(|p| p.to_string())
7978                    .collect::<Vec<String>>()
7979                    .join(",")
7980                    .to_string(),
7981            )]),
7982        };
7983    }
7984    if let Some(ref local_var_str) = color__empty {
7985        local_var_req_builder =
7986            local_var_req_builder.query(&[("color__empty", &local_var_str.to_string())]);
7987    }
7988    if let Some(ref local_var_str) = color__ic {
7989        local_var_req_builder = match "multi" {
7990            "multi" => local_var_req_builder.query(
7991                &local_var_str
7992                    .into_iter()
7993                    .map(|p| ("color__ic".to_owned(), p.to_string()))
7994                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7995            ),
7996            _ => local_var_req_builder.query(&[(
7997                "color__ic",
7998                &local_var_str
7999                    .into_iter()
8000                    .map(|p| p.to_string())
8001                    .collect::<Vec<String>>()
8002                    .join(",")
8003                    .to_string(),
8004            )]),
8005        };
8006    }
8007    if let Some(ref local_var_str) = color__ie {
8008        local_var_req_builder = match "multi" {
8009            "multi" => local_var_req_builder.query(
8010                &local_var_str
8011                    .into_iter()
8012                    .map(|p| ("color__ie".to_owned(), p.to_string()))
8013                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8014            ),
8015            _ => local_var_req_builder.query(&[(
8016                "color__ie",
8017                &local_var_str
8018                    .into_iter()
8019                    .map(|p| p.to_string())
8020                    .collect::<Vec<String>>()
8021                    .join(",")
8022                    .to_string(),
8023            )]),
8024        };
8025    }
8026    if let Some(ref local_var_str) = color__iew {
8027        local_var_req_builder = match "multi" {
8028            "multi" => local_var_req_builder.query(
8029                &local_var_str
8030                    .into_iter()
8031                    .map(|p| ("color__iew".to_owned(), p.to_string()))
8032                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8033            ),
8034            _ => local_var_req_builder.query(&[(
8035                "color__iew",
8036                &local_var_str
8037                    .into_iter()
8038                    .map(|p| p.to_string())
8039                    .collect::<Vec<String>>()
8040                    .join(",")
8041                    .to_string(),
8042            )]),
8043        };
8044    }
8045    if let Some(ref local_var_str) = color__iregex {
8046        local_var_req_builder = match "multi" {
8047            "multi" => local_var_req_builder.query(
8048                &local_var_str
8049                    .into_iter()
8050                    .map(|p| ("color__iregex".to_owned(), p.to_string()))
8051                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8052            ),
8053            _ => local_var_req_builder.query(&[(
8054                "color__iregex",
8055                &local_var_str
8056                    .into_iter()
8057                    .map(|p| p.to_string())
8058                    .collect::<Vec<String>>()
8059                    .join(",")
8060                    .to_string(),
8061            )]),
8062        };
8063    }
8064    if let Some(ref local_var_str) = color__isw {
8065        local_var_req_builder = match "multi" {
8066            "multi" => local_var_req_builder.query(
8067                &local_var_str
8068                    .into_iter()
8069                    .map(|p| ("color__isw".to_owned(), p.to_string()))
8070                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8071            ),
8072            _ => local_var_req_builder.query(&[(
8073                "color__isw",
8074                &local_var_str
8075                    .into_iter()
8076                    .map(|p| p.to_string())
8077                    .collect::<Vec<String>>()
8078                    .join(",")
8079                    .to_string(),
8080            )]),
8081        };
8082    }
8083    if let Some(ref local_var_str) = color__n {
8084        local_var_req_builder = match "multi" {
8085            "multi" => local_var_req_builder.query(
8086                &local_var_str
8087                    .into_iter()
8088                    .map(|p| ("color__n".to_owned(), p.to_string()))
8089                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8090            ),
8091            _ => local_var_req_builder.query(&[(
8092                "color__n",
8093                &local_var_str
8094                    .into_iter()
8095                    .map(|p| p.to_string())
8096                    .collect::<Vec<String>>()
8097                    .join(",")
8098                    .to_string(),
8099            )]),
8100        };
8101    }
8102    if let Some(ref local_var_str) = color__nic {
8103        local_var_req_builder = match "multi" {
8104            "multi" => local_var_req_builder.query(
8105                &local_var_str
8106                    .into_iter()
8107                    .map(|p| ("color__nic".to_owned(), p.to_string()))
8108                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8109            ),
8110            _ => local_var_req_builder.query(&[(
8111                "color__nic",
8112                &local_var_str
8113                    .into_iter()
8114                    .map(|p| p.to_string())
8115                    .collect::<Vec<String>>()
8116                    .join(",")
8117                    .to_string(),
8118            )]),
8119        };
8120    }
8121    if let Some(ref local_var_str) = color__nie {
8122        local_var_req_builder = match "multi" {
8123            "multi" => local_var_req_builder.query(
8124                &local_var_str
8125                    .into_iter()
8126                    .map(|p| ("color__nie".to_owned(), p.to_string()))
8127                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8128            ),
8129            _ => local_var_req_builder.query(&[(
8130                "color__nie",
8131                &local_var_str
8132                    .into_iter()
8133                    .map(|p| p.to_string())
8134                    .collect::<Vec<String>>()
8135                    .join(",")
8136                    .to_string(),
8137            )]),
8138        };
8139    }
8140    if let Some(ref local_var_str) = color__niew {
8141        local_var_req_builder = match "multi" {
8142            "multi" => local_var_req_builder.query(
8143                &local_var_str
8144                    .into_iter()
8145                    .map(|p| ("color__niew".to_owned(), p.to_string()))
8146                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8147            ),
8148            _ => local_var_req_builder.query(&[(
8149                "color__niew",
8150                &local_var_str
8151                    .into_iter()
8152                    .map(|p| p.to_string())
8153                    .collect::<Vec<String>>()
8154                    .join(",")
8155                    .to_string(),
8156            )]),
8157        };
8158    }
8159    if let Some(ref local_var_str) = color__nisw {
8160        local_var_req_builder = match "multi" {
8161            "multi" => local_var_req_builder.query(
8162                &local_var_str
8163                    .into_iter()
8164                    .map(|p| ("color__nisw".to_owned(), p.to_string()))
8165                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8166            ),
8167            _ => local_var_req_builder.query(&[(
8168                "color__nisw",
8169                &local_var_str
8170                    .into_iter()
8171                    .map(|p| p.to_string())
8172                    .collect::<Vec<String>>()
8173                    .join(",")
8174                    .to_string(),
8175            )]),
8176        };
8177    }
8178    if let Some(ref local_var_str) = color__regex {
8179        local_var_req_builder = match "multi" {
8180            "multi" => local_var_req_builder.query(
8181                &local_var_str
8182                    .into_iter()
8183                    .map(|p| ("color__regex".to_owned(), p.to_string()))
8184                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8185            ),
8186            _ => local_var_req_builder.query(&[(
8187                "color__regex",
8188                &local_var_str
8189                    .into_iter()
8190                    .map(|p| p.to_string())
8191                    .collect::<Vec<String>>()
8192                    .join(",")
8193                    .to_string(),
8194            )]),
8195        };
8196    }
8197    if let Some(ref local_var_str) = created {
8198        local_var_req_builder = match "multi" {
8199            "multi" => local_var_req_builder.query(
8200                &local_var_str
8201                    .into_iter()
8202                    .map(|p| ("created".to_owned(), p.to_string()))
8203                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8204            ),
8205            _ => local_var_req_builder.query(&[(
8206                "created",
8207                &local_var_str
8208                    .into_iter()
8209                    .map(|p| p.to_string())
8210                    .collect::<Vec<String>>()
8211                    .join(",")
8212                    .to_string(),
8213            )]),
8214        };
8215    }
8216    if let Some(ref local_var_str) = created__empty {
8217        local_var_req_builder = match "multi" {
8218            "multi" => local_var_req_builder.query(
8219                &local_var_str
8220                    .into_iter()
8221                    .map(|p| ("created__empty".to_owned(), p.to_string()))
8222                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8223            ),
8224            _ => local_var_req_builder.query(&[(
8225                "created__empty",
8226                &local_var_str
8227                    .into_iter()
8228                    .map(|p| p.to_string())
8229                    .collect::<Vec<String>>()
8230                    .join(",")
8231                    .to_string(),
8232            )]),
8233        };
8234    }
8235    if let Some(ref local_var_str) = created__gt {
8236        local_var_req_builder = match "multi" {
8237            "multi" => local_var_req_builder.query(
8238                &local_var_str
8239                    .into_iter()
8240                    .map(|p| ("created__gt".to_owned(), p.to_string()))
8241                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8242            ),
8243            _ => local_var_req_builder.query(&[(
8244                "created__gt",
8245                &local_var_str
8246                    .into_iter()
8247                    .map(|p| p.to_string())
8248                    .collect::<Vec<String>>()
8249                    .join(",")
8250                    .to_string(),
8251            )]),
8252        };
8253    }
8254    if let Some(ref local_var_str) = created__gte {
8255        local_var_req_builder = match "multi" {
8256            "multi" => local_var_req_builder.query(
8257                &local_var_str
8258                    .into_iter()
8259                    .map(|p| ("created__gte".to_owned(), p.to_string()))
8260                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8261            ),
8262            _ => local_var_req_builder.query(&[(
8263                "created__gte",
8264                &local_var_str
8265                    .into_iter()
8266                    .map(|p| p.to_string())
8267                    .collect::<Vec<String>>()
8268                    .join(",")
8269                    .to_string(),
8270            )]),
8271        };
8272    }
8273    if let Some(ref local_var_str) = created__lt {
8274        local_var_req_builder = match "multi" {
8275            "multi" => local_var_req_builder.query(
8276                &local_var_str
8277                    .into_iter()
8278                    .map(|p| ("created__lt".to_owned(), p.to_string()))
8279                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8280            ),
8281            _ => local_var_req_builder.query(&[(
8282                "created__lt",
8283                &local_var_str
8284                    .into_iter()
8285                    .map(|p| p.to_string())
8286                    .collect::<Vec<String>>()
8287                    .join(",")
8288                    .to_string(),
8289            )]),
8290        };
8291    }
8292    if let Some(ref local_var_str) = created__lte {
8293        local_var_req_builder = match "multi" {
8294            "multi" => local_var_req_builder.query(
8295                &local_var_str
8296                    .into_iter()
8297                    .map(|p| ("created__lte".to_owned(), p.to_string()))
8298                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8299            ),
8300            _ => local_var_req_builder.query(&[(
8301                "created__lte",
8302                &local_var_str
8303                    .into_iter()
8304                    .map(|p| p.to_string())
8305                    .collect::<Vec<String>>()
8306                    .join(",")
8307                    .to_string(),
8308            )]),
8309        };
8310    }
8311    if let Some(ref local_var_str) = created__n {
8312        local_var_req_builder = match "multi" {
8313            "multi" => local_var_req_builder.query(
8314                &local_var_str
8315                    .into_iter()
8316                    .map(|p| ("created__n".to_owned(), p.to_string()))
8317                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8318            ),
8319            _ => local_var_req_builder.query(&[(
8320                "created__n",
8321                &local_var_str
8322                    .into_iter()
8323                    .map(|p| p.to_string())
8324                    .collect::<Vec<String>>()
8325                    .join(",")
8326                    .to_string(),
8327            )]),
8328        };
8329    }
8330    if let Some(ref local_var_str) = created_by_request {
8331        local_var_req_builder =
8332            local_var_req_builder.query(&[("created_by_request", &local_var_str.to_string())]);
8333    }
8334    if let Some(ref local_var_str) = description {
8335        local_var_req_builder = match "multi" {
8336            "multi" => local_var_req_builder.query(
8337                &local_var_str
8338                    .into_iter()
8339                    .map(|p| ("description".to_owned(), p.to_string()))
8340                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8341            ),
8342            _ => local_var_req_builder.query(&[(
8343                "description",
8344                &local_var_str
8345                    .into_iter()
8346                    .map(|p| p.to_string())
8347                    .collect::<Vec<String>>()
8348                    .join(",")
8349                    .to_string(),
8350            )]),
8351        };
8352    }
8353    if let Some(ref local_var_str) = description__empty {
8354        local_var_req_builder =
8355            local_var_req_builder.query(&[("description__empty", &local_var_str.to_string())]);
8356    }
8357    if let Some(ref local_var_str) = description__ic {
8358        local_var_req_builder = match "multi" {
8359            "multi" => local_var_req_builder.query(
8360                &local_var_str
8361                    .into_iter()
8362                    .map(|p| ("description__ic".to_owned(), p.to_string()))
8363                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8364            ),
8365            _ => local_var_req_builder.query(&[(
8366                "description__ic",
8367                &local_var_str
8368                    .into_iter()
8369                    .map(|p| p.to_string())
8370                    .collect::<Vec<String>>()
8371                    .join(",")
8372                    .to_string(),
8373            )]),
8374        };
8375    }
8376    if let Some(ref local_var_str) = description__ie {
8377        local_var_req_builder = match "multi" {
8378            "multi" => local_var_req_builder.query(
8379                &local_var_str
8380                    .into_iter()
8381                    .map(|p| ("description__ie".to_owned(), p.to_string()))
8382                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8383            ),
8384            _ => local_var_req_builder.query(&[(
8385                "description__ie",
8386                &local_var_str
8387                    .into_iter()
8388                    .map(|p| p.to_string())
8389                    .collect::<Vec<String>>()
8390                    .join(",")
8391                    .to_string(),
8392            )]),
8393        };
8394    }
8395    if let Some(ref local_var_str) = description__iew {
8396        local_var_req_builder = match "multi" {
8397            "multi" => local_var_req_builder.query(
8398                &local_var_str
8399                    .into_iter()
8400                    .map(|p| ("description__iew".to_owned(), p.to_string()))
8401                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8402            ),
8403            _ => local_var_req_builder.query(&[(
8404                "description__iew",
8405                &local_var_str
8406                    .into_iter()
8407                    .map(|p| p.to_string())
8408                    .collect::<Vec<String>>()
8409                    .join(",")
8410                    .to_string(),
8411            )]),
8412        };
8413    }
8414    if let Some(ref local_var_str) = description__iregex {
8415        local_var_req_builder = match "multi" {
8416            "multi" => local_var_req_builder.query(
8417                &local_var_str
8418                    .into_iter()
8419                    .map(|p| ("description__iregex".to_owned(), p.to_string()))
8420                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8421            ),
8422            _ => local_var_req_builder.query(&[(
8423                "description__iregex",
8424                &local_var_str
8425                    .into_iter()
8426                    .map(|p| p.to_string())
8427                    .collect::<Vec<String>>()
8428                    .join(",")
8429                    .to_string(),
8430            )]),
8431        };
8432    }
8433    if let Some(ref local_var_str) = description__isw {
8434        local_var_req_builder = match "multi" {
8435            "multi" => local_var_req_builder.query(
8436                &local_var_str
8437                    .into_iter()
8438                    .map(|p| ("description__isw".to_owned(), p.to_string()))
8439                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8440            ),
8441            _ => local_var_req_builder.query(&[(
8442                "description__isw",
8443                &local_var_str
8444                    .into_iter()
8445                    .map(|p| p.to_string())
8446                    .collect::<Vec<String>>()
8447                    .join(",")
8448                    .to_string(),
8449            )]),
8450        };
8451    }
8452    if let Some(ref local_var_str) = description__n {
8453        local_var_req_builder = match "multi" {
8454            "multi" => local_var_req_builder.query(
8455                &local_var_str
8456                    .into_iter()
8457                    .map(|p| ("description__n".to_owned(), p.to_string()))
8458                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8459            ),
8460            _ => local_var_req_builder.query(&[(
8461                "description__n",
8462                &local_var_str
8463                    .into_iter()
8464                    .map(|p| p.to_string())
8465                    .collect::<Vec<String>>()
8466                    .join(",")
8467                    .to_string(),
8468            )]),
8469        };
8470    }
8471    if let Some(ref local_var_str) = description__nic {
8472        local_var_req_builder = match "multi" {
8473            "multi" => local_var_req_builder.query(
8474                &local_var_str
8475                    .into_iter()
8476                    .map(|p| ("description__nic".to_owned(), p.to_string()))
8477                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8478            ),
8479            _ => local_var_req_builder.query(&[(
8480                "description__nic",
8481                &local_var_str
8482                    .into_iter()
8483                    .map(|p| p.to_string())
8484                    .collect::<Vec<String>>()
8485                    .join(",")
8486                    .to_string(),
8487            )]),
8488        };
8489    }
8490    if let Some(ref local_var_str) = description__nie {
8491        local_var_req_builder = match "multi" {
8492            "multi" => local_var_req_builder.query(
8493                &local_var_str
8494                    .into_iter()
8495                    .map(|p| ("description__nie".to_owned(), p.to_string()))
8496                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8497            ),
8498            _ => local_var_req_builder.query(&[(
8499                "description__nie",
8500                &local_var_str
8501                    .into_iter()
8502                    .map(|p| p.to_string())
8503                    .collect::<Vec<String>>()
8504                    .join(",")
8505                    .to_string(),
8506            )]),
8507        };
8508    }
8509    if let Some(ref local_var_str) = description__niew {
8510        local_var_req_builder = match "multi" {
8511            "multi" => local_var_req_builder.query(
8512                &local_var_str
8513                    .into_iter()
8514                    .map(|p| ("description__niew".to_owned(), p.to_string()))
8515                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8516            ),
8517            _ => local_var_req_builder.query(&[(
8518                "description__niew",
8519                &local_var_str
8520                    .into_iter()
8521                    .map(|p| p.to_string())
8522                    .collect::<Vec<String>>()
8523                    .join(",")
8524                    .to_string(),
8525            )]),
8526        };
8527    }
8528    if let Some(ref local_var_str) = description__nisw {
8529        local_var_req_builder = match "multi" {
8530            "multi" => local_var_req_builder.query(
8531                &local_var_str
8532                    .into_iter()
8533                    .map(|p| ("description__nisw".to_owned(), p.to_string()))
8534                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8535            ),
8536            _ => local_var_req_builder.query(&[(
8537                "description__nisw",
8538                &local_var_str
8539                    .into_iter()
8540                    .map(|p| p.to_string())
8541                    .collect::<Vec<String>>()
8542                    .join(",")
8543                    .to_string(),
8544            )]),
8545        };
8546    }
8547    if let Some(ref local_var_str) = description__regex {
8548        local_var_req_builder = match "multi" {
8549            "multi" => local_var_req_builder.query(
8550                &local_var_str
8551                    .into_iter()
8552                    .map(|p| ("description__regex".to_owned(), p.to_string()))
8553                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8554            ),
8555            _ => local_var_req_builder.query(&[(
8556                "description__regex",
8557                &local_var_str
8558                    .into_iter()
8559                    .map(|p| p.to_string())
8560                    .collect::<Vec<String>>()
8561                    .join(",")
8562                    .to_string(),
8563            )]),
8564        };
8565    }
8566    if let Some(ref local_var_str) = id {
8567        local_var_req_builder = match "multi" {
8568            "multi" => local_var_req_builder.query(
8569                &local_var_str
8570                    .into_iter()
8571                    .map(|p| ("id".to_owned(), p.to_string()))
8572                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8573            ),
8574            _ => local_var_req_builder.query(&[(
8575                "id",
8576                &local_var_str
8577                    .into_iter()
8578                    .map(|p| p.to_string())
8579                    .collect::<Vec<String>>()
8580                    .join(",")
8581                    .to_string(),
8582            )]),
8583        };
8584    }
8585    if let Some(ref local_var_str) = id__empty {
8586        local_var_req_builder =
8587            local_var_req_builder.query(&[("id__empty", &local_var_str.to_string())]);
8588    }
8589    if let Some(ref local_var_str) = id__gt {
8590        local_var_req_builder = match "multi" {
8591            "multi" => local_var_req_builder.query(
8592                &local_var_str
8593                    .into_iter()
8594                    .map(|p| ("id__gt".to_owned(), p.to_string()))
8595                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8596            ),
8597            _ => local_var_req_builder.query(&[(
8598                "id__gt",
8599                &local_var_str
8600                    .into_iter()
8601                    .map(|p| p.to_string())
8602                    .collect::<Vec<String>>()
8603                    .join(",")
8604                    .to_string(),
8605            )]),
8606        };
8607    }
8608    if let Some(ref local_var_str) = id__gte {
8609        local_var_req_builder = match "multi" {
8610            "multi" => local_var_req_builder.query(
8611                &local_var_str
8612                    .into_iter()
8613                    .map(|p| ("id__gte".to_owned(), p.to_string()))
8614                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8615            ),
8616            _ => local_var_req_builder.query(&[(
8617                "id__gte",
8618                &local_var_str
8619                    .into_iter()
8620                    .map(|p| p.to_string())
8621                    .collect::<Vec<String>>()
8622                    .join(",")
8623                    .to_string(),
8624            )]),
8625        };
8626    }
8627    if let Some(ref local_var_str) = id__lt {
8628        local_var_req_builder = match "multi" {
8629            "multi" => local_var_req_builder.query(
8630                &local_var_str
8631                    .into_iter()
8632                    .map(|p| ("id__lt".to_owned(), p.to_string()))
8633                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8634            ),
8635            _ => local_var_req_builder.query(&[(
8636                "id__lt",
8637                &local_var_str
8638                    .into_iter()
8639                    .map(|p| p.to_string())
8640                    .collect::<Vec<String>>()
8641                    .join(",")
8642                    .to_string(),
8643            )]),
8644        };
8645    }
8646    if let Some(ref local_var_str) = id__lte {
8647        local_var_req_builder = match "multi" {
8648            "multi" => local_var_req_builder.query(
8649                &local_var_str
8650                    .into_iter()
8651                    .map(|p| ("id__lte".to_owned(), p.to_string()))
8652                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8653            ),
8654            _ => local_var_req_builder.query(&[(
8655                "id__lte",
8656                &local_var_str
8657                    .into_iter()
8658                    .map(|p| p.to_string())
8659                    .collect::<Vec<String>>()
8660                    .join(",")
8661                    .to_string(),
8662            )]),
8663        };
8664    }
8665    if let Some(ref local_var_str) = id__n {
8666        local_var_req_builder = match "multi" {
8667            "multi" => local_var_req_builder.query(
8668                &local_var_str
8669                    .into_iter()
8670                    .map(|p| ("id__n".to_owned(), p.to_string()))
8671                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8672            ),
8673            _ => local_var_req_builder.query(&[(
8674                "id__n",
8675                &local_var_str
8676                    .into_iter()
8677                    .map(|p| p.to_string())
8678                    .collect::<Vec<String>>()
8679                    .join(",")
8680                    .to_string(),
8681            )]),
8682        };
8683    }
8684    if let Some(ref local_var_str) = last_updated {
8685        local_var_req_builder = match "multi" {
8686            "multi" => local_var_req_builder.query(
8687                &local_var_str
8688                    .into_iter()
8689                    .map(|p| ("last_updated".to_owned(), p.to_string()))
8690                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8691            ),
8692            _ => local_var_req_builder.query(&[(
8693                "last_updated",
8694                &local_var_str
8695                    .into_iter()
8696                    .map(|p| p.to_string())
8697                    .collect::<Vec<String>>()
8698                    .join(",")
8699                    .to_string(),
8700            )]),
8701        };
8702    }
8703    if let Some(ref local_var_str) = last_updated__empty {
8704        local_var_req_builder = match "multi" {
8705            "multi" => local_var_req_builder.query(
8706                &local_var_str
8707                    .into_iter()
8708                    .map(|p| ("last_updated__empty".to_owned(), p.to_string()))
8709                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8710            ),
8711            _ => local_var_req_builder.query(&[(
8712                "last_updated__empty",
8713                &local_var_str
8714                    .into_iter()
8715                    .map(|p| p.to_string())
8716                    .collect::<Vec<String>>()
8717                    .join(",")
8718                    .to_string(),
8719            )]),
8720        };
8721    }
8722    if let Some(ref local_var_str) = last_updated__gt {
8723        local_var_req_builder = match "multi" {
8724            "multi" => local_var_req_builder.query(
8725                &local_var_str
8726                    .into_iter()
8727                    .map(|p| ("last_updated__gt".to_owned(), p.to_string()))
8728                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8729            ),
8730            _ => local_var_req_builder.query(&[(
8731                "last_updated__gt",
8732                &local_var_str
8733                    .into_iter()
8734                    .map(|p| p.to_string())
8735                    .collect::<Vec<String>>()
8736                    .join(",")
8737                    .to_string(),
8738            )]),
8739        };
8740    }
8741    if let Some(ref local_var_str) = last_updated__gte {
8742        local_var_req_builder = match "multi" {
8743            "multi" => local_var_req_builder.query(
8744                &local_var_str
8745                    .into_iter()
8746                    .map(|p| ("last_updated__gte".to_owned(), p.to_string()))
8747                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8748            ),
8749            _ => local_var_req_builder.query(&[(
8750                "last_updated__gte",
8751                &local_var_str
8752                    .into_iter()
8753                    .map(|p| p.to_string())
8754                    .collect::<Vec<String>>()
8755                    .join(",")
8756                    .to_string(),
8757            )]),
8758        };
8759    }
8760    if let Some(ref local_var_str) = last_updated__lt {
8761        local_var_req_builder = match "multi" {
8762            "multi" => local_var_req_builder.query(
8763                &local_var_str
8764                    .into_iter()
8765                    .map(|p| ("last_updated__lt".to_owned(), p.to_string()))
8766                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8767            ),
8768            _ => local_var_req_builder.query(&[(
8769                "last_updated__lt",
8770                &local_var_str
8771                    .into_iter()
8772                    .map(|p| p.to_string())
8773                    .collect::<Vec<String>>()
8774                    .join(",")
8775                    .to_string(),
8776            )]),
8777        };
8778    }
8779    if let Some(ref local_var_str) = last_updated__lte {
8780        local_var_req_builder = match "multi" {
8781            "multi" => local_var_req_builder.query(
8782                &local_var_str
8783                    .into_iter()
8784                    .map(|p| ("last_updated__lte".to_owned(), p.to_string()))
8785                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8786            ),
8787            _ => local_var_req_builder.query(&[(
8788                "last_updated__lte",
8789                &local_var_str
8790                    .into_iter()
8791                    .map(|p| p.to_string())
8792                    .collect::<Vec<String>>()
8793                    .join(",")
8794                    .to_string(),
8795            )]),
8796        };
8797    }
8798    if let Some(ref local_var_str) = last_updated__n {
8799        local_var_req_builder = match "multi" {
8800            "multi" => local_var_req_builder.query(
8801                &local_var_str
8802                    .into_iter()
8803                    .map(|p| ("last_updated__n".to_owned(), p.to_string()))
8804                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8805            ),
8806            _ => local_var_req_builder.query(&[(
8807                "last_updated__n",
8808                &local_var_str
8809                    .into_iter()
8810                    .map(|p| p.to_string())
8811                    .collect::<Vec<String>>()
8812                    .join(",")
8813                    .to_string(),
8814            )]),
8815        };
8816    }
8817    if let Some(ref local_var_str) = limit {
8818        local_var_req_builder =
8819            local_var_req_builder.query(&[("limit", &local_var_str.to_string())]);
8820    }
8821    if let Some(ref local_var_str) = modified_by_request {
8822        local_var_req_builder =
8823            local_var_req_builder.query(&[("modified_by_request", &local_var_str.to_string())]);
8824    }
8825    if let Some(ref local_var_str) = name {
8826        local_var_req_builder = match "multi" {
8827            "multi" => local_var_req_builder.query(
8828                &local_var_str
8829                    .into_iter()
8830                    .map(|p| ("name".to_owned(), p.to_string()))
8831                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8832            ),
8833            _ => local_var_req_builder.query(&[(
8834                "name",
8835                &local_var_str
8836                    .into_iter()
8837                    .map(|p| p.to_string())
8838                    .collect::<Vec<String>>()
8839                    .join(",")
8840                    .to_string(),
8841            )]),
8842        };
8843    }
8844    if let Some(ref local_var_str) = name__empty {
8845        local_var_req_builder =
8846            local_var_req_builder.query(&[("name__empty", &local_var_str.to_string())]);
8847    }
8848    if let Some(ref local_var_str) = name__ic {
8849        local_var_req_builder = match "multi" {
8850            "multi" => local_var_req_builder.query(
8851                &local_var_str
8852                    .into_iter()
8853                    .map(|p| ("name__ic".to_owned(), p.to_string()))
8854                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8855            ),
8856            _ => local_var_req_builder.query(&[(
8857                "name__ic",
8858                &local_var_str
8859                    .into_iter()
8860                    .map(|p| p.to_string())
8861                    .collect::<Vec<String>>()
8862                    .join(",")
8863                    .to_string(),
8864            )]),
8865        };
8866    }
8867    if let Some(ref local_var_str) = name__ie {
8868        local_var_req_builder = match "multi" {
8869            "multi" => local_var_req_builder.query(
8870                &local_var_str
8871                    .into_iter()
8872                    .map(|p| ("name__ie".to_owned(), p.to_string()))
8873                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8874            ),
8875            _ => local_var_req_builder.query(&[(
8876                "name__ie",
8877                &local_var_str
8878                    .into_iter()
8879                    .map(|p| p.to_string())
8880                    .collect::<Vec<String>>()
8881                    .join(",")
8882                    .to_string(),
8883            )]),
8884        };
8885    }
8886    if let Some(ref local_var_str) = name__iew {
8887        local_var_req_builder = match "multi" {
8888            "multi" => local_var_req_builder.query(
8889                &local_var_str
8890                    .into_iter()
8891                    .map(|p| ("name__iew".to_owned(), p.to_string()))
8892                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8893            ),
8894            _ => local_var_req_builder.query(&[(
8895                "name__iew",
8896                &local_var_str
8897                    .into_iter()
8898                    .map(|p| p.to_string())
8899                    .collect::<Vec<String>>()
8900                    .join(",")
8901                    .to_string(),
8902            )]),
8903        };
8904    }
8905    if let Some(ref local_var_str) = name__iregex {
8906        local_var_req_builder = match "multi" {
8907            "multi" => local_var_req_builder.query(
8908                &local_var_str
8909                    .into_iter()
8910                    .map(|p| ("name__iregex".to_owned(), p.to_string()))
8911                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8912            ),
8913            _ => local_var_req_builder.query(&[(
8914                "name__iregex",
8915                &local_var_str
8916                    .into_iter()
8917                    .map(|p| p.to_string())
8918                    .collect::<Vec<String>>()
8919                    .join(",")
8920                    .to_string(),
8921            )]),
8922        };
8923    }
8924    if let Some(ref local_var_str) = name__isw {
8925        local_var_req_builder = match "multi" {
8926            "multi" => local_var_req_builder.query(
8927                &local_var_str
8928                    .into_iter()
8929                    .map(|p| ("name__isw".to_owned(), p.to_string()))
8930                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8931            ),
8932            _ => local_var_req_builder.query(&[(
8933                "name__isw",
8934                &local_var_str
8935                    .into_iter()
8936                    .map(|p| p.to_string())
8937                    .collect::<Vec<String>>()
8938                    .join(",")
8939                    .to_string(),
8940            )]),
8941        };
8942    }
8943    if let Some(ref local_var_str) = name__n {
8944        local_var_req_builder = match "multi" {
8945            "multi" => local_var_req_builder.query(
8946                &local_var_str
8947                    .into_iter()
8948                    .map(|p| ("name__n".to_owned(), p.to_string()))
8949                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8950            ),
8951            _ => local_var_req_builder.query(&[(
8952                "name__n",
8953                &local_var_str
8954                    .into_iter()
8955                    .map(|p| p.to_string())
8956                    .collect::<Vec<String>>()
8957                    .join(",")
8958                    .to_string(),
8959            )]),
8960        };
8961    }
8962    if let Some(ref local_var_str) = name__nic {
8963        local_var_req_builder = match "multi" {
8964            "multi" => local_var_req_builder.query(
8965                &local_var_str
8966                    .into_iter()
8967                    .map(|p| ("name__nic".to_owned(), p.to_string()))
8968                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8969            ),
8970            _ => local_var_req_builder.query(&[(
8971                "name__nic",
8972                &local_var_str
8973                    .into_iter()
8974                    .map(|p| p.to_string())
8975                    .collect::<Vec<String>>()
8976                    .join(",")
8977                    .to_string(),
8978            )]),
8979        };
8980    }
8981    if let Some(ref local_var_str) = name__nie {
8982        local_var_req_builder = match "multi" {
8983            "multi" => local_var_req_builder.query(
8984                &local_var_str
8985                    .into_iter()
8986                    .map(|p| ("name__nie".to_owned(), p.to_string()))
8987                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8988            ),
8989            _ => local_var_req_builder.query(&[(
8990                "name__nie",
8991                &local_var_str
8992                    .into_iter()
8993                    .map(|p| p.to_string())
8994                    .collect::<Vec<String>>()
8995                    .join(",")
8996                    .to_string(),
8997            )]),
8998        };
8999    }
9000    if let Some(ref local_var_str) = name__niew {
9001        local_var_req_builder = match "multi" {
9002            "multi" => local_var_req_builder.query(
9003                &local_var_str
9004                    .into_iter()
9005                    .map(|p| ("name__niew".to_owned(), p.to_string()))
9006                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9007            ),
9008            _ => local_var_req_builder.query(&[(
9009                "name__niew",
9010                &local_var_str
9011                    .into_iter()
9012                    .map(|p| p.to_string())
9013                    .collect::<Vec<String>>()
9014                    .join(",")
9015                    .to_string(),
9016            )]),
9017        };
9018    }
9019    if let Some(ref local_var_str) = name__nisw {
9020        local_var_req_builder = match "multi" {
9021            "multi" => local_var_req_builder.query(
9022                &local_var_str
9023                    .into_iter()
9024                    .map(|p| ("name__nisw".to_owned(), p.to_string()))
9025                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9026            ),
9027            _ => local_var_req_builder.query(&[(
9028                "name__nisw",
9029                &local_var_str
9030                    .into_iter()
9031                    .map(|p| p.to_string())
9032                    .collect::<Vec<String>>()
9033                    .join(",")
9034                    .to_string(),
9035            )]),
9036        };
9037    }
9038    if let Some(ref local_var_str) = name__regex {
9039        local_var_req_builder = match "multi" {
9040            "multi" => local_var_req_builder.query(
9041                &local_var_str
9042                    .into_iter()
9043                    .map(|p| ("name__regex".to_owned(), p.to_string()))
9044                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9045            ),
9046            _ => local_var_req_builder.query(&[(
9047                "name__regex",
9048                &local_var_str
9049                    .into_iter()
9050                    .map(|p| p.to_string())
9051                    .collect::<Vec<String>>()
9052                    .join(",")
9053                    .to_string(),
9054            )]),
9055        };
9056    }
9057    if let Some(ref local_var_str) = offset {
9058        local_var_req_builder =
9059            local_var_req_builder.query(&[("offset", &local_var_str.to_string())]);
9060    }
9061    if let Some(ref local_var_str) = ordering {
9062        local_var_req_builder =
9063            local_var_req_builder.query(&[("ordering", &local_var_str.to_string())]);
9064    }
9065    if let Some(ref local_var_str) = owner {
9066        local_var_req_builder = match "multi" {
9067            "multi" => local_var_req_builder.query(
9068                &local_var_str
9069                    .into_iter()
9070                    .map(|p| ("owner".to_owned(), p.to_string()))
9071                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9072            ),
9073            _ => local_var_req_builder.query(&[(
9074                "owner",
9075                &local_var_str
9076                    .into_iter()
9077                    .map(|p| p.to_string())
9078                    .collect::<Vec<String>>()
9079                    .join(",")
9080                    .to_string(),
9081            )]),
9082        };
9083    }
9084    if let Some(ref local_var_str) = owner__n {
9085        local_var_req_builder = match "multi" {
9086            "multi" => local_var_req_builder.query(
9087                &local_var_str
9088                    .into_iter()
9089                    .map(|p| ("owner__n".to_owned(), p.to_string()))
9090                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9091            ),
9092            _ => local_var_req_builder.query(&[(
9093                "owner__n",
9094                &local_var_str
9095                    .into_iter()
9096                    .map(|p| p.to_string())
9097                    .collect::<Vec<String>>()
9098                    .join(",")
9099                    .to_string(),
9100            )]),
9101        };
9102    }
9103    if let Some(ref local_var_str) = owner_group {
9104        local_var_req_builder = match "multi" {
9105            "multi" => local_var_req_builder.query(
9106                &local_var_str
9107                    .into_iter()
9108                    .map(|p| ("owner_group".to_owned(), p.to_string()))
9109                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9110            ),
9111            _ => local_var_req_builder.query(&[(
9112                "owner_group",
9113                &local_var_str
9114                    .into_iter()
9115                    .map(|p| p.to_string())
9116                    .collect::<Vec<String>>()
9117                    .join(",")
9118                    .to_string(),
9119            )]),
9120        };
9121    }
9122    if let Some(ref local_var_str) = owner_group__n {
9123        local_var_req_builder = match "multi" {
9124            "multi" => local_var_req_builder.query(
9125                &local_var_str
9126                    .into_iter()
9127                    .map(|p| ("owner_group__n".to_owned(), p.to_string()))
9128                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9129            ),
9130            _ => local_var_req_builder.query(&[(
9131                "owner_group__n",
9132                &local_var_str
9133                    .into_iter()
9134                    .map(|p| p.to_string())
9135                    .collect::<Vec<String>>()
9136                    .join(",")
9137                    .to_string(),
9138            )]),
9139        };
9140    }
9141    if let Some(ref local_var_str) = owner_group_id {
9142        local_var_req_builder = match "multi" {
9143            "multi" => local_var_req_builder.query(
9144                &local_var_str
9145                    .into_iter()
9146                    .map(|p| ("owner_group_id".to_owned(), p.to_string()))
9147                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9148            ),
9149            _ => local_var_req_builder.query(&[(
9150                "owner_group_id",
9151                &local_var_str
9152                    .into_iter()
9153                    .map(|p| p.to_string())
9154                    .collect::<Vec<String>>()
9155                    .join(",")
9156                    .to_string(),
9157            )]),
9158        };
9159    }
9160    if let Some(ref local_var_str) = owner_group_id__n {
9161        local_var_req_builder = match "multi" {
9162            "multi" => local_var_req_builder.query(
9163                &local_var_str
9164                    .into_iter()
9165                    .map(|p| ("owner_group_id__n".to_owned(), p.to_string()))
9166                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9167            ),
9168            _ => local_var_req_builder.query(&[(
9169                "owner_group_id__n",
9170                &local_var_str
9171                    .into_iter()
9172                    .map(|p| p.to_string())
9173                    .collect::<Vec<String>>()
9174                    .join(",")
9175                    .to_string(),
9176            )]),
9177        };
9178    }
9179    if let Some(ref local_var_str) = owner_id {
9180        local_var_req_builder = match "multi" {
9181            "multi" => local_var_req_builder.query(
9182                &local_var_str
9183                    .into_iter()
9184                    .map(|p| ("owner_id".to_owned(), p.to_string()))
9185                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9186            ),
9187            _ => local_var_req_builder.query(&[(
9188                "owner_id",
9189                &local_var_str
9190                    .into_iter()
9191                    .map(|p| p.to_string())
9192                    .collect::<Vec<String>>()
9193                    .join(",")
9194                    .to_string(),
9195            )]),
9196        };
9197    }
9198    if let Some(ref local_var_str) = owner_id__n {
9199        local_var_req_builder = match "multi" {
9200            "multi" => local_var_req_builder.query(
9201                &local_var_str
9202                    .into_iter()
9203                    .map(|p| ("owner_id__n".to_owned(), p.to_string()))
9204                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9205            ),
9206            _ => local_var_req_builder.query(&[(
9207                "owner_id__n",
9208                &local_var_str
9209                    .into_iter()
9210                    .map(|p| p.to_string())
9211                    .collect::<Vec<String>>()
9212                    .join(",")
9213                    .to_string(),
9214            )]),
9215        };
9216    }
9217    if let Some(ref local_var_str) = q {
9218        local_var_req_builder = local_var_req_builder.query(&[("q", &local_var_str.to_string())]);
9219    }
9220    if let Some(ref local_var_str) = slug {
9221        local_var_req_builder = match "multi" {
9222            "multi" => local_var_req_builder.query(
9223                &local_var_str
9224                    .into_iter()
9225                    .map(|p| ("slug".to_owned(), p.to_string()))
9226                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9227            ),
9228            _ => local_var_req_builder.query(&[(
9229                "slug",
9230                &local_var_str
9231                    .into_iter()
9232                    .map(|p| p.to_string())
9233                    .collect::<Vec<String>>()
9234                    .join(",")
9235                    .to_string(),
9236            )]),
9237        };
9238    }
9239    if let Some(ref local_var_str) = slug__empty {
9240        local_var_req_builder =
9241            local_var_req_builder.query(&[("slug__empty", &local_var_str.to_string())]);
9242    }
9243    if let Some(ref local_var_str) = slug__ic {
9244        local_var_req_builder = match "multi" {
9245            "multi" => local_var_req_builder.query(
9246                &local_var_str
9247                    .into_iter()
9248                    .map(|p| ("slug__ic".to_owned(), p.to_string()))
9249                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9250            ),
9251            _ => local_var_req_builder.query(&[(
9252                "slug__ic",
9253                &local_var_str
9254                    .into_iter()
9255                    .map(|p| p.to_string())
9256                    .collect::<Vec<String>>()
9257                    .join(",")
9258                    .to_string(),
9259            )]),
9260        };
9261    }
9262    if let Some(ref local_var_str) = slug__ie {
9263        local_var_req_builder = match "multi" {
9264            "multi" => local_var_req_builder.query(
9265                &local_var_str
9266                    .into_iter()
9267                    .map(|p| ("slug__ie".to_owned(), p.to_string()))
9268                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9269            ),
9270            _ => local_var_req_builder.query(&[(
9271                "slug__ie",
9272                &local_var_str
9273                    .into_iter()
9274                    .map(|p| p.to_string())
9275                    .collect::<Vec<String>>()
9276                    .join(",")
9277                    .to_string(),
9278            )]),
9279        };
9280    }
9281    if let Some(ref local_var_str) = slug__iew {
9282        local_var_req_builder = match "multi" {
9283            "multi" => local_var_req_builder.query(
9284                &local_var_str
9285                    .into_iter()
9286                    .map(|p| ("slug__iew".to_owned(), p.to_string()))
9287                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9288            ),
9289            _ => local_var_req_builder.query(&[(
9290                "slug__iew",
9291                &local_var_str
9292                    .into_iter()
9293                    .map(|p| p.to_string())
9294                    .collect::<Vec<String>>()
9295                    .join(",")
9296                    .to_string(),
9297            )]),
9298        };
9299    }
9300    if let Some(ref local_var_str) = slug__iregex {
9301        local_var_req_builder = match "multi" {
9302            "multi" => local_var_req_builder.query(
9303                &local_var_str
9304                    .into_iter()
9305                    .map(|p| ("slug__iregex".to_owned(), p.to_string()))
9306                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9307            ),
9308            _ => local_var_req_builder.query(&[(
9309                "slug__iregex",
9310                &local_var_str
9311                    .into_iter()
9312                    .map(|p| p.to_string())
9313                    .collect::<Vec<String>>()
9314                    .join(",")
9315                    .to_string(),
9316            )]),
9317        };
9318    }
9319    if let Some(ref local_var_str) = slug__isw {
9320        local_var_req_builder = match "multi" {
9321            "multi" => local_var_req_builder.query(
9322                &local_var_str
9323                    .into_iter()
9324                    .map(|p| ("slug__isw".to_owned(), p.to_string()))
9325                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9326            ),
9327            _ => local_var_req_builder.query(&[(
9328                "slug__isw",
9329                &local_var_str
9330                    .into_iter()
9331                    .map(|p| p.to_string())
9332                    .collect::<Vec<String>>()
9333                    .join(",")
9334                    .to_string(),
9335            )]),
9336        };
9337    }
9338    if let Some(ref local_var_str) = slug__n {
9339        local_var_req_builder = match "multi" {
9340            "multi" => local_var_req_builder.query(
9341                &local_var_str
9342                    .into_iter()
9343                    .map(|p| ("slug__n".to_owned(), p.to_string()))
9344                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9345            ),
9346            _ => local_var_req_builder.query(&[(
9347                "slug__n",
9348                &local_var_str
9349                    .into_iter()
9350                    .map(|p| p.to_string())
9351                    .collect::<Vec<String>>()
9352                    .join(",")
9353                    .to_string(),
9354            )]),
9355        };
9356    }
9357    if let Some(ref local_var_str) = slug__nic {
9358        local_var_req_builder = match "multi" {
9359            "multi" => local_var_req_builder.query(
9360                &local_var_str
9361                    .into_iter()
9362                    .map(|p| ("slug__nic".to_owned(), p.to_string()))
9363                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9364            ),
9365            _ => local_var_req_builder.query(&[(
9366                "slug__nic",
9367                &local_var_str
9368                    .into_iter()
9369                    .map(|p| p.to_string())
9370                    .collect::<Vec<String>>()
9371                    .join(",")
9372                    .to_string(),
9373            )]),
9374        };
9375    }
9376    if let Some(ref local_var_str) = slug__nie {
9377        local_var_req_builder = match "multi" {
9378            "multi" => local_var_req_builder.query(
9379                &local_var_str
9380                    .into_iter()
9381                    .map(|p| ("slug__nie".to_owned(), p.to_string()))
9382                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9383            ),
9384            _ => local_var_req_builder.query(&[(
9385                "slug__nie",
9386                &local_var_str
9387                    .into_iter()
9388                    .map(|p| p.to_string())
9389                    .collect::<Vec<String>>()
9390                    .join(",")
9391                    .to_string(),
9392            )]),
9393        };
9394    }
9395    if let Some(ref local_var_str) = slug__niew {
9396        local_var_req_builder = match "multi" {
9397            "multi" => local_var_req_builder.query(
9398                &local_var_str
9399                    .into_iter()
9400                    .map(|p| ("slug__niew".to_owned(), p.to_string()))
9401                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9402            ),
9403            _ => local_var_req_builder.query(&[(
9404                "slug__niew",
9405                &local_var_str
9406                    .into_iter()
9407                    .map(|p| p.to_string())
9408                    .collect::<Vec<String>>()
9409                    .join(",")
9410                    .to_string(),
9411            )]),
9412        };
9413    }
9414    if let Some(ref local_var_str) = slug__nisw {
9415        local_var_req_builder = match "multi" {
9416            "multi" => local_var_req_builder.query(
9417                &local_var_str
9418                    .into_iter()
9419                    .map(|p| ("slug__nisw".to_owned(), p.to_string()))
9420                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9421            ),
9422            _ => local_var_req_builder.query(&[(
9423                "slug__nisw",
9424                &local_var_str
9425                    .into_iter()
9426                    .map(|p| p.to_string())
9427                    .collect::<Vec<String>>()
9428                    .join(",")
9429                    .to_string(),
9430            )]),
9431        };
9432    }
9433    if let Some(ref local_var_str) = slug__regex {
9434        local_var_req_builder = match "multi" {
9435            "multi" => local_var_req_builder.query(
9436                &local_var_str
9437                    .into_iter()
9438                    .map(|p| ("slug__regex".to_owned(), p.to_string()))
9439                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9440            ),
9441            _ => local_var_req_builder.query(&[(
9442                "slug__regex",
9443                &local_var_str
9444                    .into_iter()
9445                    .map(|p| p.to_string())
9446                    .collect::<Vec<String>>()
9447                    .join(",")
9448                    .to_string(),
9449            )]),
9450        };
9451    }
9452    if let Some(ref local_var_str) = start {
9453        local_var_req_builder =
9454            local_var_req_builder.query(&[("start", &local_var_str.to_string())]);
9455    }
9456    if let Some(ref local_var_str) = tag {
9457        local_var_req_builder = match "multi" {
9458            "multi" => local_var_req_builder.query(
9459                &local_var_str
9460                    .into_iter()
9461                    .map(|p| ("tag".to_owned(), p.to_string()))
9462                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9463            ),
9464            _ => local_var_req_builder.query(&[(
9465                "tag",
9466                &local_var_str
9467                    .into_iter()
9468                    .map(|p| p.to_string())
9469                    .collect::<Vec<String>>()
9470                    .join(",")
9471                    .to_string(),
9472            )]),
9473        };
9474    }
9475    if let Some(ref local_var_str) = tag__n {
9476        local_var_req_builder = match "multi" {
9477            "multi" => local_var_req_builder.query(
9478                &local_var_str
9479                    .into_iter()
9480                    .map(|p| ("tag__n".to_owned(), p.to_string()))
9481                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9482            ),
9483            _ => local_var_req_builder.query(&[(
9484                "tag__n",
9485                &local_var_str
9486                    .into_iter()
9487                    .map(|p| p.to_string())
9488                    .collect::<Vec<String>>()
9489                    .join(",")
9490                    .to_string(),
9491            )]),
9492        };
9493    }
9494    if let Some(ref local_var_str) = tag_id {
9495        local_var_req_builder = match "multi" {
9496            "multi" => local_var_req_builder.query(
9497                &local_var_str
9498                    .into_iter()
9499                    .map(|p| ("tag_id".to_owned(), p.to_string()))
9500                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9501            ),
9502            _ => local_var_req_builder.query(&[(
9503                "tag_id",
9504                &local_var_str
9505                    .into_iter()
9506                    .map(|p| p.to_string())
9507                    .collect::<Vec<String>>()
9508                    .join(",")
9509                    .to_string(),
9510            )]),
9511        };
9512    }
9513    if let Some(ref local_var_str) = tag_id__n {
9514        local_var_req_builder = match "multi" {
9515            "multi" => local_var_req_builder.query(
9516                &local_var_str
9517                    .into_iter()
9518                    .map(|p| ("tag_id__n".to_owned(), p.to_string()))
9519                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9520            ),
9521            _ => local_var_req_builder.query(&[(
9522                "tag_id__n",
9523                &local_var_str
9524                    .into_iter()
9525                    .map(|p| p.to_string())
9526                    .collect::<Vec<String>>()
9527                    .join(",")
9528                    .to_string(),
9529            )]),
9530        };
9531    }
9532    if let Some(ref local_var_str) = updated_by_request {
9533        local_var_req_builder =
9534            local_var_req_builder.query(&[("updated_by_request", &local_var_str.to_string())]);
9535    }
9536    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
9537        local_var_req_builder =
9538            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
9539    }
9540    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
9541        let local_var_key = local_var_apikey.key.clone();
9542        let local_var_value = match local_var_apikey.prefix {
9543            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
9544            None => local_var_key,
9545        };
9546        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
9547    };
9548
9549    let local_var_req = local_var_req_builder.build()?;
9550    let local_var_resp = local_var_client.execute(local_var_req).await?;
9551
9552    let local_var_status = local_var_resp.status();
9553    let local_var_content = local_var_resp.text().await?;
9554
9555    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
9556        serde_json::from_str(&local_var_content).map_err(Error::from)
9557    } else {
9558        let local_var_entity: Option<CircuitsCircuitTypesListError> =
9559            serde_json::from_str(&local_var_content).ok();
9560        let local_var_error = ResponseContent {
9561            status: local_var_status,
9562            content: local_var_content,
9563            entity: local_var_entity,
9564        };
9565        Err(Error::ResponseError(local_var_error))
9566    }
9567}
9568
9569/// Patch a circuit type object.
9570pub async fn circuits_circuit_types_partial_update(
9571    configuration: &configuration::Configuration,
9572    id: i32,
9573    patched_circuit_type_request: Option<crate::models::PatchedCircuitTypeRequest>,
9574) -> Result<crate::models::CircuitType, Error<CircuitsCircuitTypesPartialUpdateError>> {
9575    let local_var_configuration = configuration;
9576
9577    let local_var_client = &local_var_configuration.client;
9578
9579    let local_var_uri_str = format!(
9580        "{}/api/circuits/circuit-types/{id}/",
9581        local_var_configuration.base_path,
9582        id = id
9583    );
9584    let mut local_var_req_builder =
9585        local_var_client.request(reqwest::Method::PATCH, local_var_uri_str.as_str());
9586
9587    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
9588        local_var_req_builder =
9589            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
9590    }
9591    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
9592        let local_var_key = local_var_apikey.key.clone();
9593        let local_var_value = match local_var_apikey.prefix {
9594            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
9595            None => local_var_key,
9596        };
9597        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
9598    };
9599    local_var_req_builder = local_var_req_builder.json(&patched_circuit_type_request);
9600
9601    let local_var_req = local_var_req_builder.build()?;
9602    let local_var_resp = local_var_client.execute(local_var_req).await?;
9603
9604    let local_var_status = local_var_resp.status();
9605    let local_var_content = local_var_resp.text().await?;
9606
9607    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
9608        serde_json::from_str(&local_var_content).map_err(Error::from)
9609    } else {
9610        let local_var_entity: Option<CircuitsCircuitTypesPartialUpdateError> =
9611            serde_json::from_str(&local_var_content).ok();
9612        let local_var_error = ResponseContent {
9613            status: local_var_status,
9614            content: local_var_content,
9615            entity: local_var_entity,
9616        };
9617        Err(Error::ResponseError(local_var_error))
9618    }
9619}
9620
9621/// Get a circuit type object.
9622pub async fn circuits_circuit_types_retrieve(
9623    configuration: &configuration::Configuration,
9624    id: i32,
9625) -> Result<crate::models::CircuitType, Error<CircuitsCircuitTypesRetrieveError>> {
9626    let local_var_configuration = configuration;
9627
9628    let local_var_client = &local_var_configuration.client;
9629
9630    let local_var_uri_str = format!(
9631        "{}/api/circuits/circuit-types/{id}/",
9632        local_var_configuration.base_path,
9633        id = id
9634    );
9635    let mut local_var_req_builder =
9636        local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
9637
9638    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
9639        local_var_req_builder =
9640            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
9641    }
9642    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
9643        let local_var_key = local_var_apikey.key.clone();
9644        let local_var_value = match local_var_apikey.prefix {
9645            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
9646            None => local_var_key,
9647        };
9648        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
9649    };
9650
9651    let local_var_req = local_var_req_builder.build()?;
9652    let local_var_resp = local_var_client.execute(local_var_req).await?;
9653
9654    let local_var_status = local_var_resp.status();
9655    let local_var_content = local_var_resp.text().await?;
9656
9657    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
9658        serde_json::from_str(&local_var_content).map_err(Error::from)
9659    } else {
9660        let local_var_entity: Option<CircuitsCircuitTypesRetrieveError> =
9661            serde_json::from_str(&local_var_content).ok();
9662        let local_var_error = ResponseContent {
9663            status: local_var_status,
9664            content: local_var_content,
9665            entity: local_var_entity,
9666        };
9667        Err(Error::ResponseError(local_var_error))
9668    }
9669}
9670
9671/// Put a circuit type object.
9672pub async fn circuits_circuit_types_update(
9673    configuration: &configuration::Configuration,
9674    id: i32,
9675    circuit_type_request: crate::models::CircuitTypeRequest,
9676) -> Result<crate::models::CircuitType, Error<CircuitsCircuitTypesUpdateError>> {
9677    let local_var_configuration = configuration;
9678
9679    let local_var_client = &local_var_configuration.client;
9680
9681    let local_var_uri_str = format!(
9682        "{}/api/circuits/circuit-types/{id}/",
9683        local_var_configuration.base_path,
9684        id = id
9685    );
9686    let mut local_var_req_builder =
9687        local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());
9688
9689    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
9690        local_var_req_builder =
9691            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
9692    }
9693    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
9694        let local_var_key = local_var_apikey.key.clone();
9695        let local_var_value = match local_var_apikey.prefix {
9696            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
9697            None => local_var_key,
9698        };
9699        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
9700    };
9701    local_var_req_builder = local_var_req_builder.json(&circuit_type_request);
9702
9703    let local_var_req = local_var_req_builder.build()?;
9704    let local_var_resp = local_var_client.execute(local_var_req).await?;
9705
9706    let local_var_status = local_var_resp.status();
9707    let local_var_content = local_var_resp.text().await?;
9708
9709    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
9710        serde_json::from_str(&local_var_content).map_err(Error::from)
9711    } else {
9712        let local_var_entity: Option<CircuitsCircuitTypesUpdateError> =
9713            serde_json::from_str(&local_var_content).ok();
9714        let local_var_error = ResponseContent {
9715            status: local_var_status,
9716            content: local_var_content,
9717            entity: local_var_entity,
9718        };
9719        Err(Error::ResponseError(local_var_error))
9720    }
9721}
9722
9723/// Delete a list of circuit objects.
9724pub async fn circuits_circuits_bulk_destroy(
9725    configuration: &configuration::Configuration,
9726    circuit_request: Vec<crate::models::CircuitRequest>,
9727) -> Result<(), Error<CircuitsCircuitsBulkDestroyError>> {
9728    let local_var_configuration = configuration;
9729
9730    let local_var_client = &local_var_configuration.client;
9731
9732    let local_var_uri_str = format!(
9733        "{}/api/circuits/circuits/",
9734        local_var_configuration.base_path
9735    );
9736    let mut local_var_req_builder =
9737        local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());
9738
9739    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
9740        local_var_req_builder =
9741            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
9742    }
9743    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
9744        let local_var_key = local_var_apikey.key.clone();
9745        let local_var_value = match local_var_apikey.prefix {
9746            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
9747            None => local_var_key,
9748        };
9749        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
9750    };
9751    local_var_req_builder = local_var_req_builder.json(&circuit_request);
9752
9753    let local_var_req = local_var_req_builder.build()?;
9754    let local_var_resp = local_var_client.execute(local_var_req).await?;
9755
9756    let local_var_status = local_var_resp.status();
9757    let local_var_content = local_var_resp.text().await?;
9758
9759    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
9760        Ok(())
9761    } else {
9762        let local_var_entity: Option<CircuitsCircuitsBulkDestroyError> =
9763            serde_json::from_str(&local_var_content).ok();
9764        let local_var_error = ResponseContent {
9765            status: local_var_status,
9766            content: local_var_content,
9767            entity: local_var_entity,
9768        };
9769        Err(Error::ResponseError(local_var_error))
9770    }
9771}
9772
9773/// Patch a list of circuit objects.
9774pub async fn circuits_circuits_bulk_partial_update(
9775    configuration: &configuration::Configuration,
9776    circuit_request: Vec<crate::models::CircuitRequest>,
9777) -> Result<Vec<crate::models::Circuit>, Error<CircuitsCircuitsBulkPartialUpdateError>> {
9778    let local_var_configuration = configuration;
9779
9780    let local_var_client = &local_var_configuration.client;
9781
9782    let local_var_uri_str = format!(
9783        "{}/api/circuits/circuits/",
9784        local_var_configuration.base_path
9785    );
9786    let mut local_var_req_builder =
9787        local_var_client.request(reqwest::Method::PATCH, local_var_uri_str.as_str());
9788
9789    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
9790        local_var_req_builder =
9791            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
9792    }
9793    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
9794        let local_var_key = local_var_apikey.key.clone();
9795        let local_var_value = match local_var_apikey.prefix {
9796            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
9797            None => local_var_key,
9798        };
9799        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
9800    };
9801    local_var_req_builder = local_var_req_builder.json(&circuit_request);
9802
9803    let local_var_req = local_var_req_builder.build()?;
9804    let local_var_resp = local_var_client.execute(local_var_req).await?;
9805
9806    let local_var_status = local_var_resp.status();
9807    let local_var_content = local_var_resp.text().await?;
9808
9809    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
9810        serde_json::from_str(&local_var_content).map_err(Error::from)
9811    } else {
9812        let local_var_entity: Option<CircuitsCircuitsBulkPartialUpdateError> =
9813            serde_json::from_str(&local_var_content).ok();
9814        let local_var_error = ResponseContent {
9815            status: local_var_status,
9816            content: local_var_content,
9817            entity: local_var_entity,
9818        };
9819        Err(Error::ResponseError(local_var_error))
9820    }
9821}
9822
9823/// Put a list of circuit objects.
9824pub async fn circuits_circuits_bulk_update(
9825    configuration: &configuration::Configuration,
9826    circuit_request: Vec<crate::models::CircuitRequest>,
9827) -> Result<Vec<crate::models::Circuit>, Error<CircuitsCircuitsBulkUpdateError>> {
9828    let local_var_configuration = configuration;
9829
9830    let local_var_client = &local_var_configuration.client;
9831
9832    let local_var_uri_str = format!(
9833        "{}/api/circuits/circuits/",
9834        local_var_configuration.base_path
9835    );
9836    let mut local_var_req_builder =
9837        local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());
9838
9839    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
9840        local_var_req_builder =
9841            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
9842    }
9843    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
9844        let local_var_key = local_var_apikey.key.clone();
9845        let local_var_value = match local_var_apikey.prefix {
9846            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
9847            None => local_var_key,
9848        };
9849        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
9850    };
9851    local_var_req_builder = local_var_req_builder.json(&circuit_request);
9852
9853    let local_var_req = local_var_req_builder.build()?;
9854    let local_var_resp = local_var_client.execute(local_var_req).await?;
9855
9856    let local_var_status = local_var_resp.status();
9857    let local_var_content = local_var_resp.text().await?;
9858
9859    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
9860        serde_json::from_str(&local_var_content).map_err(Error::from)
9861    } else {
9862        let local_var_entity: Option<CircuitsCircuitsBulkUpdateError> =
9863            serde_json::from_str(&local_var_content).ok();
9864        let local_var_error = ResponseContent {
9865            status: local_var_status,
9866            content: local_var_content,
9867            entity: local_var_entity,
9868        };
9869        Err(Error::ResponseError(local_var_error))
9870    }
9871}
9872
9873/// Post a list of circuit objects.
9874pub async fn circuits_circuits_create(
9875    configuration: &configuration::Configuration,
9876    circuits_circuits_create_request: crate::models::CircuitsCircuitsCreateRequest,
9877) -> Result<crate::models::Circuit, Error<CircuitsCircuitsCreateError>> {
9878    let local_var_configuration = configuration;
9879
9880    let local_var_client = &local_var_configuration.client;
9881
9882    let local_var_uri_str = format!(
9883        "{}/api/circuits/circuits/",
9884        local_var_configuration.base_path
9885    );
9886    let mut local_var_req_builder =
9887        local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
9888
9889    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
9890        local_var_req_builder =
9891            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
9892    }
9893    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
9894        let local_var_key = local_var_apikey.key.clone();
9895        let local_var_value = match local_var_apikey.prefix {
9896            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
9897            None => local_var_key,
9898        };
9899        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
9900    };
9901    local_var_req_builder = local_var_req_builder.json(&circuits_circuits_create_request);
9902
9903    let local_var_req = local_var_req_builder.build()?;
9904    let local_var_resp = local_var_client.execute(local_var_req).await?;
9905
9906    let local_var_status = local_var_resp.status();
9907    let local_var_content = local_var_resp.text().await?;
9908
9909    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
9910        serde_json::from_str(&local_var_content).map_err(Error::from)
9911    } else {
9912        let local_var_entity: Option<CircuitsCircuitsCreateError> =
9913            serde_json::from_str(&local_var_content).ok();
9914        let local_var_error = ResponseContent {
9915            status: local_var_status,
9916            content: local_var_content,
9917            entity: local_var_entity,
9918        };
9919        Err(Error::ResponseError(local_var_error))
9920    }
9921}
9922
9923/// Delete a circuit object.
9924pub async fn circuits_circuits_destroy(
9925    configuration: &configuration::Configuration,
9926    id: i32,
9927) -> Result<(), Error<CircuitsCircuitsDestroyError>> {
9928    let local_var_configuration = configuration;
9929
9930    let local_var_client = &local_var_configuration.client;
9931
9932    let local_var_uri_str = format!(
9933        "{}/api/circuits/circuits/{id}/",
9934        local_var_configuration.base_path,
9935        id = id
9936    );
9937    let mut local_var_req_builder =
9938        local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());
9939
9940    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
9941        local_var_req_builder =
9942            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
9943    }
9944    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
9945        let local_var_key = local_var_apikey.key.clone();
9946        let local_var_value = match local_var_apikey.prefix {
9947            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
9948            None => local_var_key,
9949        };
9950        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
9951    };
9952
9953    let local_var_req = local_var_req_builder.build()?;
9954    let local_var_resp = local_var_client.execute(local_var_req).await?;
9955
9956    let local_var_status = local_var_resp.status();
9957    let local_var_content = local_var_resp.text().await?;
9958
9959    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
9960        Ok(())
9961    } else {
9962        let local_var_entity: Option<CircuitsCircuitsDestroyError> =
9963            serde_json::from_str(&local_var_content).ok();
9964        let local_var_error = ResponseContent {
9965            status: local_var_status,
9966            content: local_var_content,
9967            entity: local_var_entity,
9968        };
9969        Err(Error::ResponseError(local_var_error))
9970    }
9971}
9972
9973/// Get a list of circuit objects.
9974pub async fn circuits_circuits_list(
9975    configuration: &configuration::Configuration,
9976    cid: Option<Vec<String>>,
9977    cid__empty: Option<bool>,
9978    cid__ic: Option<Vec<String>>,
9979    cid__ie: Option<Vec<String>>,
9980    cid__iew: Option<Vec<String>>,
9981    cid__iregex: Option<Vec<String>>,
9982    cid__isw: Option<Vec<String>>,
9983    cid__n: Option<Vec<String>>,
9984    cid__nic: Option<Vec<String>>,
9985    cid__nie: Option<Vec<String>>,
9986    cid__niew: Option<Vec<String>>,
9987    cid__nisw: Option<Vec<String>>,
9988    cid__regex: Option<Vec<String>>,
9989    commit_rate: Option<Vec<i32>>,
9990    commit_rate__empty: Option<bool>,
9991    commit_rate__gt: Option<Vec<i32>>,
9992    commit_rate__gte: Option<Vec<i32>>,
9993    commit_rate__lt: Option<Vec<i32>>,
9994    commit_rate__lte: Option<Vec<i32>>,
9995    commit_rate__n: Option<Vec<i32>>,
9996    contact: Option<Vec<i32>>,
9997    contact__n: Option<Vec<i32>>,
9998    contact_group: Option<Vec<String>>,
9999    contact_group__n: Option<Vec<String>>,
10000    contact_role: Option<Vec<i32>>,
10001    contact_role__n: Option<Vec<i32>>,
10002    created: Option<Vec<String>>,
10003    created__empty: Option<Vec<String>>,
10004    created__gt: Option<Vec<String>>,
10005    created__gte: Option<Vec<String>>,
10006    created__lt: Option<Vec<String>>,
10007    created__lte: Option<Vec<String>>,
10008    created__n: Option<Vec<String>>,
10009    created_by_request: Option<&str>,
10010    description: Option<Vec<String>>,
10011    description__empty: Option<bool>,
10012    description__ic: Option<Vec<String>>,
10013    description__ie: Option<Vec<String>>,
10014    description__iew: Option<Vec<String>>,
10015    description__iregex: Option<Vec<String>>,
10016    description__isw: Option<Vec<String>>,
10017    description__n: Option<Vec<String>>,
10018    description__nic: Option<Vec<String>>,
10019    description__nie: Option<Vec<String>>,
10020    description__niew: Option<Vec<String>>,
10021    description__nisw: Option<Vec<String>>,
10022    description__regex: Option<Vec<String>>,
10023    distance: Option<Vec<f64>>,
10024    distance__empty: Option<bool>,
10025    distance__gt: Option<Vec<f64>>,
10026    distance__gte: Option<Vec<f64>>,
10027    distance__lt: Option<Vec<f64>>,
10028    distance__lte: Option<Vec<f64>>,
10029    distance__n: Option<Vec<f64>>,
10030    distance_unit: Option<&str>,
10031    distance_unit__empty: Option<bool>,
10032    distance_unit__ic: Option<Vec<String>>,
10033    distance_unit__ie: Option<Vec<String>>,
10034    distance_unit__iew: Option<Vec<String>>,
10035    distance_unit__iregex: Option<Vec<String>>,
10036    distance_unit__isw: Option<Vec<String>>,
10037    distance_unit__n: Option<&str>,
10038    distance_unit__nic: Option<Vec<String>>,
10039    distance_unit__nie: Option<Vec<String>>,
10040    distance_unit__niew: Option<Vec<String>>,
10041    distance_unit__nisw: Option<Vec<String>>,
10042    distance_unit__regex: Option<Vec<String>>,
10043    id: Option<Vec<i32>>,
10044    id__empty: Option<bool>,
10045    id__gt: Option<Vec<i32>>,
10046    id__gte: Option<Vec<i32>>,
10047    id__lt: Option<Vec<i32>>,
10048    id__lte: Option<Vec<i32>>,
10049    id__n: Option<Vec<i32>>,
10050    install_date: Option<Vec<String>>,
10051    install_date__empty: Option<bool>,
10052    install_date__gt: Option<Vec<String>>,
10053    install_date__gte: Option<Vec<String>>,
10054    install_date__lt: Option<Vec<String>>,
10055    install_date__lte: Option<Vec<String>>,
10056    install_date__n: Option<Vec<String>>,
10057    last_updated: Option<Vec<String>>,
10058    last_updated__empty: Option<Vec<String>>,
10059    last_updated__gt: Option<Vec<String>>,
10060    last_updated__gte: Option<Vec<String>>,
10061    last_updated__lt: Option<Vec<String>>,
10062    last_updated__lte: Option<Vec<String>>,
10063    last_updated__n: Option<Vec<String>>,
10064    limit: Option<i32>,
10065    location_id: Option<Vec<i32>>,
10066    location_id__n: Option<Vec<i32>>,
10067    modified_by_request: Option<&str>,
10068    offset: Option<i32>,
10069    ordering: Option<&str>,
10070    owner: Option<Vec<String>>,
10071    owner__n: Option<Vec<String>>,
10072    owner_group: Option<Vec<String>>,
10073    owner_group__n: Option<Vec<String>>,
10074    owner_group_id: Option<Vec<i32>>,
10075    owner_group_id__n: Option<Vec<i32>>,
10076    owner_id: Option<Vec<i32>>,
10077    owner_id__n: Option<Vec<i32>>,
10078    provider: Option<Vec<String>>,
10079    provider__n: Option<Vec<String>>,
10080    provider_account: Option<Vec<String>>,
10081    provider_account__n: Option<Vec<String>>,
10082    provider_account_id: Option<Vec<i32>>,
10083    provider_account_id__n: Option<Vec<i32>>,
10084    provider_id: Option<Vec<i32>>,
10085    provider_id__n: Option<Vec<i32>>,
10086    provider_network_id: Option<Vec<i32>>,
10087    provider_network_id__n: Option<Vec<i32>>,
10088    q: Option<&str>,
10089    region: Option<Vec<String>>,
10090    region__n: Option<Vec<String>>,
10091    region_id: Option<Vec<String>>,
10092    region_id__n: Option<Vec<String>>,
10093    site: Option<Vec<String>>,
10094    site__n: Option<Vec<String>>,
10095    site_group: Option<Vec<String>>,
10096    site_group__n: Option<Vec<String>>,
10097    site_group_id: Option<Vec<String>>,
10098    site_group_id__n: Option<Vec<String>>,
10099    site_id: Option<Vec<i32>>,
10100    site_id__n: Option<Vec<i32>>,
10101    start: Option<i32>,
10102    status: Option<Vec<String>>,
10103    status__empty: Option<bool>,
10104    status__ic: Option<Vec<String>>,
10105    status__ie: Option<Vec<String>>,
10106    status__iew: Option<Vec<String>>,
10107    status__iregex: Option<Vec<String>>,
10108    status__isw: Option<Vec<String>>,
10109    status__n: Option<Vec<String>>,
10110    status__nic: Option<Vec<String>>,
10111    status__nie: Option<Vec<String>>,
10112    status__niew: Option<Vec<String>>,
10113    status__nisw: Option<Vec<String>>,
10114    status__regex: Option<Vec<String>>,
10115    tag: Option<Vec<String>>,
10116    tag__n: Option<Vec<String>>,
10117    tag_id: Option<Vec<i32>>,
10118    tag_id__n: Option<Vec<i32>>,
10119    tenant: Option<Vec<String>>,
10120    tenant__n: Option<Vec<String>>,
10121    tenant_group: Option<Vec<String>>,
10122    tenant_group__n: Option<Vec<String>>,
10123    tenant_group_id: Option<Vec<String>>,
10124    tenant_group_id__n: Option<Vec<String>>,
10125    tenant_id: Option<Vec<i32>>,
10126    tenant_id__n: Option<Vec<i32>>,
10127    termination_a_id: Option<Vec<i32>>,
10128    termination_a_id__n: Option<Vec<i32>>,
10129    termination_date: Option<Vec<String>>,
10130    termination_date__empty: Option<bool>,
10131    termination_date__gt: Option<Vec<String>>,
10132    termination_date__gte: Option<Vec<String>>,
10133    termination_date__lt: Option<Vec<String>>,
10134    termination_date__lte: Option<Vec<String>>,
10135    termination_date__n: Option<Vec<String>>,
10136    termination_z_id: Option<Vec<i32>>,
10137    termination_z_id__n: Option<Vec<i32>>,
10138    r#type: Option<Vec<String>>,
10139    type__n: Option<Vec<String>>,
10140    type_id: Option<Vec<i32>>,
10141    type_id__n: Option<Vec<i32>>,
10142    updated_by_request: Option<&str>,
10143) -> Result<crate::models::PaginatedCircuitList, Error<CircuitsCircuitsListError>> {
10144    let local_var_configuration = configuration;
10145
10146    let local_var_client = &local_var_configuration.client;
10147
10148    let local_var_uri_str = format!(
10149        "{}/api/circuits/circuits/",
10150        local_var_configuration.base_path
10151    );
10152    let mut local_var_req_builder =
10153        local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
10154
10155    if let Some(ref local_var_str) = cid {
10156        local_var_req_builder = match "multi" {
10157            "multi" => local_var_req_builder.query(
10158                &local_var_str
10159                    .into_iter()
10160                    .map(|p| ("cid".to_owned(), p.to_string()))
10161                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10162            ),
10163            _ => local_var_req_builder.query(&[(
10164                "cid",
10165                &local_var_str
10166                    .into_iter()
10167                    .map(|p| p.to_string())
10168                    .collect::<Vec<String>>()
10169                    .join(",")
10170                    .to_string(),
10171            )]),
10172        };
10173    }
10174    if let Some(ref local_var_str) = cid__empty {
10175        local_var_req_builder =
10176            local_var_req_builder.query(&[("cid__empty", &local_var_str.to_string())]);
10177    }
10178    if let Some(ref local_var_str) = cid__ic {
10179        local_var_req_builder = match "multi" {
10180            "multi" => local_var_req_builder.query(
10181                &local_var_str
10182                    .into_iter()
10183                    .map(|p| ("cid__ic".to_owned(), p.to_string()))
10184                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10185            ),
10186            _ => local_var_req_builder.query(&[(
10187                "cid__ic",
10188                &local_var_str
10189                    .into_iter()
10190                    .map(|p| p.to_string())
10191                    .collect::<Vec<String>>()
10192                    .join(",")
10193                    .to_string(),
10194            )]),
10195        };
10196    }
10197    if let Some(ref local_var_str) = cid__ie {
10198        local_var_req_builder = match "multi" {
10199            "multi" => local_var_req_builder.query(
10200                &local_var_str
10201                    .into_iter()
10202                    .map(|p| ("cid__ie".to_owned(), p.to_string()))
10203                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10204            ),
10205            _ => local_var_req_builder.query(&[(
10206                "cid__ie",
10207                &local_var_str
10208                    .into_iter()
10209                    .map(|p| p.to_string())
10210                    .collect::<Vec<String>>()
10211                    .join(",")
10212                    .to_string(),
10213            )]),
10214        };
10215    }
10216    if let Some(ref local_var_str) = cid__iew {
10217        local_var_req_builder = match "multi" {
10218            "multi" => local_var_req_builder.query(
10219                &local_var_str
10220                    .into_iter()
10221                    .map(|p| ("cid__iew".to_owned(), p.to_string()))
10222                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10223            ),
10224            _ => local_var_req_builder.query(&[(
10225                "cid__iew",
10226                &local_var_str
10227                    .into_iter()
10228                    .map(|p| p.to_string())
10229                    .collect::<Vec<String>>()
10230                    .join(",")
10231                    .to_string(),
10232            )]),
10233        };
10234    }
10235    if let Some(ref local_var_str) = cid__iregex {
10236        local_var_req_builder = match "multi" {
10237            "multi" => local_var_req_builder.query(
10238                &local_var_str
10239                    .into_iter()
10240                    .map(|p| ("cid__iregex".to_owned(), p.to_string()))
10241                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10242            ),
10243            _ => local_var_req_builder.query(&[(
10244                "cid__iregex",
10245                &local_var_str
10246                    .into_iter()
10247                    .map(|p| p.to_string())
10248                    .collect::<Vec<String>>()
10249                    .join(",")
10250                    .to_string(),
10251            )]),
10252        };
10253    }
10254    if let Some(ref local_var_str) = cid__isw {
10255        local_var_req_builder = match "multi" {
10256            "multi" => local_var_req_builder.query(
10257                &local_var_str
10258                    .into_iter()
10259                    .map(|p| ("cid__isw".to_owned(), p.to_string()))
10260                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10261            ),
10262            _ => local_var_req_builder.query(&[(
10263                "cid__isw",
10264                &local_var_str
10265                    .into_iter()
10266                    .map(|p| p.to_string())
10267                    .collect::<Vec<String>>()
10268                    .join(",")
10269                    .to_string(),
10270            )]),
10271        };
10272    }
10273    if let Some(ref local_var_str) = cid__n {
10274        local_var_req_builder = match "multi" {
10275            "multi" => local_var_req_builder.query(
10276                &local_var_str
10277                    .into_iter()
10278                    .map(|p| ("cid__n".to_owned(), p.to_string()))
10279                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10280            ),
10281            _ => local_var_req_builder.query(&[(
10282                "cid__n",
10283                &local_var_str
10284                    .into_iter()
10285                    .map(|p| p.to_string())
10286                    .collect::<Vec<String>>()
10287                    .join(",")
10288                    .to_string(),
10289            )]),
10290        };
10291    }
10292    if let Some(ref local_var_str) = cid__nic {
10293        local_var_req_builder = match "multi" {
10294            "multi" => local_var_req_builder.query(
10295                &local_var_str
10296                    .into_iter()
10297                    .map(|p| ("cid__nic".to_owned(), p.to_string()))
10298                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10299            ),
10300            _ => local_var_req_builder.query(&[(
10301                "cid__nic",
10302                &local_var_str
10303                    .into_iter()
10304                    .map(|p| p.to_string())
10305                    .collect::<Vec<String>>()
10306                    .join(",")
10307                    .to_string(),
10308            )]),
10309        };
10310    }
10311    if let Some(ref local_var_str) = cid__nie {
10312        local_var_req_builder = match "multi" {
10313            "multi" => local_var_req_builder.query(
10314                &local_var_str
10315                    .into_iter()
10316                    .map(|p| ("cid__nie".to_owned(), p.to_string()))
10317                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10318            ),
10319            _ => local_var_req_builder.query(&[(
10320                "cid__nie",
10321                &local_var_str
10322                    .into_iter()
10323                    .map(|p| p.to_string())
10324                    .collect::<Vec<String>>()
10325                    .join(",")
10326                    .to_string(),
10327            )]),
10328        };
10329    }
10330    if let Some(ref local_var_str) = cid__niew {
10331        local_var_req_builder = match "multi" {
10332            "multi" => local_var_req_builder.query(
10333                &local_var_str
10334                    .into_iter()
10335                    .map(|p| ("cid__niew".to_owned(), p.to_string()))
10336                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10337            ),
10338            _ => local_var_req_builder.query(&[(
10339                "cid__niew",
10340                &local_var_str
10341                    .into_iter()
10342                    .map(|p| p.to_string())
10343                    .collect::<Vec<String>>()
10344                    .join(",")
10345                    .to_string(),
10346            )]),
10347        };
10348    }
10349    if let Some(ref local_var_str) = cid__nisw {
10350        local_var_req_builder = match "multi" {
10351            "multi" => local_var_req_builder.query(
10352                &local_var_str
10353                    .into_iter()
10354                    .map(|p| ("cid__nisw".to_owned(), p.to_string()))
10355                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10356            ),
10357            _ => local_var_req_builder.query(&[(
10358                "cid__nisw",
10359                &local_var_str
10360                    .into_iter()
10361                    .map(|p| p.to_string())
10362                    .collect::<Vec<String>>()
10363                    .join(",")
10364                    .to_string(),
10365            )]),
10366        };
10367    }
10368    if let Some(ref local_var_str) = cid__regex {
10369        local_var_req_builder = match "multi" {
10370            "multi" => local_var_req_builder.query(
10371                &local_var_str
10372                    .into_iter()
10373                    .map(|p| ("cid__regex".to_owned(), p.to_string()))
10374                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10375            ),
10376            _ => local_var_req_builder.query(&[(
10377                "cid__regex",
10378                &local_var_str
10379                    .into_iter()
10380                    .map(|p| p.to_string())
10381                    .collect::<Vec<String>>()
10382                    .join(",")
10383                    .to_string(),
10384            )]),
10385        };
10386    }
10387    if let Some(ref local_var_str) = commit_rate {
10388        local_var_req_builder = match "multi" {
10389            "multi" => local_var_req_builder.query(
10390                &local_var_str
10391                    .into_iter()
10392                    .map(|p| ("commit_rate".to_owned(), p.to_string()))
10393                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10394            ),
10395            _ => local_var_req_builder.query(&[(
10396                "commit_rate",
10397                &local_var_str
10398                    .into_iter()
10399                    .map(|p| p.to_string())
10400                    .collect::<Vec<String>>()
10401                    .join(",")
10402                    .to_string(),
10403            )]),
10404        };
10405    }
10406    if let Some(ref local_var_str) = commit_rate__empty {
10407        local_var_req_builder =
10408            local_var_req_builder.query(&[("commit_rate__empty", &local_var_str.to_string())]);
10409    }
10410    if let Some(ref local_var_str) = commit_rate__gt {
10411        local_var_req_builder = match "multi" {
10412            "multi" => local_var_req_builder.query(
10413                &local_var_str
10414                    .into_iter()
10415                    .map(|p| ("commit_rate__gt".to_owned(), p.to_string()))
10416                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10417            ),
10418            _ => local_var_req_builder.query(&[(
10419                "commit_rate__gt",
10420                &local_var_str
10421                    .into_iter()
10422                    .map(|p| p.to_string())
10423                    .collect::<Vec<String>>()
10424                    .join(",")
10425                    .to_string(),
10426            )]),
10427        };
10428    }
10429    if let Some(ref local_var_str) = commit_rate__gte {
10430        local_var_req_builder = match "multi" {
10431            "multi" => local_var_req_builder.query(
10432                &local_var_str
10433                    .into_iter()
10434                    .map(|p| ("commit_rate__gte".to_owned(), p.to_string()))
10435                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10436            ),
10437            _ => local_var_req_builder.query(&[(
10438                "commit_rate__gte",
10439                &local_var_str
10440                    .into_iter()
10441                    .map(|p| p.to_string())
10442                    .collect::<Vec<String>>()
10443                    .join(",")
10444                    .to_string(),
10445            )]),
10446        };
10447    }
10448    if let Some(ref local_var_str) = commit_rate__lt {
10449        local_var_req_builder = match "multi" {
10450            "multi" => local_var_req_builder.query(
10451                &local_var_str
10452                    .into_iter()
10453                    .map(|p| ("commit_rate__lt".to_owned(), p.to_string()))
10454                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10455            ),
10456            _ => local_var_req_builder.query(&[(
10457                "commit_rate__lt",
10458                &local_var_str
10459                    .into_iter()
10460                    .map(|p| p.to_string())
10461                    .collect::<Vec<String>>()
10462                    .join(",")
10463                    .to_string(),
10464            )]),
10465        };
10466    }
10467    if let Some(ref local_var_str) = commit_rate__lte {
10468        local_var_req_builder = match "multi" {
10469            "multi" => local_var_req_builder.query(
10470                &local_var_str
10471                    .into_iter()
10472                    .map(|p| ("commit_rate__lte".to_owned(), p.to_string()))
10473                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10474            ),
10475            _ => local_var_req_builder.query(&[(
10476                "commit_rate__lte",
10477                &local_var_str
10478                    .into_iter()
10479                    .map(|p| p.to_string())
10480                    .collect::<Vec<String>>()
10481                    .join(",")
10482                    .to_string(),
10483            )]),
10484        };
10485    }
10486    if let Some(ref local_var_str) = commit_rate__n {
10487        local_var_req_builder = match "multi" {
10488            "multi" => local_var_req_builder.query(
10489                &local_var_str
10490                    .into_iter()
10491                    .map(|p| ("commit_rate__n".to_owned(), p.to_string()))
10492                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10493            ),
10494            _ => local_var_req_builder.query(&[(
10495                "commit_rate__n",
10496                &local_var_str
10497                    .into_iter()
10498                    .map(|p| p.to_string())
10499                    .collect::<Vec<String>>()
10500                    .join(",")
10501                    .to_string(),
10502            )]),
10503        };
10504    }
10505    if let Some(ref local_var_str) = contact {
10506        local_var_req_builder = match "multi" {
10507            "multi" => local_var_req_builder.query(
10508                &local_var_str
10509                    .into_iter()
10510                    .map(|p| ("contact".to_owned(), p.to_string()))
10511                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10512            ),
10513            _ => local_var_req_builder.query(&[(
10514                "contact",
10515                &local_var_str
10516                    .into_iter()
10517                    .map(|p| p.to_string())
10518                    .collect::<Vec<String>>()
10519                    .join(",")
10520                    .to_string(),
10521            )]),
10522        };
10523    }
10524    if let Some(ref local_var_str) = contact__n {
10525        local_var_req_builder = match "multi" {
10526            "multi" => local_var_req_builder.query(
10527                &local_var_str
10528                    .into_iter()
10529                    .map(|p| ("contact__n".to_owned(), p.to_string()))
10530                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10531            ),
10532            _ => local_var_req_builder.query(&[(
10533                "contact__n",
10534                &local_var_str
10535                    .into_iter()
10536                    .map(|p| p.to_string())
10537                    .collect::<Vec<String>>()
10538                    .join(",")
10539                    .to_string(),
10540            )]),
10541        };
10542    }
10543    if let Some(ref local_var_str) = contact_group {
10544        local_var_req_builder = match "multi" {
10545            "multi" => local_var_req_builder.query(
10546                &local_var_str
10547                    .into_iter()
10548                    .map(|p| ("contact_group".to_owned(), p.to_string()))
10549                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10550            ),
10551            _ => local_var_req_builder.query(&[(
10552                "contact_group",
10553                &local_var_str
10554                    .into_iter()
10555                    .map(|p| p.to_string())
10556                    .collect::<Vec<String>>()
10557                    .join(",")
10558                    .to_string(),
10559            )]),
10560        };
10561    }
10562    if let Some(ref local_var_str) = contact_group__n {
10563        local_var_req_builder = match "multi" {
10564            "multi" => local_var_req_builder.query(
10565                &local_var_str
10566                    .into_iter()
10567                    .map(|p| ("contact_group__n".to_owned(), p.to_string()))
10568                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10569            ),
10570            _ => local_var_req_builder.query(&[(
10571                "contact_group__n",
10572                &local_var_str
10573                    .into_iter()
10574                    .map(|p| p.to_string())
10575                    .collect::<Vec<String>>()
10576                    .join(",")
10577                    .to_string(),
10578            )]),
10579        };
10580    }
10581    if let Some(ref local_var_str) = contact_role {
10582        local_var_req_builder = match "multi" {
10583            "multi" => local_var_req_builder.query(
10584                &local_var_str
10585                    .into_iter()
10586                    .map(|p| ("contact_role".to_owned(), p.to_string()))
10587                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10588            ),
10589            _ => local_var_req_builder.query(&[(
10590                "contact_role",
10591                &local_var_str
10592                    .into_iter()
10593                    .map(|p| p.to_string())
10594                    .collect::<Vec<String>>()
10595                    .join(",")
10596                    .to_string(),
10597            )]),
10598        };
10599    }
10600    if let Some(ref local_var_str) = contact_role__n {
10601        local_var_req_builder = match "multi" {
10602            "multi" => local_var_req_builder.query(
10603                &local_var_str
10604                    .into_iter()
10605                    .map(|p| ("contact_role__n".to_owned(), p.to_string()))
10606                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10607            ),
10608            _ => local_var_req_builder.query(&[(
10609                "contact_role__n",
10610                &local_var_str
10611                    .into_iter()
10612                    .map(|p| p.to_string())
10613                    .collect::<Vec<String>>()
10614                    .join(",")
10615                    .to_string(),
10616            )]),
10617        };
10618    }
10619    if let Some(ref local_var_str) = created {
10620        local_var_req_builder = match "multi" {
10621            "multi" => local_var_req_builder.query(
10622                &local_var_str
10623                    .into_iter()
10624                    .map(|p| ("created".to_owned(), p.to_string()))
10625                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10626            ),
10627            _ => local_var_req_builder.query(&[(
10628                "created",
10629                &local_var_str
10630                    .into_iter()
10631                    .map(|p| p.to_string())
10632                    .collect::<Vec<String>>()
10633                    .join(",")
10634                    .to_string(),
10635            )]),
10636        };
10637    }
10638    if let Some(ref local_var_str) = created__empty {
10639        local_var_req_builder = match "multi" {
10640            "multi" => local_var_req_builder.query(
10641                &local_var_str
10642                    .into_iter()
10643                    .map(|p| ("created__empty".to_owned(), p.to_string()))
10644                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10645            ),
10646            _ => local_var_req_builder.query(&[(
10647                "created__empty",
10648                &local_var_str
10649                    .into_iter()
10650                    .map(|p| p.to_string())
10651                    .collect::<Vec<String>>()
10652                    .join(",")
10653                    .to_string(),
10654            )]),
10655        };
10656    }
10657    if let Some(ref local_var_str) = created__gt {
10658        local_var_req_builder = match "multi" {
10659            "multi" => local_var_req_builder.query(
10660                &local_var_str
10661                    .into_iter()
10662                    .map(|p| ("created__gt".to_owned(), p.to_string()))
10663                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10664            ),
10665            _ => local_var_req_builder.query(&[(
10666                "created__gt",
10667                &local_var_str
10668                    .into_iter()
10669                    .map(|p| p.to_string())
10670                    .collect::<Vec<String>>()
10671                    .join(",")
10672                    .to_string(),
10673            )]),
10674        };
10675    }
10676    if let Some(ref local_var_str) = created__gte {
10677        local_var_req_builder = match "multi" {
10678            "multi" => local_var_req_builder.query(
10679                &local_var_str
10680                    .into_iter()
10681                    .map(|p| ("created__gte".to_owned(), p.to_string()))
10682                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10683            ),
10684            _ => local_var_req_builder.query(&[(
10685                "created__gte",
10686                &local_var_str
10687                    .into_iter()
10688                    .map(|p| p.to_string())
10689                    .collect::<Vec<String>>()
10690                    .join(",")
10691                    .to_string(),
10692            )]),
10693        };
10694    }
10695    if let Some(ref local_var_str) = created__lt {
10696        local_var_req_builder = match "multi" {
10697            "multi" => local_var_req_builder.query(
10698                &local_var_str
10699                    .into_iter()
10700                    .map(|p| ("created__lt".to_owned(), p.to_string()))
10701                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10702            ),
10703            _ => local_var_req_builder.query(&[(
10704                "created__lt",
10705                &local_var_str
10706                    .into_iter()
10707                    .map(|p| p.to_string())
10708                    .collect::<Vec<String>>()
10709                    .join(",")
10710                    .to_string(),
10711            )]),
10712        };
10713    }
10714    if let Some(ref local_var_str) = created__lte {
10715        local_var_req_builder = match "multi" {
10716            "multi" => local_var_req_builder.query(
10717                &local_var_str
10718                    .into_iter()
10719                    .map(|p| ("created__lte".to_owned(), p.to_string()))
10720                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10721            ),
10722            _ => local_var_req_builder.query(&[(
10723                "created__lte",
10724                &local_var_str
10725                    .into_iter()
10726                    .map(|p| p.to_string())
10727                    .collect::<Vec<String>>()
10728                    .join(",")
10729                    .to_string(),
10730            )]),
10731        };
10732    }
10733    if let Some(ref local_var_str) = created__n {
10734        local_var_req_builder = match "multi" {
10735            "multi" => local_var_req_builder.query(
10736                &local_var_str
10737                    .into_iter()
10738                    .map(|p| ("created__n".to_owned(), p.to_string()))
10739                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10740            ),
10741            _ => local_var_req_builder.query(&[(
10742                "created__n",
10743                &local_var_str
10744                    .into_iter()
10745                    .map(|p| p.to_string())
10746                    .collect::<Vec<String>>()
10747                    .join(",")
10748                    .to_string(),
10749            )]),
10750        };
10751    }
10752    if let Some(ref local_var_str) = created_by_request {
10753        local_var_req_builder =
10754            local_var_req_builder.query(&[("created_by_request", &local_var_str.to_string())]);
10755    }
10756    if let Some(ref local_var_str) = description {
10757        local_var_req_builder = match "multi" {
10758            "multi" => local_var_req_builder.query(
10759                &local_var_str
10760                    .into_iter()
10761                    .map(|p| ("description".to_owned(), p.to_string()))
10762                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10763            ),
10764            _ => local_var_req_builder.query(&[(
10765                "description",
10766                &local_var_str
10767                    .into_iter()
10768                    .map(|p| p.to_string())
10769                    .collect::<Vec<String>>()
10770                    .join(",")
10771                    .to_string(),
10772            )]),
10773        };
10774    }
10775    if let Some(ref local_var_str) = description__empty {
10776        local_var_req_builder =
10777            local_var_req_builder.query(&[("description__empty", &local_var_str.to_string())]);
10778    }
10779    if let Some(ref local_var_str) = description__ic {
10780        local_var_req_builder = match "multi" {
10781            "multi" => local_var_req_builder.query(
10782                &local_var_str
10783                    .into_iter()
10784                    .map(|p| ("description__ic".to_owned(), p.to_string()))
10785                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10786            ),
10787            _ => local_var_req_builder.query(&[(
10788                "description__ic",
10789                &local_var_str
10790                    .into_iter()
10791                    .map(|p| p.to_string())
10792                    .collect::<Vec<String>>()
10793                    .join(",")
10794                    .to_string(),
10795            )]),
10796        };
10797    }
10798    if let Some(ref local_var_str) = description__ie {
10799        local_var_req_builder = match "multi" {
10800            "multi" => local_var_req_builder.query(
10801                &local_var_str
10802                    .into_iter()
10803                    .map(|p| ("description__ie".to_owned(), p.to_string()))
10804                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10805            ),
10806            _ => local_var_req_builder.query(&[(
10807                "description__ie",
10808                &local_var_str
10809                    .into_iter()
10810                    .map(|p| p.to_string())
10811                    .collect::<Vec<String>>()
10812                    .join(",")
10813                    .to_string(),
10814            )]),
10815        };
10816    }
10817    if let Some(ref local_var_str) = description__iew {
10818        local_var_req_builder = match "multi" {
10819            "multi" => local_var_req_builder.query(
10820                &local_var_str
10821                    .into_iter()
10822                    .map(|p| ("description__iew".to_owned(), p.to_string()))
10823                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10824            ),
10825            _ => local_var_req_builder.query(&[(
10826                "description__iew",
10827                &local_var_str
10828                    .into_iter()
10829                    .map(|p| p.to_string())
10830                    .collect::<Vec<String>>()
10831                    .join(",")
10832                    .to_string(),
10833            )]),
10834        };
10835    }
10836    if let Some(ref local_var_str) = description__iregex {
10837        local_var_req_builder = match "multi" {
10838            "multi" => local_var_req_builder.query(
10839                &local_var_str
10840                    .into_iter()
10841                    .map(|p| ("description__iregex".to_owned(), p.to_string()))
10842                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10843            ),
10844            _ => local_var_req_builder.query(&[(
10845                "description__iregex",
10846                &local_var_str
10847                    .into_iter()
10848                    .map(|p| p.to_string())
10849                    .collect::<Vec<String>>()
10850                    .join(",")
10851                    .to_string(),
10852            )]),
10853        };
10854    }
10855    if let Some(ref local_var_str) = description__isw {
10856        local_var_req_builder = match "multi" {
10857            "multi" => local_var_req_builder.query(
10858                &local_var_str
10859                    .into_iter()
10860                    .map(|p| ("description__isw".to_owned(), p.to_string()))
10861                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10862            ),
10863            _ => local_var_req_builder.query(&[(
10864                "description__isw",
10865                &local_var_str
10866                    .into_iter()
10867                    .map(|p| p.to_string())
10868                    .collect::<Vec<String>>()
10869                    .join(",")
10870                    .to_string(),
10871            )]),
10872        };
10873    }
10874    if let Some(ref local_var_str) = description__n {
10875        local_var_req_builder = match "multi" {
10876            "multi" => local_var_req_builder.query(
10877                &local_var_str
10878                    .into_iter()
10879                    .map(|p| ("description__n".to_owned(), p.to_string()))
10880                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10881            ),
10882            _ => local_var_req_builder.query(&[(
10883                "description__n",
10884                &local_var_str
10885                    .into_iter()
10886                    .map(|p| p.to_string())
10887                    .collect::<Vec<String>>()
10888                    .join(",")
10889                    .to_string(),
10890            )]),
10891        };
10892    }
10893    if let Some(ref local_var_str) = description__nic {
10894        local_var_req_builder = match "multi" {
10895            "multi" => local_var_req_builder.query(
10896                &local_var_str
10897                    .into_iter()
10898                    .map(|p| ("description__nic".to_owned(), p.to_string()))
10899                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10900            ),
10901            _ => local_var_req_builder.query(&[(
10902                "description__nic",
10903                &local_var_str
10904                    .into_iter()
10905                    .map(|p| p.to_string())
10906                    .collect::<Vec<String>>()
10907                    .join(",")
10908                    .to_string(),
10909            )]),
10910        };
10911    }
10912    if let Some(ref local_var_str) = description__nie {
10913        local_var_req_builder = match "multi" {
10914            "multi" => local_var_req_builder.query(
10915                &local_var_str
10916                    .into_iter()
10917                    .map(|p| ("description__nie".to_owned(), p.to_string()))
10918                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10919            ),
10920            _ => local_var_req_builder.query(&[(
10921                "description__nie",
10922                &local_var_str
10923                    .into_iter()
10924                    .map(|p| p.to_string())
10925                    .collect::<Vec<String>>()
10926                    .join(",")
10927                    .to_string(),
10928            )]),
10929        };
10930    }
10931    if let Some(ref local_var_str) = description__niew {
10932        local_var_req_builder = match "multi" {
10933            "multi" => local_var_req_builder.query(
10934                &local_var_str
10935                    .into_iter()
10936                    .map(|p| ("description__niew".to_owned(), p.to_string()))
10937                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10938            ),
10939            _ => local_var_req_builder.query(&[(
10940                "description__niew",
10941                &local_var_str
10942                    .into_iter()
10943                    .map(|p| p.to_string())
10944                    .collect::<Vec<String>>()
10945                    .join(",")
10946                    .to_string(),
10947            )]),
10948        };
10949    }
10950    if let Some(ref local_var_str) = description__nisw {
10951        local_var_req_builder = match "multi" {
10952            "multi" => local_var_req_builder.query(
10953                &local_var_str
10954                    .into_iter()
10955                    .map(|p| ("description__nisw".to_owned(), p.to_string()))
10956                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10957            ),
10958            _ => local_var_req_builder.query(&[(
10959                "description__nisw",
10960                &local_var_str
10961                    .into_iter()
10962                    .map(|p| p.to_string())
10963                    .collect::<Vec<String>>()
10964                    .join(",")
10965                    .to_string(),
10966            )]),
10967        };
10968    }
10969    if let Some(ref local_var_str) = description__regex {
10970        local_var_req_builder = match "multi" {
10971            "multi" => local_var_req_builder.query(
10972                &local_var_str
10973                    .into_iter()
10974                    .map(|p| ("description__regex".to_owned(), p.to_string()))
10975                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10976            ),
10977            _ => local_var_req_builder.query(&[(
10978                "description__regex",
10979                &local_var_str
10980                    .into_iter()
10981                    .map(|p| p.to_string())
10982                    .collect::<Vec<String>>()
10983                    .join(",")
10984                    .to_string(),
10985            )]),
10986        };
10987    }
10988    if let Some(ref local_var_str) = distance {
10989        local_var_req_builder = match "multi" {
10990            "multi" => local_var_req_builder.query(
10991                &local_var_str
10992                    .into_iter()
10993                    .map(|p| ("distance".to_owned(), p.to_string()))
10994                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10995            ),
10996            _ => local_var_req_builder.query(&[(
10997                "distance",
10998                &local_var_str
10999                    .into_iter()
11000                    .map(|p| p.to_string())
11001                    .collect::<Vec<String>>()
11002                    .join(",")
11003                    .to_string(),
11004            )]),
11005        };
11006    }
11007    if let Some(ref local_var_str) = distance__empty {
11008        local_var_req_builder =
11009            local_var_req_builder.query(&[("distance__empty", &local_var_str.to_string())]);
11010    }
11011    if let Some(ref local_var_str) = distance__gt {
11012        local_var_req_builder = match "multi" {
11013            "multi" => local_var_req_builder.query(
11014                &local_var_str
11015                    .into_iter()
11016                    .map(|p| ("distance__gt".to_owned(), p.to_string()))
11017                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11018            ),
11019            _ => local_var_req_builder.query(&[(
11020                "distance__gt",
11021                &local_var_str
11022                    .into_iter()
11023                    .map(|p| p.to_string())
11024                    .collect::<Vec<String>>()
11025                    .join(",")
11026                    .to_string(),
11027            )]),
11028        };
11029    }
11030    if let Some(ref local_var_str) = distance__gte {
11031        local_var_req_builder = match "multi" {
11032            "multi" => local_var_req_builder.query(
11033                &local_var_str
11034                    .into_iter()
11035                    .map(|p| ("distance__gte".to_owned(), p.to_string()))
11036                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11037            ),
11038            _ => local_var_req_builder.query(&[(
11039                "distance__gte",
11040                &local_var_str
11041                    .into_iter()
11042                    .map(|p| p.to_string())
11043                    .collect::<Vec<String>>()
11044                    .join(",")
11045                    .to_string(),
11046            )]),
11047        };
11048    }
11049    if let Some(ref local_var_str) = distance__lt {
11050        local_var_req_builder = match "multi" {
11051            "multi" => local_var_req_builder.query(
11052                &local_var_str
11053                    .into_iter()
11054                    .map(|p| ("distance__lt".to_owned(), p.to_string()))
11055                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11056            ),
11057            _ => local_var_req_builder.query(&[(
11058                "distance__lt",
11059                &local_var_str
11060                    .into_iter()
11061                    .map(|p| p.to_string())
11062                    .collect::<Vec<String>>()
11063                    .join(",")
11064                    .to_string(),
11065            )]),
11066        };
11067    }
11068    if let Some(ref local_var_str) = distance__lte {
11069        local_var_req_builder = match "multi" {
11070            "multi" => local_var_req_builder.query(
11071                &local_var_str
11072                    .into_iter()
11073                    .map(|p| ("distance__lte".to_owned(), p.to_string()))
11074                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11075            ),
11076            _ => local_var_req_builder.query(&[(
11077                "distance__lte",
11078                &local_var_str
11079                    .into_iter()
11080                    .map(|p| p.to_string())
11081                    .collect::<Vec<String>>()
11082                    .join(",")
11083                    .to_string(),
11084            )]),
11085        };
11086    }
11087    if let Some(ref local_var_str) = distance__n {
11088        local_var_req_builder = match "multi" {
11089            "multi" => local_var_req_builder.query(
11090                &local_var_str
11091                    .into_iter()
11092                    .map(|p| ("distance__n".to_owned(), p.to_string()))
11093                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11094            ),
11095            _ => local_var_req_builder.query(&[(
11096                "distance__n",
11097                &local_var_str
11098                    .into_iter()
11099                    .map(|p| p.to_string())
11100                    .collect::<Vec<String>>()
11101                    .join(",")
11102                    .to_string(),
11103            )]),
11104        };
11105    }
11106    if let Some(ref local_var_str) = distance_unit {
11107        local_var_req_builder =
11108            local_var_req_builder.query(&[("distance_unit", &local_var_str.to_string())]);
11109    }
11110    if let Some(ref local_var_str) = distance_unit__empty {
11111        local_var_req_builder =
11112            local_var_req_builder.query(&[("distance_unit__empty", &local_var_str.to_string())]);
11113    }
11114    if let Some(ref local_var_str) = distance_unit__ic {
11115        local_var_req_builder = match "multi" {
11116            "multi" => local_var_req_builder.query(
11117                &local_var_str
11118                    .into_iter()
11119                    .map(|p| ("distance_unit__ic".to_owned(), p.to_string()))
11120                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11121            ),
11122            _ => local_var_req_builder.query(&[(
11123                "distance_unit__ic",
11124                &local_var_str
11125                    .into_iter()
11126                    .map(|p| p.to_string())
11127                    .collect::<Vec<String>>()
11128                    .join(",")
11129                    .to_string(),
11130            )]),
11131        };
11132    }
11133    if let Some(ref local_var_str) = distance_unit__ie {
11134        local_var_req_builder = match "multi" {
11135            "multi" => local_var_req_builder.query(
11136                &local_var_str
11137                    .into_iter()
11138                    .map(|p| ("distance_unit__ie".to_owned(), p.to_string()))
11139                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11140            ),
11141            _ => local_var_req_builder.query(&[(
11142                "distance_unit__ie",
11143                &local_var_str
11144                    .into_iter()
11145                    .map(|p| p.to_string())
11146                    .collect::<Vec<String>>()
11147                    .join(",")
11148                    .to_string(),
11149            )]),
11150        };
11151    }
11152    if let Some(ref local_var_str) = distance_unit__iew {
11153        local_var_req_builder = match "multi" {
11154            "multi" => local_var_req_builder.query(
11155                &local_var_str
11156                    .into_iter()
11157                    .map(|p| ("distance_unit__iew".to_owned(), p.to_string()))
11158                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11159            ),
11160            _ => local_var_req_builder.query(&[(
11161                "distance_unit__iew",
11162                &local_var_str
11163                    .into_iter()
11164                    .map(|p| p.to_string())
11165                    .collect::<Vec<String>>()
11166                    .join(",")
11167                    .to_string(),
11168            )]),
11169        };
11170    }
11171    if let Some(ref local_var_str) = distance_unit__iregex {
11172        local_var_req_builder = match "multi" {
11173            "multi" => local_var_req_builder.query(
11174                &local_var_str
11175                    .into_iter()
11176                    .map(|p| ("distance_unit__iregex".to_owned(), p.to_string()))
11177                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11178            ),
11179            _ => local_var_req_builder.query(&[(
11180                "distance_unit__iregex",
11181                &local_var_str
11182                    .into_iter()
11183                    .map(|p| p.to_string())
11184                    .collect::<Vec<String>>()
11185                    .join(",")
11186                    .to_string(),
11187            )]),
11188        };
11189    }
11190    if let Some(ref local_var_str) = distance_unit__isw {
11191        local_var_req_builder = match "multi" {
11192            "multi" => local_var_req_builder.query(
11193                &local_var_str
11194                    .into_iter()
11195                    .map(|p| ("distance_unit__isw".to_owned(), p.to_string()))
11196                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11197            ),
11198            _ => local_var_req_builder.query(&[(
11199                "distance_unit__isw",
11200                &local_var_str
11201                    .into_iter()
11202                    .map(|p| p.to_string())
11203                    .collect::<Vec<String>>()
11204                    .join(",")
11205                    .to_string(),
11206            )]),
11207        };
11208    }
11209    if let Some(ref local_var_str) = distance_unit__n {
11210        local_var_req_builder =
11211            local_var_req_builder.query(&[("distance_unit__n", &local_var_str.to_string())]);
11212    }
11213    if let Some(ref local_var_str) = distance_unit__nic {
11214        local_var_req_builder = match "multi" {
11215            "multi" => local_var_req_builder.query(
11216                &local_var_str
11217                    .into_iter()
11218                    .map(|p| ("distance_unit__nic".to_owned(), p.to_string()))
11219                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11220            ),
11221            _ => local_var_req_builder.query(&[(
11222                "distance_unit__nic",
11223                &local_var_str
11224                    .into_iter()
11225                    .map(|p| p.to_string())
11226                    .collect::<Vec<String>>()
11227                    .join(",")
11228                    .to_string(),
11229            )]),
11230        };
11231    }
11232    if let Some(ref local_var_str) = distance_unit__nie {
11233        local_var_req_builder = match "multi" {
11234            "multi" => local_var_req_builder.query(
11235                &local_var_str
11236                    .into_iter()
11237                    .map(|p| ("distance_unit__nie".to_owned(), p.to_string()))
11238                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11239            ),
11240            _ => local_var_req_builder.query(&[(
11241                "distance_unit__nie",
11242                &local_var_str
11243                    .into_iter()
11244                    .map(|p| p.to_string())
11245                    .collect::<Vec<String>>()
11246                    .join(",")
11247                    .to_string(),
11248            )]),
11249        };
11250    }
11251    if let Some(ref local_var_str) = distance_unit__niew {
11252        local_var_req_builder = match "multi" {
11253            "multi" => local_var_req_builder.query(
11254                &local_var_str
11255                    .into_iter()
11256                    .map(|p| ("distance_unit__niew".to_owned(), p.to_string()))
11257                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11258            ),
11259            _ => local_var_req_builder.query(&[(
11260                "distance_unit__niew",
11261                &local_var_str
11262                    .into_iter()
11263                    .map(|p| p.to_string())
11264                    .collect::<Vec<String>>()
11265                    .join(",")
11266                    .to_string(),
11267            )]),
11268        };
11269    }
11270    if let Some(ref local_var_str) = distance_unit__nisw {
11271        local_var_req_builder = match "multi" {
11272            "multi" => local_var_req_builder.query(
11273                &local_var_str
11274                    .into_iter()
11275                    .map(|p| ("distance_unit__nisw".to_owned(), p.to_string()))
11276                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11277            ),
11278            _ => local_var_req_builder.query(&[(
11279                "distance_unit__nisw",
11280                &local_var_str
11281                    .into_iter()
11282                    .map(|p| p.to_string())
11283                    .collect::<Vec<String>>()
11284                    .join(",")
11285                    .to_string(),
11286            )]),
11287        };
11288    }
11289    if let Some(ref local_var_str) = distance_unit__regex {
11290        local_var_req_builder = match "multi" {
11291            "multi" => local_var_req_builder.query(
11292                &local_var_str
11293                    .into_iter()
11294                    .map(|p| ("distance_unit__regex".to_owned(), p.to_string()))
11295                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11296            ),
11297            _ => local_var_req_builder.query(&[(
11298                "distance_unit__regex",
11299                &local_var_str
11300                    .into_iter()
11301                    .map(|p| p.to_string())
11302                    .collect::<Vec<String>>()
11303                    .join(",")
11304                    .to_string(),
11305            )]),
11306        };
11307    }
11308    if let Some(ref local_var_str) = id {
11309        local_var_req_builder = match "multi" {
11310            "multi" => local_var_req_builder.query(
11311                &local_var_str
11312                    .into_iter()
11313                    .map(|p| ("id".to_owned(), p.to_string()))
11314                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11315            ),
11316            _ => local_var_req_builder.query(&[(
11317                "id",
11318                &local_var_str
11319                    .into_iter()
11320                    .map(|p| p.to_string())
11321                    .collect::<Vec<String>>()
11322                    .join(",")
11323                    .to_string(),
11324            )]),
11325        };
11326    }
11327    if let Some(ref local_var_str) = id__empty {
11328        local_var_req_builder =
11329            local_var_req_builder.query(&[("id__empty", &local_var_str.to_string())]);
11330    }
11331    if let Some(ref local_var_str) = id__gt {
11332        local_var_req_builder = match "multi" {
11333            "multi" => local_var_req_builder.query(
11334                &local_var_str
11335                    .into_iter()
11336                    .map(|p| ("id__gt".to_owned(), p.to_string()))
11337                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11338            ),
11339            _ => local_var_req_builder.query(&[(
11340                "id__gt",
11341                &local_var_str
11342                    .into_iter()
11343                    .map(|p| p.to_string())
11344                    .collect::<Vec<String>>()
11345                    .join(",")
11346                    .to_string(),
11347            )]),
11348        };
11349    }
11350    if let Some(ref local_var_str) = id__gte {
11351        local_var_req_builder = match "multi" {
11352            "multi" => local_var_req_builder.query(
11353                &local_var_str
11354                    .into_iter()
11355                    .map(|p| ("id__gte".to_owned(), p.to_string()))
11356                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11357            ),
11358            _ => local_var_req_builder.query(&[(
11359                "id__gte",
11360                &local_var_str
11361                    .into_iter()
11362                    .map(|p| p.to_string())
11363                    .collect::<Vec<String>>()
11364                    .join(",")
11365                    .to_string(),
11366            )]),
11367        };
11368    }
11369    if let Some(ref local_var_str) = id__lt {
11370        local_var_req_builder = match "multi" {
11371            "multi" => local_var_req_builder.query(
11372                &local_var_str
11373                    .into_iter()
11374                    .map(|p| ("id__lt".to_owned(), p.to_string()))
11375                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11376            ),
11377            _ => local_var_req_builder.query(&[(
11378                "id__lt",
11379                &local_var_str
11380                    .into_iter()
11381                    .map(|p| p.to_string())
11382                    .collect::<Vec<String>>()
11383                    .join(",")
11384                    .to_string(),
11385            )]),
11386        };
11387    }
11388    if let Some(ref local_var_str) = id__lte {
11389        local_var_req_builder = match "multi" {
11390            "multi" => local_var_req_builder.query(
11391                &local_var_str
11392                    .into_iter()
11393                    .map(|p| ("id__lte".to_owned(), p.to_string()))
11394                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11395            ),
11396            _ => local_var_req_builder.query(&[(
11397                "id__lte",
11398                &local_var_str
11399                    .into_iter()
11400                    .map(|p| p.to_string())
11401                    .collect::<Vec<String>>()
11402                    .join(",")
11403                    .to_string(),
11404            )]),
11405        };
11406    }
11407    if let Some(ref local_var_str) = id__n {
11408        local_var_req_builder = match "multi" {
11409            "multi" => local_var_req_builder.query(
11410                &local_var_str
11411                    .into_iter()
11412                    .map(|p| ("id__n".to_owned(), p.to_string()))
11413                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11414            ),
11415            _ => local_var_req_builder.query(&[(
11416                "id__n",
11417                &local_var_str
11418                    .into_iter()
11419                    .map(|p| p.to_string())
11420                    .collect::<Vec<String>>()
11421                    .join(",")
11422                    .to_string(),
11423            )]),
11424        };
11425    }
11426    if let Some(ref local_var_str) = install_date {
11427        local_var_req_builder = match "multi" {
11428            "multi" => local_var_req_builder.query(
11429                &local_var_str
11430                    .into_iter()
11431                    .map(|p| ("install_date".to_owned(), p.to_string()))
11432                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11433            ),
11434            _ => local_var_req_builder.query(&[(
11435                "install_date",
11436                &local_var_str
11437                    .into_iter()
11438                    .map(|p| p.to_string())
11439                    .collect::<Vec<String>>()
11440                    .join(",")
11441                    .to_string(),
11442            )]),
11443        };
11444    }
11445    if let Some(ref local_var_str) = install_date__empty {
11446        local_var_req_builder =
11447            local_var_req_builder.query(&[("install_date__empty", &local_var_str.to_string())]);
11448    }
11449    if let Some(ref local_var_str) = install_date__gt {
11450        local_var_req_builder = match "multi" {
11451            "multi" => local_var_req_builder.query(
11452                &local_var_str
11453                    .into_iter()
11454                    .map(|p| ("install_date__gt".to_owned(), p.to_string()))
11455                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11456            ),
11457            _ => local_var_req_builder.query(&[(
11458                "install_date__gt",
11459                &local_var_str
11460                    .into_iter()
11461                    .map(|p| p.to_string())
11462                    .collect::<Vec<String>>()
11463                    .join(",")
11464                    .to_string(),
11465            )]),
11466        };
11467    }
11468    if let Some(ref local_var_str) = install_date__gte {
11469        local_var_req_builder = match "multi" {
11470            "multi" => local_var_req_builder.query(
11471                &local_var_str
11472                    .into_iter()
11473                    .map(|p| ("install_date__gte".to_owned(), p.to_string()))
11474                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11475            ),
11476            _ => local_var_req_builder.query(&[(
11477                "install_date__gte",
11478                &local_var_str
11479                    .into_iter()
11480                    .map(|p| p.to_string())
11481                    .collect::<Vec<String>>()
11482                    .join(",")
11483                    .to_string(),
11484            )]),
11485        };
11486    }
11487    if let Some(ref local_var_str) = install_date__lt {
11488        local_var_req_builder = match "multi" {
11489            "multi" => local_var_req_builder.query(
11490                &local_var_str
11491                    .into_iter()
11492                    .map(|p| ("install_date__lt".to_owned(), p.to_string()))
11493                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11494            ),
11495            _ => local_var_req_builder.query(&[(
11496                "install_date__lt",
11497                &local_var_str
11498                    .into_iter()
11499                    .map(|p| p.to_string())
11500                    .collect::<Vec<String>>()
11501                    .join(",")
11502                    .to_string(),
11503            )]),
11504        };
11505    }
11506    if let Some(ref local_var_str) = install_date__lte {
11507        local_var_req_builder = match "multi" {
11508            "multi" => local_var_req_builder.query(
11509                &local_var_str
11510                    .into_iter()
11511                    .map(|p| ("install_date__lte".to_owned(), p.to_string()))
11512                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11513            ),
11514            _ => local_var_req_builder.query(&[(
11515                "install_date__lte",
11516                &local_var_str
11517                    .into_iter()
11518                    .map(|p| p.to_string())
11519                    .collect::<Vec<String>>()
11520                    .join(",")
11521                    .to_string(),
11522            )]),
11523        };
11524    }
11525    if let Some(ref local_var_str) = install_date__n {
11526        local_var_req_builder = match "multi" {
11527            "multi" => local_var_req_builder.query(
11528                &local_var_str
11529                    .into_iter()
11530                    .map(|p| ("install_date__n".to_owned(), p.to_string()))
11531                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11532            ),
11533            _ => local_var_req_builder.query(&[(
11534                "install_date__n",
11535                &local_var_str
11536                    .into_iter()
11537                    .map(|p| p.to_string())
11538                    .collect::<Vec<String>>()
11539                    .join(",")
11540                    .to_string(),
11541            )]),
11542        };
11543    }
11544    if let Some(ref local_var_str) = last_updated {
11545        local_var_req_builder = match "multi" {
11546            "multi" => local_var_req_builder.query(
11547                &local_var_str
11548                    .into_iter()
11549                    .map(|p| ("last_updated".to_owned(), p.to_string()))
11550                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11551            ),
11552            _ => local_var_req_builder.query(&[(
11553                "last_updated",
11554                &local_var_str
11555                    .into_iter()
11556                    .map(|p| p.to_string())
11557                    .collect::<Vec<String>>()
11558                    .join(",")
11559                    .to_string(),
11560            )]),
11561        };
11562    }
11563    if let Some(ref local_var_str) = last_updated__empty {
11564        local_var_req_builder = match "multi" {
11565            "multi" => local_var_req_builder.query(
11566                &local_var_str
11567                    .into_iter()
11568                    .map(|p| ("last_updated__empty".to_owned(), p.to_string()))
11569                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11570            ),
11571            _ => local_var_req_builder.query(&[(
11572                "last_updated__empty",
11573                &local_var_str
11574                    .into_iter()
11575                    .map(|p| p.to_string())
11576                    .collect::<Vec<String>>()
11577                    .join(",")
11578                    .to_string(),
11579            )]),
11580        };
11581    }
11582    if let Some(ref local_var_str) = last_updated__gt {
11583        local_var_req_builder = match "multi" {
11584            "multi" => local_var_req_builder.query(
11585                &local_var_str
11586                    .into_iter()
11587                    .map(|p| ("last_updated__gt".to_owned(), p.to_string()))
11588                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11589            ),
11590            _ => local_var_req_builder.query(&[(
11591                "last_updated__gt",
11592                &local_var_str
11593                    .into_iter()
11594                    .map(|p| p.to_string())
11595                    .collect::<Vec<String>>()
11596                    .join(",")
11597                    .to_string(),
11598            )]),
11599        };
11600    }
11601    if let Some(ref local_var_str) = last_updated__gte {
11602        local_var_req_builder = match "multi" {
11603            "multi" => local_var_req_builder.query(
11604                &local_var_str
11605                    .into_iter()
11606                    .map(|p| ("last_updated__gte".to_owned(), p.to_string()))
11607                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11608            ),
11609            _ => local_var_req_builder.query(&[(
11610                "last_updated__gte",
11611                &local_var_str
11612                    .into_iter()
11613                    .map(|p| p.to_string())
11614                    .collect::<Vec<String>>()
11615                    .join(",")
11616                    .to_string(),
11617            )]),
11618        };
11619    }
11620    if let Some(ref local_var_str) = last_updated__lt {
11621        local_var_req_builder = match "multi" {
11622            "multi" => local_var_req_builder.query(
11623                &local_var_str
11624                    .into_iter()
11625                    .map(|p| ("last_updated__lt".to_owned(), p.to_string()))
11626                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11627            ),
11628            _ => local_var_req_builder.query(&[(
11629                "last_updated__lt",
11630                &local_var_str
11631                    .into_iter()
11632                    .map(|p| p.to_string())
11633                    .collect::<Vec<String>>()
11634                    .join(",")
11635                    .to_string(),
11636            )]),
11637        };
11638    }
11639    if let Some(ref local_var_str) = last_updated__lte {
11640        local_var_req_builder = match "multi" {
11641            "multi" => local_var_req_builder.query(
11642                &local_var_str
11643                    .into_iter()
11644                    .map(|p| ("last_updated__lte".to_owned(), p.to_string()))
11645                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11646            ),
11647            _ => local_var_req_builder.query(&[(
11648                "last_updated__lte",
11649                &local_var_str
11650                    .into_iter()
11651                    .map(|p| p.to_string())
11652                    .collect::<Vec<String>>()
11653                    .join(",")
11654                    .to_string(),
11655            )]),
11656        };
11657    }
11658    if let Some(ref local_var_str) = last_updated__n {
11659        local_var_req_builder = match "multi" {
11660            "multi" => local_var_req_builder.query(
11661                &local_var_str
11662                    .into_iter()
11663                    .map(|p| ("last_updated__n".to_owned(), p.to_string()))
11664                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11665            ),
11666            _ => local_var_req_builder.query(&[(
11667                "last_updated__n",
11668                &local_var_str
11669                    .into_iter()
11670                    .map(|p| p.to_string())
11671                    .collect::<Vec<String>>()
11672                    .join(",")
11673                    .to_string(),
11674            )]),
11675        };
11676    }
11677    if let Some(ref local_var_str) = limit {
11678        local_var_req_builder =
11679            local_var_req_builder.query(&[("limit", &local_var_str.to_string())]);
11680    }
11681    if let Some(ref local_var_str) = location_id {
11682        local_var_req_builder = match "multi" {
11683            "multi" => local_var_req_builder.query(
11684                &local_var_str
11685                    .into_iter()
11686                    .map(|p| ("location_id".to_owned(), p.to_string()))
11687                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11688            ),
11689            _ => local_var_req_builder.query(&[(
11690                "location_id",
11691                &local_var_str
11692                    .into_iter()
11693                    .map(|p| p.to_string())
11694                    .collect::<Vec<String>>()
11695                    .join(",")
11696                    .to_string(),
11697            )]),
11698        };
11699    }
11700    if let Some(ref local_var_str) = location_id__n {
11701        local_var_req_builder = match "multi" {
11702            "multi" => local_var_req_builder.query(
11703                &local_var_str
11704                    .into_iter()
11705                    .map(|p| ("location_id__n".to_owned(), p.to_string()))
11706                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11707            ),
11708            _ => local_var_req_builder.query(&[(
11709                "location_id__n",
11710                &local_var_str
11711                    .into_iter()
11712                    .map(|p| p.to_string())
11713                    .collect::<Vec<String>>()
11714                    .join(",")
11715                    .to_string(),
11716            )]),
11717        };
11718    }
11719    if let Some(ref local_var_str) = modified_by_request {
11720        local_var_req_builder =
11721            local_var_req_builder.query(&[("modified_by_request", &local_var_str.to_string())]);
11722    }
11723    if let Some(ref local_var_str) = offset {
11724        local_var_req_builder =
11725            local_var_req_builder.query(&[("offset", &local_var_str.to_string())]);
11726    }
11727    if let Some(ref local_var_str) = ordering {
11728        local_var_req_builder =
11729            local_var_req_builder.query(&[("ordering", &local_var_str.to_string())]);
11730    }
11731    if let Some(ref local_var_str) = owner {
11732        local_var_req_builder = match "multi" {
11733            "multi" => local_var_req_builder.query(
11734                &local_var_str
11735                    .into_iter()
11736                    .map(|p| ("owner".to_owned(), p.to_string()))
11737                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11738            ),
11739            _ => local_var_req_builder.query(&[(
11740                "owner",
11741                &local_var_str
11742                    .into_iter()
11743                    .map(|p| p.to_string())
11744                    .collect::<Vec<String>>()
11745                    .join(",")
11746                    .to_string(),
11747            )]),
11748        };
11749    }
11750    if let Some(ref local_var_str) = owner__n {
11751        local_var_req_builder = match "multi" {
11752            "multi" => local_var_req_builder.query(
11753                &local_var_str
11754                    .into_iter()
11755                    .map(|p| ("owner__n".to_owned(), p.to_string()))
11756                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11757            ),
11758            _ => local_var_req_builder.query(&[(
11759                "owner__n",
11760                &local_var_str
11761                    .into_iter()
11762                    .map(|p| p.to_string())
11763                    .collect::<Vec<String>>()
11764                    .join(",")
11765                    .to_string(),
11766            )]),
11767        };
11768    }
11769    if let Some(ref local_var_str) = owner_group {
11770        local_var_req_builder = match "multi" {
11771            "multi" => local_var_req_builder.query(
11772                &local_var_str
11773                    .into_iter()
11774                    .map(|p| ("owner_group".to_owned(), p.to_string()))
11775                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11776            ),
11777            _ => local_var_req_builder.query(&[(
11778                "owner_group",
11779                &local_var_str
11780                    .into_iter()
11781                    .map(|p| p.to_string())
11782                    .collect::<Vec<String>>()
11783                    .join(",")
11784                    .to_string(),
11785            )]),
11786        };
11787    }
11788    if let Some(ref local_var_str) = owner_group__n {
11789        local_var_req_builder = match "multi" {
11790            "multi" => local_var_req_builder.query(
11791                &local_var_str
11792                    .into_iter()
11793                    .map(|p| ("owner_group__n".to_owned(), p.to_string()))
11794                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11795            ),
11796            _ => local_var_req_builder.query(&[(
11797                "owner_group__n",
11798                &local_var_str
11799                    .into_iter()
11800                    .map(|p| p.to_string())
11801                    .collect::<Vec<String>>()
11802                    .join(",")
11803                    .to_string(),
11804            )]),
11805        };
11806    }
11807    if let Some(ref local_var_str) = owner_group_id {
11808        local_var_req_builder = match "multi" {
11809            "multi" => local_var_req_builder.query(
11810                &local_var_str
11811                    .into_iter()
11812                    .map(|p| ("owner_group_id".to_owned(), p.to_string()))
11813                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11814            ),
11815            _ => local_var_req_builder.query(&[(
11816                "owner_group_id",
11817                &local_var_str
11818                    .into_iter()
11819                    .map(|p| p.to_string())
11820                    .collect::<Vec<String>>()
11821                    .join(",")
11822                    .to_string(),
11823            )]),
11824        };
11825    }
11826    if let Some(ref local_var_str) = owner_group_id__n {
11827        local_var_req_builder = match "multi" {
11828            "multi" => local_var_req_builder.query(
11829                &local_var_str
11830                    .into_iter()
11831                    .map(|p| ("owner_group_id__n".to_owned(), p.to_string()))
11832                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11833            ),
11834            _ => local_var_req_builder.query(&[(
11835                "owner_group_id__n",
11836                &local_var_str
11837                    .into_iter()
11838                    .map(|p| p.to_string())
11839                    .collect::<Vec<String>>()
11840                    .join(",")
11841                    .to_string(),
11842            )]),
11843        };
11844    }
11845    if let Some(ref local_var_str) = owner_id {
11846        local_var_req_builder = match "multi" {
11847            "multi" => local_var_req_builder.query(
11848                &local_var_str
11849                    .into_iter()
11850                    .map(|p| ("owner_id".to_owned(), p.to_string()))
11851                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11852            ),
11853            _ => local_var_req_builder.query(&[(
11854                "owner_id",
11855                &local_var_str
11856                    .into_iter()
11857                    .map(|p| p.to_string())
11858                    .collect::<Vec<String>>()
11859                    .join(",")
11860                    .to_string(),
11861            )]),
11862        };
11863    }
11864    if let Some(ref local_var_str) = owner_id__n {
11865        local_var_req_builder = match "multi" {
11866            "multi" => local_var_req_builder.query(
11867                &local_var_str
11868                    .into_iter()
11869                    .map(|p| ("owner_id__n".to_owned(), p.to_string()))
11870                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11871            ),
11872            _ => local_var_req_builder.query(&[(
11873                "owner_id__n",
11874                &local_var_str
11875                    .into_iter()
11876                    .map(|p| p.to_string())
11877                    .collect::<Vec<String>>()
11878                    .join(",")
11879                    .to_string(),
11880            )]),
11881        };
11882    }
11883    if let Some(ref local_var_str) = provider {
11884        local_var_req_builder = match "multi" {
11885            "multi" => local_var_req_builder.query(
11886                &local_var_str
11887                    .into_iter()
11888                    .map(|p| ("provider".to_owned(), p.to_string()))
11889                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11890            ),
11891            _ => local_var_req_builder.query(&[(
11892                "provider",
11893                &local_var_str
11894                    .into_iter()
11895                    .map(|p| p.to_string())
11896                    .collect::<Vec<String>>()
11897                    .join(",")
11898                    .to_string(),
11899            )]),
11900        };
11901    }
11902    if let Some(ref local_var_str) = provider__n {
11903        local_var_req_builder = match "multi" {
11904            "multi" => local_var_req_builder.query(
11905                &local_var_str
11906                    .into_iter()
11907                    .map(|p| ("provider__n".to_owned(), p.to_string()))
11908                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11909            ),
11910            _ => local_var_req_builder.query(&[(
11911                "provider__n",
11912                &local_var_str
11913                    .into_iter()
11914                    .map(|p| p.to_string())
11915                    .collect::<Vec<String>>()
11916                    .join(",")
11917                    .to_string(),
11918            )]),
11919        };
11920    }
11921    if let Some(ref local_var_str) = provider_account {
11922        local_var_req_builder = match "multi" {
11923            "multi" => local_var_req_builder.query(
11924                &local_var_str
11925                    .into_iter()
11926                    .map(|p| ("provider_account".to_owned(), p.to_string()))
11927                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11928            ),
11929            _ => local_var_req_builder.query(&[(
11930                "provider_account",
11931                &local_var_str
11932                    .into_iter()
11933                    .map(|p| p.to_string())
11934                    .collect::<Vec<String>>()
11935                    .join(",")
11936                    .to_string(),
11937            )]),
11938        };
11939    }
11940    if let Some(ref local_var_str) = provider_account__n {
11941        local_var_req_builder = match "multi" {
11942            "multi" => local_var_req_builder.query(
11943                &local_var_str
11944                    .into_iter()
11945                    .map(|p| ("provider_account__n".to_owned(), p.to_string()))
11946                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11947            ),
11948            _ => local_var_req_builder.query(&[(
11949                "provider_account__n",
11950                &local_var_str
11951                    .into_iter()
11952                    .map(|p| p.to_string())
11953                    .collect::<Vec<String>>()
11954                    .join(",")
11955                    .to_string(),
11956            )]),
11957        };
11958    }
11959    if let Some(ref local_var_str) = provider_account_id {
11960        local_var_req_builder = match "multi" {
11961            "multi" => local_var_req_builder.query(
11962                &local_var_str
11963                    .into_iter()
11964                    .map(|p| ("provider_account_id".to_owned(), p.to_string()))
11965                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11966            ),
11967            _ => local_var_req_builder.query(&[(
11968                "provider_account_id",
11969                &local_var_str
11970                    .into_iter()
11971                    .map(|p| p.to_string())
11972                    .collect::<Vec<String>>()
11973                    .join(",")
11974                    .to_string(),
11975            )]),
11976        };
11977    }
11978    if let Some(ref local_var_str) = provider_account_id__n {
11979        local_var_req_builder = match "multi" {
11980            "multi" => local_var_req_builder.query(
11981                &local_var_str
11982                    .into_iter()
11983                    .map(|p| ("provider_account_id__n".to_owned(), p.to_string()))
11984                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11985            ),
11986            _ => local_var_req_builder.query(&[(
11987                "provider_account_id__n",
11988                &local_var_str
11989                    .into_iter()
11990                    .map(|p| p.to_string())
11991                    .collect::<Vec<String>>()
11992                    .join(",")
11993                    .to_string(),
11994            )]),
11995        };
11996    }
11997    if let Some(ref local_var_str) = provider_id {
11998        local_var_req_builder = match "multi" {
11999            "multi" => local_var_req_builder.query(
12000                &local_var_str
12001                    .into_iter()
12002                    .map(|p| ("provider_id".to_owned(), p.to_string()))
12003                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12004            ),
12005            _ => local_var_req_builder.query(&[(
12006                "provider_id",
12007                &local_var_str
12008                    .into_iter()
12009                    .map(|p| p.to_string())
12010                    .collect::<Vec<String>>()
12011                    .join(",")
12012                    .to_string(),
12013            )]),
12014        };
12015    }
12016    if let Some(ref local_var_str) = provider_id__n {
12017        local_var_req_builder = match "multi" {
12018            "multi" => local_var_req_builder.query(
12019                &local_var_str
12020                    .into_iter()
12021                    .map(|p| ("provider_id__n".to_owned(), p.to_string()))
12022                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12023            ),
12024            _ => local_var_req_builder.query(&[(
12025                "provider_id__n",
12026                &local_var_str
12027                    .into_iter()
12028                    .map(|p| p.to_string())
12029                    .collect::<Vec<String>>()
12030                    .join(",")
12031                    .to_string(),
12032            )]),
12033        };
12034    }
12035    if let Some(ref local_var_str) = provider_network_id {
12036        local_var_req_builder = match "multi" {
12037            "multi" => local_var_req_builder.query(
12038                &local_var_str
12039                    .into_iter()
12040                    .map(|p| ("provider_network_id".to_owned(), p.to_string()))
12041                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12042            ),
12043            _ => local_var_req_builder.query(&[(
12044                "provider_network_id",
12045                &local_var_str
12046                    .into_iter()
12047                    .map(|p| p.to_string())
12048                    .collect::<Vec<String>>()
12049                    .join(",")
12050                    .to_string(),
12051            )]),
12052        };
12053    }
12054    if let Some(ref local_var_str) = provider_network_id__n {
12055        local_var_req_builder = match "multi" {
12056            "multi" => local_var_req_builder.query(
12057                &local_var_str
12058                    .into_iter()
12059                    .map(|p| ("provider_network_id__n".to_owned(), p.to_string()))
12060                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12061            ),
12062            _ => local_var_req_builder.query(&[(
12063                "provider_network_id__n",
12064                &local_var_str
12065                    .into_iter()
12066                    .map(|p| p.to_string())
12067                    .collect::<Vec<String>>()
12068                    .join(",")
12069                    .to_string(),
12070            )]),
12071        };
12072    }
12073    if let Some(ref local_var_str) = q {
12074        local_var_req_builder = local_var_req_builder.query(&[("q", &local_var_str.to_string())]);
12075    }
12076    if let Some(ref local_var_str) = region {
12077        local_var_req_builder = match "multi" {
12078            "multi" => local_var_req_builder.query(
12079                &local_var_str
12080                    .into_iter()
12081                    .map(|p| ("region".to_owned(), p.to_string()))
12082                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12083            ),
12084            _ => local_var_req_builder.query(&[(
12085                "region",
12086                &local_var_str
12087                    .into_iter()
12088                    .map(|p| p.to_string())
12089                    .collect::<Vec<String>>()
12090                    .join(",")
12091                    .to_string(),
12092            )]),
12093        };
12094    }
12095    if let Some(ref local_var_str) = region__n {
12096        local_var_req_builder = match "multi" {
12097            "multi" => local_var_req_builder.query(
12098                &local_var_str
12099                    .into_iter()
12100                    .map(|p| ("region__n".to_owned(), p.to_string()))
12101                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12102            ),
12103            _ => local_var_req_builder.query(&[(
12104                "region__n",
12105                &local_var_str
12106                    .into_iter()
12107                    .map(|p| p.to_string())
12108                    .collect::<Vec<String>>()
12109                    .join(",")
12110                    .to_string(),
12111            )]),
12112        };
12113    }
12114    if let Some(ref local_var_str) = region_id {
12115        local_var_req_builder = match "multi" {
12116            "multi" => local_var_req_builder.query(
12117                &local_var_str
12118                    .into_iter()
12119                    .map(|p| ("region_id".to_owned(), p.to_string()))
12120                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12121            ),
12122            _ => local_var_req_builder.query(&[(
12123                "region_id",
12124                &local_var_str
12125                    .into_iter()
12126                    .map(|p| p.to_string())
12127                    .collect::<Vec<String>>()
12128                    .join(",")
12129                    .to_string(),
12130            )]),
12131        };
12132    }
12133    if let Some(ref local_var_str) = region_id__n {
12134        local_var_req_builder = match "multi" {
12135            "multi" => local_var_req_builder.query(
12136                &local_var_str
12137                    .into_iter()
12138                    .map(|p| ("region_id__n".to_owned(), p.to_string()))
12139                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12140            ),
12141            _ => local_var_req_builder.query(&[(
12142                "region_id__n",
12143                &local_var_str
12144                    .into_iter()
12145                    .map(|p| p.to_string())
12146                    .collect::<Vec<String>>()
12147                    .join(",")
12148                    .to_string(),
12149            )]),
12150        };
12151    }
12152    if let Some(ref local_var_str) = site {
12153        local_var_req_builder = match "multi" {
12154            "multi" => local_var_req_builder.query(
12155                &local_var_str
12156                    .into_iter()
12157                    .map(|p| ("site".to_owned(), p.to_string()))
12158                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12159            ),
12160            _ => local_var_req_builder.query(&[(
12161                "site",
12162                &local_var_str
12163                    .into_iter()
12164                    .map(|p| p.to_string())
12165                    .collect::<Vec<String>>()
12166                    .join(",")
12167                    .to_string(),
12168            )]),
12169        };
12170    }
12171    if let Some(ref local_var_str) = site__n {
12172        local_var_req_builder = match "multi" {
12173            "multi" => local_var_req_builder.query(
12174                &local_var_str
12175                    .into_iter()
12176                    .map(|p| ("site__n".to_owned(), p.to_string()))
12177                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12178            ),
12179            _ => local_var_req_builder.query(&[(
12180                "site__n",
12181                &local_var_str
12182                    .into_iter()
12183                    .map(|p| p.to_string())
12184                    .collect::<Vec<String>>()
12185                    .join(",")
12186                    .to_string(),
12187            )]),
12188        };
12189    }
12190    if let Some(ref local_var_str) = site_group {
12191        local_var_req_builder = match "multi" {
12192            "multi" => local_var_req_builder.query(
12193                &local_var_str
12194                    .into_iter()
12195                    .map(|p| ("site_group".to_owned(), p.to_string()))
12196                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12197            ),
12198            _ => local_var_req_builder.query(&[(
12199                "site_group",
12200                &local_var_str
12201                    .into_iter()
12202                    .map(|p| p.to_string())
12203                    .collect::<Vec<String>>()
12204                    .join(",")
12205                    .to_string(),
12206            )]),
12207        };
12208    }
12209    if let Some(ref local_var_str) = site_group__n {
12210        local_var_req_builder = match "multi" {
12211            "multi" => local_var_req_builder.query(
12212                &local_var_str
12213                    .into_iter()
12214                    .map(|p| ("site_group__n".to_owned(), p.to_string()))
12215                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12216            ),
12217            _ => local_var_req_builder.query(&[(
12218                "site_group__n",
12219                &local_var_str
12220                    .into_iter()
12221                    .map(|p| p.to_string())
12222                    .collect::<Vec<String>>()
12223                    .join(",")
12224                    .to_string(),
12225            )]),
12226        };
12227    }
12228    if let Some(ref local_var_str) = site_group_id {
12229        local_var_req_builder = match "multi" {
12230            "multi" => local_var_req_builder.query(
12231                &local_var_str
12232                    .into_iter()
12233                    .map(|p| ("site_group_id".to_owned(), p.to_string()))
12234                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12235            ),
12236            _ => local_var_req_builder.query(&[(
12237                "site_group_id",
12238                &local_var_str
12239                    .into_iter()
12240                    .map(|p| p.to_string())
12241                    .collect::<Vec<String>>()
12242                    .join(",")
12243                    .to_string(),
12244            )]),
12245        };
12246    }
12247    if let Some(ref local_var_str) = site_group_id__n {
12248        local_var_req_builder = match "multi" {
12249            "multi" => local_var_req_builder.query(
12250                &local_var_str
12251                    .into_iter()
12252                    .map(|p| ("site_group_id__n".to_owned(), p.to_string()))
12253                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12254            ),
12255            _ => local_var_req_builder.query(&[(
12256                "site_group_id__n",
12257                &local_var_str
12258                    .into_iter()
12259                    .map(|p| p.to_string())
12260                    .collect::<Vec<String>>()
12261                    .join(",")
12262                    .to_string(),
12263            )]),
12264        };
12265    }
12266    if let Some(ref local_var_str) = site_id {
12267        local_var_req_builder = match "multi" {
12268            "multi" => local_var_req_builder.query(
12269                &local_var_str
12270                    .into_iter()
12271                    .map(|p| ("site_id".to_owned(), p.to_string()))
12272                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12273            ),
12274            _ => local_var_req_builder.query(&[(
12275                "site_id",
12276                &local_var_str
12277                    .into_iter()
12278                    .map(|p| p.to_string())
12279                    .collect::<Vec<String>>()
12280                    .join(",")
12281                    .to_string(),
12282            )]),
12283        };
12284    }
12285    if let Some(ref local_var_str) = site_id__n {
12286        local_var_req_builder = match "multi" {
12287            "multi" => local_var_req_builder.query(
12288                &local_var_str
12289                    .into_iter()
12290                    .map(|p| ("site_id__n".to_owned(), p.to_string()))
12291                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12292            ),
12293            _ => local_var_req_builder.query(&[(
12294                "site_id__n",
12295                &local_var_str
12296                    .into_iter()
12297                    .map(|p| p.to_string())
12298                    .collect::<Vec<String>>()
12299                    .join(",")
12300                    .to_string(),
12301            )]),
12302        };
12303    }
12304    if let Some(ref local_var_str) = start {
12305        local_var_req_builder =
12306            local_var_req_builder.query(&[("start", &local_var_str.to_string())]);
12307    }
12308    if let Some(ref local_var_str) = status {
12309        local_var_req_builder = match "multi" {
12310            "multi" => local_var_req_builder.query(
12311                &local_var_str
12312                    .into_iter()
12313                    .map(|p| ("status".to_owned(), p.to_string()))
12314                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12315            ),
12316            _ => local_var_req_builder.query(&[(
12317                "status",
12318                &local_var_str
12319                    .into_iter()
12320                    .map(|p| p.to_string())
12321                    .collect::<Vec<String>>()
12322                    .join(",")
12323                    .to_string(),
12324            )]),
12325        };
12326    }
12327    if let Some(ref local_var_str) = status__empty {
12328        local_var_req_builder =
12329            local_var_req_builder.query(&[("status__empty", &local_var_str.to_string())]);
12330    }
12331    if let Some(ref local_var_str) = status__ic {
12332        local_var_req_builder = match "multi" {
12333            "multi" => local_var_req_builder.query(
12334                &local_var_str
12335                    .into_iter()
12336                    .map(|p| ("status__ic".to_owned(), p.to_string()))
12337                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12338            ),
12339            _ => local_var_req_builder.query(&[(
12340                "status__ic",
12341                &local_var_str
12342                    .into_iter()
12343                    .map(|p| p.to_string())
12344                    .collect::<Vec<String>>()
12345                    .join(",")
12346                    .to_string(),
12347            )]),
12348        };
12349    }
12350    if let Some(ref local_var_str) = status__ie {
12351        local_var_req_builder = match "multi" {
12352            "multi" => local_var_req_builder.query(
12353                &local_var_str
12354                    .into_iter()
12355                    .map(|p| ("status__ie".to_owned(), p.to_string()))
12356                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12357            ),
12358            _ => local_var_req_builder.query(&[(
12359                "status__ie",
12360                &local_var_str
12361                    .into_iter()
12362                    .map(|p| p.to_string())
12363                    .collect::<Vec<String>>()
12364                    .join(",")
12365                    .to_string(),
12366            )]),
12367        };
12368    }
12369    if let Some(ref local_var_str) = status__iew {
12370        local_var_req_builder = match "multi" {
12371            "multi" => local_var_req_builder.query(
12372                &local_var_str
12373                    .into_iter()
12374                    .map(|p| ("status__iew".to_owned(), p.to_string()))
12375                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12376            ),
12377            _ => local_var_req_builder.query(&[(
12378                "status__iew",
12379                &local_var_str
12380                    .into_iter()
12381                    .map(|p| p.to_string())
12382                    .collect::<Vec<String>>()
12383                    .join(",")
12384                    .to_string(),
12385            )]),
12386        };
12387    }
12388    if let Some(ref local_var_str) = status__iregex {
12389        local_var_req_builder = match "multi" {
12390            "multi" => local_var_req_builder.query(
12391                &local_var_str
12392                    .into_iter()
12393                    .map(|p| ("status__iregex".to_owned(), p.to_string()))
12394                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12395            ),
12396            _ => local_var_req_builder.query(&[(
12397                "status__iregex",
12398                &local_var_str
12399                    .into_iter()
12400                    .map(|p| p.to_string())
12401                    .collect::<Vec<String>>()
12402                    .join(",")
12403                    .to_string(),
12404            )]),
12405        };
12406    }
12407    if let Some(ref local_var_str) = status__isw {
12408        local_var_req_builder = match "multi" {
12409            "multi" => local_var_req_builder.query(
12410                &local_var_str
12411                    .into_iter()
12412                    .map(|p| ("status__isw".to_owned(), p.to_string()))
12413                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12414            ),
12415            _ => local_var_req_builder.query(&[(
12416                "status__isw",
12417                &local_var_str
12418                    .into_iter()
12419                    .map(|p| p.to_string())
12420                    .collect::<Vec<String>>()
12421                    .join(",")
12422                    .to_string(),
12423            )]),
12424        };
12425    }
12426    if let Some(ref local_var_str) = status__n {
12427        local_var_req_builder = match "multi" {
12428            "multi" => local_var_req_builder.query(
12429                &local_var_str
12430                    .into_iter()
12431                    .map(|p| ("status__n".to_owned(), p.to_string()))
12432                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12433            ),
12434            _ => local_var_req_builder.query(&[(
12435                "status__n",
12436                &local_var_str
12437                    .into_iter()
12438                    .map(|p| p.to_string())
12439                    .collect::<Vec<String>>()
12440                    .join(",")
12441                    .to_string(),
12442            )]),
12443        };
12444    }
12445    if let Some(ref local_var_str) = status__nic {
12446        local_var_req_builder = match "multi" {
12447            "multi" => local_var_req_builder.query(
12448                &local_var_str
12449                    .into_iter()
12450                    .map(|p| ("status__nic".to_owned(), p.to_string()))
12451                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12452            ),
12453            _ => local_var_req_builder.query(&[(
12454                "status__nic",
12455                &local_var_str
12456                    .into_iter()
12457                    .map(|p| p.to_string())
12458                    .collect::<Vec<String>>()
12459                    .join(",")
12460                    .to_string(),
12461            )]),
12462        };
12463    }
12464    if let Some(ref local_var_str) = status__nie {
12465        local_var_req_builder = match "multi" {
12466            "multi" => local_var_req_builder.query(
12467                &local_var_str
12468                    .into_iter()
12469                    .map(|p| ("status__nie".to_owned(), p.to_string()))
12470                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12471            ),
12472            _ => local_var_req_builder.query(&[(
12473                "status__nie",
12474                &local_var_str
12475                    .into_iter()
12476                    .map(|p| p.to_string())
12477                    .collect::<Vec<String>>()
12478                    .join(",")
12479                    .to_string(),
12480            )]),
12481        };
12482    }
12483    if let Some(ref local_var_str) = status__niew {
12484        local_var_req_builder = match "multi" {
12485            "multi" => local_var_req_builder.query(
12486                &local_var_str
12487                    .into_iter()
12488                    .map(|p| ("status__niew".to_owned(), p.to_string()))
12489                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12490            ),
12491            _ => local_var_req_builder.query(&[(
12492                "status__niew",
12493                &local_var_str
12494                    .into_iter()
12495                    .map(|p| p.to_string())
12496                    .collect::<Vec<String>>()
12497                    .join(",")
12498                    .to_string(),
12499            )]),
12500        };
12501    }
12502    if let Some(ref local_var_str) = status__nisw {
12503        local_var_req_builder = match "multi" {
12504            "multi" => local_var_req_builder.query(
12505                &local_var_str
12506                    .into_iter()
12507                    .map(|p| ("status__nisw".to_owned(), p.to_string()))
12508                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12509            ),
12510            _ => local_var_req_builder.query(&[(
12511                "status__nisw",
12512                &local_var_str
12513                    .into_iter()
12514                    .map(|p| p.to_string())
12515                    .collect::<Vec<String>>()
12516                    .join(",")
12517                    .to_string(),
12518            )]),
12519        };
12520    }
12521    if let Some(ref local_var_str) = status__regex {
12522        local_var_req_builder = match "multi" {
12523            "multi" => local_var_req_builder.query(
12524                &local_var_str
12525                    .into_iter()
12526                    .map(|p| ("status__regex".to_owned(), p.to_string()))
12527                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12528            ),
12529            _ => local_var_req_builder.query(&[(
12530                "status__regex",
12531                &local_var_str
12532                    .into_iter()
12533                    .map(|p| p.to_string())
12534                    .collect::<Vec<String>>()
12535                    .join(",")
12536                    .to_string(),
12537            )]),
12538        };
12539    }
12540    if let Some(ref local_var_str) = tag {
12541        local_var_req_builder = match "multi" {
12542            "multi" => local_var_req_builder.query(
12543                &local_var_str
12544                    .into_iter()
12545                    .map(|p| ("tag".to_owned(), p.to_string()))
12546                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12547            ),
12548            _ => local_var_req_builder.query(&[(
12549                "tag",
12550                &local_var_str
12551                    .into_iter()
12552                    .map(|p| p.to_string())
12553                    .collect::<Vec<String>>()
12554                    .join(",")
12555                    .to_string(),
12556            )]),
12557        };
12558    }
12559    if let Some(ref local_var_str) = tag__n {
12560        local_var_req_builder = match "multi" {
12561            "multi" => local_var_req_builder.query(
12562                &local_var_str
12563                    .into_iter()
12564                    .map(|p| ("tag__n".to_owned(), p.to_string()))
12565                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12566            ),
12567            _ => local_var_req_builder.query(&[(
12568                "tag__n",
12569                &local_var_str
12570                    .into_iter()
12571                    .map(|p| p.to_string())
12572                    .collect::<Vec<String>>()
12573                    .join(",")
12574                    .to_string(),
12575            )]),
12576        };
12577    }
12578    if let Some(ref local_var_str) = tag_id {
12579        local_var_req_builder = match "multi" {
12580            "multi" => local_var_req_builder.query(
12581                &local_var_str
12582                    .into_iter()
12583                    .map(|p| ("tag_id".to_owned(), p.to_string()))
12584                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12585            ),
12586            _ => local_var_req_builder.query(&[(
12587                "tag_id",
12588                &local_var_str
12589                    .into_iter()
12590                    .map(|p| p.to_string())
12591                    .collect::<Vec<String>>()
12592                    .join(",")
12593                    .to_string(),
12594            )]),
12595        };
12596    }
12597    if let Some(ref local_var_str) = tag_id__n {
12598        local_var_req_builder = match "multi" {
12599            "multi" => local_var_req_builder.query(
12600                &local_var_str
12601                    .into_iter()
12602                    .map(|p| ("tag_id__n".to_owned(), p.to_string()))
12603                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12604            ),
12605            _ => local_var_req_builder.query(&[(
12606                "tag_id__n",
12607                &local_var_str
12608                    .into_iter()
12609                    .map(|p| p.to_string())
12610                    .collect::<Vec<String>>()
12611                    .join(",")
12612                    .to_string(),
12613            )]),
12614        };
12615    }
12616    if let Some(ref local_var_str) = tenant {
12617        local_var_req_builder = match "multi" {
12618            "multi" => local_var_req_builder.query(
12619                &local_var_str
12620                    .into_iter()
12621                    .map(|p| ("tenant".to_owned(), p.to_string()))
12622                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12623            ),
12624            _ => local_var_req_builder.query(&[(
12625                "tenant",
12626                &local_var_str
12627                    .into_iter()
12628                    .map(|p| p.to_string())
12629                    .collect::<Vec<String>>()
12630                    .join(",")
12631                    .to_string(),
12632            )]),
12633        };
12634    }
12635    if let Some(ref local_var_str) = tenant__n {
12636        local_var_req_builder = match "multi" {
12637            "multi" => local_var_req_builder.query(
12638                &local_var_str
12639                    .into_iter()
12640                    .map(|p| ("tenant__n".to_owned(), p.to_string()))
12641                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12642            ),
12643            _ => local_var_req_builder.query(&[(
12644                "tenant__n",
12645                &local_var_str
12646                    .into_iter()
12647                    .map(|p| p.to_string())
12648                    .collect::<Vec<String>>()
12649                    .join(",")
12650                    .to_string(),
12651            )]),
12652        };
12653    }
12654    if let Some(ref local_var_str) = tenant_group {
12655        local_var_req_builder = match "multi" {
12656            "multi" => local_var_req_builder.query(
12657                &local_var_str
12658                    .into_iter()
12659                    .map(|p| ("tenant_group".to_owned(), p.to_string()))
12660                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12661            ),
12662            _ => local_var_req_builder.query(&[(
12663                "tenant_group",
12664                &local_var_str
12665                    .into_iter()
12666                    .map(|p| p.to_string())
12667                    .collect::<Vec<String>>()
12668                    .join(",")
12669                    .to_string(),
12670            )]),
12671        };
12672    }
12673    if let Some(ref local_var_str) = tenant_group__n {
12674        local_var_req_builder = match "multi" {
12675            "multi" => local_var_req_builder.query(
12676                &local_var_str
12677                    .into_iter()
12678                    .map(|p| ("tenant_group__n".to_owned(), p.to_string()))
12679                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12680            ),
12681            _ => local_var_req_builder.query(&[(
12682                "tenant_group__n",
12683                &local_var_str
12684                    .into_iter()
12685                    .map(|p| p.to_string())
12686                    .collect::<Vec<String>>()
12687                    .join(",")
12688                    .to_string(),
12689            )]),
12690        };
12691    }
12692    if let Some(ref local_var_str) = tenant_group_id {
12693        local_var_req_builder = match "multi" {
12694            "multi" => local_var_req_builder.query(
12695                &local_var_str
12696                    .into_iter()
12697                    .map(|p| ("tenant_group_id".to_owned(), p.to_string()))
12698                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12699            ),
12700            _ => local_var_req_builder.query(&[(
12701                "tenant_group_id",
12702                &local_var_str
12703                    .into_iter()
12704                    .map(|p| p.to_string())
12705                    .collect::<Vec<String>>()
12706                    .join(",")
12707                    .to_string(),
12708            )]),
12709        };
12710    }
12711    if let Some(ref local_var_str) = tenant_group_id__n {
12712        local_var_req_builder = match "multi" {
12713            "multi" => local_var_req_builder.query(
12714                &local_var_str
12715                    .into_iter()
12716                    .map(|p| ("tenant_group_id__n".to_owned(), p.to_string()))
12717                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12718            ),
12719            _ => local_var_req_builder.query(&[(
12720                "tenant_group_id__n",
12721                &local_var_str
12722                    .into_iter()
12723                    .map(|p| p.to_string())
12724                    .collect::<Vec<String>>()
12725                    .join(",")
12726                    .to_string(),
12727            )]),
12728        };
12729    }
12730    if let Some(ref local_var_str) = tenant_id {
12731        local_var_req_builder = match "multi" {
12732            "multi" => local_var_req_builder.query(
12733                &local_var_str
12734                    .into_iter()
12735                    .map(|p| ("tenant_id".to_owned(), p.to_string()))
12736                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12737            ),
12738            _ => local_var_req_builder.query(&[(
12739                "tenant_id",
12740                &local_var_str
12741                    .into_iter()
12742                    .map(|p| p.to_string())
12743                    .collect::<Vec<String>>()
12744                    .join(",")
12745                    .to_string(),
12746            )]),
12747        };
12748    }
12749    if let Some(ref local_var_str) = tenant_id__n {
12750        local_var_req_builder = match "multi" {
12751            "multi" => local_var_req_builder.query(
12752                &local_var_str
12753                    .into_iter()
12754                    .map(|p| ("tenant_id__n".to_owned(), p.to_string()))
12755                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12756            ),
12757            _ => local_var_req_builder.query(&[(
12758                "tenant_id__n",
12759                &local_var_str
12760                    .into_iter()
12761                    .map(|p| p.to_string())
12762                    .collect::<Vec<String>>()
12763                    .join(",")
12764                    .to_string(),
12765            )]),
12766        };
12767    }
12768    if let Some(ref local_var_str) = termination_a_id {
12769        local_var_req_builder = match "multi" {
12770            "multi" => local_var_req_builder.query(
12771                &local_var_str
12772                    .into_iter()
12773                    .map(|p| ("termination_a_id".to_owned(), p.to_string()))
12774                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12775            ),
12776            _ => local_var_req_builder.query(&[(
12777                "termination_a_id",
12778                &local_var_str
12779                    .into_iter()
12780                    .map(|p| p.to_string())
12781                    .collect::<Vec<String>>()
12782                    .join(",")
12783                    .to_string(),
12784            )]),
12785        };
12786    }
12787    if let Some(ref local_var_str) = termination_a_id__n {
12788        local_var_req_builder = match "multi" {
12789            "multi" => local_var_req_builder.query(
12790                &local_var_str
12791                    .into_iter()
12792                    .map(|p| ("termination_a_id__n".to_owned(), p.to_string()))
12793                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12794            ),
12795            _ => local_var_req_builder.query(&[(
12796                "termination_a_id__n",
12797                &local_var_str
12798                    .into_iter()
12799                    .map(|p| p.to_string())
12800                    .collect::<Vec<String>>()
12801                    .join(",")
12802                    .to_string(),
12803            )]),
12804        };
12805    }
12806    if let Some(ref local_var_str) = termination_date {
12807        local_var_req_builder = match "multi" {
12808            "multi" => local_var_req_builder.query(
12809                &local_var_str
12810                    .into_iter()
12811                    .map(|p| ("termination_date".to_owned(), p.to_string()))
12812                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12813            ),
12814            _ => local_var_req_builder.query(&[(
12815                "termination_date",
12816                &local_var_str
12817                    .into_iter()
12818                    .map(|p| p.to_string())
12819                    .collect::<Vec<String>>()
12820                    .join(",")
12821                    .to_string(),
12822            )]),
12823        };
12824    }
12825    if let Some(ref local_var_str) = termination_date__empty {
12826        local_var_req_builder =
12827            local_var_req_builder.query(&[("termination_date__empty", &local_var_str.to_string())]);
12828    }
12829    if let Some(ref local_var_str) = termination_date__gt {
12830        local_var_req_builder = match "multi" {
12831            "multi" => local_var_req_builder.query(
12832                &local_var_str
12833                    .into_iter()
12834                    .map(|p| ("termination_date__gt".to_owned(), p.to_string()))
12835                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12836            ),
12837            _ => local_var_req_builder.query(&[(
12838                "termination_date__gt",
12839                &local_var_str
12840                    .into_iter()
12841                    .map(|p| p.to_string())
12842                    .collect::<Vec<String>>()
12843                    .join(",")
12844                    .to_string(),
12845            )]),
12846        };
12847    }
12848    if let Some(ref local_var_str) = termination_date__gte {
12849        local_var_req_builder = match "multi" {
12850            "multi" => local_var_req_builder.query(
12851                &local_var_str
12852                    .into_iter()
12853                    .map(|p| ("termination_date__gte".to_owned(), p.to_string()))
12854                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12855            ),
12856            _ => local_var_req_builder.query(&[(
12857                "termination_date__gte",
12858                &local_var_str
12859                    .into_iter()
12860                    .map(|p| p.to_string())
12861                    .collect::<Vec<String>>()
12862                    .join(",")
12863                    .to_string(),
12864            )]),
12865        };
12866    }
12867    if let Some(ref local_var_str) = termination_date__lt {
12868        local_var_req_builder = match "multi" {
12869            "multi" => local_var_req_builder.query(
12870                &local_var_str
12871                    .into_iter()
12872                    .map(|p| ("termination_date__lt".to_owned(), p.to_string()))
12873                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12874            ),
12875            _ => local_var_req_builder.query(&[(
12876                "termination_date__lt",
12877                &local_var_str
12878                    .into_iter()
12879                    .map(|p| p.to_string())
12880                    .collect::<Vec<String>>()
12881                    .join(",")
12882                    .to_string(),
12883            )]),
12884        };
12885    }
12886    if let Some(ref local_var_str) = termination_date__lte {
12887        local_var_req_builder = match "multi" {
12888            "multi" => local_var_req_builder.query(
12889                &local_var_str
12890                    .into_iter()
12891                    .map(|p| ("termination_date__lte".to_owned(), p.to_string()))
12892                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12893            ),
12894            _ => local_var_req_builder.query(&[(
12895                "termination_date__lte",
12896                &local_var_str
12897                    .into_iter()
12898                    .map(|p| p.to_string())
12899                    .collect::<Vec<String>>()
12900                    .join(",")
12901                    .to_string(),
12902            )]),
12903        };
12904    }
12905    if let Some(ref local_var_str) = termination_date__n {
12906        local_var_req_builder = match "multi" {
12907            "multi" => local_var_req_builder.query(
12908                &local_var_str
12909                    .into_iter()
12910                    .map(|p| ("termination_date__n".to_owned(), p.to_string()))
12911                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12912            ),
12913            _ => local_var_req_builder.query(&[(
12914                "termination_date__n",
12915                &local_var_str
12916                    .into_iter()
12917                    .map(|p| p.to_string())
12918                    .collect::<Vec<String>>()
12919                    .join(",")
12920                    .to_string(),
12921            )]),
12922        };
12923    }
12924    if let Some(ref local_var_str) = termination_z_id {
12925        local_var_req_builder = match "multi" {
12926            "multi" => local_var_req_builder.query(
12927                &local_var_str
12928                    .into_iter()
12929                    .map(|p| ("termination_z_id".to_owned(), p.to_string()))
12930                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12931            ),
12932            _ => local_var_req_builder.query(&[(
12933                "termination_z_id",
12934                &local_var_str
12935                    .into_iter()
12936                    .map(|p| p.to_string())
12937                    .collect::<Vec<String>>()
12938                    .join(",")
12939                    .to_string(),
12940            )]),
12941        };
12942    }
12943    if let Some(ref local_var_str) = termination_z_id__n {
12944        local_var_req_builder = match "multi" {
12945            "multi" => local_var_req_builder.query(
12946                &local_var_str
12947                    .into_iter()
12948                    .map(|p| ("termination_z_id__n".to_owned(), p.to_string()))
12949                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12950            ),
12951            _ => local_var_req_builder.query(&[(
12952                "termination_z_id__n",
12953                &local_var_str
12954                    .into_iter()
12955                    .map(|p| p.to_string())
12956                    .collect::<Vec<String>>()
12957                    .join(",")
12958                    .to_string(),
12959            )]),
12960        };
12961    }
12962    if let Some(ref local_var_str) = r#type {
12963        local_var_req_builder = match "multi" {
12964            "multi" => local_var_req_builder.query(
12965                &local_var_str
12966                    .into_iter()
12967                    .map(|p| ("type".to_owned(), p.to_string()))
12968                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12969            ),
12970            _ => local_var_req_builder.query(&[(
12971                "type",
12972                &local_var_str
12973                    .into_iter()
12974                    .map(|p| p.to_string())
12975                    .collect::<Vec<String>>()
12976                    .join(",")
12977                    .to_string(),
12978            )]),
12979        };
12980    }
12981    if let Some(ref local_var_str) = type__n {
12982        local_var_req_builder = match "multi" {
12983            "multi" => local_var_req_builder.query(
12984                &local_var_str
12985                    .into_iter()
12986                    .map(|p| ("type__n".to_owned(), p.to_string()))
12987                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12988            ),
12989            _ => local_var_req_builder.query(&[(
12990                "type__n",
12991                &local_var_str
12992                    .into_iter()
12993                    .map(|p| p.to_string())
12994                    .collect::<Vec<String>>()
12995                    .join(",")
12996                    .to_string(),
12997            )]),
12998        };
12999    }
13000    if let Some(ref local_var_str) = type_id {
13001        local_var_req_builder = match "multi" {
13002            "multi" => local_var_req_builder.query(
13003                &local_var_str
13004                    .into_iter()
13005                    .map(|p| ("type_id".to_owned(), p.to_string()))
13006                    .collect::<Vec<(std::string::String, std::string::String)>>(),
13007            ),
13008            _ => local_var_req_builder.query(&[(
13009                "type_id",
13010                &local_var_str
13011                    .into_iter()
13012                    .map(|p| p.to_string())
13013                    .collect::<Vec<String>>()
13014                    .join(",")
13015                    .to_string(),
13016            )]),
13017        };
13018    }
13019    if let Some(ref local_var_str) = type_id__n {
13020        local_var_req_builder = match "multi" {
13021            "multi" => local_var_req_builder.query(
13022                &local_var_str
13023                    .into_iter()
13024                    .map(|p| ("type_id__n".to_owned(), p.to_string()))
13025                    .collect::<Vec<(std::string::String, std::string::String)>>(),
13026            ),
13027            _ => local_var_req_builder.query(&[(
13028                "type_id__n",
13029                &local_var_str
13030                    .into_iter()
13031                    .map(|p| p.to_string())
13032                    .collect::<Vec<String>>()
13033                    .join(",")
13034                    .to_string(),
13035            )]),
13036        };
13037    }
13038    if let Some(ref local_var_str) = updated_by_request {
13039        local_var_req_builder =
13040            local_var_req_builder.query(&[("updated_by_request", &local_var_str.to_string())]);
13041    }
13042    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
13043        local_var_req_builder =
13044            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
13045    }
13046    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
13047        let local_var_key = local_var_apikey.key.clone();
13048        let local_var_value = match local_var_apikey.prefix {
13049            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
13050            None => local_var_key,
13051        };
13052        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
13053    };
13054
13055    let local_var_req = local_var_req_builder.build()?;
13056    let local_var_resp = local_var_client.execute(local_var_req).await?;
13057
13058    let local_var_status = local_var_resp.status();
13059    let local_var_content = local_var_resp.text().await?;
13060
13061    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
13062        serde_json::from_str(&local_var_content).map_err(Error::from)
13063    } else {
13064        let local_var_entity: Option<CircuitsCircuitsListError> =
13065            serde_json::from_str(&local_var_content).ok();
13066        let local_var_error = ResponseContent {
13067            status: local_var_status,
13068            content: local_var_content,
13069            entity: local_var_entity,
13070        };
13071        Err(Error::ResponseError(local_var_error))
13072    }
13073}
13074
13075/// Patch a circuit object.
13076pub async fn circuits_circuits_partial_update(
13077    configuration: &configuration::Configuration,
13078    id: i32,
13079    patched_writable_circuit_request: Option<crate::models::PatchedWritableCircuitRequest>,
13080) -> Result<crate::models::Circuit, Error<CircuitsCircuitsPartialUpdateError>> {
13081    let local_var_configuration = configuration;
13082
13083    let local_var_client = &local_var_configuration.client;
13084
13085    let local_var_uri_str = format!(
13086        "{}/api/circuits/circuits/{id}/",
13087        local_var_configuration.base_path,
13088        id = id
13089    );
13090    let mut local_var_req_builder =
13091        local_var_client.request(reqwest::Method::PATCH, local_var_uri_str.as_str());
13092
13093    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
13094        local_var_req_builder =
13095            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
13096    }
13097    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
13098        let local_var_key = local_var_apikey.key.clone();
13099        let local_var_value = match local_var_apikey.prefix {
13100            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
13101            None => local_var_key,
13102        };
13103        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
13104    };
13105    local_var_req_builder = local_var_req_builder.json(&patched_writable_circuit_request);
13106
13107    let local_var_req = local_var_req_builder.build()?;
13108    let local_var_resp = local_var_client.execute(local_var_req).await?;
13109
13110    let local_var_status = local_var_resp.status();
13111    let local_var_content = local_var_resp.text().await?;
13112
13113    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
13114        serde_json::from_str(&local_var_content).map_err(Error::from)
13115    } else {
13116        let local_var_entity: Option<CircuitsCircuitsPartialUpdateError> =
13117            serde_json::from_str(&local_var_content).ok();
13118        let local_var_error = ResponseContent {
13119            status: local_var_status,
13120            content: local_var_content,
13121            entity: local_var_entity,
13122        };
13123        Err(Error::ResponseError(local_var_error))
13124    }
13125}
13126
13127/// Get a circuit object.
13128pub async fn circuits_circuits_retrieve(
13129    configuration: &configuration::Configuration,
13130    id: i32,
13131) -> Result<crate::models::Circuit, Error<CircuitsCircuitsRetrieveError>> {
13132    let local_var_configuration = configuration;
13133
13134    let local_var_client = &local_var_configuration.client;
13135
13136    let local_var_uri_str = format!(
13137        "{}/api/circuits/circuits/{id}/",
13138        local_var_configuration.base_path,
13139        id = id
13140    );
13141    let mut local_var_req_builder =
13142        local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
13143
13144    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
13145        local_var_req_builder =
13146            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
13147    }
13148    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
13149        let local_var_key = local_var_apikey.key.clone();
13150        let local_var_value = match local_var_apikey.prefix {
13151            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
13152            None => local_var_key,
13153        };
13154        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
13155    };
13156
13157    let local_var_req = local_var_req_builder.build()?;
13158    let local_var_resp = local_var_client.execute(local_var_req).await?;
13159
13160    let local_var_status = local_var_resp.status();
13161    let local_var_content = local_var_resp.text().await?;
13162
13163    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
13164        serde_json::from_str(&local_var_content).map_err(Error::from)
13165    } else {
13166        let local_var_entity: Option<CircuitsCircuitsRetrieveError> =
13167            serde_json::from_str(&local_var_content).ok();
13168        let local_var_error = ResponseContent {
13169            status: local_var_status,
13170            content: local_var_content,
13171            entity: local_var_entity,
13172        };
13173        Err(Error::ResponseError(local_var_error))
13174    }
13175}
13176
13177/// Put a circuit object.
13178pub async fn circuits_circuits_update(
13179    configuration: &configuration::Configuration,
13180    id: i32,
13181    writable_circuit_request: crate::models::WritableCircuitRequest,
13182) -> Result<crate::models::Circuit, Error<CircuitsCircuitsUpdateError>> {
13183    let local_var_configuration = configuration;
13184
13185    let local_var_client = &local_var_configuration.client;
13186
13187    let local_var_uri_str = format!(
13188        "{}/api/circuits/circuits/{id}/",
13189        local_var_configuration.base_path,
13190        id = id
13191    );
13192    let mut local_var_req_builder =
13193        local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());
13194
13195    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
13196        local_var_req_builder =
13197            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
13198    }
13199    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
13200        let local_var_key = local_var_apikey.key.clone();
13201        let local_var_value = match local_var_apikey.prefix {
13202            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
13203            None => local_var_key,
13204        };
13205        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
13206    };
13207    local_var_req_builder = local_var_req_builder.json(&writable_circuit_request);
13208
13209    let local_var_req = local_var_req_builder.build()?;
13210    let local_var_resp = local_var_client.execute(local_var_req).await?;
13211
13212    let local_var_status = local_var_resp.status();
13213    let local_var_content = local_var_resp.text().await?;
13214
13215    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
13216        serde_json::from_str(&local_var_content).map_err(Error::from)
13217    } else {
13218        let local_var_entity: Option<CircuitsCircuitsUpdateError> =
13219            serde_json::from_str(&local_var_content).ok();
13220        let local_var_error = ResponseContent {
13221            status: local_var_status,
13222            content: local_var_content,
13223            entity: local_var_entity,
13224        };
13225        Err(Error::ResponseError(local_var_error))
13226    }
13227}
13228
13229/// Delete a list of provider account objects.
13230pub async fn circuits_provider_accounts_bulk_destroy(
13231    configuration: &configuration::Configuration,
13232    provider_account_request: Vec<crate::models::ProviderAccountRequest>,
13233) -> Result<(), Error<CircuitsProviderAccountsBulkDestroyError>> {
13234    let local_var_configuration = configuration;
13235
13236    let local_var_client = &local_var_configuration.client;
13237
13238    let local_var_uri_str = format!(
13239        "{}/api/circuits/provider-accounts/",
13240        local_var_configuration.base_path
13241    );
13242    let mut local_var_req_builder =
13243        local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());
13244
13245    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
13246        local_var_req_builder =
13247            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
13248    }
13249    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
13250        let local_var_key = local_var_apikey.key.clone();
13251        let local_var_value = match local_var_apikey.prefix {
13252            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
13253            None => local_var_key,
13254        };
13255        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
13256    };
13257    local_var_req_builder = local_var_req_builder.json(&provider_account_request);
13258
13259    let local_var_req = local_var_req_builder.build()?;
13260    let local_var_resp = local_var_client.execute(local_var_req).await?;
13261
13262    let local_var_status = local_var_resp.status();
13263    let local_var_content = local_var_resp.text().await?;
13264
13265    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
13266        Ok(())
13267    } else {
13268        let local_var_entity: Option<CircuitsProviderAccountsBulkDestroyError> =
13269            serde_json::from_str(&local_var_content).ok();
13270        let local_var_error = ResponseContent {
13271            status: local_var_status,
13272            content: local_var_content,
13273            entity: local_var_entity,
13274        };
13275        Err(Error::ResponseError(local_var_error))
13276    }
13277}
13278
13279/// Patch a list of provider account objects.
13280pub async fn circuits_provider_accounts_bulk_partial_update(
13281    configuration: &configuration::Configuration,
13282    provider_account_request: Vec<crate::models::ProviderAccountRequest>,
13283) -> Result<
13284    Vec<crate::models::ProviderAccount>,
13285    Error<CircuitsProviderAccountsBulkPartialUpdateError>,
13286> {
13287    let local_var_configuration = configuration;
13288
13289    let local_var_client = &local_var_configuration.client;
13290
13291    let local_var_uri_str = format!(
13292        "{}/api/circuits/provider-accounts/",
13293        local_var_configuration.base_path
13294    );
13295    let mut local_var_req_builder =
13296        local_var_client.request(reqwest::Method::PATCH, local_var_uri_str.as_str());
13297
13298    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
13299        local_var_req_builder =
13300            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
13301    }
13302    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
13303        let local_var_key = local_var_apikey.key.clone();
13304        let local_var_value = match local_var_apikey.prefix {
13305            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
13306            None => local_var_key,
13307        };
13308        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
13309    };
13310    local_var_req_builder = local_var_req_builder.json(&provider_account_request);
13311
13312    let local_var_req = local_var_req_builder.build()?;
13313    let local_var_resp = local_var_client.execute(local_var_req).await?;
13314
13315    let local_var_status = local_var_resp.status();
13316    let local_var_content = local_var_resp.text().await?;
13317
13318    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
13319        serde_json::from_str(&local_var_content).map_err(Error::from)
13320    } else {
13321        let local_var_entity: Option<CircuitsProviderAccountsBulkPartialUpdateError> =
13322            serde_json::from_str(&local_var_content).ok();
13323        let local_var_error = ResponseContent {
13324            status: local_var_status,
13325            content: local_var_content,
13326            entity: local_var_entity,
13327        };
13328        Err(Error::ResponseError(local_var_error))
13329    }
13330}
13331
13332/// Put a list of provider account objects.
13333pub async fn circuits_provider_accounts_bulk_update(
13334    configuration: &configuration::Configuration,
13335    provider_account_request: Vec<crate::models::ProviderAccountRequest>,
13336) -> Result<Vec<crate::models::ProviderAccount>, Error<CircuitsProviderAccountsBulkUpdateError>> {
13337    let local_var_configuration = configuration;
13338
13339    let local_var_client = &local_var_configuration.client;
13340
13341    let local_var_uri_str = format!(
13342        "{}/api/circuits/provider-accounts/",
13343        local_var_configuration.base_path
13344    );
13345    let mut local_var_req_builder =
13346        local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());
13347
13348    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
13349        local_var_req_builder =
13350            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
13351    }
13352    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
13353        let local_var_key = local_var_apikey.key.clone();
13354        let local_var_value = match local_var_apikey.prefix {
13355            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
13356            None => local_var_key,
13357        };
13358        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
13359    };
13360    local_var_req_builder = local_var_req_builder.json(&provider_account_request);
13361
13362    let local_var_req = local_var_req_builder.build()?;
13363    let local_var_resp = local_var_client.execute(local_var_req).await?;
13364
13365    let local_var_status = local_var_resp.status();
13366    let local_var_content = local_var_resp.text().await?;
13367
13368    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
13369        serde_json::from_str(&local_var_content).map_err(Error::from)
13370    } else {
13371        let local_var_entity: Option<CircuitsProviderAccountsBulkUpdateError> =
13372            serde_json::from_str(&local_var_content).ok();
13373        let local_var_error = ResponseContent {
13374            status: local_var_status,
13375            content: local_var_content,
13376            entity: local_var_entity,
13377        };
13378        Err(Error::ResponseError(local_var_error))
13379    }
13380}
13381
13382/// Post a list of provider account objects.
13383pub async fn circuits_provider_accounts_create(
13384    configuration: &configuration::Configuration,
13385    circuits_provider_accounts_create_request: crate::models::CircuitsProviderAccountsCreateRequest,
13386) -> Result<crate::models::ProviderAccount, Error<CircuitsProviderAccountsCreateError>> {
13387    let local_var_configuration = configuration;
13388
13389    let local_var_client = &local_var_configuration.client;
13390
13391    let local_var_uri_str = format!(
13392        "{}/api/circuits/provider-accounts/",
13393        local_var_configuration.base_path
13394    );
13395    let mut local_var_req_builder =
13396        local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
13397
13398    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
13399        local_var_req_builder =
13400            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
13401    }
13402    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
13403        let local_var_key = local_var_apikey.key.clone();
13404        let local_var_value = match local_var_apikey.prefix {
13405            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
13406            None => local_var_key,
13407        };
13408        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
13409    };
13410    local_var_req_builder = local_var_req_builder.json(&circuits_provider_accounts_create_request);
13411
13412    let local_var_req = local_var_req_builder.build()?;
13413    let local_var_resp = local_var_client.execute(local_var_req).await?;
13414
13415    let local_var_status = local_var_resp.status();
13416    let local_var_content = local_var_resp.text().await?;
13417
13418    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
13419        serde_json::from_str(&local_var_content).map_err(Error::from)
13420    } else {
13421        let local_var_entity: Option<CircuitsProviderAccountsCreateError> =
13422            serde_json::from_str(&local_var_content).ok();
13423        let local_var_error = ResponseContent {
13424            status: local_var_status,
13425            content: local_var_content,
13426            entity: local_var_entity,
13427        };
13428        Err(Error::ResponseError(local_var_error))
13429    }
13430}
13431
13432/// Delete a provider account object.
13433pub async fn circuits_provider_accounts_destroy(
13434    configuration: &configuration::Configuration,
13435    id: i32,
13436) -> Result<(), Error<CircuitsProviderAccountsDestroyError>> {
13437    let local_var_configuration = configuration;
13438
13439    let local_var_client = &local_var_configuration.client;
13440
13441    let local_var_uri_str = format!(
13442        "{}/api/circuits/provider-accounts/{id}/",
13443        local_var_configuration.base_path,
13444        id = id
13445    );
13446    let mut local_var_req_builder =
13447        local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());
13448
13449    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
13450        local_var_req_builder =
13451            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
13452    }
13453    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
13454        let local_var_key = local_var_apikey.key.clone();
13455        let local_var_value = match local_var_apikey.prefix {
13456            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
13457            None => local_var_key,
13458        };
13459        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
13460    };
13461
13462    let local_var_req = local_var_req_builder.build()?;
13463    let local_var_resp = local_var_client.execute(local_var_req).await?;
13464
13465    let local_var_status = local_var_resp.status();
13466    let local_var_content = local_var_resp.text().await?;
13467
13468    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
13469        Ok(())
13470    } else {
13471        let local_var_entity: Option<CircuitsProviderAccountsDestroyError> =
13472            serde_json::from_str(&local_var_content).ok();
13473        let local_var_error = ResponseContent {
13474            status: local_var_status,
13475            content: local_var_content,
13476            entity: local_var_entity,
13477        };
13478        Err(Error::ResponseError(local_var_error))
13479    }
13480}
13481
13482/// Get a list of provider account objects.
13483pub async fn circuits_provider_accounts_list(
13484    configuration: &configuration::Configuration,
13485    account: Option<Vec<String>>,
13486    account__empty: Option<bool>,
13487    account__ic: Option<Vec<String>>,
13488    account__ie: Option<Vec<String>>,
13489    account__iew: Option<Vec<String>>,
13490    account__iregex: Option<Vec<String>>,
13491    account__isw: Option<Vec<String>>,
13492    account__n: Option<Vec<String>>,
13493    account__nic: Option<Vec<String>>,
13494    account__nie: Option<Vec<String>>,
13495    account__niew: Option<Vec<String>>,
13496    account__nisw: Option<Vec<String>>,
13497    account__regex: Option<Vec<String>>,
13498    contact: Option<Vec<i32>>,
13499    contact__n: Option<Vec<i32>>,
13500    contact_group: Option<Vec<String>>,
13501    contact_group__n: Option<Vec<String>>,
13502    contact_role: Option<Vec<i32>>,
13503    contact_role__n: Option<Vec<i32>>,
13504    created: Option<Vec<String>>,
13505    created__empty: Option<Vec<String>>,
13506    created__gt: Option<Vec<String>>,
13507    created__gte: Option<Vec<String>>,
13508    created__lt: Option<Vec<String>>,
13509    created__lte: Option<Vec<String>>,
13510    created__n: Option<Vec<String>>,
13511    created_by_request: Option<&str>,
13512    description: Option<Vec<String>>,
13513    description__empty: Option<bool>,
13514    description__ic: Option<Vec<String>>,
13515    description__ie: Option<Vec<String>>,
13516    description__iew: Option<Vec<String>>,
13517    description__iregex: Option<Vec<String>>,
13518    description__isw: Option<Vec<String>>,
13519    description__n: Option<Vec<String>>,
13520    description__nic: Option<Vec<String>>,
13521    description__nie: Option<Vec<String>>,
13522    description__niew: Option<Vec<String>>,
13523    description__nisw: Option<Vec<String>>,
13524    description__regex: Option<Vec<String>>,
13525    id: Option<Vec<i32>>,
13526    id__empty: Option<bool>,
13527    id__gt: Option<Vec<i32>>,
13528    id__gte: Option<Vec<i32>>,
13529    id__lt: Option<Vec<i32>>,
13530    id__lte: Option<Vec<i32>>,
13531    id__n: Option<Vec<i32>>,
13532    last_updated: Option<Vec<String>>,
13533    last_updated__empty: Option<Vec<String>>,
13534    last_updated__gt: Option<Vec<String>>,
13535    last_updated__gte: Option<Vec<String>>,
13536    last_updated__lt: Option<Vec<String>>,
13537    last_updated__lte: Option<Vec<String>>,
13538    last_updated__n: Option<Vec<String>>,
13539    limit: Option<i32>,
13540    modified_by_request: Option<&str>,
13541    name: Option<Vec<String>>,
13542    name__empty: Option<bool>,
13543    name__ic: Option<Vec<String>>,
13544    name__ie: Option<Vec<String>>,
13545    name__iew: Option<Vec<String>>,
13546    name__iregex: Option<Vec<String>>,
13547    name__isw: Option<Vec<String>>,
13548    name__n: Option<Vec<String>>,
13549    name__nic: Option<Vec<String>>,
13550    name__nie: Option<Vec<String>>,
13551    name__niew: Option<Vec<String>>,
13552    name__nisw: Option<Vec<String>>,
13553    name__regex: Option<Vec<String>>,
13554    offset: Option<i32>,
13555    ordering: Option<&str>,
13556    owner: Option<Vec<String>>,
13557    owner__n: Option<Vec<String>>,
13558    owner_group: Option<Vec<String>>,
13559    owner_group__n: Option<Vec<String>>,
13560    owner_group_id: Option<Vec<i32>>,
13561    owner_group_id__n: Option<Vec<i32>>,
13562    owner_id: Option<Vec<i32>>,
13563    owner_id__n: Option<Vec<i32>>,
13564    provider: Option<Vec<String>>,
13565    provider__n: Option<Vec<String>>,
13566    provider_id: Option<Vec<i32>>,
13567    provider_id__n: Option<Vec<i32>>,
13568    q: Option<&str>,
13569    start: Option<i32>,
13570    tag: Option<Vec<String>>,
13571    tag__n: Option<Vec<String>>,
13572    tag_id: Option<Vec<i32>>,
13573    tag_id__n: Option<Vec<i32>>,
13574    updated_by_request: Option<&str>,
13575) -> Result<crate::models::PaginatedProviderAccountList, Error<CircuitsProviderAccountsListError>> {
13576    let local_var_configuration = configuration;
13577
13578    let local_var_client = &local_var_configuration.client;
13579
13580    let local_var_uri_str = format!(
13581        "{}/api/circuits/provider-accounts/",
13582        local_var_configuration.base_path
13583    );
13584    let mut local_var_req_builder =
13585        local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
13586
13587    if let Some(ref local_var_str) = account {
13588        local_var_req_builder = match "multi" {
13589            "multi" => local_var_req_builder.query(
13590                &local_var_str
13591                    .into_iter()
13592                    .map(|p| ("account".to_owned(), p.to_string()))
13593                    .collect::<Vec<(std::string::String, std::string::String)>>(),
13594            ),
13595            _ => local_var_req_builder.query(&[(
13596                "account",
13597                &local_var_str
13598                    .into_iter()
13599                    .map(|p| p.to_string())
13600                    .collect::<Vec<String>>()
13601                    .join(",")
13602                    .to_string(),
13603            )]),
13604        };
13605    }
13606    if let Some(ref local_var_str) = account__empty {
13607        local_var_req_builder =
13608            local_var_req_builder.query(&[("account__empty", &local_var_str.to_string())]);
13609    }
13610    if let Some(ref local_var_str) = account__ic {
13611        local_var_req_builder = match "multi" {
13612            "multi" => local_var_req_builder.query(
13613                &local_var_str
13614                    .into_iter()
13615                    .map(|p| ("account__ic".to_owned(), p.to_string()))
13616                    .collect::<Vec<(std::string::String, std::string::String)>>(),
13617            ),
13618            _ => local_var_req_builder.query(&[(
13619                "account__ic",
13620                &local_var_str
13621                    .into_iter()
13622                    .map(|p| p.to_string())
13623                    .collect::<Vec<String>>()
13624                    .join(",")
13625                    .to_string(),
13626            )]),
13627        };
13628    }
13629    if let Some(ref local_var_str) = account__ie {
13630        local_var_req_builder = match "multi" {
13631            "multi" => local_var_req_builder.query(
13632                &local_var_str
13633                    .into_iter()
13634                    .map(|p| ("account__ie".to_owned(), p.to_string()))
13635                    .collect::<Vec<(std::string::String, std::string::String)>>(),
13636            ),
13637            _ => local_var_req_builder.query(&[(
13638                "account__ie",
13639                &local_var_str
13640                    .into_iter()
13641                    .map(|p| p.to_string())
13642                    .collect::<Vec<String>>()
13643                    .join(",")
13644                    .to_string(),
13645            )]),
13646        };
13647    }
13648    if let Some(ref local_var_str) = account__iew {
13649        local_var_req_builder = match "multi" {
13650            "multi" => local_var_req_builder.query(
13651                &local_var_str
13652                    .into_iter()
13653                    .map(|p| ("account__iew".to_owned(), p.to_string()))
13654                    .collect::<Vec<(std::string::String, std::string::String)>>(),
13655            ),
13656            _ => local_var_req_builder.query(&[(
13657                "account__iew",
13658                &local_var_str
13659                    .into_iter()
13660                    .map(|p| p.to_string())
13661                    .collect::<Vec<String>>()
13662                    .join(",")
13663                    .to_string(),
13664            )]),
13665        };
13666    }
13667    if let Some(ref local_var_str) = account__iregex {
13668        local_var_req_builder = match "multi" {
13669            "multi" => local_var_req_builder.query(
13670                &local_var_str
13671                    .into_iter()
13672                    .map(|p| ("account__iregex".to_owned(), p.to_string()))
13673                    .collect::<Vec<(std::string::String, std::string::String)>>(),
13674            ),
13675            _ => local_var_req_builder.query(&[(
13676                "account__iregex",
13677                &local_var_str
13678                    .into_iter()
13679                    .map(|p| p.to_string())
13680                    .collect::<Vec<String>>()
13681                    .join(",")
13682                    .to_string(),
13683            )]),
13684        };
13685    }
13686    if let Some(ref local_var_str) = account__isw {
13687        local_var_req_builder = match "multi" {
13688            "multi" => local_var_req_builder.query(
13689                &local_var_str
13690                    .into_iter()
13691                    .map(|p| ("account__isw".to_owned(), p.to_string()))
13692                    .collect::<Vec<(std::string::String, std::string::String)>>(),
13693            ),
13694            _ => local_var_req_builder.query(&[(
13695                "account__isw",
13696                &local_var_str
13697                    .into_iter()
13698                    .map(|p| p.to_string())
13699                    .collect::<Vec<String>>()
13700                    .join(",")
13701                    .to_string(),
13702            )]),
13703        };
13704    }
13705    if let Some(ref local_var_str) = account__n {
13706        local_var_req_builder = match "multi" {
13707            "multi" => local_var_req_builder.query(
13708                &local_var_str
13709                    .into_iter()
13710                    .map(|p| ("account__n".to_owned(), p.to_string()))
13711                    .collect::<Vec<(std::string::String, std::string::String)>>(),
13712            ),
13713            _ => local_var_req_builder.query(&[(
13714                "account__n",
13715                &local_var_str
13716                    .into_iter()
13717                    .map(|p| p.to_string())
13718                    .collect::<Vec<String>>()
13719                    .join(",")
13720                    .to_string(),
13721            )]),
13722        };
13723    }
13724    if let Some(ref local_var_str) = account__nic {
13725        local_var_req_builder = match "multi" {
13726            "multi" => local_var_req_builder.query(
13727                &local_var_str
13728                    .into_iter()
13729                    .map(|p| ("account__nic".to_owned(), p.to_string()))
13730                    .collect::<Vec<(std::string::String, std::string::String)>>(),
13731            ),
13732            _ => local_var_req_builder.query(&[(
13733                "account__nic",
13734                &local_var_str
13735                    .into_iter()
13736                    .map(|p| p.to_string())
13737                    .collect::<Vec<String>>()
13738                    .join(",")
13739                    .to_string(),
13740            )]),
13741        };
13742    }
13743    if let Some(ref local_var_str) = account__nie {
13744        local_var_req_builder = match "multi" {
13745            "multi" => local_var_req_builder.query(
13746                &local_var_str
13747                    .into_iter()
13748                    .map(|p| ("account__nie".to_owned(), p.to_string()))
13749                    .collect::<Vec<(std::string::String, std::string::String)>>(),
13750            ),
13751            _ => local_var_req_builder.query(&[(
13752                "account__nie",
13753                &local_var_str
13754                    .into_iter()
13755                    .map(|p| p.to_string())
13756                    .collect::<Vec<String>>()
13757                    .join(",")
13758                    .to_string(),
13759            )]),
13760        };
13761    }
13762    if let Some(ref local_var_str) = account__niew {
13763        local_var_req_builder = match "multi" {
13764            "multi" => local_var_req_builder.query(
13765                &local_var_str
13766                    .into_iter()
13767                    .map(|p| ("account__niew".to_owned(), p.to_string()))
13768                    .collect::<Vec<(std::string::String, std::string::String)>>(),
13769            ),
13770            _ => local_var_req_builder.query(&[(
13771                "account__niew",
13772                &local_var_str
13773                    .into_iter()
13774                    .map(|p| p.to_string())
13775                    .collect::<Vec<String>>()
13776                    .join(",")
13777                    .to_string(),
13778            )]),
13779        };
13780    }
13781    if let Some(ref local_var_str) = account__nisw {
13782        local_var_req_builder = match "multi" {
13783            "multi" => local_var_req_builder.query(
13784                &local_var_str
13785                    .into_iter()
13786                    .map(|p| ("account__nisw".to_owned(), p.to_string()))
13787                    .collect::<Vec<(std::string::String, std::string::String)>>(),
13788            ),
13789            _ => local_var_req_builder.query(&[(
13790                "account__nisw",
13791                &local_var_str
13792                    .into_iter()
13793                    .map(|p| p.to_string())
13794                    .collect::<Vec<String>>()
13795                    .join(",")
13796                    .to_string(),
13797            )]),
13798        };
13799    }
13800    if let Some(ref local_var_str) = account__regex {
13801        local_var_req_builder = match "multi" {
13802            "multi" => local_var_req_builder.query(
13803                &local_var_str
13804                    .into_iter()
13805                    .map(|p| ("account__regex".to_owned(), p.to_string()))
13806                    .collect::<Vec<(std::string::String, std::string::String)>>(),
13807            ),
13808            _ => local_var_req_builder.query(&[(
13809                "account__regex",
13810                &local_var_str
13811                    .into_iter()
13812                    .map(|p| p.to_string())
13813                    .collect::<Vec<String>>()
13814                    .join(",")
13815                    .to_string(),
13816            )]),
13817        };
13818    }
13819    if let Some(ref local_var_str) = contact {
13820        local_var_req_builder = match "multi" {
13821            "multi" => local_var_req_builder.query(
13822                &local_var_str
13823                    .into_iter()
13824                    .map(|p| ("contact".to_owned(), p.to_string()))
13825                    .collect::<Vec<(std::string::String, std::string::String)>>(),
13826            ),
13827            _ => local_var_req_builder.query(&[(
13828                "contact",
13829                &local_var_str
13830                    .into_iter()
13831                    .map(|p| p.to_string())
13832                    .collect::<Vec<String>>()
13833                    .join(",")
13834                    .to_string(),
13835            )]),
13836        };
13837    }
13838    if let Some(ref local_var_str) = contact__n {
13839        local_var_req_builder = match "multi" {
13840            "multi" => local_var_req_builder.query(
13841                &local_var_str
13842                    .into_iter()
13843                    .map(|p| ("contact__n".to_owned(), p.to_string()))
13844                    .collect::<Vec<(std::string::String, std::string::String)>>(),
13845            ),
13846            _ => local_var_req_builder.query(&[(
13847                "contact__n",
13848                &local_var_str
13849                    .into_iter()
13850                    .map(|p| p.to_string())
13851                    .collect::<Vec<String>>()
13852                    .join(",")
13853                    .to_string(),
13854            )]),
13855        };
13856    }
13857    if let Some(ref local_var_str) = contact_group {
13858        local_var_req_builder = match "multi" {
13859            "multi" => local_var_req_builder.query(
13860                &local_var_str
13861                    .into_iter()
13862                    .map(|p| ("contact_group".to_owned(), p.to_string()))
13863                    .collect::<Vec<(std::string::String, std::string::String)>>(),
13864            ),
13865            _ => local_var_req_builder.query(&[(
13866                "contact_group",
13867                &local_var_str
13868                    .into_iter()
13869                    .map(|p| p.to_string())
13870                    .collect::<Vec<String>>()
13871                    .join(",")
13872                    .to_string(),
13873            )]),
13874        };
13875    }
13876    if let Some(ref local_var_str) = contact_group__n {
13877        local_var_req_builder = match "multi" {
13878            "multi" => local_var_req_builder.query(
13879                &local_var_str
13880                    .into_iter()
13881                    .map(|p| ("contact_group__n".to_owned(), p.to_string()))
13882                    .collect::<Vec<(std::string::String, std::string::String)>>(),
13883            ),
13884            _ => local_var_req_builder.query(&[(
13885                "contact_group__n",
13886                &local_var_str
13887                    .into_iter()
13888                    .map(|p| p.to_string())
13889                    .collect::<Vec<String>>()
13890                    .join(",")
13891                    .to_string(),
13892            )]),
13893        };
13894    }
13895    if let Some(ref local_var_str) = contact_role {
13896        local_var_req_builder = match "multi" {
13897            "multi" => local_var_req_builder.query(
13898                &local_var_str
13899                    .into_iter()
13900                    .map(|p| ("contact_role".to_owned(), p.to_string()))
13901                    .collect::<Vec<(std::string::String, std::string::String)>>(),
13902            ),
13903            _ => local_var_req_builder.query(&[(
13904                "contact_role",
13905                &local_var_str
13906                    .into_iter()
13907                    .map(|p| p.to_string())
13908                    .collect::<Vec<String>>()
13909                    .join(",")
13910                    .to_string(),
13911            )]),
13912        };
13913    }
13914    if let Some(ref local_var_str) = contact_role__n {
13915        local_var_req_builder = match "multi" {
13916            "multi" => local_var_req_builder.query(
13917                &local_var_str
13918                    .into_iter()
13919                    .map(|p| ("contact_role__n".to_owned(), p.to_string()))
13920                    .collect::<Vec<(std::string::String, std::string::String)>>(),
13921            ),
13922            _ => local_var_req_builder.query(&[(
13923                "contact_role__n",
13924                &local_var_str
13925                    .into_iter()
13926                    .map(|p| p.to_string())
13927                    .collect::<Vec<String>>()
13928                    .join(",")
13929                    .to_string(),
13930            )]),
13931        };
13932    }
13933    if let Some(ref local_var_str) = created {
13934        local_var_req_builder = match "multi" {
13935            "multi" => local_var_req_builder.query(
13936                &local_var_str
13937                    .into_iter()
13938                    .map(|p| ("created".to_owned(), p.to_string()))
13939                    .collect::<Vec<(std::string::String, std::string::String)>>(),
13940            ),
13941            _ => local_var_req_builder.query(&[(
13942                "created",
13943                &local_var_str
13944                    .into_iter()
13945                    .map(|p| p.to_string())
13946                    .collect::<Vec<String>>()
13947                    .join(",")
13948                    .to_string(),
13949            )]),
13950        };
13951    }
13952    if let Some(ref local_var_str) = created__empty {
13953        local_var_req_builder = match "multi" {
13954            "multi" => local_var_req_builder.query(
13955                &local_var_str
13956                    .into_iter()
13957                    .map(|p| ("created__empty".to_owned(), p.to_string()))
13958                    .collect::<Vec<(std::string::String, std::string::String)>>(),
13959            ),
13960            _ => local_var_req_builder.query(&[(
13961                "created__empty",
13962                &local_var_str
13963                    .into_iter()
13964                    .map(|p| p.to_string())
13965                    .collect::<Vec<String>>()
13966                    .join(",")
13967                    .to_string(),
13968            )]),
13969        };
13970    }
13971    if let Some(ref local_var_str) = created__gt {
13972        local_var_req_builder = match "multi" {
13973            "multi" => local_var_req_builder.query(
13974                &local_var_str
13975                    .into_iter()
13976                    .map(|p| ("created__gt".to_owned(), p.to_string()))
13977                    .collect::<Vec<(std::string::String, std::string::String)>>(),
13978            ),
13979            _ => local_var_req_builder.query(&[(
13980                "created__gt",
13981                &local_var_str
13982                    .into_iter()
13983                    .map(|p| p.to_string())
13984                    .collect::<Vec<String>>()
13985                    .join(",")
13986                    .to_string(),
13987            )]),
13988        };
13989    }
13990    if let Some(ref local_var_str) = created__gte {
13991        local_var_req_builder = match "multi" {
13992            "multi" => local_var_req_builder.query(
13993                &local_var_str
13994                    .into_iter()
13995                    .map(|p| ("created__gte".to_owned(), p.to_string()))
13996                    .collect::<Vec<(std::string::String, std::string::String)>>(),
13997            ),
13998            _ => local_var_req_builder.query(&[(
13999                "created__gte",
14000                &local_var_str
14001                    .into_iter()
14002                    .map(|p| p.to_string())
14003                    .collect::<Vec<String>>()
14004                    .join(",")
14005                    .to_string(),
14006            )]),
14007        };
14008    }
14009    if let Some(ref local_var_str) = created__lt {
14010        local_var_req_builder = match "multi" {
14011            "multi" => local_var_req_builder.query(
14012                &local_var_str
14013                    .into_iter()
14014                    .map(|p| ("created__lt".to_owned(), p.to_string()))
14015                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14016            ),
14017            _ => local_var_req_builder.query(&[(
14018                "created__lt",
14019                &local_var_str
14020                    .into_iter()
14021                    .map(|p| p.to_string())
14022                    .collect::<Vec<String>>()
14023                    .join(",")
14024                    .to_string(),
14025            )]),
14026        };
14027    }
14028    if let Some(ref local_var_str) = created__lte {
14029        local_var_req_builder = match "multi" {
14030            "multi" => local_var_req_builder.query(
14031                &local_var_str
14032                    .into_iter()
14033                    .map(|p| ("created__lte".to_owned(), p.to_string()))
14034                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14035            ),
14036            _ => local_var_req_builder.query(&[(
14037                "created__lte",
14038                &local_var_str
14039                    .into_iter()
14040                    .map(|p| p.to_string())
14041                    .collect::<Vec<String>>()
14042                    .join(",")
14043                    .to_string(),
14044            )]),
14045        };
14046    }
14047    if let Some(ref local_var_str) = created__n {
14048        local_var_req_builder = match "multi" {
14049            "multi" => local_var_req_builder.query(
14050                &local_var_str
14051                    .into_iter()
14052                    .map(|p| ("created__n".to_owned(), p.to_string()))
14053                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14054            ),
14055            _ => local_var_req_builder.query(&[(
14056                "created__n",
14057                &local_var_str
14058                    .into_iter()
14059                    .map(|p| p.to_string())
14060                    .collect::<Vec<String>>()
14061                    .join(",")
14062                    .to_string(),
14063            )]),
14064        };
14065    }
14066    if let Some(ref local_var_str) = created_by_request {
14067        local_var_req_builder =
14068            local_var_req_builder.query(&[("created_by_request", &local_var_str.to_string())]);
14069    }
14070    if let Some(ref local_var_str) = description {
14071        local_var_req_builder = match "multi" {
14072            "multi" => local_var_req_builder.query(
14073                &local_var_str
14074                    .into_iter()
14075                    .map(|p| ("description".to_owned(), p.to_string()))
14076                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14077            ),
14078            _ => local_var_req_builder.query(&[(
14079                "description",
14080                &local_var_str
14081                    .into_iter()
14082                    .map(|p| p.to_string())
14083                    .collect::<Vec<String>>()
14084                    .join(",")
14085                    .to_string(),
14086            )]),
14087        };
14088    }
14089    if let Some(ref local_var_str) = description__empty {
14090        local_var_req_builder =
14091            local_var_req_builder.query(&[("description__empty", &local_var_str.to_string())]);
14092    }
14093    if let Some(ref local_var_str) = description__ic {
14094        local_var_req_builder = match "multi" {
14095            "multi" => local_var_req_builder.query(
14096                &local_var_str
14097                    .into_iter()
14098                    .map(|p| ("description__ic".to_owned(), p.to_string()))
14099                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14100            ),
14101            _ => local_var_req_builder.query(&[(
14102                "description__ic",
14103                &local_var_str
14104                    .into_iter()
14105                    .map(|p| p.to_string())
14106                    .collect::<Vec<String>>()
14107                    .join(",")
14108                    .to_string(),
14109            )]),
14110        };
14111    }
14112    if let Some(ref local_var_str) = description__ie {
14113        local_var_req_builder = match "multi" {
14114            "multi" => local_var_req_builder.query(
14115                &local_var_str
14116                    .into_iter()
14117                    .map(|p| ("description__ie".to_owned(), p.to_string()))
14118                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14119            ),
14120            _ => local_var_req_builder.query(&[(
14121                "description__ie",
14122                &local_var_str
14123                    .into_iter()
14124                    .map(|p| p.to_string())
14125                    .collect::<Vec<String>>()
14126                    .join(",")
14127                    .to_string(),
14128            )]),
14129        };
14130    }
14131    if let Some(ref local_var_str) = description__iew {
14132        local_var_req_builder = match "multi" {
14133            "multi" => local_var_req_builder.query(
14134                &local_var_str
14135                    .into_iter()
14136                    .map(|p| ("description__iew".to_owned(), p.to_string()))
14137                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14138            ),
14139            _ => local_var_req_builder.query(&[(
14140                "description__iew",
14141                &local_var_str
14142                    .into_iter()
14143                    .map(|p| p.to_string())
14144                    .collect::<Vec<String>>()
14145                    .join(",")
14146                    .to_string(),
14147            )]),
14148        };
14149    }
14150    if let Some(ref local_var_str) = description__iregex {
14151        local_var_req_builder = match "multi" {
14152            "multi" => local_var_req_builder.query(
14153                &local_var_str
14154                    .into_iter()
14155                    .map(|p| ("description__iregex".to_owned(), p.to_string()))
14156                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14157            ),
14158            _ => local_var_req_builder.query(&[(
14159                "description__iregex",
14160                &local_var_str
14161                    .into_iter()
14162                    .map(|p| p.to_string())
14163                    .collect::<Vec<String>>()
14164                    .join(",")
14165                    .to_string(),
14166            )]),
14167        };
14168    }
14169    if let Some(ref local_var_str) = description__isw {
14170        local_var_req_builder = match "multi" {
14171            "multi" => local_var_req_builder.query(
14172                &local_var_str
14173                    .into_iter()
14174                    .map(|p| ("description__isw".to_owned(), p.to_string()))
14175                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14176            ),
14177            _ => local_var_req_builder.query(&[(
14178                "description__isw",
14179                &local_var_str
14180                    .into_iter()
14181                    .map(|p| p.to_string())
14182                    .collect::<Vec<String>>()
14183                    .join(",")
14184                    .to_string(),
14185            )]),
14186        };
14187    }
14188    if let Some(ref local_var_str) = description__n {
14189        local_var_req_builder = match "multi" {
14190            "multi" => local_var_req_builder.query(
14191                &local_var_str
14192                    .into_iter()
14193                    .map(|p| ("description__n".to_owned(), p.to_string()))
14194                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14195            ),
14196            _ => local_var_req_builder.query(&[(
14197                "description__n",
14198                &local_var_str
14199                    .into_iter()
14200                    .map(|p| p.to_string())
14201                    .collect::<Vec<String>>()
14202                    .join(",")
14203                    .to_string(),
14204            )]),
14205        };
14206    }
14207    if let Some(ref local_var_str) = description__nic {
14208        local_var_req_builder = match "multi" {
14209            "multi" => local_var_req_builder.query(
14210                &local_var_str
14211                    .into_iter()
14212                    .map(|p| ("description__nic".to_owned(), p.to_string()))
14213                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14214            ),
14215            _ => local_var_req_builder.query(&[(
14216                "description__nic",
14217                &local_var_str
14218                    .into_iter()
14219                    .map(|p| p.to_string())
14220                    .collect::<Vec<String>>()
14221                    .join(",")
14222                    .to_string(),
14223            )]),
14224        };
14225    }
14226    if let Some(ref local_var_str) = description__nie {
14227        local_var_req_builder = match "multi" {
14228            "multi" => local_var_req_builder.query(
14229                &local_var_str
14230                    .into_iter()
14231                    .map(|p| ("description__nie".to_owned(), p.to_string()))
14232                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14233            ),
14234            _ => local_var_req_builder.query(&[(
14235                "description__nie",
14236                &local_var_str
14237                    .into_iter()
14238                    .map(|p| p.to_string())
14239                    .collect::<Vec<String>>()
14240                    .join(",")
14241                    .to_string(),
14242            )]),
14243        };
14244    }
14245    if let Some(ref local_var_str) = description__niew {
14246        local_var_req_builder = match "multi" {
14247            "multi" => local_var_req_builder.query(
14248                &local_var_str
14249                    .into_iter()
14250                    .map(|p| ("description__niew".to_owned(), p.to_string()))
14251                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14252            ),
14253            _ => local_var_req_builder.query(&[(
14254                "description__niew",
14255                &local_var_str
14256                    .into_iter()
14257                    .map(|p| p.to_string())
14258                    .collect::<Vec<String>>()
14259                    .join(",")
14260                    .to_string(),
14261            )]),
14262        };
14263    }
14264    if let Some(ref local_var_str) = description__nisw {
14265        local_var_req_builder = match "multi" {
14266            "multi" => local_var_req_builder.query(
14267                &local_var_str
14268                    .into_iter()
14269                    .map(|p| ("description__nisw".to_owned(), p.to_string()))
14270                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14271            ),
14272            _ => local_var_req_builder.query(&[(
14273                "description__nisw",
14274                &local_var_str
14275                    .into_iter()
14276                    .map(|p| p.to_string())
14277                    .collect::<Vec<String>>()
14278                    .join(",")
14279                    .to_string(),
14280            )]),
14281        };
14282    }
14283    if let Some(ref local_var_str) = description__regex {
14284        local_var_req_builder = match "multi" {
14285            "multi" => local_var_req_builder.query(
14286                &local_var_str
14287                    .into_iter()
14288                    .map(|p| ("description__regex".to_owned(), p.to_string()))
14289                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14290            ),
14291            _ => local_var_req_builder.query(&[(
14292                "description__regex",
14293                &local_var_str
14294                    .into_iter()
14295                    .map(|p| p.to_string())
14296                    .collect::<Vec<String>>()
14297                    .join(",")
14298                    .to_string(),
14299            )]),
14300        };
14301    }
14302    if let Some(ref local_var_str) = id {
14303        local_var_req_builder = match "multi" {
14304            "multi" => local_var_req_builder.query(
14305                &local_var_str
14306                    .into_iter()
14307                    .map(|p| ("id".to_owned(), p.to_string()))
14308                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14309            ),
14310            _ => local_var_req_builder.query(&[(
14311                "id",
14312                &local_var_str
14313                    .into_iter()
14314                    .map(|p| p.to_string())
14315                    .collect::<Vec<String>>()
14316                    .join(",")
14317                    .to_string(),
14318            )]),
14319        };
14320    }
14321    if let Some(ref local_var_str) = id__empty {
14322        local_var_req_builder =
14323            local_var_req_builder.query(&[("id__empty", &local_var_str.to_string())]);
14324    }
14325    if let Some(ref local_var_str) = id__gt {
14326        local_var_req_builder = match "multi" {
14327            "multi" => local_var_req_builder.query(
14328                &local_var_str
14329                    .into_iter()
14330                    .map(|p| ("id__gt".to_owned(), p.to_string()))
14331                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14332            ),
14333            _ => local_var_req_builder.query(&[(
14334                "id__gt",
14335                &local_var_str
14336                    .into_iter()
14337                    .map(|p| p.to_string())
14338                    .collect::<Vec<String>>()
14339                    .join(",")
14340                    .to_string(),
14341            )]),
14342        };
14343    }
14344    if let Some(ref local_var_str) = id__gte {
14345        local_var_req_builder = match "multi" {
14346            "multi" => local_var_req_builder.query(
14347                &local_var_str
14348                    .into_iter()
14349                    .map(|p| ("id__gte".to_owned(), p.to_string()))
14350                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14351            ),
14352            _ => local_var_req_builder.query(&[(
14353                "id__gte",
14354                &local_var_str
14355                    .into_iter()
14356                    .map(|p| p.to_string())
14357                    .collect::<Vec<String>>()
14358                    .join(",")
14359                    .to_string(),
14360            )]),
14361        };
14362    }
14363    if let Some(ref local_var_str) = id__lt {
14364        local_var_req_builder = match "multi" {
14365            "multi" => local_var_req_builder.query(
14366                &local_var_str
14367                    .into_iter()
14368                    .map(|p| ("id__lt".to_owned(), p.to_string()))
14369                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14370            ),
14371            _ => local_var_req_builder.query(&[(
14372                "id__lt",
14373                &local_var_str
14374                    .into_iter()
14375                    .map(|p| p.to_string())
14376                    .collect::<Vec<String>>()
14377                    .join(",")
14378                    .to_string(),
14379            )]),
14380        };
14381    }
14382    if let Some(ref local_var_str) = id__lte {
14383        local_var_req_builder = match "multi" {
14384            "multi" => local_var_req_builder.query(
14385                &local_var_str
14386                    .into_iter()
14387                    .map(|p| ("id__lte".to_owned(), p.to_string()))
14388                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14389            ),
14390            _ => local_var_req_builder.query(&[(
14391                "id__lte",
14392                &local_var_str
14393                    .into_iter()
14394                    .map(|p| p.to_string())
14395                    .collect::<Vec<String>>()
14396                    .join(",")
14397                    .to_string(),
14398            )]),
14399        };
14400    }
14401    if let Some(ref local_var_str) = id__n {
14402        local_var_req_builder = match "multi" {
14403            "multi" => local_var_req_builder.query(
14404                &local_var_str
14405                    .into_iter()
14406                    .map(|p| ("id__n".to_owned(), p.to_string()))
14407                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14408            ),
14409            _ => local_var_req_builder.query(&[(
14410                "id__n",
14411                &local_var_str
14412                    .into_iter()
14413                    .map(|p| p.to_string())
14414                    .collect::<Vec<String>>()
14415                    .join(",")
14416                    .to_string(),
14417            )]),
14418        };
14419    }
14420    if let Some(ref local_var_str) = last_updated {
14421        local_var_req_builder = match "multi" {
14422            "multi" => local_var_req_builder.query(
14423                &local_var_str
14424                    .into_iter()
14425                    .map(|p| ("last_updated".to_owned(), p.to_string()))
14426                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14427            ),
14428            _ => local_var_req_builder.query(&[(
14429                "last_updated",
14430                &local_var_str
14431                    .into_iter()
14432                    .map(|p| p.to_string())
14433                    .collect::<Vec<String>>()
14434                    .join(",")
14435                    .to_string(),
14436            )]),
14437        };
14438    }
14439    if let Some(ref local_var_str) = last_updated__empty {
14440        local_var_req_builder = match "multi" {
14441            "multi" => local_var_req_builder.query(
14442                &local_var_str
14443                    .into_iter()
14444                    .map(|p| ("last_updated__empty".to_owned(), p.to_string()))
14445                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14446            ),
14447            _ => local_var_req_builder.query(&[(
14448                "last_updated__empty",
14449                &local_var_str
14450                    .into_iter()
14451                    .map(|p| p.to_string())
14452                    .collect::<Vec<String>>()
14453                    .join(",")
14454                    .to_string(),
14455            )]),
14456        };
14457    }
14458    if let Some(ref local_var_str) = last_updated__gt {
14459        local_var_req_builder = match "multi" {
14460            "multi" => local_var_req_builder.query(
14461                &local_var_str
14462                    .into_iter()
14463                    .map(|p| ("last_updated__gt".to_owned(), p.to_string()))
14464                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14465            ),
14466            _ => local_var_req_builder.query(&[(
14467                "last_updated__gt",
14468                &local_var_str
14469                    .into_iter()
14470                    .map(|p| p.to_string())
14471                    .collect::<Vec<String>>()
14472                    .join(",")
14473                    .to_string(),
14474            )]),
14475        };
14476    }
14477    if let Some(ref local_var_str) = last_updated__gte {
14478        local_var_req_builder = match "multi" {
14479            "multi" => local_var_req_builder.query(
14480                &local_var_str
14481                    .into_iter()
14482                    .map(|p| ("last_updated__gte".to_owned(), p.to_string()))
14483                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14484            ),
14485            _ => local_var_req_builder.query(&[(
14486                "last_updated__gte",
14487                &local_var_str
14488                    .into_iter()
14489                    .map(|p| p.to_string())
14490                    .collect::<Vec<String>>()
14491                    .join(",")
14492                    .to_string(),
14493            )]),
14494        };
14495    }
14496    if let Some(ref local_var_str) = last_updated__lt {
14497        local_var_req_builder = match "multi" {
14498            "multi" => local_var_req_builder.query(
14499                &local_var_str
14500                    .into_iter()
14501                    .map(|p| ("last_updated__lt".to_owned(), p.to_string()))
14502                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14503            ),
14504            _ => local_var_req_builder.query(&[(
14505                "last_updated__lt",
14506                &local_var_str
14507                    .into_iter()
14508                    .map(|p| p.to_string())
14509                    .collect::<Vec<String>>()
14510                    .join(",")
14511                    .to_string(),
14512            )]),
14513        };
14514    }
14515    if let Some(ref local_var_str) = last_updated__lte {
14516        local_var_req_builder = match "multi" {
14517            "multi" => local_var_req_builder.query(
14518                &local_var_str
14519                    .into_iter()
14520                    .map(|p| ("last_updated__lte".to_owned(), p.to_string()))
14521                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14522            ),
14523            _ => local_var_req_builder.query(&[(
14524                "last_updated__lte",
14525                &local_var_str
14526                    .into_iter()
14527                    .map(|p| p.to_string())
14528                    .collect::<Vec<String>>()
14529                    .join(",")
14530                    .to_string(),
14531            )]),
14532        };
14533    }
14534    if let Some(ref local_var_str) = last_updated__n {
14535        local_var_req_builder = match "multi" {
14536            "multi" => local_var_req_builder.query(
14537                &local_var_str
14538                    .into_iter()
14539                    .map(|p| ("last_updated__n".to_owned(), p.to_string()))
14540                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14541            ),
14542            _ => local_var_req_builder.query(&[(
14543                "last_updated__n",
14544                &local_var_str
14545                    .into_iter()
14546                    .map(|p| p.to_string())
14547                    .collect::<Vec<String>>()
14548                    .join(",")
14549                    .to_string(),
14550            )]),
14551        };
14552    }
14553    if let Some(ref local_var_str) = limit {
14554        local_var_req_builder =
14555            local_var_req_builder.query(&[("limit", &local_var_str.to_string())]);
14556    }
14557    if let Some(ref local_var_str) = modified_by_request {
14558        local_var_req_builder =
14559            local_var_req_builder.query(&[("modified_by_request", &local_var_str.to_string())]);
14560    }
14561    if let Some(ref local_var_str) = name {
14562        local_var_req_builder = match "multi" {
14563            "multi" => local_var_req_builder.query(
14564                &local_var_str
14565                    .into_iter()
14566                    .map(|p| ("name".to_owned(), p.to_string()))
14567                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14568            ),
14569            _ => local_var_req_builder.query(&[(
14570                "name",
14571                &local_var_str
14572                    .into_iter()
14573                    .map(|p| p.to_string())
14574                    .collect::<Vec<String>>()
14575                    .join(",")
14576                    .to_string(),
14577            )]),
14578        };
14579    }
14580    if let Some(ref local_var_str) = name__empty {
14581        local_var_req_builder =
14582            local_var_req_builder.query(&[("name__empty", &local_var_str.to_string())]);
14583    }
14584    if let Some(ref local_var_str) = name__ic {
14585        local_var_req_builder = match "multi" {
14586            "multi" => local_var_req_builder.query(
14587                &local_var_str
14588                    .into_iter()
14589                    .map(|p| ("name__ic".to_owned(), p.to_string()))
14590                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14591            ),
14592            _ => local_var_req_builder.query(&[(
14593                "name__ic",
14594                &local_var_str
14595                    .into_iter()
14596                    .map(|p| p.to_string())
14597                    .collect::<Vec<String>>()
14598                    .join(",")
14599                    .to_string(),
14600            )]),
14601        };
14602    }
14603    if let Some(ref local_var_str) = name__ie {
14604        local_var_req_builder = match "multi" {
14605            "multi" => local_var_req_builder.query(
14606                &local_var_str
14607                    .into_iter()
14608                    .map(|p| ("name__ie".to_owned(), p.to_string()))
14609                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14610            ),
14611            _ => local_var_req_builder.query(&[(
14612                "name__ie",
14613                &local_var_str
14614                    .into_iter()
14615                    .map(|p| p.to_string())
14616                    .collect::<Vec<String>>()
14617                    .join(",")
14618                    .to_string(),
14619            )]),
14620        };
14621    }
14622    if let Some(ref local_var_str) = name__iew {
14623        local_var_req_builder = match "multi" {
14624            "multi" => local_var_req_builder.query(
14625                &local_var_str
14626                    .into_iter()
14627                    .map(|p| ("name__iew".to_owned(), p.to_string()))
14628                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14629            ),
14630            _ => local_var_req_builder.query(&[(
14631                "name__iew",
14632                &local_var_str
14633                    .into_iter()
14634                    .map(|p| p.to_string())
14635                    .collect::<Vec<String>>()
14636                    .join(",")
14637                    .to_string(),
14638            )]),
14639        };
14640    }
14641    if let Some(ref local_var_str) = name__iregex {
14642        local_var_req_builder = match "multi" {
14643            "multi" => local_var_req_builder.query(
14644                &local_var_str
14645                    .into_iter()
14646                    .map(|p| ("name__iregex".to_owned(), p.to_string()))
14647                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14648            ),
14649            _ => local_var_req_builder.query(&[(
14650                "name__iregex",
14651                &local_var_str
14652                    .into_iter()
14653                    .map(|p| p.to_string())
14654                    .collect::<Vec<String>>()
14655                    .join(",")
14656                    .to_string(),
14657            )]),
14658        };
14659    }
14660    if let Some(ref local_var_str) = name__isw {
14661        local_var_req_builder = match "multi" {
14662            "multi" => local_var_req_builder.query(
14663                &local_var_str
14664                    .into_iter()
14665                    .map(|p| ("name__isw".to_owned(), p.to_string()))
14666                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14667            ),
14668            _ => local_var_req_builder.query(&[(
14669                "name__isw",
14670                &local_var_str
14671                    .into_iter()
14672                    .map(|p| p.to_string())
14673                    .collect::<Vec<String>>()
14674                    .join(",")
14675                    .to_string(),
14676            )]),
14677        };
14678    }
14679    if let Some(ref local_var_str) = name__n {
14680        local_var_req_builder = match "multi" {
14681            "multi" => local_var_req_builder.query(
14682                &local_var_str
14683                    .into_iter()
14684                    .map(|p| ("name__n".to_owned(), p.to_string()))
14685                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14686            ),
14687            _ => local_var_req_builder.query(&[(
14688                "name__n",
14689                &local_var_str
14690                    .into_iter()
14691                    .map(|p| p.to_string())
14692                    .collect::<Vec<String>>()
14693                    .join(",")
14694                    .to_string(),
14695            )]),
14696        };
14697    }
14698    if let Some(ref local_var_str) = name__nic {
14699        local_var_req_builder = match "multi" {
14700            "multi" => local_var_req_builder.query(
14701                &local_var_str
14702                    .into_iter()
14703                    .map(|p| ("name__nic".to_owned(), p.to_string()))
14704                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14705            ),
14706            _ => local_var_req_builder.query(&[(
14707                "name__nic",
14708                &local_var_str
14709                    .into_iter()
14710                    .map(|p| p.to_string())
14711                    .collect::<Vec<String>>()
14712                    .join(",")
14713                    .to_string(),
14714            )]),
14715        };
14716    }
14717    if let Some(ref local_var_str) = name__nie {
14718        local_var_req_builder = match "multi" {
14719            "multi" => local_var_req_builder.query(
14720                &local_var_str
14721                    .into_iter()
14722                    .map(|p| ("name__nie".to_owned(), p.to_string()))
14723                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14724            ),
14725            _ => local_var_req_builder.query(&[(
14726                "name__nie",
14727                &local_var_str
14728                    .into_iter()
14729                    .map(|p| p.to_string())
14730                    .collect::<Vec<String>>()
14731                    .join(",")
14732                    .to_string(),
14733            )]),
14734        };
14735    }
14736    if let Some(ref local_var_str) = name__niew {
14737        local_var_req_builder = match "multi" {
14738            "multi" => local_var_req_builder.query(
14739                &local_var_str
14740                    .into_iter()
14741                    .map(|p| ("name__niew".to_owned(), p.to_string()))
14742                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14743            ),
14744            _ => local_var_req_builder.query(&[(
14745                "name__niew",
14746                &local_var_str
14747                    .into_iter()
14748                    .map(|p| p.to_string())
14749                    .collect::<Vec<String>>()
14750                    .join(",")
14751                    .to_string(),
14752            )]),
14753        };
14754    }
14755    if let Some(ref local_var_str) = name__nisw {
14756        local_var_req_builder = match "multi" {
14757            "multi" => local_var_req_builder.query(
14758                &local_var_str
14759                    .into_iter()
14760                    .map(|p| ("name__nisw".to_owned(), p.to_string()))
14761                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14762            ),
14763            _ => local_var_req_builder.query(&[(
14764                "name__nisw",
14765                &local_var_str
14766                    .into_iter()
14767                    .map(|p| p.to_string())
14768                    .collect::<Vec<String>>()
14769                    .join(",")
14770                    .to_string(),
14771            )]),
14772        };
14773    }
14774    if let Some(ref local_var_str) = name__regex {
14775        local_var_req_builder = match "multi" {
14776            "multi" => local_var_req_builder.query(
14777                &local_var_str
14778                    .into_iter()
14779                    .map(|p| ("name__regex".to_owned(), p.to_string()))
14780                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14781            ),
14782            _ => local_var_req_builder.query(&[(
14783                "name__regex",
14784                &local_var_str
14785                    .into_iter()
14786                    .map(|p| p.to_string())
14787                    .collect::<Vec<String>>()
14788                    .join(",")
14789                    .to_string(),
14790            )]),
14791        };
14792    }
14793    if let Some(ref local_var_str) = offset {
14794        local_var_req_builder =
14795            local_var_req_builder.query(&[("offset", &local_var_str.to_string())]);
14796    }
14797    if let Some(ref local_var_str) = ordering {
14798        local_var_req_builder =
14799            local_var_req_builder.query(&[("ordering", &local_var_str.to_string())]);
14800    }
14801    if let Some(ref local_var_str) = owner {
14802        local_var_req_builder = match "multi" {
14803            "multi" => local_var_req_builder.query(
14804                &local_var_str
14805                    .into_iter()
14806                    .map(|p| ("owner".to_owned(), p.to_string()))
14807                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14808            ),
14809            _ => local_var_req_builder.query(&[(
14810                "owner",
14811                &local_var_str
14812                    .into_iter()
14813                    .map(|p| p.to_string())
14814                    .collect::<Vec<String>>()
14815                    .join(",")
14816                    .to_string(),
14817            )]),
14818        };
14819    }
14820    if let Some(ref local_var_str) = owner__n {
14821        local_var_req_builder = match "multi" {
14822            "multi" => local_var_req_builder.query(
14823                &local_var_str
14824                    .into_iter()
14825                    .map(|p| ("owner__n".to_owned(), p.to_string()))
14826                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14827            ),
14828            _ => local_var_req_builder.query(&[(
14829                "owner__n",
14830                &local_var_str
14831                    .into_iter()
14832                    .map(|p| p.to_string())
14833                    .collect::<Vec<String>>()
14834                    .join(",")
14835                    .to_string(),
14836            )]),
14837        };
14838    }
14839    if let Some(ref local_var_str) = owner_group {
14840        local_var_req_builder = match "multi" {
14841            "multi" => local_var_req_builder.query(
14842                &local_var_str
14843                    .into_iter()
14844                    .map(|p| ("owner_group".to_owned(), p.to_string()))
14845                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14846            ),
14847            _ => local_var_req_builder.query(&[(
14848                "owner_group",
14849                &local_var_str
14850                    .into_iter()
14851                    .map(|p| p.to_string())
14852                    .collect::<Vec<String>>()
14853                    .join(",")
14854                    .to_string(),
14855            )]),
14856        };
14857    }
14858    if let Some(ref local_var_str) = owner_group__n {
14859        local_var_req_builder = match "multi" {
14860            "multi" => local_var_req_builder.query(
14861                &local_var_str
14862                    .into_iter()
14863                    .map(|p| ("owner_group__n".to_owned(), p.to_string()))
14864                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14865            ),
14866            _ => local_var_req_builder.query(&[(
14867                "owner_group__n",
14868                &local_var_str
14869                    .into_iter()
14870                    .map(|p| p.to_string())
14871                    .collect::<Vec<String>>()
14872                    .join(",")
14873                    .to_string(),
14874            )]),
14875        };
14876    }
14877    if let Some(ref local_var_str) = owner_group_id {
14878        local_var_req_builder = match "multi" {
14879            "multi" => local_var_req_builder.query(
14880                &local_var_str
14881                    .into_iter()
14882                    .map(|p| ("owner_group_id".to_owned(), p.to_string()))
14883                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14884            ),
14885            _ => local_var_req_builder.query(&[(
14886                "owner_group_id",
14887                &local_var_str
14888                    .into_iter()
14889                    .map(|p| p.to_string())
14890                    .collect::<Vec<String>>()
14891                    .join(",")
14892                    .to_string(),
14893            )]),
14894        };
14895    }
14896    if let Some(ref local_var_str) = owner_group_id__n {
14897        local_var_req_builder = match "multi" {
14898            "multi" => local_var_req_builder.query(
14899                &local_var_str
14900                    .into_iter()
14901                    .map(|p| ("owner_group_id__n".to_owned(), p.to_string()))
14902                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14903            ),
14904            _ => local_var_req_builder.query(&[(
14905                "owner_group_id__n",
14906                &local_var_str
14907                    .into_iter()
14908                    .map(|p| p.to_string())
14909                    .collect::<Vec<String>>()
14910                    .join(",")
14911                    .to_string(),
14912            )]),
14913        };
14914    }
14915    if let Some(ref local_var_str) = owner_id {
14916        local_var_req_builder = match "multi" {
14917            "multi" => local_var_req_builder.query(
14918                &local_var_str
14919                    .into_iter()
14920                    .map(|p| ("owner_id".to_owned(), p.to_string()))
14921                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14922            ),
14923            _ => local_var_req_builder.query(&[(
14924                "owner_id",
14925                &local_var_str
14926                    .into_iter()
14927                    .map(|p| p.to_string())
14928                    .collect::<Vec<String>>()
14929                    .join(",")
14930                    .to_string(),
14931            )]),
14932        };
14933    }
14934    if let Some(ref local_var_str) = owner_id__n {
14935        local_var_req_builder = match "multi" {
14936            "multi" => local_var_req_builder.query(
14937                &local_var_str
14938                    .into_iter()
14939                    .map(|p| ("owner_id__n".to_owned(), p.to_string()))
14940                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14941            ),
14942            _ => local_var_req_builder.query(&[(
14943                "owner_id__n",
14944                &local_var_str
14945                    .into_iter()
14946                    .map(|p| p.to_string())
14947                    .collect::<Vec<String>>()
14948                    .join(",")
14949                    .to_string(),
14950            )]),
14951        };
14952    }
14953    if let Some(ref local_var_str) = provider {
14954        local_var_req_builder = match "multi" {
14955            "multi" => local_var_req_builder.query(
14956                &local_var_str
14957                    .into_iter()
14958                    .map(|p| ("provider".to_owned(), p.to_string()))
14959                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14960            ),
14961            _ => local_var_req_builder.query(&[(
14962                "provider",
14963                &local_var_str
14964                    .into_iter()
14965                    .map(|p| p.to_string())
14966                    .collect::<Vec<String>>()
14967                    .join(",")
14968                    .to_string(),
14969            )]),
14970        };
14971    }
14972    if let Some(ref local_var_str) = provider__n {
14973        local_var_req_builder = match "multi" {
14974            "multi" => local_var_req_builder.query(
14975                &local_var_str
14976                    .into_iter()
14977                    .map(|p| ("provider__n".to_owned(), p.to_string()))
14978                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14979            ),
14980            _ => local_var_req_builder.query(&[(
14981                "provider__n",
14982                &local_var_str
14983                    .into_iter()
14984                    .map(|p| p.to_string())
14985                    .collect::<Vec<String>>()
14986                    .join(",")
14987                    .to_string(),
14988            )]),
14989        };
14990    }
14991    if let Some(ref local_var_str) = provider_id {
14992        local_var_req_builder = match "multi" {
14993            "multi" => local_var_req_builder.query(
14994                &local_var_str
14995                    .into_iter()
14996                    .map(|p| ("provider_id".to_owned(), p.to_string()))
14997                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14998            ),
14999            _ => local_var_req_builder.query(&[(
15000                "provider_id",
15001                &local_var_str
15002                    .into_iter()
15003                    .map(|p| p.to_string())
15004                    .collect::<Vec<String>>()
15005                    .join(",")
15006                    .to_string(),
15007            )]),
15008        };
15009    }
15010    if let Some(ref local_var_str) = provider_id__n {
15011        local_var_req_builder = match "multi" {
15012            "multi" => local_var_req_builder.query(
15013                &local_var_str
15014                    .into_iter()
15015                    .map(|p| ("provider_id__n".to_owned(), p.to_string()))
15016                    .collect::<Vec<(std::string::String, std::string::String)>>(),
15017            ),
15018            _ => local_var_req_builder.query(&[(
15019                "provider_id__n",
15020                &local_var_str
15021                    .into_iter()
15022                    .map(|p| p.to_string())
15023                    .collect::<Vec<String>>()
15024                    .join(",")
15025                    .to_string(),
15026            )]),
15027        };
15028    }
15029    if let Some(ref local_var_str) = q {
15030        local_var_req_builder = local_var_req_builder.query(&[("q", &local_var_str.to_string())]);
15031    }
15032    if let Some(ref local_var_str) = start {
15033        local_var_req_builder =
15034            local_var_req_builder.query(&[("start", &local_var_str.to_string())]);
15035    }
15036    if let Some(ref local_var_str) = tag {
15037        local_var_req_builder = match "multi" {
15038            "multi" => local_var_req_builder.query(
15039                &local_var_str
15040                    .into_iter()
15041                    .map(|p| ("tag".to_owned(), p.to_string()))
15042                    .collect::<Vec<(std::string::String, std::string::String)>>(),
15043            ),
15044            _ => local_var_req_builder.query(&[(
15045                "tag",
15046                &local_var_str
15047                    .into_iter()
15048                    .map(|p| p.to_string())
15049                    .collect::<Vec<String>>()
15050                    .join(",")
15051                    .to_string(),
15052            )]),
15053        };
15054    }
15055    if let Some(ref local_var_str) = tag__n {
15056        local_var_req_builder = match "multi" {
15057            "multi" => local_var_req_builder.query(
15058                &local_var_str
15059                    .into_iter()
15060                    .map(|p| ("tag__n".to_owned(), p.to_string()))
15061                    .collect::<Vec<(std::string::String, std::string::String)>>(),
15062            ),
15063            _ => local_var_req_builder.query(&[(
15064                "tag__n",
15065                &local_var_str
15066                    .into_iter()
15067                    .map(|p| p.to_string())
15068                    .collect::<Vec<String>>()
15069                    .join(",")
15070                    .to_string(),
15071            )]),
15072        };
15073    }
15074    if let Some(ref local_var_str) = tag_id {
15075        local_var_req_builder = match "multi" {
15076            "multi" => local_var_req_builder.query(
15077                &local_var_str
15078                    .into_iter()
15079                    .map(|p| ("tag_id".to_owned(), p.to_string()))
15080                    .collect::<Vec<(std::string::String, std::string::String)>>(),
15081            ),
15082            _ => local_var_req_builder.query(&[(
15083                "tag_id",
15084                &local_var_str
15085                    .into_iter()
15086                    .map(|p| p.to_string())
15087                    .collect::<Vec<String>>()
15088                    .join(",")
15089                    .to_string(),
15090            )]),
15091        };
15092    }
15093    if let Some(ref local_var_str) = tag_id__n {
15094        local_var_req_builder = match "multi" {
15095            "multi" => local_var_req_builder.query(
15096                &local_var_str
15097                    .into_iter()
15098                    .map(|p| ("tag_id__n".to_owned(), p.to_string()))
15099                    .collect::<Vec<(std::string::String, std::string::String)>>(),
15100            ),
15101            _ => local_var_req_builder.query(&[(
15102                "tag_id__n",
15103                &local_var_str
15104                    .into_iter()
15105                    .map(|p| p.to_string())
15106                    .collect::<Vec<String>>()
15107                    .join(",")
15108                    .to_string(),
15109            )]),
15110        };
15111    }
15112    if let Some(ref local_var_str) = updated_by_request {
15113        local_var_req_builder =
15114            local_var_req_builder.query(&[("updated_by_request", &local_var_str.to_string())]);
15115    }
15116    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
15117        local_var_req_builder =
15118            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
15119    }
15120    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
15121        let local_var_key = local_var_apikey.key.clone();
15122        let local_var_value = match local_var_apikey.prefix {
15123            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
15124            None => local_var_key,
15125        };
15126        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
15127    };
15128
15129    let local_var_req = local_var_req_builder.build()?;
15130    let local_var_resp = local_var_client.execute(local_var_req).await?;
15131
15132    let local_var_status = local_var_resp.status();
15133    let local_var_content = local_var_resp.text().await?;
15134
15135    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
15136        serde_json::from_str(&local_var_content).map_err(Error::from)
15137    } else {
15138        let local_var_entity: Option<CircuitsProviderAccountsListError> =
15139            serde_json::from_str(&local_var_content).ok();
15140        let local_var_error = ResponseContent {
15141            status: local_var_status,
15142            content: local_var_content,
15143            entity: local_var_entity,
15144        };
15145        Err(Error::ResponseError(local_var_error))
15146    }
15147}
15148
15149/// Patch a provider account object.
15150pub async fn circuits_provider_accounts_partial_update(
15151    configuration: &configuration::Configuration,
15152    id: i32,
15153    patched_provider_account_request: Option<crate::models::PatchedProviderAccountRequest>,
15154) -> Result<crate::models::ProviderAccount, Error<CircuitsProviderAccountsPartialUpdateError>> {
15155    let local_var_configuration = configuration;
15156
15157    let local_var_client = &local_var_configuration.client;
15158
15159    let local_var_uri_str = format!(
15160        "{}/api/circuits/provider-accounts/{id}/",
15161        local_var_configuration.base_path,
15162        id = id
15163    );
15164    let mut local_var_req_builder =
15165        local_var_client.request(reqwest::Method::PATCH, local_var_uri_str.as_str());
15166
15167    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
15168        local_var_req_builder =
15169            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
15170    }
15171    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
15172        let local_var_key = local_var_apikey.key.clone();
15173        let local_var_value = match local_var_apikey.prefix {
15174            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
15175            None => local_var_key,
15176        };
15177        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
15178    };
15179    local_var_req_builder = local_var_req_builder.json(&patched_provider_account_request);
15180
15181    let local_var_req = local_var_req_builder.build()?;
15182    let local_var_resp = local_var_client.execute(local_var_req).await?;
15183
15184    let local_var_status = local_var_resp.status();
15185    let local_var_content = local_var_resp.text().await?;
15186
15187    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
15188        serde_json::from_str(&local_var_content).map_err(Error::from)
15189    } else {
15190        let local_var_entity: Option<CircuitsProviderAccountsPartialUpdateError> =
15191            serde_json::from_str(&local_var_content).ok();
15192        let local_var_error = ResponseContent {
15193            status: local_var_status,
15194            content: local_var_content,
15195            entity: local_var_entity,
15196        };
15197        Err(Error::ResponseError(local_var_error))
15198    }
15199}
15200
15201/// Get a provider account object.
15202pub async fn circuits_provider_accounts_retrieve(
15203    configuration: &configuration::Configuration,
15204    id: i32,
15205) -> Result<crate::models::ProviderAccount, Error<CircuitsProviderAccountsRetrieveError>> {
15206    let local_var_configuration = configuration;
15207
15208    let local_var_client = &local_var_configuration.client;
15209
15210    let local_var_uri_str = format!(
15211        "{}/api/circuits/provider-accounts/{id}/",
15212        local_var_configuration.base_path,
15213        id = id
15214    );
15215    let mut local_var_req_builder =
15216        local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
15217
15218    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
15219        local_var_req_builder =
15220            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
15221    }
15222    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
15223        let local_var_key = local_var_apikey.key.clone();
15224        let local_var_value = match local_var_apikey.prefix {
15225            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
15226            None => local_var_key,
15227        };
15228        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
15229    };
15230
15231    let local_var_req = local_var_req_builder.build()?;
15232    let local_var_resp = local_var_client.execute(local_var_req).await?;
15233
15234    let local_var_status = local_var_resp.status();
15235    let local_var_content = local_var_resp.text().await?;
15236
15237    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
15238        serde_json::from_str(&local_var_content).map_err(Error::from)
15239    } else {
15240        let local_var_entity: Option<CircuitsProviderAccountsRetrieveError> =
15241            serde_json::from_str(&local_var_content).ok();
15242        let local_var_error = ResponseContent {
15243            status: local_var_status,
15244            content: local_var_content,
15245            entity: local_var_entity,
15246        };
15247        Err(Error::ResponseError(local_var_error))
15248    }
15249}
15250
15251/// Put a provider account object.
15252pub async fn circuits_provider_accounts_update(
15253    configuration: &configuration::Configuration,
15254    id: i32,
15255    provider_account_request: crate::models::ProviderAccountRequest,
15256) -> Result<crate::models::ProviderAccount, Error<CircuitsProviderAccountsUpdateError>> {
15257    let local_var_configuration = configuration;
15258
15259    let local_var_client = &local_var_configuration.client;
15260
15261    let local_var_uri_str = format!(
15262        "{}/api/circuits/provider-accounts/{id}/",
15263        local_var_configuration.base_path,
15264        id = id
15265    );
15266    let mut local_var_req_builder =
15267        local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());
15268
15269    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
15270        local_var_req_builder =
15271            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
15272    }
15273    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
15274        let local_var_key = local_var_apikey.key.clone();
15275        let local_var_value = match local_var_apikey.prefix {
15276            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
15277            None => local_var_key,
15278        };
15279        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
15280    };
15281    local_var_req_builder = local_var_req_builder.json(&provider_account_request);
15282
15283    let local_var_req = local_var_req_builder.build()?;
15284    let local_var_resp = local_var_client.execute(local_var_req).await?;
15285
15286    let local_var_status = local_var_resp.status();
15287    let local_var_content = local_var_resp.text().await?;
15288
15289    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
15290        serde_json::from_str(&local_var_content).map_err(Error::from)
15291    } else {
15292        let local_var_entity: Option<CircuitsProviderAccountsUpdateError> =
15293            serde_json::from_str(&local_var_content).ok();
15294        let local_var_error = ResponseContent {
15295            status: local_var_status,
15296            content: local_var_content,
15297            entity: local_var_entity,
15298        };
15299        Err(Error::ResponseError(local_var_error))
15300    }
15301}
15302
15303/// Delete a list of provider network objects.
15304pub async fn circuits_provider_networks_bulk_destroy(
15305    configuration: &configuration::Configuration,
15306    provider_network_request: Vec<crate::models::ProviderNetworkRequest>,
15307) -> Result<(), Error<CircuitsProviderNetworksBulkDestroyError>> {
15308    let local_var_configuration = configuration;
15309
15310    let local_var_client = &local_var_configuration.client;
15311
15312    let local_var_uri_str = format!(
15313        "{}/api/circuits/provider-networks/",
15314        local_var_configuration.base_path
15315    );
15316    let mut local_var_req_builder =
15317        local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());
15318
15319    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
15320        local_var_req_builder =
15321            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
15322    }
15323    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
15324        let local_var_key = local_var_apikey.key.clone();
15325        let local_var_value = match local_var_apikey.prefix {
15326            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
15327            None => local_var_key,
15328        };
15329        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
15330    };
15331    local_var_req_builder = local_var_req_builder.json(&provider_network_request);
15332
15333    let local_var_req = local_var_req_builder.build()?;
15334    let local_var_resp = local_var_client.execute(local_var_req).await?;
15335
15336    let local_var_status = local_var_resp.status();
15337    let local_var_content = local_var_resp.text().await?;
15338
15339    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
15340        Ok(())
15341    } else {
15342        let local_var_entity: Option<CircuitsProviderNetworksBulkDestroyError> =
15343            serde_json::from_str(&local_var_content).ok();
15344        let local_var_error = ResponseContent {
15345            status: local_var_status,
15346            content: local_var_content,
15347            entity: local_var_entity,
15348        };
15349        Err(Error::ResponseError(local_var_error))
15350    }
15351}
15352
15353/// Patch a list of provider network objects.
15354pub async fn circuits_provider_networks_bulk_partial_update(
15355    configuration: &configuration::Configuration,
15356    provider_network_request: Vec<crate::models::ProviderNetworkRequest>,
15357) -> Result<
15358    Vec<crate::models::ProviderNetwork>,
15359    Error<CircuitsProviderNetworksBulkPartialUpdateError>,
15360> {
15361    let local_var_configuration = configuration;
15362
15363    let local_var_client = &local_var_configuration.client;
15364
15365    let local_var_uri_str = format!(
15366        "{}/api/circuits/provider-networks/",
15367        local_var_configuration.base_path
15368    );
15369    let mut local_var_req_builder =
15370        local_var_client.request(reqwest::Method::PATCH, local_var_uri_str.as_str());
15371
15372    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
15373        local_var_req_builder =
15374            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
15375    }
15376    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
15377        let local_var_key = local_var_apikey.key.clone();
15378        let local_var_value = match local_var_apikey.prefix {
15379            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
15380            None => local_var_key,
15381        };
15382        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
15383    };
15384    local_var_req_builder = local_var_req_builder.json(&provider_network_request);
15385
15386    let local_var_req = local_var_req_builder.build()?;
15387    let local_var_resp = local_var_client.execute(local_var_req).await?;
15388
15389    let local_var_status = local_var_resp.status();
15390    let local_var_content = local_var_resp.text().await?;
15391
15392    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
15393        serde_json::from_str(&local_var_content).map_err(Error::from)
15394    } else {
15395        let local_var_entity: Option<CircuitsProviderNetworksBulkPartialUpdateError> =
15396            serde_json::from_str(&local_var_content).ok();
15397        let local_var_error = ResponseContent {
15398            status: local_var_status,
15399            content: local_var_content,
15400            entity: local_var_entity,
15401        };
15402        Err(Error::ResponseError(local_var_error))
15403    }
15404}
15405
15406/// Put a list of provider network objects.
15407pub async fn circuits_provider_networks_bulk_update(
15408    configuration: &configuration::Configuration,
15409    provider_network_request: Vec<crate::models::ProviderNetworkRequest>,
15410) -> Result<Vec<crate::models::ProviderNetwork>, Error<CircuitsProviderNetworksBulkUpdateError>> {
15411    let local_var_configuration = configuration;
15412
15413    let local_var_client = &local_var_configuration.client;
15414
15415    let local_var_uri_str = format!(
15416        "{}/api/circuits/provider-networks/",
15417        local_var_configuration.base_path
15418    );
15419    let mut local_var_req_builder =
15420        local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());
15421
15422    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
15423        local_var_req_builder =
15424            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
15425    }
15426    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
15427        let local_var_key = local_var_apikey.key.clone();
15428        let local_var_value = match local_var_apikey.prefix {
15429            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
15430            None => local_var_key,
15431        };
15432        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
15433    };
15434    local_var_req_builder = local_var_req_builder.json(&provider_network_request);
15435
15436    let local_var_req = local_var_req_builder.build()?;
15437    let local_var_resp = local_var_client.execute(local_var_req).await?;
15438
15439    let local_var_status = local_var_resp.status();
15440    let local_var_content = local_var_resp.text().await?;
15441
15442    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
15443        serde_json::from_str(&local_var_content).map_err(Error::from)
15444    } else {
15445        let local_var_entity: Option<CircuitsProviderNetworksBulkUpdateError> =
15446            serde_json::from_str(&local_var_content).ok();
15447        let local_var_error = ResponseContent {
15448            status: local_var_status,
15449            content: local_var_content,
15450            entity: local_var_entity,
15451        };
15452        Err(Error::ResponseError(local_var_error))
15453    }
15454}
15455
15456/// Post a list of provider network objects.
15457pub async fn circuits_provider_networks_create(
15458    configuration: &configuration::Configuration,
15459    circuits_provider_networks_create_request: crate::models::CircuitsProviderNetworksCreateRequest,
15460) -> Result<crate::models::ProviderNetwork, Error<CircuitsProviderNetworksCreateError>> {
15461    let local_var_configuration = configuration;
15462
15463    let local_var_client = &local_var_configuration.client;
15464
15465    let local_var_uri_str = format!(
15466        "{}/api/circuits/provider-networks/",
15467        local_var_configuration.base_path
15468    );
15469    let mut local_var_req_builder =
15470        local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
15471
15472    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
15473        local_var_req_builder =
15474            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
15475    }
15476    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
15477        let local_var_key = local_var_apikey.key.clone();
15478        let local_var_value = match local_var_apikey.prefix {
15479            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
15480            None => local_var_key,
15481        };
15482        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
15483    };
15484    local_var_req_builder = local_var_req_builder.json(&circuits_provider_networks_create_request);
15485
15486    let local_var_req = local_var_req_builder.build()?;
15487    let local_var_resp = local_var_client.execute(local_var_req).await?;
15488
15489    let local_var_status = local_var_resp.status();
15490    let local_var_content = local_var_resp.text().await?;
15491
15492    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
15493        serde_json::from_str(&local_var_content).map_err(Error::from)
15494    } else {
15495        let local_var_entity: Option<CircuitsProviderNetworksCreateError> =
15496            serde_json::from_str(&local_var_content).ok();
15497        let local_var_error = ResponseContent {
15498            status: local_var_status,
15499            content: local_var_content,
15500            entity: local_var_entity,
15501        };
15502        Err(Error::ResponseError(local_var_error))
15503    }
15504}
15505
15506/// Delete a provider network object.
15507pub async fn circuits_provider_networks_destroy(
15508    configuration: &configuration::Configuration,
15509    id: i32,
15510) -> Result<(), Error<CircuitsProviderNetworksDestroyError>> {
15511    let local_var_configuration = configuration;
15512
15513    let local_var_client = &local_var_configuration.client;
15514
15515    let local_var_uri_str = format!(
15516        "{}/api/circuits/provider-networks/{id}/",
15517        local_var_configuration.base_path,
15518        id = id
15519    );
15520    let mut local_var_req_builder =
15521        local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());
15522
15523    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
15524        local_var_req_builder =
15525            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
15526    }
15527    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
15528        let local_var_key = local_var_apikey.key.clone();
15529        let local_var_value = match local_var_apikey.prefix {
15530            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
15531            None => local_var_key,
15532        };
15533        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
15534    };
15535
15536    let local_var_req = local_var_req_builder.build()?;
15537    let local_var_resp = local_var_client.execute(local_var_req).await?;
15538
15539    let local_var_status = local_var_resp.status();
15540    let local_var_content = local_var_resp.text().await?;
15541
15542    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
15543        Ok(())
15544    } else {
15545        let local_var_entity: Option<CircuitsProviderNetworksDestroyError> =
15546            serde_json::from_str(&local_var_content).ok();
15547        let local_var_error = ResponseContent {
15548            status: local_var_status,
15549            content: local_var_content,
15550            entity: local_var_entity,
15551        };
15552        Err(Error::ResponseError(local_var_error))
15553    }
15554}
15555
15556/// Get a list of provider network objects.
15557pub async fn circuits_provider_networks_list(
15558    configuration: &configuration::Configuration,
15559    created: Option<Vec<String>>,
15560    created__empty: Option<Vec<String>>,
15561    created__gt: Option<Vec<String>>,
15562    created__gte: Option<Vec<String>>,
15563    created__lt: Option<Vec<String>>,
15564    created__lte: Option<Vec<String>>,
15565    created__n: Option<Vec<String>>,
15566    created_by_request: Option<&str>,
15567    description: Option<Vec<String>>,
15568    description__empty: Option<bool>,
15569    description__ic: Option<Vec<String>>,
15570    description__ie: Option<Vec<String>>,
15571    description__iew: Option<Vec<String>>,
15572    description__iregex: Option<Vec<String>>,
15573    description__isw: Option<Vec<String>>,
15574    description__n: Option<Vec<String>>,
15575    description__nic: Option<Vec<String>>,
15576    description__nie: Option<Vec<String>>,
15577    description__niew: Option<Vec<String>>,
15578    description__nisw: Option<Vec<String>>,
15579    description__regex: Option<Vec<String>>,
15580    id: Option<Vec<i32>>,
15581    id__empty: Option<bool>,
15582    id__gt: Option<Vec<i32>>,
15583    id__gte: Option<Vec<i32>>,
15584    id__lt: Option<Vec<i32>>,
15585    id__lte: Option<Vec<i32>>,
15586    id__n: Option<Vec<i32>>,
15587    last_updated: Option<Vec<String>>,
15588    last_updated__empty: Option<Vec<String>>,
15589    last_updated__gt: Option<Vec<String>>,
15590    last_updated__gte: Option<Vec<String>>,
15591    last_updated__lt: Option<Vec<String>>,
15592    last_updated__lte: Option<Vec<String>>,
15593    last_updated__n: Option<Vec<String>>,
15594    limit: Option<i32>,
15595    modified_by_request: Option<&str>,
15596    name: Option<Vec<String>>,
15597    name__empty: Option<bool>,
15598    name__ic: Option<Vec<String>>,
15599    name__ie: Option<Vec<String>>,
15600    name__iew: Option<Vec<String>>,
15601    name__iregex: Option<Vec<String>>,
15602    name__isw: Option<Vec<String>>,
15603    name__n: Option<Vec<String>>,
15604    name__nic: Option<Vec<String>>,
15605    name__nie: Option<Vec<String>>,
15606    name__niew: Option<Vec<String>>,
15607    name__nisw: Option<Vec<String>>,
15608    name__regex: Option<Vec<String>>,
15609    offset: Option<i32>,
15610    ordering: Option<&str>,
15611    owner: Option<Vec<String>>,
15612    owner__n: Option<Vec<String>>,
15613    owner_group: Option<Vec<String>>,
15614    owner_group__n: Option<Vec<String>>,
15615    owner_group_id: Option<Vec<i32>>,
15616    owner_group_id__n: Option<Vec<i32>>,
15617    owner_id: Option<Vec<i32>>,
15618    owner_id__n: Option<Vec<i32>>,
15619    provider: Option<Vec<String>>,
15620    provider__n: Option<Vec<String>>,
15621    provider_id: Option<Vec<i32>>,
15622    provider_id__n: Option<Vec<i32>>,
15623    q: Option<&str>,
15624    service_id: Option<Vec<String>>,
15625    service_id__empty: Option<bool>,
15626    service_id__ic: Option<Vec<String>>,
15627    service_id__ie: Option<Vec<String>>,
15628    service_id__iew: Option<Vec<String>>,
15629    service_id__iregex: Option<Vec<String>>,
15630    service_id__isw: Option<Vec<String>>,
15631    service_id__n: Option<Vec<String>>,
15632    service_id__nic: Option<Vec<String>>,
15633    service_id__nie: Option<Vec<String>>,
15634    service_id__niew: Option<Vec<String>>,
15635    service_id__nisw: Option<Vec<String>>,
15636    service_id__regex: Option<Vec<String>>,
15637    start: Option<i32>,
15638    tag: Option<Vec<String>>,
15639    tag__n: Option<Vec<String>>,
15640    tag_id: Option<Vec<i32>>,
15641    tag_id__n: Option<Vec<i32>>,
15642    updated_by_request: Option<&str>,
15643) -> Result<crate::models::PaginatedProviderNetworkList, Error<CircuitsProviderNetworksListError>> {
15644    let local_var_configuration = configuration;
15645
15646    let local_var_client = &local_var_configuration.client;
15647
15648    let local_var_uri_str = format!(
15649        "{}/api/circuits/provider-networks/",
15650        local_var_configuration.base_path
15651    );
15652    let mut local_var_req_builder =
15653        local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
15654
15655    if let Some(ref local_var_str) = created {
15656        local_var_req_builder = match "multi" {
15657            "multi" => local_var_req_builder.query(
15658                &local_var_str
15659                    .into_iter()
15660                    .map(|p| ("created".to_owned(), p.to_string()))
15661                    .collect::<Vec<(std::string::String, std::string::String)>>(),
15662            ),
15663            _ => local_var_req_builder.query(&[(
15664                "created",
15665                &local_var_str
15666                    .into_iter()
15667                    .map(|p| p.to_string())
15668                    .collect::<Vec<String>>()
15669                    .join(",")
15670                    .to_string(),
15671            )]),
15672        };
15673    }
15674    if let Some(ref local_var_str) = created__empty {
15675        local_var_req_builder = match "multi" {
15676            "multi" => local_var_req_builder.query(
15677                &local_var_str
15678                    .into_iter()
15679                    .map(|p| ("created__empty".to_owned(), p.to_string()))
15680                    .collect::<Vec<(std::string::String, std::string::String)>>(),
15681            ),
15682            _ => local_var_req_builder.query(&[(
15683                "created__empty",
15684                &local_var_str
15685                    .into_iter()
15686                    .map(|p| p.to_string())
15687                    .collect::<Vec<String>>()
15688                    .join(",")
15689                    .to_string(),
15690            )]),
15691        };
15692    }
15693    if let Some(ref local_var_str) = created__gt {
15694        local_var_req_builder = match "multi" {
15695            "multi" => local_var_req_builder.query(
15696                &local_var_str
15697                    .into_iter()
15698                    .map(|p| ("created__gt".to_owned(), p.to_string()))
15699                    .collect::<Vec<(std::string::String, std::string::String)>>(),
15700            ),
15701            _ => local_var_req_builder.query(&[(
15702                "created__gt",
15703                &local_var_str
15704                    .into_iter()
15705                    .map(|p| p.to_string())
15706                    .collect::<Vec<String>>()
15707                    .join(",")
15708                    .to_string(),
15709            )]),
15710        };
15711    }
15712    if let Some(ref local_var_str) = created__gte {
15713        local_var_req_builder = match "multi" {
15714            "multi" => local_var_req_builder.query(
15715                &local_var_str
15716                    .into_iter()
15717                    .map(|p| ("created__gte".to_owned(), p.to_string()))
15718                    .collect::<Vec<(std::string::String, std::string::String)>>(),
15719            ),
15720            _ => local_var_req_builder.query(&[(
15721                "created__gte",
15722                &local_var_str
15723                    .into_iter()
15724                    .map(|p| p.to_string())
15725                    .collect::<Vec<String>>()
15726                    .join(",")
15727                    .to_string(),
15728            )]),
15729        };
15730    }
15731    if let Some(ref local_var_str) = created__lt {
15732        local_var_req_builder = match "multi" {
15733            "multi" => local_var_req_builder.query(
15734                &local_var_str
15735                    .into_iter()
15736                    .map(|p| ("created__lt".to_owned(), p.to_string()))
15737                    .collect::<Vec<(std::string::String, std::string::String)>>(),
15738            ),
15739            _ => local_var_req_builder.query(&[(
15740                "created__lt",
15741                &local_var_str
15742                    .into_iter()
15743                    .map(|p| p.to_string())
15744                    .collect::<Vec<String>>()
15745                    .join(",")
15746                    .to_string(),
15747            )]),
15748        };
15749    }
15750    if let Some(ref local_var_str) = created__lte {
15751        local_var_req_builder = match "multi" {
15752            "multi" => local_var_req_builder.query(
15753                &local_var_str
15754                    .into_iter()
15755                    .map(|p| ("created__lte".to_owned(), p.to_string()))
15756                    .collect::<Vec<(std::string::String, std::string::String)>>(),
15757            ),
15758            _ => local_var_req_builder.query(&[(
15759                "created__lte",
15760                &local_var_str
15761                    .into_iter()
15762                    .map(|p| p.to_string())
15763                    .collect::<Vec<String>>()
15764                    .join(",")
15765                    .to_string(),
15766            )]),
15767        };
15768    }
15769    if let Some(ref local_var_str) = created__n {
15770        local_var_req_builder = match "multi" {
15771            "multi" => local_var_req_builder.query(
15772                &local_var_str
15773                    .into_iter()
15774                    .map(|p| ("created__n".to_owned(), p.to_string()))
15775                    .collect::<Vec<(std::string::String, std::string::String)>>(),
15776            ),
15777            _ => local_var_req_builder.query(&[(
15778                "created__n",
15779                &local_var_str
15780                    .into_iter()
15781                    .map(|p| p.to_string())
15782                    .collect::<Vec<String>>()
15783                    .join(",")
15784                    .to_string(),
15785            )]),
15786        };
15787    }
15788    if let Some(ref local_var_str) = created_by_request {
15789        local_var_req_builder =
15790            local_var_req_builder.query(&[("created_by_request", &local_var_str.to_string())]);
15791    }
15792    if let Some(ref local_var_str) = description {
15793        local_var_req_builder = match "multi" {
15794            "multi" => local_var_req_builder.query(
15795                &local_var_str
15796                    .into_iter()
15797                    .map(|p| ("description".to_owned(), p.to_string()))
15798                    .collect::<Vec<(std::string::String, std::string::String)>>(),
15799            ),
15800            _ => local_var_req_builder.query(&[(
15801                "description",
15802                &local_var_str
15803                    .into_iter()
15804                    .map(|p| p.to_string())
15805                    .collect::<Vec<String>>()
15806                    .join(",")
15807                    .to_string(),
15808            )]),
15809        };
15810    }
15811    if let Some(ref local_var_str) = description__empty {
15812        local_var_req_builder =
15813            local_var_req_builder.query(&[("description__empty", &local_var_str.to_string())]);
15814    }
15815    if let Some(ref local_var_str) = description__ic {
15816        local_var_req_builder = match "multi" {
15817            "multi" => local_var_req_builder.query(
15818                &local_var_str
15819                    .into_iter()
15820                    .map(|p| ("description__ic".to_owned(), p.to_string()))
15821                    .collect::<Vec<(std::string::String, std::string::String)>>(),
15822            ),
15823            _ => local_var_req_builder.query(&[(
15824                "description__ic",
15825                &local_var_str
15826                    .into_iter()
15827                    .map(|p| p.to_string())
15828                    .collect::<Vec<String>>()
15829                    .join(",")
15830                    .to_string(),
15831            )]),
15832        };
15833    }
15834    if let Some(ref local_var_str) = description__ie {
15835        local_var_req_builder = match "multi" {
15836            "multi" => local_var_req_builder.query(
15837                &local_var_str
15838                    .into_iter()
15839                    .map(|p| ("description__ie".to_owned(), p.to_string()))
15840                    .collect::<Vec<(std::string::String, std::string::String)>>(),
15841            ),
15842            _ => local_var_req_builder.query(&[(
15843                "description__ie",
15844                &local_var_str
15845                    .into_iter()
15846                    .map(|p| p.to_string())
15847                    .collect::<Vec<String>>()
15848                    .join(",")
15849                    .to_string(),
15850            )]),
15851        };
15852    }
15853    if let Some(ref local_var_str) = description__iew {
15854        local_var_req_builder = match "multi" {
15855            "multi" => local_var_req_builder.query(
15856                &local_var_str
15857                    .into_iter()
15858                    .map(|p| ("description__iew".to_owned(), p.to_string()))
15859                    .collect::<Vec<(std::string::String, std::string::String)>>(),
15860            ),
15861            _ => local_var_req_builder.query(&[(
15862                "description__iew",
15863                &local_var_str
15864                    .into_iter()
15865                    .map(|p| p.to_string())
15866                    .collect::<Vec<String>>()
15867                    .join(",")
15868                    .to_string(),
15869            )]),
15870        };
15871    }
15872    if let Some(ref local_var_str) = description__iregex {
15873        local_var_req_builder = match "multi" {
15874            "multi" => local_var_req_builder.query(
15875                &local_var_str
15876                    .into_iter()
15877                    .map(|p| ("description__iregex".to_owned(), p.to_string()))
15878                    .collect::<Vec<(std::string::String, std::string::String)>>(),
15879            ),
15880            _ => local_var_req_builder.query(&[(
15881                "description__iregex",
15882                &local_var_str
15883                    .into_iter()
15884                    .map(|p| p.to_string())
15885                    .collect::<Vec<String>>()
15886                    .join(",")
15887                    .to_string(),
15888            )]),
15889        };
15890    }
15891    if let Some(ref local_var_str) = description__isw {
15892        local_var_req_builder = match "multi" {
15893            "multi" => local_var_req_builder.query(
15894                &local_var_str
15895                    .into_iter()
15896                    .map(|p| ("description__isw".to_owned(), p.to_string()))
15897                    .collect::<Vec<(std::string::String, std::string::String)>>(),
15898            ),
15899            _ => local_var_req_builder.query(&[(
15900                "description__isw",
15901                &local_var_str
15902                    .into_iter()
15903                    .map(|p| p.to_string())
15904                    .collect::<Vec<String>>()
15905                    .join(",")
15906                    .to_string(),
15907            )]),
15908        };
15909    }
15910    if let Some(ref local_var_str) = description__n {
15911        local_var_req_builder = match "multi" {
15912            "multi" => local_var_req_builder.query(
15913                &local_var_str
15914                    .into_iter()
15915                    .map(|p| ("description__n".to_owned(), p.to_string()))
15916                    .collect::<Vec<(std::string::String, std::string::String)>>(),
15917            ),
15918            _ => local_var_req_builder.query(&[(
15919                "description__n",
15920                &local_var_str
15921                    .into_iter()
15922                    .map(|p| p.to_string())
15923                    .collect::<Vec<String>>()
15924                    .join(",")
15925                    .to_string(),
15926            )]),
15927        };
15928    }
15929    if let Some(ref local_var_str) = description__nic {
15930        local_var_req_builder = match "multi" {
15931            "multi" => local_var_req_builder.query(
15932                &local_var_str
15933                    .into_iter()
15934                    .map(|p| ("description__nic".to_owned(), p.to_string()))
15935                    .collect::<Vec<(std::string::String, std::string::String)>>(),
15936            ),
15937            _ => local_var_req_builder.query(&[(
15938                "description__nic",
15939                &local_var_str
15940                    .into_iter()
15941                    .map(|p| p.to_string())
15942                    .collect::<Vec<String>>()
15943                    .join(",")
15944                    .to_string(),
15945            )]),
15946        };
15947    }
15948    if let Some(ref local_var_str) = description__nie {
15949        local_var_req_builder = match "multi" {
15950            "multi" => local_var_req_builder.query(
15951                &local_var_str
15952                    .into_iter()
15953                    .map(|p| ("description__nie".to_owned(), p.to_string()))
15954                    .collect::<Vec<(std::string::String, std::string::String)>>(),
15955            ),
15956            _ => local_var_req_builder.query(&[(
15957                "description__nie",
15958                &local_var_str
15959                    .into_iter()
15960                    .map(|p| p.to_string())
15961                    .collect::<Vec<String>>()
15962                    .join(",")
15963                    .to_string(),
15964            )]),
15965        };
15966    }
15967    if let Some(ref local_var_str) = description__niew {
15968        local_var_req_builder = match "multi" {
15969            "multi" => local_var_req_builder.query(
15970                &local_var_str
15971                    .into_iter()
15972                    .map(|p| ("description__niew".to_owned(), p.to_string()))
15973                    .collect::<Vec<(std::string::String, std::string::String)>>(),
15974            ),
15975            _ => local_var_req_builder.query(&[(
15976                "description__niew",
15977                &local_var_str
15978                    .into_iter()
15979                    .map(|p| p.to_string())
15980                    .collect::<Vec<String>>()
15981                    .join(",")
15982                    .to_string(),
15983            )]),
15984        };
15985    }
15986    if let Some(ref local_var_str) = description__nisw {
15987        local_var_req_builder = match "multi" {
15988            "multi" => local_var_req_builder.query(
15989                &local_var_str
15990                    .into_iter()
15991                    .map(|p| ("description__nisw".to_owned(), p.to_string()))
15992                    .collect::<Vec<(std::string::String, std::string::String)>>(),
15993            ),
15994            _ => local_var_req_builder.query(&[(
15995                "description__nisw",
15996                &local_var_str
15997                    .into_iter()
15998                    .map(|p| p.to_string())
15999                    .collect::<Vec<String>>()
16000                    .join(",")
16001                    .to_string(),
16002            )]),
16003        };
16004    }
16005    if let Some(ref local_var_str) = description__regex {
16006        local_var_req_builder = match "multi" {
16007            "multi" => local_var_req_builder.query(
16008                &local_var_str
16009                    .into_iter()
16010                    .map(|p| ("description__regex".to_owned(), p.to_string()))
16011                    .collect::<Vec<(std::string::String, std::string::String)>>(),
16012            ),
16013            _ => local_var_req_builder.query(&[(
16014                "description__regex",
16015                &local_var_str
16016                    .into_iter()
16017                    .map(|p| p.to_string())
16018                    .collect::<Vec<String>>()
16019                    .join(",")
16020                    .to_string(),
16021            )]),
16022        };
16023    }
16024    if let Some(ref local_var_str) = id {
16025        local_var_req_builder = match "multi" {
16026            "multi" => local_var_req_builder.query(
16027                &local_var_str
16028                    .into_iter()
16029                    .map(|p| ("id".to_owned(), p.to_string()))
16030                    .collect::<Vec<(std::string::String, std::string::String)>>(),
16031            ),
16032            _ => local_var_req_builder.query(&[(
16033                "id",
16034                &local_var_str
16035                    .into_iter()
16036                    .map(|p| p.to_string())
16037                    .collect::<Vec<String>>()
16038                    .join(",")
16039                    .to_string(),
16040            )]),
16041        };
16042    }
16043    if let Some(ref local_var_str) = id__empty {
16044        local_var_req_builder =
16045            local_var_req_builder.query(&[("id__empty", &local_var_str.to_string())]);
16046    }
16047    if let Some(ref local_var_str) = id__gt {
16048        local_var_req_builder = match "multi" {
16049            "multi" => local_var_req_builder.query(
16050                &local_var_str
16051                    .into_iter()
16052                    .map(|p| ("id__gt".to_owned(), p.to_string()))
16053                    .collect::<Vec<(std::string::String, std::string::String)>>(),
16054            ),
16055            _ => local_var_req_builder.query(&[(
16056                "id__gt",
16057                &local_var_str
16058                    .into_iter()
16059                    .map(|p| p.to_string())
16060                    .collect::<Vec<String>>()
16061                    .join(",")
16062                    .to_string(),
16063            )]),
16064        };
16065    }
16066    if let Some(ref local_var_str) = id__gte {
16067        local_var_req_builder = match "multi" {
16068            "multi" => local_var_req_builder.query(
16069                &local_var_str
16070                    .into_iter()
16071                    .map(|p| ("id__gte".to_owned(), p.to_string()))
16072                    .collect::<Vec<(std::string::String, std::string::String)>>(),
16073            ),
16074            _ => local_var_req_builder.query(&[(
16075                "id__gte",
16076                &local_var_str
16077                    .into_iter()
16078                    .map(|p| p.to_string())
16079                    .collect::<Vec<String>>()
16080                    .join(",")
16081                    .to_string(),
16082            )]),
16083        };
16084    }
16085    if let Some(ref local_var_str) = id__lt {
16086        local_var_req_builder = match "multi" {
16087            "multi" => local_var_req_builder.query(
16088                &local_var_str
16089                    .into_iter()
16090                    .map(|p| ("id__lt".to_owned(), p.to_string()))
16091                    .collect::<Vec<(std::string::String, std::string::String)>>(),
16092            ),
16093            _ => local_var_req_builder.query(&[(
16094                "id__lt",
16095                &local_var_str
16096                    .into_iter()
16097                    .map(|p| p.to_string())
16098                    .collect::<Vec<String>>()
16099                    .join(",")
16100                    .to_string(),
16101            )]),
16102        };
16103    }
16104    if let Some(ref local_var_str) = id__lte {
16105        local_var_req_builder = match "multi" {
16106            "multi" => local_var_req_builder.query(
16107                &local_var_str
16108                    .into_iter()
16109                    .map(|p| ("id__lte".to_owned(), p.to_string()))
16110                    .collect::<Vec<(std::string::String, std::string::String)>>(),
16111            ),
16112            _ => local_var_req_builder.query(&[(
16113                "id__lte",
16114                &local_var_str
16115                    .into_iter()
16116                    .map(|p| p.to_string())
16117                    .collect::<Vec<String>>()
16118                    .join(",")
16119                    .to_string(),
16120            )]),
16121        };
16122    }
16123    if let Some(ref local_var_str) = id__n {
16124        local_var_req_builder = match "multi" {
16125            "multi" => local_var_req_builder.query(
16126                &local_var_str
16127                    .into_iter()
16128                    .map(|p| ("id__n".to_owned(), p.to_string()))
16129                    .collect::<Vec<(std::string::String, std::string::String)>>(),
16130            ),
16131            _ => local_var_req_builder.query(&[(
16132                "id__n",
16133                &local_var_str
16134                    .into_iter()
16135                    .map(|p| p.to_string())
16136                    .collect::<Vec<String>>()
16137                    .join(",")
16138                    .to_string(),
16139            )]),
16140        };
16141    }
16142    if let Some(ref local_var_str) = last_updated {
16143        local_var_req_builder = match "multi" {
16144            "multi" => local_var_req_builder.query(
16145                &local_var_str
16146                    .into_iter()
16147                    .map(|p| ("last_updated".to_owned(), p.to_string()))
16148                    .collect::<Vec<(std::string::String, std::string::String)>>(),
16149            ),
16150            _ => local_var_req_builder.query(&[(
16151                "last_updated",
16152                &local_var_str
16153                    .into_iter()
16154                    .map(|p| p.to_string())
16155                    .collect::<Vec<String>>()
16156                    .join(",")
16157                    .to_string(),
16158            )]),
16159        };
16160    }
16161    if let Some(ref local_var_str) = last_updated__empty {
16162        local_var_req_builder = match "multi" {
16163            "multi" => local_var_req_builder.query(
16164                &local_var_str
16165                    .into_iter()
16166                    .map(|p| ("last_updated__empty".to_owned(), p.to_string()))
16167                    .collect::<Vec<(std::string::String, std::string::String)>>(),
16168            ),
16169            _ => local_var_req_builder.query(&[(
16170                "last_updated__empty",
16171                &local_var_str
16172                    .into_iter()
16173                    .map(|p| p.to_string())
16174                    .collect::<Vec<String>>()
16175                    .join(",")
16176                    .to_string(),
16177            )]),
16178        };
16179    }
16180    if let Some(ref local_var_str) = last_updated__gt {
16181        local_var_req_builder = match "multi" {
16182            "multi" => local_var_req_builder.query(
16183                &local_var_str
16184                    .into_iter()
16185                    .map(|p| ("last_updated__gt".to_owned(), p.to_string()))
16186                    .collect::<Vec<(std::string::String, std::string::String)>>(),
16187            ),
16188            _ => local_var_req_builder.query(&[(
16189                "last_updated__gt",
16190                &local_var_str
16191                    .into_iter()
16192                    .map(|p| p.to_string())
16193                    .collect::<Vec<String>>()
16194                    .join(",")
16195                    .to_string(),
16196            )]),
16197        };
16198    }
16199    if let Some(ref local_var_str) = last_updated__gte {
16200        local_var_req_builder = match "multi" {
16201            "multi" => local_var_req_builder.query(
16202                &local_var_str
16203                    .into_iter()
16204                    .map(|p| ("last_updated__gte".to_owned(), p.to_string()))
16205                    .collect::<Vec<(std::string::String, std::string::String)>>(),
16206            ),
16207            _ => local_var_req_builder.query(&[(
16208                "last_updated__gte",
16209                &local_var_str
16210                    .into_iter()
16211                    .map(|p| p.to_string())
16212                    .collect::<Vec<String>>()
16213                    .join(",")
16214                    .to_string(),
16215            )]),
16216        };
16217    }
16218    if let Some(ref local_var_str) = last_updated__lt {
16219        local_var_req_builder = match "multi" {
16220            "multi" => local_var_req_builder.query(
16221                &local_var_str
16222                    .into_iter()
16223                    .map(|p| ("last_updated__lt".to_owned(), p.to_string()))
16224                    .collect::<Vec<(std::string::String, std::string::String)>>(),
16225            ),
16226            _ => local_var_req_builder.query(&[(
16227                "last_updated__lt",
16228                &local_var_str
16229                    .into_iter()
16230                    .map(|p| p.to_string())
16231                    .collect::<Vec<String>>()
16232                    .join(",")
16233                    .to_string(),
16234            )]),
16235        };
16236    }
16237    if let Some(ref local_var_str) = last_updated__lte {
16238        local_var_req_builder = match "multi" {
16239            "multi" => local_var_req_builder.query(
16240                &local_var_str
16241                    .into_iter()
16242                    .map(|p| ("last_updated__lte".to_owned(), p.to_string()))
16243                    .collect::<Vec<(std::string::String, std::string::String)>>(),
16244            ),
16245            _ => local_var_req_builder.query(&[(
16246                "last_updated__lte",
16247                &local_var_str
16248                    .into_iter()
16249                    .map(|p| p.to_string())
16250                    .collect::<Vec<String>>()
16251                    .join(",")
16252                    .to_string(),
16253            )]),
16254        };
16255    }
16256    if let Some(ref local_var_str) = last_updated__n {
16257        local_var_req_builder = match "multi" {
16258            "multi" => local_var_req_builder.query(
16259                &local_var_str
16260                    .into_iter()
16261                    .map(|p| ("last_updated__n".to_owned(), p.to_string()))
16262                    .collect::<Vec<(std::string::String, std::string::String)>>(),
16263            ),
16264            _ => local_var_req_builder.query(&[(
16265                "last_updated__n",
16266                &local_var_str
16267                    .into_iter()
16268                    .map(|p| p.to_string())
16269                    .collect::<Vec<String>>()
16270                    .join(",")
16271                    .to_string(),
16272            )]),
16273        };
16274    }
16275    if let Some(ref local_var_str) = limit {
16276        local_var_req_builder =
16277            local_var_req_builder.query(&[("limit", &local_var_str.to_string())]);
16278    }
16279    if let Some(ref local_var_str) = modified_by_request {
16280        local_var_req_builder =
16281            local_var_req_builder.query(&[("modified_by_request", &local_var_str.to_string())]);
16282    }
16283    if let Some(ref local_var_str) = name {
16284        local_var_req_builder = match "multi" {
16285            "multi" => local_var_req_builder.query(
16286                &local_var_str
16287                    .into_iter()
16288                    .map(|p| ("name".to_owned(), p.to_string()))
16289                    .collect::<Vec<(std::string::String, std::string::String)>>(),
16290            ),
16291            _ => local_var_req_builder.query(&[(
16292                "name",
16293                &local_var_str
16294                    .into_iter()
16295                    .map(|p| p.to_string())
16296                    .collect::<Vec<String>>()
16297                    .join(",")
16298                    .to_string(),
16299            )]),
16300        };
16301    }
16302    if let Some(ref local_var_str) = name__empty {
16303        local_var_req_builder =
16304            local_var_req_builder.query(&[("name__empty", &local_var_str.to_string())]);
16305    }
16306    if let Some(ref local_var_str) = name__ic {
16307        local_var_req_builder = match "multi" {
16308            "multi" => local_var_req_builder.query(
16309                &local_var_str
16310                    .into_iter()
16311                    .map(|p| ("name__ic".to_owned(), p.to_string()))
16312                    .collect::<Vec<(std::string::String, std::string::String)>>(),
16313            ),
16314            _ => local_var_req_builder.query(&[(
16315                "name__ic",
16316                &local_var_str
16317                    .into_iter()
16318                    .map(|p| p.to_string())
16319                    .collect::<Vec<String>>()
16320                    .join(",")
16321                    .to_string(),
16322            )]),
16323        };
16324    }
16325    if let Some(ref local_var_str) = name__ie {
16326        local_var_req_builder = match "multi" {
16327            "multi" => local_var_req_builder.query(
16328                &local_var_str
16329                    .into_iter()
16330                    .map(|p| ("name__ie".to_owned(), p.to_string()))
16331                    .collect::<Vec<(std::string::String, std::string::String)>>(),
16332            ),
16333            _ => local_var_req_builder.query(&[(
16334                "name__ie",
16335                &local_var_str
16336                    .into_iter()
16337                    .map(|p| p.to_string())
16338                    .collect::<Vec<String>>()
16339                    .join(",")
16340                    .to_string(),
16341            )]),
16342        };
16343    }
16344    if let Some(ref local_var_str) = name__iew {
16345        local_var_req_builder = match "multi" {
16346            "multi" => local_var_req_builder.query(
16347                &local_var_str
16348                    .into_iter()
16349                    .map(|p| ("name__iew".to_owned(), p.to_string()))
16350                    .collect::<Vec<(std::string::String, std::string::String)>>(),
16351            ),
16352            _ => local_var_req_builder.query(&[(
16353                "name__iew",
16354                &local_var_str
16355                    .into_iter()
16356                    .map(|p| p.to_string())
16357                    .collect::<Vec<String>>()
16358                    .join(",")
16359                    .to_string(),
16360            )]),
16361        };
16362    }
16363    if let Some(ref local_var_str) = name__iregex {
16364        local_var_req_builder = match "multi" {
16365            "multi" => local_var_req_builder.query(
16366                &local_var_str
16367                    .into_iter()
16368                    .map(|p| ("name__iregex".to_owned(), p.to_string()))
16369                    .collect::<Vec<(std::string::String, std::string::String)>>(),
16370            ),
16371            _ => local_var_req_builder.query(&[(
16372                "name__iregex",
16373                &local_var_str
16374                    .into_iter()
16375                    .map(|p| p.to_string())
16376                    .collect::<Vec<String>>()
16377                    .join(",")
16378                    .to_string(),
16379            )]),
16380        };
16381    }
16382    if let Some(ref local_var_str) = name__isw {
16383        local_var_req_builder = match "multi" {
16384            "multi" => local_var_req_builder.query(
16385                &local_var_str
16386                    .into_iter()
16387                    .map(|p| ("name__isw".to_owned(), p.to_string()))
16388                    .collect::<Vec<(std::string::String, std::string::String)>>(),
16389            ),
16390            _ => local_var_req_builder.query(&[(
16391                "name__isw",
16392                &local_var_str
16393                    .into_iter()
16394                    .map(|p| p.to_string())
16395                    .collect::<Vec<String>>()
16396                    .join(",")
16397                    .to_string(),
16398            )]),
16399        };
16400    }
16401    if let Some(ref local_var_str) = name__n {
16402        local_var_req_builder = match "multi" {
16403            "multi" => local_var_req_builder.query(
16404                &local_var_str
16405                    .into_iter()
16406                    .map(|p| ("name__n".to_owned(), p.to_string()))
16407                    .collect::<Vec<(std::string::String, std::string::String)>>(),
16408            ),
16409            _ => local_var_req_builder.query(&[(
16410                "name__n",
16411                &local_var_str
16412                    .into_iter()
16413                    .map(|p| p.to_string())
16414                    .collect::<Vec<String>>()
16415                    .join(",")
16416                    .to_string(),
16417            )]),
16418        };
16419    }
16420    if let Some(ref local_var_str) = name__nic {
16421        local_var_req_builder = match "multi" {
16422            "multi" => local_var_req_builder.query(
16423                &local_var_str
16424                    .into_iter()
16425                    .map(|p| ("name__nic".to_owned(), p.to_string()))
16426                    .collect::<Vec<(std::string::String, std::string::String)>>(),
16427            ),
16428            _ => local_var_req_builder.query(&[(
16429                "name__nic",
16430                &local_var_str
16431                    .into_iter()
16432                    .map(|p| p.to_string())
16433                    .collect::<Vec<String>>()
16434                    .join(",")
16435                    .to_string(),
16436            )]),
16437        };
16438    }
16439    if let Some(ref local_var_str) = name__nie {
16440        local_var_req_builder = match "multi" {
16441            "multi" => local_var_req_builder.query(
16442                &local_var_str
16443                    .into_iter()
16444                    .map(|p| ("name__nie".to_owned(), p.to_string()))
16445                    .collect::<Vec<(std::string::String, std::string::String)>>(),
16446            ),
16447            _ => local_var_req_builder.query(&[(
16448                "name__nie",
16449                &local_var_str
16450                    .into_iter()
16451                    .map(|p| p.to_string())
16452                    .collect::<Vec<String>>()
16453                    .join(",")
16454                    .to_string(),
16455            )]),
16456        };
16457    }
16458    if let Some(ref local_var_str) = name__niew {
16459        local_var_req_builder = match "multi" {
16460            "multi" => local_var_req_builder.query(
16461                &local_var_str
16462                    .into_iter()
16463                    .map(|p| ("name__niew".to_owned(), p.to_string()))
16464                    .collect::<Vec<(std::string::String, std::string::String)>>(),
16465            ),
16466            _ => local_var_req_builder.query(&[(
16467                "name__niew",
16468                &local_var_str
16469                    .into_iter()
16470                    .map(|p| p.to_string())
16471                    .collect::<Vec<String>>()
16472                    .join(",")
16473                    .to_string(),
16474            )]),
16475        };
16476    }
16477    if let Some(ref local_var_str) = name__nisw {
16478        local_var_req_builder = match "multi" {
16479            "multi" => local_var_req_builder.query(
16480                &local_var_str
16481                    .into_iter()
16482                    .map(|p| ("name__nisw".to_owned(), p.to_string()))
16483                    .collect::<Vec<(std::string::String, std::string::String)>>(),
16484            ),
16485            _ => local_var_req_builder.query(&[(
16486                "name__nisw",
16487                &local_var_str
16488                    .into_iter()
16489                    .map(|p| p.to_string())
16490                    .collect::<Vec<String>>()
16491                    .join(",")
16492                    .to_string(),
16493            )]),
16494        };
16495    }
16496    if let Some(ref local_var_str) = name__regex {
16497        local_var_req_builder = match "multi" {
16498            "multi" => local_var_req_builder.query(
16499                &local_var_str
16500                    .into_iter()
16501                    .map(|p| ("name__regex".to_owned(), p.to_string()))
16502                    .collect::<Vec<(std::string::String, std::string::String)>>(),
16503            ),
16504            _ => local_var_req_builder.query(&[(
16505                "name__regex",
16506                &local_var_str
16507                    .into_iter()
16508                    .map(|p| p.to_string())
16509                    .collect::<Vec<String>>()
16510                    .join(",")
16511                    .to_string(),
16512            )]),
16513        };
16514    }
16515    if let Some(ref local_var_str) = offset {
16516        local_var_req_builder =
16517            local_var_req_builder.query(&[("offset", &local_var_str.to_string())]);
16518    }
16519    if let Some(ref local_var_str) = ordering {
16520        local_var_req_builder =
16521            local_var_req_builder.query(&[("ordering", &local_var_str.to_string())]);
16522    }
16523    if let Some(ref local_var_str) = owner {
16524        local_var_req_builder = match "multi" {
16525            "multi" => local_var_req_builder.query(
16526                &local_var_str
16527                    .into_iter()
16528                    .map(|p| ("owner".to_owned(), p.to_string()))
16529                    .collect::<Vec<(std::string::String, std::string::String)>>(),
16530            ),
16531            _ => local_var_req_builder.query(&[(
16532                "owner",
16533                &local_var_str
16534                    .into_iter()
16535                    .map(|p| p.to_string())
16536                    .collect::<Vec<String>>()
16537                    .join(",")
16538                    .to_string(),
16539            )]),
16540        };
16541    }
16542    if let Some(ref local_var_str) = owner__n {
16543        local_var_req_builder = match "multi" {
16544            "multi" => local_var_req_builder.query(
16545                &local_var_str
16546                    .into_iter()
16547                    .map(|p| ("owner__n".to_owned(), p.to_string()))
16548                    .collect::<Vec<(std::string::String, std::string::String)>>(),
16549            ),
16550            _ => local_var_req_builder.query(&[(
16551                "owner__n",
16552                &local_var_str
16553                    .into_iter()
16554                    .map(|p| p.to_string())
16555                    .collect::<Vec<String>>()
16556                    .join(",")
16557                    .to_string(),
16558            )]),
16559        };
16560    }
16561    if let Some(ref local_var_str) = owner_group {
16562        local_var_req_builder = match "multi" {
16563            "multi" => local_var_req_builder.query(
16564                &local_var_str
16565                    .into_iter()
16566                    .map(|p| ("owner_group".to_owned(), p.to_string()))
16567                    .collect::<Vec<(std::string::String, std::string::String)>>(),
16568            ),
16569            _ => local_var_req_builder.query(&[(
16570                "owner_group",
16571                &local_var_str
16572                    .into_iter()
16573                    .map(|p| p.to_string())
16574                    .collect::<Vec<String>>()
16575                    .join(",")
16576                    .to_string(),
16577            )]),
16578        };
16579    }
16580    if let Some(ref local_var_str) = owner_group__n {
16581        local_var_req_builder = match "multi" {
16582            "multi" => local_var_req_builder.query(
16583                &local_var_str
16584                    .into_iter()
16585                    .map(|p| ("owner_group__n".to_owned(), p.to_string()))
16586                    .collect::<Vec<(std::string::String, std::string::String)>>(),
16587            ),
16588            _ => local_var_req_builder.query(&[(
16589                "owner_group__n",
16590                &local_var_str
16591                    .into_iter()
16592                    .map(|p| p.to_string())
16593                    .collect::<Vec<String>>()
16594                    .join(",")
16595                    .to_string(),
16596            )]),
16597        };
16598    }
16599    if let Some(ref local_var_str) = owner_group_id {
16600        local_var_req_builder = match "multi" {
16601            "multi" => local_var_req_builder.query(
16602                &local_var_str
16603                    .into_iter()
16604                    .map(|p| ("owner_group_id".to_owned(), p.to_string()))
16605                    .collect::<Vec<(std::string::String, std::string::String)>>(),
16606            ),
16607            _ => local_var_req_builder.query(&[(
16608                "owner_group_id",
16609                &local_var_str
16610                    .into_iter()
16611                    .map(|p| p.to_string())
16612                    .collect::<Vec<String>>()
16613                    .join(",")
16614                    .to_string(),
16615            )]),
16616        };
16617    }
16618    if let Some(ref local_var_str) = owner_group_id__n {
16619        local_var_req_builder = match "multi" {
16620            "multi" => local_var_req_builder.query(
16621                &local_var_str
16622                    .into_iter()
16623                    .map(|p| ("owner_group_id__n".to_owned(), p.to_string()))
16624                    .collect::<Vec<(std::string::String, std::string::String)>>(),
16625            ),
16626            _ => local_var_req_builder.query(&[(
16627                "owner_group_id__n",
16628                &local_var_str
16629                    .into_iter()
16630                    .map(|p| p.to_string())
16631                    .collect::<Vec<String>>()
16632                    .join(",")
16633                    .to_string(),
16634            )]),
16635        };
16636    }
16637    if let Some(ref local_var_str) = owner_id {
16638        local_var_req_builder = match "multi" {
16639            "multi" => local_var_req_builder.query(
16640                &local_var_str
16641                    .into_iter()
16642                    .map(|p| ("owner_id".to_owned(), p.to_string()))
16643                    .collect::<Vec<(std::string::String, std::string::String)>>(),
16644            ),
16645            _ => local_var_req_builder.query(&[(
16646                "owner_id",
16647                &local_var_str
16648                    .into_iter()
16649                    .map(|p| p.to_string())
16650                    .collect::<Vec<String>>()
16651                    .join(",")
16652                    .to_string(),
16653            )]),
16654        };
16655    }
16656    if let Some(ref local_var_str) = owner_id__n {
16657        local_var_req_builder = match "multi" {
16658            "multi" => local_var_req_builder.query(
16659                &local_var_str
16660                    .into_iter()
16661                    .map(|p| ("owner_id__n".to_owned(), p.to_string()))
16662                    .collect::<Vec<(std::string::String, std::string::String)>>(),
16663            ),
16664            _ => local_var_req_builder.query(&[(
16665                "owner_id__n",
16666                &local_var_str
16667                    .into_iter()
16668                    .map(|p| p.to_string())
16669                    .collect::<Vec<String>>()
16670                    .join(",")
16671                    .to_string(),
16672            )]),
16673        };
16674    }
16675    if let Some(ref local_var_str) = provider {
16676        local_var_req_builder = match "multi" {
16677            "multi" => local_var_req_builder.query(
16678                &local_var_str
16679                    .into_iter()
16680                    .map(|p| ("provider".to_owned(), p.to_string()))
16681                    .collect::<Vec<(std::string::String, std::string::String)>>(),
16682            ),
16683            _ => local_var_req_builder.query(&[(
16684                "provider",
16685                &local_var_str
16686                    .into_iter()
16687                    .map(|p| p.to_string())
16688                    .collect::<Vec<String>>()
16689                    .join(",")
16690                    .to_string(),
16691            )]),
16692        };
16693    }
16694    if let Some(ref local_var_str) = provider__n {
16695        local_var_req_builder = match "multi" {
16696            "multi" => local_var_req_builder.query(
16697                &local_var_str
16698                    .into_iter()
16699                    .map(|p| ("provider__n".to_owned(), p.to_string()))
16700                    .collect::<Vec<(std::string::String, std::string::String)>>(),
16701            ),
16702            _ => local_var_req_builder.query(&[(
16703                "provider__n",
16704                &local_var_str
16705                    .into_iter()
16706                    .map(|p| p.to_string())
16707                    .collect::<Vec<String>>()
16708                    .join(",")
16709                    .to_string(),
16710            )]),
16711        };
16712    }
16713    if let Some(ref local_var_str) = provider_id {
16714        local_var_req_builder = match "multi" {
16715            "multi" => local_var_req_builder.query(
16716                &local_var_str
16717                    .into_iter()
16718                    .map(|p| ("provider_id".to_owned(), p.to_string()))
16719                    .collect::<Vec<(std::string::String, std::string::String)>>(),
16720            ),
16721            _ => local_var_req_builder.query(&[(
16722                "provider_id",
16723                &local_var_str
16724                    .into_iter()
16725                    .map(|p| p.to_string())
16726                    .collect::<Vec<String>>()
16727                    .join(",")
16728                    .to_string(),
16729            )]),
16730        };
16731    }
16732    if let Some(ref local_var_str) = provider_id__n {
16733        local_var_req_builder = match "multi" {
16734            "multi" => local_var_req_builder.query(
16735                &local_var_str
16736                    .into_iter()
16737                    .map(|p| ("provider_id__n".to_owned(), p.to_string()))
16738                    .collect::<Vec<(std::string::String, std::string::String)>>(),
16739            ),
16740            _ => local_var_req_builder.query(&[(
16741                "provider_id__n",
16742                &local_var_str
16743                    .into_iter()
16744                    .map(|p| p.to_string())
16745                    .collect::<Vec<String>>()
16746                    .join(",")
16747                    .to_string(),
16748            )]),
16749        };
16750    }
16751    if let Some(ref local_var_str) = q {
16752        local_var_req_builder = local_var_req_builder.query(&[("q", &local_var_str.to_string())]);
16753    }
16754    if let Some(ref local_var_str) = service_id {
16755        local_var_req_builder = match "multi" {
16756            "multi" => local_var_req_builder.query(
16757                &local_var_str
16758                    .into_iter()
16759                    .map(|p| ("service_id".to_owned(), p.to_string()))
16760                    .collect::<Vec<(std::string::String, std::string::String)>>(),
16761            ),
16762            _ => local_var_req_builder.query(&[(
16763                "service_id",
16764                &local_var_str
16765                    .into_iter()
16766                    .map(|p| p.to_string())
16767                    .collect::<Vec<String>>()
16768                    .join(",")
16769                    .to_string(),
16770            )]),
16771        };
16772    }
16773    if let Some(ref local_var_str) = service_id__empty {
16774        local_var_req_builder =
16775            local_var_req_builder.query(&[("service_id__empty", &local_var_str.to_string())]);
16776    }
16777    if let Some(ref local_var_str) = service_id__ic {
16778        local_var_req_builder = match "multi" {
16779            "multi" => local_var_req_builder.query(
16780                &local_var_str
16781                    .into_iter()
16782                    .map(|p| ("service_id__ic".to_owned(), p.to_string()))
16783                    .collect::<Vec<(std::string::String, std::string::String)>>(),
16784            ),
16785            _ => local_var_req_builder.query(&[(
16786                "service_id__ic",
16787                &local_var_str
16788                    .into_iter()
16789                    .map(|p| p.to_string())
16790                    .collect::<Vec<String>>()
16791                    .join(",")
16792                    .to_string(),
16793            )]),
16794        };
16795    }
16796    if let Some(ref local_var_str) = service_id__ie {
16797        local_var_req_builder = match "multi" {
16798            "multi" => local_var_req_builder.query(
16799                &local_var_str
16800                    .into_iter()
16801                    .map(|p| ("service_id__ie".to_owned(), p.to_string()))
16802                    .collect::<Vec<(std::string::String, std::string::String)>>(),
16803            ),
16804            _ => local_var_req_builder.query(&[(
16805                "service_id__ie",
16806                &local_var_str
16807                    .into_iter()
16808                    .map(|p| p.to_string())
16809                    .collect::<Vec<String>>()
16810                    .join(",")
16811                    .to_string(),
16812            )]),
16813        };
16814    }
16815    if let Some(ref local_var_str) = service_id__iew {
16816        local_var_req_builder = match "multi" {
16817            "multi" => local_var_req_builder.query(
16818                &local_var_str
16819                    .into_iter()
16820                    .map(|p| ("service_id__iew".to_owned(), p.to_string()))
16821                    .collect::<Vec<(std::string::String, std::string::String)>>(),
16822            ),
16823            _ => local_var_req_builder.query(&[(
16824                "service_id__iew",
16825                &local_var_str
16826                    .into_iter()
16827                    .map(|p| p.to_string())
16828                    .collect::<Vec<String>>()
16829                    .join(",")
16830                    .to_string(),
16831            )]),
16832        };
16833    }
16834    if let Some(ref local_var_str) = service_id__iregex {
16835        local_var_req_builder = match "multi" {
16836            "multi" => local_var_req_builder.query(
16837                &local_var_str
16838                    .into_iter()
16839                    .map(|p| ("service_id__iregex".to_owned(), p.to_string()))
16840                    .collect::<Vec<(std::string::String, std::string::String)>>(),
16841            ),
16842            _ => local_var_req_builder.query(&[(
16843                "service_id__iregex",
16844                &local_var_str
16845                    .into_iter()
16846                    .map(|p| p.to_string())
16847                    .collect::<Vec<String>>()
16848                    .join(",")
16849                    .to_string(),
16850            )]),
16851        };
16852    }
16853    if let Some(ref local_var_str) = service_id__isw {
16854        local_var_req_builder = match "multi" {
16855            "multi" => local_var_req_builder.query(
16856                &local_var_str
16857                    .into_iter()
16858                    .map(|p| ("service_id__isw".to_owned(), p.to_string()))
16859                    .collect::<Vec<(std::string::String, std::string::String)>>(),
16860            ),
16861            _ => local_var_req_builder.query(&[(
16862                "service_id__isw",
16863                &local_var_str
16864                    .into_iter()
16865                    .map(|p| p.to_string())
16866                    .collect::<Vec<String>>()
16867                    .join(",")
16868                    .to_string(),
16869            )]),
16870        };
16871    }
16872    if let Some(ref local_var_str) = service_id__n {
16873        local_var_req_builder = match "multi" {
16874            "multi" => local_var_req_builder.query(
16875                &local_var_str
16876                    .into_iter()
16877                    .map(|p| ("service_id__n".to_owned(), p.to_string()))
16878                    .collect::<Vec<(std::string::String, std::string::String)>>(),
16879            ),
16880            _ => local_var_req_builder.query(&[(
16881                "service_id__n",
16882                &local_var_str
16883                    .into_iter()
16884                    .map(|p| p.to_string())
16885                    .collect::<Vec<String>>()
16886                    .join(",")
16887                    .to_string(),
16888            )]),
16889        };
16890    }
16891    if let Some(ref local_var_str) = service_id__nic {
16892        local_var_req_builder = match "multi" {
16893            "multi" => local_var_req_builder.query(
16894                &local_var_str
16895                    .into_iter()
16896                    .map(|p| ("service_id__nic".to_owned(), p.to_string()))
16897                    .collect::<Vec<(std::string::String, std::string::String)>>(),
16898            ),
16899            _ => local_var_req_builder.query(&[(
16900                "service_id__nic",
16901                &local_var_str
16902                    .into_iter()
16903                    .map(|p| p.to_string())
16904                    .collect::<Vec<String>>()
16905                    .join(",")
16906                    .to_string(),
16907            )]),
16908        };
16909    }
16910    if let Some(ref local_var_str) = service_id__nie {
16911        local_var_req_builder = match "multi" {
16912            "multi" => local_var_req_builder.query(
16913                &local_var_str
16914                    .into_iter()
16915                    .map(|p| ("service_id__nie".to_owned(), p.to_string()))
16916                    .collect::<Vec<(std::string::String, std::string::String)>>(),
16917            ),
16918            _ => local_var_req_builder.query(&[(
16919                "service_id__nie",
16920                &local_var_str
16921                    .into_iter()
16922                    .map(|p| p.to_string())
16923                    .collect::<Vec<String>>()
16924                    .join(",")
16925                    .to_string(),
16926            )]),
16927        };
16928    }
16929    if let Some(ref local_var_str) = service_id__niew {
16930        local_var_req_builder = match "multi" {
16931            "multi" => local_var_req_builder.query(
16932                &local_var_str
16933                    .into_iter()
16934                    .map(|p| ("service_id__niew".to_owned(), p.to_string()))
16935                    .collect::<Vec<(std::string::String, std::string::String)>>(),
16936            ),
16937            _ => local_var_req_builder.query(&[(
16938                "service_id__niew",
16939                &local_var_str
16940                    .into_iter()
16941                    .map(|p| p.to_string())
16942                    .collect::<Vec<String>>()
16943                    .join(",")
16944                    .to_string(),
16945            )]),
16946        };
16947    }
16948    if let Some(ref local_var_str) = service_id__nisw {
16949        local_var_req_builder = match "multi" {
16950            "multi" => local_var_req_builder.query(
16951                &local_var_str
16952                    .into_iter()
16953                    .map(|p| ("service_id__nisw".to_owned(), p.to_string()))
16954                    .collect::<Vec<(std::string::String, std::string::String)>>(),
16955            ),
16956            _ => local_var_req_builder.query(&[(
16957                "service_id__nisw",
16958                &local_var_str
16959                    .into_iter()
16960                    .map(|p| p.to_string())
16961                    .collect::<Vec<String>>()
16962                    .join(",")
16963                    .to_string(),
16964            )]),
16965        };
16966    }
16967    if let Some(ref local_var_str) = service_id__regex {
16968        local_var_req_builder = match "multi" {
16969            "multi" => local_var_req_builder.query(
16970                &local_var_str
16971                    .into_iter()
16972                    .map(|p| ("service_id__regex".to_owned(), p.to_string()))
16973                    .collect::<Vec<(std::string::String, std::string::String)>>(),
16974            ),
16975            _ => local_var_req_builder.query(&[(
16976                "service_id__regex",
16977                &local_var_str
16978                    .into_iter()
16979                    .map(|p| p.to_string())
16980                    .collect::<Vec<String>>()
16981                    .join(",")
16982                    .to_string(),
16983            )]),
16984        };
16985    }
16986    if let Some(ref local_var_str) = start {
16987        local_var_req_builder =
16988            local_var_req_builder.query(&[("start", &local_var_str.to_string())]);
16989    }
16990    if let Some(ref local_var_str) = tag {
16991        local_var_req_builder = match "multi" {
16992            "multi" => local_var_req_builder.query(
16993                &local_var_str
16994                    .into_iter()
16995                    .map(|p| ("tag".to_owned(), p.to_string()))
16996                    .collect::<Vec<(std::string::String, std::string::String)>>(),
16997            ),
16998            _ => local_var_req_builder.query(&[(
16999                "tag",
17000                &local_var_str
17001                    .into_iter()
17002                    .map(|p| p.to_string())
17003                    .collect::<Vec<String>>()
17004                    .join(",")
17005                    .to_string(),
17006            )]),
17007        };
17008    }
17009    if let Some(ref local_var_str) = tag__n {
17010        local_var_req_builder = match "multi" {
17011            "multi" => local_var_req_builder.query(
17012                &local_var_str
17013                    .into_iter()
17014                    .map(|p| ("tag__n".to_owned(), p.to_string()))
17015                    .collect::<Vec<(std::string::String, std::string::String)>>(),
17016            ),
17017            _ => local_var_req_builder.query(&[(
17018                "tag__n",
17019                &local_var_str
17020                    .into_iter()
17021                    .map(|p| p.to_string())
17022                    .collect::<Vec<String>>()
17023                    .join(",")
17024                    .to_string(),
17025            )]),
17026        };
17027    }
17028    if let Some(ref local_var_str) = tag_id {
17029        local_var_req_builder = match "multi" {
17030            "multi" => local_var_req_builder.query(
17031                &local_var_str
17032                    .into_iter()
17033                    .map(|p| ("tag_id".to_owned(), p.to_string()))
17034                    .collect::<Vec<(std::string::String, std::string::String)>>(),
17035            ),
17036            _ => local_var_req_builder.query(&[(
17037                "tag_id",
17038                &local_var_str
17039                    .into_iter()
17040                    .map(|p| p.to_string())
17041                    .collect::<Vec<String>>()
17042                    .join(",")
17043                    .to_string(),
17044            )]),
17045        };
17046    }
17047    if let Some(ref local_var_str) = tag_id__n {
17048        local_var_req_builder = match "multi" {
17049            "multi" => local_var_req_builder.query(
17050                &local_var_str
17051                    .into_iter()
17052                    .map(|p| ("tag_id__n".to_owned(), p.to_string()))
17053                    .collect::<Vec<(std::string::String, std::string::String)>>(),
17054            ),
17055            _ => local_var_req_builder.query(&[(
17056                "tag_id__n",
17057                &local_var_str
17058                    .into_iter()
17059                    .map(|p| p.to_string())
17060                    .collect::<Vec<String>>()
17061                    .join(",")
17062                    .to_string(),
17063            )]),
17064        };
17065    }
17066    if let Some(ref local_var_str) = updated_by_request {
17067        local_var_req_builder =
17068            local_var_req_builder.query(&[("updated_by_request", &local_var_str.to_string())]);
17069    }
17070    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
17071        local_var_req_builder =
17072            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
17073    }
17074    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
17075        let local_var_key = local_var_apikey.key.clone();
17076        let local_var_value = match local_var_apikey.prefix {
17077            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
17078            None => local_var_key,
17079        };
17080        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
17081    };
17082
17083    let local_var_req = local_var_req_builder.build()?;
17084    let local_var_resp = local_var_client.execute(local_var_req).await?;
17085
17086    let local_var_status = local_var_resp.status();
17087    let local_var_content = local_var_resp.text().await?;
17088
17089    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
17090        serde_json::from_str(&local_var_content).map_err(Error::from)
17091    } else {
17092        let local_var_entity: Option<CircuitsProviderNetworksListError> =
17093            serde_json::from_str(&local_var_content).ok();
17094        let local_var_error = ResponseContent {
17095            status: local_var_status,
17096            content: local_var_content,
17097            entity: local_var_entity,
17098        };
17099        Err(Error::ResponseError(local_var_error))
17100    }
17101}
17102
17103/// Patch a provider network object.
17104pub async fn circuits_provider_networks_partial_update(
17105    configuration: &configuration::Configuration,
17106    id: i32,
17107    patched_provider_network_request: Option<crate::models::PatchedProviderNetworkRequest>,
17108) -> Result<crate::models::ProviderNetwork, Error<CircuitsProviderNetworksPartialUpdateError>> {
17109    let local_var_configuration = configuration;
17110
17111    let local_var_client = &local_var_configuration.client;
17112
17113    let local_var_uri_str = format!(
17114        "{}/api/circuits/provider-networks/{id}/",
17115        local_var_configuration.base_path,
17116        id = id
17117    );
17118    let mut local_var_req_builder =
17119        local_var_client.request(reqwest::Method::PATCH, local_var_uri_str.as_str());
17120
17121    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
17122        local_var_req_builder =
17123            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
17124    }
17125    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
17126        let local_var_key = local_var_apikey.key.clone();
17127        let local_var_value = match local_var_apikey.prefix {
17128            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
17129            None => local_var_key,
17130        };
17131        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
17132    };
17133    local_var_req_builder = local_var_req_builder.json(&patched_provider_network_request);
17134
17135    let local_var_req = local_var_req_builder.build()?;
17136    let local_var_resp = local_var_client.execute(local_var_req).await?;
17137
17138    let local_var_status = local_var_resp.status();
17139    let local_var_content = local_var_resp.text().await?;
17140
17141    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
17142        serde_json::from_str(&local_var_content).map_err(Error::from)
17143    } else {
17144        let local_var_entity: Option<CircuitsProviderNetworksPartialUpdateError> =
17145            serde_json::from_str(&local_var_content).ok();
17146        let local_var_error = ResponseContent {
17147            status: local_var_status,
17148            content: local_var_content,
17149            entity: local_var_entity,
17150        };
17151        Err(Error::ResponseError(local_var_error))
17152    }
17153}
17154
17155/// Get a provider network object.
17156pub async fn circuits_provider_networks_retrieve(
17157    configuration: &configuration::Configuration,
17158    id: i32,
17159) -> Result<crate::models::ProviderNetwork, Error<CircuitsProviderNetworksRetrieveError>> {
17160    let local_var_configuration = configuration;
17161
17162    let local_var_client = &local_var_configuration.client;
17163
17164    let local_var_uri_str = format!(
17165        "{}/api/circuits/provider-networks/{id}/",
17166        local_var_configuration.base_path,
17167        id = id
17168    );
17169    let mut local_var_req_builder =
17170        local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
17171
17172    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
17173        local_var_req_builder =
17174            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
17175    }
17176    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
17177        let local_var_key = local_var_apikey.key.clone();
17178        let local_var_value = match local_var_apikey.prefix {
17179            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
17180            None => local_var_key,
17181        };
17182        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
17183    };
17184
17185    let local_var_req = local_var_req_builder.build()?;
17186    let local_var_resp = local_var_client.execute(local_var_req).await?;
17187
17188    let local_var_status = local_var_resp.status();
17189    let local_var_content = local_var_resp.text().await?;
17190
17191    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
17192        serde_json::from_str(&local_var_content).map_err(Error::from)
17193    } else {
17194        let local_var_entity: Option<CircuitsProviderNetworksRetrieveError> =
17195            serde_json::from_str(&local_var_content).ok();
17196        let local_var_error = ResponseContent {
17197            status: local_var_status,
17198            content: local_var_content,
17199            entity: local_var_entity,
17200        };
17201        Err(Error::ResponseError(local_var_error))
17202    }
17203}
17204
17205/// Put a provider network object.
17206pub async fn circuits_provider_networks_update(
17207    configuration: &configuration::Configuration,
17208    id: i32,
17209    provider_network_request: crate::models::ProviderNetworkRequest,
17210) -> Result<crate::models::ProviderNetwork, Error<CircuitsProviderNetworksUpdateError>> {
17211    let local_var_configuration = configuration;
17212
17213    let local_var_client = &local_var_configuration.client;
17214
17215    let local_var_uri_str = format!(
17216        "{}/api/circuits/provider-networks/{id}/",
17217        local_var_configuration.base_path,
17218        id = id
17219    );
17220    let mut local_var_req_builder =
17221        local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());
17222
17223    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
17224        local_var_req_builder =
17225            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
17226    }
17227    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
17228        let local_var_key = local_var_apikey.key.clone();
17229        let local_var_value = match local_var_apikey.prefix {
17230            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
17231            None => local_var_key,
17232        };
17233        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
17234    };
17235    local_var_req_builder = local_var_req_builder.json(&provider_network_request);
17236
17237    let local_var_req = local_var_req_builder.build()?;
17238    let local_var_resp = local_var_client.execute(local_var_req).await?;
17239
17240    let local_var_status = local_var_resp.status();
17241    let local_var_content = local_var_resp.text().await?;
17242
17243    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
17244        serde_json::from_str(&local_var_content).map_err(Error::from)
17245    } else {
17246        let local_var_entity: Option<CircuitsProviderNetworksUpdateError> =
17247            serde_json::from_str(&local_var_content).ok();
17248        let local_var_error = ResponseContent {
17249            status: local_var_status,
17250            content: local_var_content,
17251            entity: local_var_entity,
17252        };
17253        Err(Error::ResponseError(local_var_error))
17254    }
17255}
17256
17257/// Delete a list of provider objects.
17258pub async fn circuits_providers_bulk_destroy(
17259    configuration: &configuration::Configuration,
17260    provider_request: Vec<crate::models::ProviderRequest>,
17261) -> Result<(), Error<CircuitsProvidersBulkDestroyError>> {
17262    let local_var_configuration = configuration;
17263
17264    let local_var_client = &local_var_configuration.client;
17265
17266    let local_var_uri_str = format!(
17267        "{}/api/circuits/providers/",
17268        local_var_configuration.base_path
17269    );
17270    let mut local_var_req_builder =
17271        local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());
17272
17273    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
17274        local_var_req_builder =
17275            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
17276    }
17277    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
17278        let local_var_key = local_var_apikey.key.clone();
17279        let local_var_value = match local_var_apikey.prefix {
17280            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
17281            None => local_var_key,
17282        };
17283        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
17284    };
17285    local_var_req_builder = local_var_req_builder.json(&provider_request);
17286
17287    let local_var_req = local_var_req_builder.build()?;
17288    let local_var_resp = local_var_client.execute(local_var_req).await?;
17289
17290    let local_var_status = local_var_resp.status();
17291    let local_var_content = local_var_resp.text().await?;
17292
17293    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
17294        Ok(())
17295    } else {
17296        let local_var_entity: Option<CircuitsProvidersBulkDestroyError> =
17297            serde_json::from_str(&local_var_content).ok();
17298        let local_var_error = ResponseContent {
17299            status: local_var_status,
17300            content: local_var_content,
17301            entity: local_var_entity,
17302        };
17303        Err(Error::ResponseError(local_var_error))
17304    }
17305}
17306
17307/// Patch a list of provider objects.
17308pub async fn circuits_providers_bulk_partial_update(
17309    configuration: &configuration::Configuration,
17310    provider_request: Vec<crate::models::ProviderRequest>,
17311) -> Result<Vec<crate::models::Provider>, Error<CircuitsProvidersBulkPartialUpdateError>> {
17312    let local_var_configuration = configuration;
17313
17314    let local_var_client = &local_var_configuration.client;
17315
17316    let local_var_uri_str = format!(
17317        "{}/api/circuits/providers/",
17318        local_var_configuration.base_path
17319    );
17320    let mut local_var_req_builder =
17321        local_var_client.request(reqwest::Method::PATCH, local_var_uri_str.as_str());
17322
17323    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
17324        local_var_req_builder =
17325            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
17326    }
17327    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
17328        let local_var_key = local_var_apikey.key.clone();
17329        let local_var_value = match local_var_apikey.prefix {
17330            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
17331            None => local_var_key,
17332        };
17333        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
17334    };
17335    local_var_req_builder = local_var_req_builder.json(&provider_request);
17336
17337    let local_var_req = local_var_req_builder.build()?;
17338    let local_var_resp = local_var_client.execute(local_var_req).await?;
17339
17340    let local_var_status = local_var_resp.status();
17341    let local_var_content = local_var_resp.text().await?;
17342
17343    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
17344        serde_json::from_str(&local_var_content).map_err(Error::from)
17345    } else {
17346        let local_var_entity: Option<CircuitsProvidersBulkPartialUpdateError> =
17347            serde_json::from_str(&local_var_content).ok();
17348        let local_var_error = ResponseContent {
17349            status: local_var_status,
17350            content: local_var_content,
17351            entity: local_var_entity,
17352        };
17353        Err(Error::ResponseError(local_var_error))
17354    }
17355}
17356
17357/// Put a list of provider objects.
17358pub async fn circuits_providers_bulk_update(
17359    configuration: &configuration::Configuration,
17360    provider_request: Vec<crate::models::ProviderRequest>,
17361) -> Result<Vec<crate::models::Provider>, Error<CircuitsProvidersBulkUpdateError>> {
17362    let local_var_configuration = configuration;
17363
17364    let local_var_client = &local_var_configuration.client;
17365
17366    let local_var_uri_str = format!(
17367        "{}/api/circuits/providers/",
17368        local_var_configuration.base_path
17369    );
17370    let mut local_var_req_builder =
17371        local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());
17372
17373    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
17374        local_var_req_builder =
17375            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
17376    }
17377    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
17378        let local_var_key = local_var_apikey.key.clone();
17379        let local_var_value = match local_var_apikey.prefix {
17380            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
17381            None => local_var_key,
17382        };
17383        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
17384    };
17385    local_var_req_builder = local_var_req_builder.json(&provider_request);
17386
17387    let local_var_req = local_var_req_builder.build()?;
17388    let local_var_resp = local_var_client.execute(local_var_req).await?;
17389
17390    let local_var_status = local_var_resp.status();
17391    let local_var_content = local_var_resp.text().await?;
17392
17393    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
17394        serde_json::from_str(&local_var_content).map_err(Error::from)
17395    } else {
17396        let local_var_entity: Option<CircuitsProvidersBulkUpdateError> =
17397            serde_json::from_str(&local_var_content).ok();
17398        let local_var_error = ResponseContent {
17399            status: local_var_status,
17400            content: local_var_content,
17401            entity: local_var_entity,
17402        };
17403        Err(Error::ResponseError(local_var_error))
17404    }
17405}
17406
17407/// Post a list of provider objects.
17408pub async fn circuits_providers_create(
17409    configuration: &configuration::Configuration,
17410    circuits_providers_create_request: crate::models::CircuitsProvidersCreateRequest,
17411) -> Result<crate::models::Provider, Error<CircuitsProvidersCreateError>> {
17412    let local_var_configuration = configuration;
17413
17414    let local_var_client = &local_var_configuration.client;
17415
17416    let local_var_uri_str = format!(
17417        "{}/api/circuits/providers/",
17418        local_var_configuration.base_path
17419    );
17420    let mut local_var_req_builder =
17421        local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
17422
17423    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
17424        local_var_req_builder =
17425            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
17426    }
17427    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
17428        let local_var_key = local_var_apikey.key.clone();
17429        let local_var_value = match local_var_apikey.prefix {
17430            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
17431            None => local_var_key,
17432        };
17433        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
17434    };
17435    local_var_req_builder = local_var_req_builder.json(&circuits_providers_create_request);
17436
17437    let local_var_req = local_var_req_builder.build()?;
17438    let local_var_resp = local_var_client.execute(local_var_req).await?;
17439
17440    let local_var_status = local_var_resp.status();
17441    let local_var_content = local_var_resp.text().await?;
17442
17443    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
17444        serde_json::from_str(&local_var_content).map_err(Error::from)
17445    } else {
17446        let local_var_entity: Option<CircuitsProvidersCreateError> =
17447            serde_json::from_str(&local_var_content).ok();
17448        let local_var_error = ResponseContent {
17449            status: local_var_status,
17450            content: local_var_content,
17451            entity: local_var_entity,
17452        };
17453        Err(Error::ResponseError(local_var_error))
17454    }
17455}
17456
17457/// Delete a provider object.
17458pub async fn circuits_providers_destroy(
17459    configuration: &configuration::Configuration,
17460    id: i32,
17461) -> Result<(), Error<CircuitsProvidersDestroyError>> {
17462    let local_var_configuration = configuration;
17463
17464    let local_var_client = &local_var_configuration.client;
17465
17466    let local_var_uri_str = format!(
17467        "{}/api/circuits/providers/{id}/",
17468        local_var_configuration.base_path,
17469        id = id
17470    );
17471    let mut local_var_req_builder =
17472        local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());
17473
17474    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
17475        local_var_req_builder =
17476            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
17477    }
17478    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
17479        let local_var_key = local_var_apikey.key.clone();
17480        let local_var_value = match local_var_apikey.prefix {
17481            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
17482            None => local_var_key,
17483        };
17484        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
17485    };
17486
17487    let local_var_req = local_var_req_builder.build()?;
17488    let local_var_resp = local_var_client.execute(local_var_req).await?;
17489
17490    let local_var_status = local_var_resp.status();
17491    let local_var_content = local_var_resp.text().await?;
17492
17493    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
17494        Ok(())
17495    } else {
17496        let local_var_entity: Option<CircuitsProvidersDestroyError> =
17497            serde_json::from_str(&local_var_content).ok();
17498        let local_var_error = ResponseContent {
17499            status: local_var_status,
17500            content: local_var_content,
17501            entity: local_var_entity,
17502        };
17503        Err(Error::ResponseError(local_var_error))
17504    }
17505}
17506
17507/// Get a list of provider objects.
17508pub async fn circuits_providers_list(
17509    configuration: &configuration::Configuration,
17510    asn: Option<Vec<i64>>,
17511    asn__n: Option<Vec<i64>>,
17512    asn_id: Option<Vec<i32>>,
17513    asn_id__n: Option<Vec<i32>>,
17514    contact: Option<Vec<i32>>,
17515    contact__n: Option<Vec<i32>>,
17516    contact_group: Option<Vec<String>>,
17517    contact_group__n: Option<Vec<String>>,
17518    contact_role: Option<Vec<i32>>,
17519    contact_role__n: Option<Vec<i32>>,
17520    created: Option<Vec<String>>,
17521    created__empty: Option<Vec<String>>,
17522    created__gt: Option<Vec<String>>,
17523    created__gte: Option<Vec<String>>,
17524    created__lt: Option<Vec<String>>,
17525    created__lte: Option<Vec<String>>,
17526    created__n: Option<Vec<String>>,
17527    created_by_request: Option<&str>,
17528    description: Option<Vec<String>>,
17529    description__empty: Option<bool>,
17530    description__ic: Option<Vec<String>>,
17531    description__ie: Option<Vec<String>>,
17532    description__iew: Option<Vec<String>>,
17533    description__iregex: Option<Vec<String>>,
17534    description__isw: Option<Vec<String>>,
17535    description__n: Option<Vec<String>>,
17536    description__nic: Option<Vec<String>>,
17537    description__nie: Option<Vec<String>>,
17538    description__niew: Option<Vec<String>>,
17539    description__nisw: Option<Vec<String>>,
17540    description__regex: Option<Vec<String>>,
17541    id: Option<Vec<i32>>,
17542    id__empty: Option<bool>,
17543    id__gt: Option<Vec<i32>>,
17544    id__gte: Option<Vec<i32>>,
17545    id__lt: Option<Vec<i32>>,
17546    id__lte: Option<Vec<i32>>,
17547    id__n: Option<Vec<i32>>,
17548    last_updated: Option<Vec<String>>,
17549    last_updated__empty: Option<Vec<String>>,
17550    last_updated__gt: Option<Vec<String>>,
17551    last_updated__gte: Option<Vec<String>>,
17552    last_updated__lt: Option<Vec<String>>,
17553    last_updated__lte: Option<Vec<String>>,
17554    last_updated__n: Option<Vec<String>>,
17555    limit: Option<i32>,
17556    modified_by_request: Option<&str>,
17557    name: Option<Vec<String>>,
17558    name__empty: Option<bool>,
17559    name__ic: Option<Vec<String>>,
17560    name__ie: Option<Vec<String>>,
17561    name__iew: Option<Vec<String>>,
17562    name__iregex: Option<Vec<String>>,
17563    name__isw: Option<Vec<String>>,
17564    name__n: Option<Vec<String>>,
17565    name__nic: Option<Vec<String>>,
17566    name__nie: Option<Vec<String>>,
17567    name__niew: Option<Vec<String>>,
17568    name__nisw: Option<Vec<String>>,
17569    name__regex: Option<Vec<String>>,
17570    offset: Option<i32>,
17571    ordering: Option<&str>,
17572    owner: Option<Vec<String>>,
17573    owner__n: Option<Vec<String>>,
17574    owner_group: Option<Vec<String>>,
17575    owner_group__n: Option<Vec<String>>,
17576    owner_group_id: Option<Vec<i32>>,
17577    owner_group_id__n: Option<Vec<i32>>,
17578    owner_id: Option<Vec<i32>>,
17579    owner_id__n: Option<Vec<i32>>,
17580    q: Option<&str>,
17581    region: Option<Vec<String>>,
17582    region__n: Option<Vec<String>>,
17583    region_id: Option<Vec<String>>,
17584    region_id__n: Option<Vec<String>>,
17585    site: Option<Vec<String>>,
17586    site__n: Option<Vec<String>>,
17587    site_group: Option<Vec<String>>,
17588    site_group__n: Option<Vec<String>>,
17589    site_group_id: Option<Vec<String>>,
17590    site_group_id__n: Option<Vec<String>>,
17591    site_id: Option<Vec<i32>>,
17592    site_id__n: Option<Vec<i32>>,
17593    slug: Option<Vec<String>>,
17594    slug__empty: Option<bool>,
17595    slug__ic: Option<Vec<String>>,
17596    slug__ie: Option<Vec<String>>,
17597    slug__iew: Option<Vec<String>>,
17598    slug__iregex: Option<Vec<String>>,
17599    slug__isw: Option<Vec<String>>,
17600    slug__n: Option<Vec<String>>,
17601    slug__nic: Option<Vec<String>>,
17602    slug__nie: Option<Vec<String>>,
17603    slug__niew: Option<Vec<String>>,
17604    slug__nisw: Option<Vec<String>>,
17605    slug__regex: Option<Vec<String>>,
17606    start: Option<i32>,
17607    tag: Option<Vec<String>>,
17608    tag__n: Option<Vec<String>>,
17609    tag_id: Option<Vec<i32>>,
17610    tag_id__n: Option<Vec<i32>>,
17611    updated_by_request: Option<&str>,
17612) -> Result<crate::models::PaginatedProviderList, Error<CircuitsProvidersListError>> {
17613    let local_var_configuration = configuration;
17614
17615    let local_var_client = &local_var_configuration.client;
17616
17617    let local_var_uri_str = format!(
17618        "{}/api/circuits/providers/",
17619        local_var_configuration.base_path
17620    );
17621    let mut local_var_req_builder =
17622        local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
17623
17624    if let Some(ref local_var_str) = asn {
17625        local_var_req_builder = match "multi" {
17626            "multi" => local_var_req_builder.query(
17627                &local_var_str
17628                    .into_iter()
17629                    .map(|p| ("asn".to_owned(), p.to_string()))
17630                    .collect::<Vec<(std::string::String, std::string::String)>>(),
17631            ),
17632            _ => local_var_req_builder.query(&[(
17633                "asn",
17634                &local_var_str
17635                    .into_iter()
17636                    .map(|p| p.to_string())
17637                    .collect::<Vec<String>>()
17638                    .join(",")
17639                    .to_string(),
17640            )]),
17641        };
17642    }
17643    if let Some(ref local_var_str) = asn__n {
17644        local_var_req_builder = match "multi" {
17645            "multi" => local_var_req_builder.query(
17646                &local_var_str
17647                    .into_iter()
17648                    .map(|p| ("asn__n".to_owned(), p.to_string()))
17649                    .collect::<Vec<(std::string::String, std::string::String)>>(),
17650            ),
17651            _ => local_var_req_builder.query(&[(
17652                "asn__n",
17653                &local_var_str
17654                    .into_iter()
17655                    .map(|p| p.to_string())
17656                    .collect::<Vec<String>>()
17657                    .join(",")
17658                    .to_string(),
17659            )]),
17660        };
17661    }
17662    if let Some(ref local_var_str) = asn_id {
17663        local_var_req_builder = match "multi" {
17664            "multi" => local_var_req_builder.query(
17665                &local_var_str
17666                    .into_iter()
17667                    .map(|p| ("asn_id".to_owned(), p.to_string()))
17668                    .collect::<Vec<(std::string::String, std::string::String)>>(),
17669            ),
17670            _ => local_var_req_builder.query(&[(
17671                "asn_id",
17672                &local_var_str
17673                    .into_iter()
17674                    .map(|p| p.to_string())
17675                    .collect::<Vec<String>>()
17676                    .join(",")
17677                    .to_string(),
17678            )]),
17679        };
17680    }
17681    if let Some(ref local_var_str) = asn_id__n {
17682        local_var_req_builder = match "multi" {
17683            "multi" => local_var_req_builder.query(
17684                &local_var_str
17685                    .into_iter()
17686                    .map(|p| ("asn_id__n".to_owned(), p.to_string()))
17687                    .collect::<Vec<(std::string::String, std::string::String)>>(),
17688            ),
17689            _ => local_var_req_builder.query(&[(
17690                "asn_id__n",
17691                &local_var_str
17692                    .into_iter()
17693                    .map(|p| p.to_string())
17694                    .collect::<Vec<String>>()
17695                    .join(",")
17696                    .to_string(),
17697            )]),
17698        };
17699    }
17700    if let Some(ref local_var_str) = contact {
17701        local_var_req_builder = match "multi" {
17702            "multi" => local_var_req_builder.query(
17703                &local_var_str
17704                    .into_iter()
17705                    .map(|p| ("contact".to_owned(), p.to_string()))
17706                    .collect::<Vec<(std::string::String, std::string::String)>>(),
17707            ),
17708            _ => local_var_req_builder.query(&[(
17709                "contact",
17710                &local_var_str
17711                    .into_iter()
17712                    .map(|p| p.to_string())
17713                    .collect::<Vec<String>>()
17714                    .join(",")
17715                    .to_string(),
17716            )]),
17717        };
17718    }
17719    if let Some(ref local_var_str) = contact__n {
17720        local_var_req_builder = match "multi" {
17721            "multi" => local_var_req_builder.query(
17722                &local_var_str
17723                    .into_iter()
17724                    .map(|p| ("contact__n".to_owned(), p.to_string()))
17725                    .collect::<Vec<(std::string::String, std::string::String)>>(),
17726            ),
17727            _ => local_var_req_builder.query(&[(
17728                "contact__n",
17729                &local_var_str
17730                    .into_iter()
17731                    .map(|p| p.to_string())
17732                    .collect::<Vec<String>>()
17733                    .join(",")
17734                    .to_string(),
17735            )]),
17736        };
17737    }
17738    if let Some(ref local_var_str) = contact_group {
17739        local_var_req_builder = match "multi" {
17740            "multi" => local_var_req_builder.query(
17741                &local_var_str
17742                    .into_iter()
17743                    .map(|p| ("contact_group".to_owned(), p.to_string()))
17744                    .collect::<Vec<(std::string::String, std::string::String)>>(),
17745            ),
17746            _ => local_var_req_builder.query(&[(
17747                "contact_group",
17748                &local_var_str
17749                    .into_iter()
17750                    .map(|p| p.to_string())
17751                    .collect::<Vec<String>>()
17752                    .join(",")
17753                    .to_string(),
17754            )]),
17755        };
17756    }
17757    if let Some(ref local_var_str) = contact_group__n {
17758        local_var_req_builder = match "multi" {
17759            "multi" => local_var_req_builder.query(
17760                &local_var_str
17761                    .into_iter()
17762                    .map(|p| ("contact_group__n".to_owned(), p.to_string()))
17763                    .collect::<Vec<(std::string::String, std::string::String)>>(),
17764            ),
17765            _ => local_var_req_builder.query(&[(
17766                "contact_group__n",
17767                &local_var_str
17768                    .into_iter()
17769                    .map(|p| p.to_string())
17770                    .collect::<Vec<String>>()
17771                    .join(",")
17772                    .to_string(),
17773            )]),
17774        };
17775    }
17776    if let Some(ref local_var_str) = contact_role {
17777        local_var_req_builder = match "multi" {
17778            "multi" => local_var_req_builder.query(
17779                &local_var_str
17780                    .into_iter()
17781                    .map(|p| ("contact_role".to_owned(), p.to_string()))
17782                    .collect::<Vec<(std::string::String, std::string::String)>>(),
17783            ),
17784            _ => local_var_req_builder.query(&[(
17785                "contact_role",
17786                &local_var_str
17787                    .into_iter()
17788                    .map(|p| p.to_string())
17789                    .collect::<Vec<String>>()
17790                    .join(",")
17791                    .to_string(),
17792            )]),
17793        };
17794    }
17795    if let Some(ref local_var_str) = contact_role__n {
17796        local_var_req_builder = match "multi" {
17797            "multi" => local_var_req_builder.query(
17798                &local_var_str
17799                    .into_iter()
17800                    .map(|p| ("contact_role__n".to_owned(), p.to_string()))
17801                    .collect::<Vec<(std::string::String, std::string::String)>>(),
17802            ),
17803            _ => local_var_req_builder.query(&[(
17804                "contact_role__n",
17805                &local_var_str
17806                    .into_iter()
17807                    .map(|p| p.to_string())
17808                    .collect::<Vec<String>>()
17809                    .join(",")
17810                    .to_string(),
17811            )]),
17812        };
17813    }
17814    if let Some(ref local_var_str) = created {
17815        local_var_req_builder = match "multi" {
17816            "multi" => local_var_req_builder.query(
17817                &local_var_str
17818                    .into_iter()
17819                    .map(|p| ("created".to_owned(), p.to_string()))
17820                    .collect::<Vec<(std::string::String, std::string::String)>>(),
17821            ),
17822            _ => local_var_req_builder.query(&[(
17823                "created",
17824                &local_var_str
17825                    .into_iter()
17826                    .map(|p| p.to_string())
17827                    .collect::<Vec<String>>()
17828                    .join(",")
17829                    .to_string(),
17830            )]),
17831        };
17832    }
17833    if let Some(ref local_var_str) = created__empty {
17834        local_var_req_builder = match "multi" {
17835            "multi" => local_var_req_builder.query(
17836                &local_var_str
17837                    .into_iter()
17838                    .map(|p| ("created__empty".to_owned(), p.to_string()))
17839                    .collect::<Vec<(std::string::String, std::string::String)>>(),
17840            ),
17841            _ => local_var_req_builder.query(&[(
17842                "created__empty",
17843                &local_var_str
17844                    .into_iter()
17845                    .map(|p| p.to_string())
17846                    .collect::<Vec<String>>()
17847                    .join(",")
17848                    .to_string(),
17849            )]),
17850        };
17851    }
17852    if let Some(ref local_var_str) = created__gt {
17853        local_var_req_builder = match "multi" {
17854            "multi" => local_var_req_builder.query(
17855                &local_var_str
17856                    .into_iter()
17857                    .map(|p| ("created__gt".to_owned(), p.to_string()))
17858                    .collect::<Vec<(std::string::String, std::string::String)>>(),
17859            ),
17860            _ => local_var_req_builder.query(&[(
17861                "created__gt",
17862                &local_var_str
17863                    .into_iter()
17864                    .map(|p| p.to_string())
17865                    .collect::<Vec<String>>()
17866                    .join(",")
17867                    .to_string(),
17868            )]),
17869        };
17870    }
17871    if let Some(ref local_var_str) = created__gte {
17872        local_var_req_builder = match "multi" {
17873            "multi" => local_var_req_builder.query(
17874                &local_var_str
17875                    .into_iter()
17876                    .map(|p| ("created__gte".to_owned(), p.to_string()))
17877                    .collect::<Vec<(std::string::String, std::string::String)>>(),
17878            ),
17879            _ => local_var_req_builder.query(&[(
17880                "created__gte",
17881                &local_var_str
17882                    .into_iter()
17883                    .map(|p| p.to_string())
17884                    .collect::<Vec<String>>()
17885                    .join(",")
17886                    .to_string(),
17887            )]),
17888        };
17889    }
17890    if let Some(ref local_var_str) = created__lt {
17891        local_var_req_builder = match "multi" {
17892            "multi" => local_var_req_builder.query(
17893                &local_var_str
17894                    .into_iter()
17895                    .map(|p| ("created__lt".to_owned(), p.to_string()))
17896                    .collect::<Vec<(std::string::String, std::string::String)>>(),
17897            ),
17898            _ => local_var_req_builder.query(&[(
17899                "created__lt",
17900                &local_var_str
17901                    .into_iter()
17902                    .map(|p| p.to_string())
17903                    .collect::<Vec<String>>()
17904                    .join(",")
17905                    .to_string(),
17906            )]),
17907        };
17908    }
17909    if let Some(ref local_var_str) = created__lte {
17910        local_var_req_builder = match "multi" {
17911            "multi" => local_var_req_builder.query(
17912                &local_var_str
17913                    .into_iter()
17914                    .map(|p| ("created__lte".to_owned(), p.to_string()))
17915                    .collect::<Vec<(std::string::String, std::string::String)>>(),
17916            ),
17917            _ => local_var_req_builder.query(&[(
17918                "created__lte",
17919                &local_var_str
17920                    .into_iter()
17921                    .map(|p| p.to_string())
17922                    .collect::<Vec<String>>()
17923                    .join(",")
17924                    .to_string(),
17925            )]),
17926        };
17927    }
17928    if let Some(ref local_var_str) = created__n {
17929        local_var_req_builder = match "multi" {
17930            "multi" => local_var_req_builder.query(
17931                &local_var_str
17932                    .into_iter()
17933                    .map(|p| ("created__n".to_owned(), p.to_string()))
17934                    .collect::<Vec<(std::string::String, std::string::String)>>(),
17935            ),
17936            _ => local_var_req_builder.query(&[(
17937                "created__n",
17938                &local_var_str
17939                    .into_iter()
17940                    .map(|p| p.to_string())
17941                    .collect::<Vec<String>>()
17942                    .join(",")
17943                    .to_string(),
17944            )]),
17945        };
17946    }
17947    if let Some(ref local_var_str) = created_by_request {
17948        local_var_req_builder =
17949            local_var_req_builder.query(&[("created_by_request", &local_var_str.to_string())]);
17950    }
17951    if let Some(ref local_var_str) = description {
17952        local_var_req_builder = match "multi" {
17953            "multi" => local_var_req_builder.query(
17954                &local_var_str
17955                    .into_iter()
17956                    .map(|p| ("description".to_owned(), p.to_string()))
17957                    .collect::<Vec<(std::string::String, std::string::String)>>(),
17958            ),
17959            _ => local_var_req_builder.query(&[(
17960                "description",
17961                &local_var_str
17962                    .into_iter()
17963                    .map(|p| p.to_string())
17964                    .collect::<Vec<String>>()
17965                    .join(",")
17966                    .to_string(),
17967            )]),
17968        };
17969    }
17970    if let Some(ref local_var_str) = description__empty {
17971        local_var_req_builder =
17972            local_var_req_builder.query(&[("description__empty", &local_var_str.to_string())]);
17973    }
17974    if let Some(ref local_var_str) = description__ic {
17975        local_var_req_builder = match "multi" {
17976            "multi" => local_var_req_builder.query(
17977                &local_var_str
17978                    .into_iter()
17979                    .map(|p| ("description__ic".to_owned(), p.to_string()))
17980                    .collect::<Vec<(std::string::String, std::string::String)>>(),
17981            ),
17982            _ => local_var_req_builder.query(&[(
17983                "description__ic",
17984                &local_var_str
17985                    .into_iter()
17986                    .map(|p| p.to_string())
17987                    .collect::<Vec<String>>()
17988                    .join(",")
17989                    .to_string(),
17990            )]),
17991        };
17992    }
17993    if let Some(ref local_var_str) = description__ie {
17994        local_var_req_builder = match "multi" {
17995            "multi" => local_var_req_builder.query(
17996                &local_var_str
17997                    .into_iter()
17998                    .map(|p| ("description__ie".to_owned(), p.to_string()))
17999                    .collect::<Vec<(std::string::String, std::string::String)>>(),
18000            ),
18001            _ => local_var_req_builder.query(&[(
18002                "description__ie",
18003                &local_var_str
18004                    .into_iter()
18005                    .map(|p| p.to_string())
18006                    .collect::<Vec<String>>()
18007                    .join(",")
18008                    .to_string(),
18009            )]),
18010        };
18011    }
18012    if let Some(ref local_var_str) = description__iew {
18013        local_var_req_builder = match "multi" {
18014            "multi" => local_var_req_builder.query(
18015                &local_var_str
18016                    .into_iter()
18017                    .map(|p| ("description__iew".to_owned(), p.to_string()))
18018                    .collect::<Vec<(std::string::String, std::string::String)>>(),
18019            ),
18020            _ => local_var_req_builder.query(&[(
18021                "description__iew",
18022                &local_var_str
18023                    .into_iter()
18024                    .map(|p| p.to_string())
18025                    .collect::<Vec<String>>()
18026                    .join(",")
18027                    .to_string(),
18028            )]),
18029        };
18030    }
18031    if let Some(ref local_var_str) = description__iregex {
18032        local_var_req_builder = match "multi" {
18033            "multi" => local_var_req_builder.query(
18034                &local_var_str
18035                    .into_iter()
18036                    .map(|p| ("description__iregex".to_owned(), p.to_string()))
18037                    .collect::<Vec<(std::string::String, std::string::String)>>(),
18038            ),
18039            _ => local_var_req_builder.query(&[(
18040                "description__iregex",
18041                &local_var_str
18042                    .into_iter()
18043                    .map(|p| p.to_string())
18044                    .collect::<Vec<String>>()
18045                    .join(",")
18046                    .to_string(),
18047            )]),
18048        };
18049    }
18050    if let Some(ref local_var_str) = description__isw {
18051        local_var_req_builder = match "multi" {
18052            "multi" => local_var_req_builder.query(
18053                &local_var_str
18054                    .into_iter()
18055                    .map(|p| ("description__isw".to_owned(), p.to_string()))
18056                    .collect::<Vec<(std::string::String, std::string::String)>>(),
18057            ),
18058            _ => local_var_req_builder.query(&[(
18059                "description__isw",
18060                &local_var_str
18061                    .into_iter()
18062                    .map(|p| p.to_string())
18063                    .collect::<Vec<String>>()
18064                    .join(",")
18065                    .to_string(),
18066            )]),
18067        };
18068    }
18069    if let Some(ref local_var_str) = description__n {
18070        local_var_req_builder = match "multi" {
18071            "multi" => local_var_req_builder.query(
18072                &local_var_str
18073                    .into_iter()
18074                    .map(|p| ("description__n".to_owned(), p.to_string()))
18075                    .collect::<Vec<(std::string::String, std::string::String)>>(),
18076            ),
18077            _ => local_var_req_builder.query(&[(
18078                "description__n",
18079                &local_var_str
18080                    .into_iter()
18081                    .map(|p| p.to_string())
18082                    .collect::<Vec<String>>()
18083                    .join(",")
18084                    .to_string(),
18085            )]),
18086        };
18087    }
18088    if let Some(ref local_var_str) = description__nic {
18089        local_var_req_builder = match "multi" {
18090            "multi" => local_var_req_builder.query(
18091                &local_var_str
18092                    .into_iter()
18093                    .map(|p| ("description__nic".to_owned(), p.to_string()))
18094                    .collect::<Vec<(std::string::String, std::string::String)>>(),
18095            ),
18096            _ => local_var_req_builder.query(&[(
18097                "description__nic",
18098                &local_var_str
18099                    .into_iter()
18100                    .map(|p| p.to_string())
18101                    .collect::<Vec<String>>()
18102                    .join(",")
18103                    .to_string(),
18104            )]),
18105        };
18106    }
18107    if let Some(ref local_var_str) = description__nie {
18108        local_var_req_builder = match "multi" {
18109            "multi" => local_var_req_builder.query(
18110                &local_var_str
18111                    .into_iter()
18112                    .map(|p| ("description__nie".to_owned(), p.to_string()))
18113                    .collect::<Vec<(std::string::String, std::string::String)>>(),
18114            ),
18115            _ => local_var_req_builder.query(&[(
18116                "description__nie",
18117                &local_var_str
18118                    .into_iter()
18119                    .map(|p| p.to_string())
18120                    .collect::<Vec<String>>()
18121                    .join(",")
18122                    .to_string(),
18123            )]),
18124        };
18125    }
18126    if let Some(ref local_var_str) = description__niew {
18127        local_var_req_builder = match "multi" {
18128            "multi" => local_var_req_builder.query(
18129                &local_var_str
18130                    .into_iter()
18131                    .map(|p| ("description__niew".to_owned(), p.to_string()))
18132                    .collect::<Vec<(std::string::String, std::string::String)>>(),
18133            ),
18134            _ => local_var_req_builder.query(&[(
18135                "description__niew",
18136                &local_var_str
18137                    .into_iter()
18138                    .map(|p| p.to_string())
18139                    .collect::<Vec<String>>()
18140                    .join(",")
18141                    .to_string(),
18142            )]),
18143        };
18144    }
18145    if let Some(ref local_var_str) = description__nisw {
18146        local_var_req_builder = match "multi" {
18147            "multi" => local_var_req_builder.query(
18148                &local_var_str
18149                    .into_iter()
18150                    .map(|p| ("description__nisw".to_owned(), p.to_string()))
18151                    .collect::<Vec<(std::string::String, std::string::String)>>(),
18152            ),
18153            _ => local_var_req_builder.query(&[(
18154                "description__nisw",
18155                &local_var_str
18156                    .into_iter()
18157                    .map(|p| p.to_string())
18158                    .collect::<Vec<String>>()
18159                    .join(",")
18160                    .to_string(),
18161            )]),
18162        };
18163    }
18164    if let Some(ref local_var_str) = description__regex {
18165        local_var_req_builder = match "multi" {
18166            "multi" => local_var_req_builder.query(
18167                &local_var_str
18168                    .into_iter()
18169                    .map(|p| ("description__regex".to_owned(), p.to_string()))
18170                    .collect::<Vec<(std::string::String, std::string::String)>>(),
18171            ),
18172            _ => local_var_req_builder.query(&[(
18173                "description__regex",
18174                &local_var_str
18175                    .into_iter()
18176                    .map(|p| p.to_string())
18177                    .collect::<Vec<String>>()
18178                    .join(",")
18179                    .to_string(),
18180            )]),
18181        };
18182    }
18183    if let Some(ref local_var_str) = id {
18184        local_var_req_builder = match "multi" {
18185            "multi" => local_var_req_builder.query(
18186                &local_var_str
18187                    .into_iter()
18188                    .map(|p| ("id".to_owned(), p.to_string()))
18189                    .collect::<Vec<(std::string::String, std::string::String)>>(),
18190            ),
18191            _ => local_var_req_builder.query(&[(
18192                "id",
18193                &local_var_str
18194                    .into_iter()
18195                    .map(|p| p.to_string())
18196                    .collect::<Vec<String>>()
18197                    .join(",")
18198                    .to_string(),
18199            )]),
18200        };
18201    }
18202    if let Some(ref local_var_str) = id__empty {
18203        local_var_req_builder =
18204            local_var_req_builder.query(&[("id__empty", &local_var_str.to_string())]);
18205    }
18206    if let Some(ref local_var_str) = id__gt {
18207        local_var_req_builder = match "multi" {
18208            "multi" => local_var_req_builder.query(
18209                &local_var_str
18210                    .into_iter()
18211                    .map(|p| ("id__gt".to_owned(), p.to_string()))
18212                    .collect::<Vec<(std::string::String, std::string::String)>>(),
18213            ),
18214            _ => local_var_req_builder.query(&[(
18215                "id__gt",
18216                &local_var_str
18217                    .into_iter()
18218                    .map(|p| p.to_string())
18219                    .collect::<Vec<String>>()
18220                    .join(",")
18221                    .to_string(),
18222            )]),
18223        };
18224    }
18225    if let Some(ref local_var_str) = id__gte {
18226        local_var_req_builder = match "multi" {
18227            "multi" => local_var_req_builder.query(
18228                &local_var_str
18229                    .into_iter()
18230                    .map(|p| ("id__gte".to_owned(), p.to_string()))
18231                    .collect::<Vec<(std::string::String, std::string::String)>>(),
18232            ),
18233            _ => local_var_req_builder.query(&[(
18234                "id__gte",
18235                &local_var_str
18236                    .into_iter()
18237                    .map(|p| p.to_string())
18238                    .collect::<Vec<String>>()
18239                    .join(",")
18240                    .to_string(),
18241            )]),
18242        };
18243    }
18244    if let Some(ref local_var_str) = id__lt {
18245        local_var_req_builder = match "multi" {
18246            "multi" => local_var_req_builder.query(
18247                &local_var_str
18248                    .into_iter()
18249                    .map(|p| ("id__lt".to_owned(), p.to_string()))
18250                    .collect::<Vec<(std::string::String, std::string::String)>>(),
18251            ),
18252            _ => local_var_req_builder.query(&[(
18253                "id__lt",
18254                &local_var_str
18255                    .into_iter()
18256                    .map(|p| p.to_string())
18257                    .collect::<Vec<String>>()
18258                    .join(",")
18259                    .to_string(),
18260            )]),
18261        };
18262    }
18263    if let Some(ref local_var_str) = id__lte {
18264        local_var_req_builder = match "multi" {
18265            "multi" => local_var_req_builder.query(
18266                &local_var_str
18267                    .into_iter()
18268                    .map(|p| ("id__lte".to_owned(), p.to_string()))
18269                    .collect::<Vec<(std::string::String, std::string::String)>>(),
18270            ),
18271            _ => local_var_req_builder.query(&[(
18272                "id__lte",
18273                &local_var_str
18274                    .into_iter()
18275                    .map(|p| p.to_string())
18276                    .collect::<Vec<String>>()
18277                    .join(",")
18278                    .to_string(),
18279            )]),
18280        };
18281    }
18282    if let Some(ref local_var_str) = id__n {
18283        local_var_req_builder = match "multi" {
18284            "multi" => local_var_req_builder.query(
18285                &local_var_str
18286                    .into_iter()
18287                    .map(|p| ("id__n".to_owned(), p.to_string()))
18288                    .collect::<Vec<(std::string::String, std::string::String)>>(),
18289            ),
18290            _ => local_var_req_builder.query(&[(
18291                "id__n",
18292                &local_var_str
18293                    .into_iter()
18294                    .map(|p| p.to_string())
18295                    .collect::<Vec<String>>()
18296                    .join(",")
18297                    .to_string(),
18298            )]),
18299        };
18300    }
18301    if let Some(ref local_var_str) = last_updated {
18302        local_var_req_builder = match "multi" {
18303            "multi" => local_var_req_builder.query(
18304                &local_var_str
18305                    .into_iter()
18306                    .map(|p| ("last_updated".to_owned(), p.to_string()))
18307                    .collect::<Vec<(std::string::String, std::string::String)>>(),
18308            ),
18309            _ => local_var_req_builder.query(&[(
18310                "last_updated",
18311                &local_var_str
18312                    .into_iter()
18313                    .map(|p| p.to_string())
18314                    .collect::<Vec<String>>()
18315                    .join(",")
18316                    .to_string(),
18317            )]),
18318        };
18319    }
18320    if let Some(ref local_var_str) = last_updated__empty {
18321        local_var_req_builder = match "multi" {
18322            "multi" => local_var_req_builder.query(
18323                &local_var_str
18324                    .into_iter()
18325                    .map(|p| ("last_updated__empty".to_owned(), p.to_string()))
18326                    .collect::<Vec<(std::string::String, std::string::String)>>(),
18327            ),
18328            _ => local_var_req_builder.query(&[(
18329                "last_updated__empty",
18330                &local_var_str
18331                    .into_iter()
18332                    .map(|p| p.to_string())
18333                    .collect::<Vec<String>>()
18334                    .join(",")
18335                    .to_string(),
18336            )]),
18337        };
18338    }
18339    if let Some(ref local_var_str) = last_updated__gt {
18340        local_var_req_builder = match "multi" {
18341            "multi" => local_var_req_builder.query(
18342                &local_var_str
18343                    .into_iter()
18344                    .map(|p| ("last_updated__gt".to_owned(), p.to_string()))
18345                    .collect::<Vec<(std::string::String, std::string::String)>>(),
18346            ),
18347            _ => local_var_req_builder.query(&[(
18348                "last_updated__gt",
18349                &local_var_str
18350                    .into_iter()
18351                    .map(|p| p.to_string())
18352                    .collect::<Vec<String>>()
18353                    .join(",")
18354                    .to_string(),
18355            )]),
18356        };
18357    }
18358    if let Some(ref local_var_str) = last_updated__gte {
18359        local_var_req_builder = match "multi" {
18360            "multi" => local_var_req_builder.query(
18361                &local_var_str
18362                    .into_iter()
18363                    .map(|p| ("last_updated__gte".to_owned(), p.to_string()))
18364                    .collect::<Vec<(std::string::String, std::string::String)>>(),
18365            ),
18366            _ => local_var_req_builder.query(&[(
18367                "last_updated__gte",
18368                &local_var_str
18369                    .into_iter()
18370                    .map(|p| p.to_string())
18371                    .collect::<Vec<String>>()
18372                    .join(",")
18373                    .to_string(),
18374            )]),
18375        };
18376    }
18377    if let Some(ref local_var_str) = last_updated__lt {
18378        local_var_req_builder = match "multi" {
18379            "multi" => local_var_req_builder.query(
18380                &local_var_str
18381                    .into_iter()
18382                    .map(|p| ("last_updated__lt".to_owned(), p.to_string()))
18383                    .collect::<Vec<(std::string::String, std::string::String)>>(),
18384            ),
18385            _ => local_var_req_builder.query(&[(
18386                "last_updated__lt",
18387                &local_var_str
18388                    .into_iter()
18389                    .map(|p| p.to_string())
18390                    .collect::<Vec<String>>()
18391                    .join(",")
18392                    .to_string(),
18393            )]),
18394        };
18395    }
18396    if let Some(ref local_var_str) = last_updated__lte {
18397        local_var_req_builder = match "multi" {
18398            "multi" => local_var_req_builder.query(
18399                &local_var_str
18400                    .into_iter()
18401                    .map(|p| ("last_updated__lte".to_owned(), p.to_string()))
18402                    .collect::<Vec<(std::string::String, std::string::String)>>(),
18403            ),
18404            _ => local_var_req_builder.query(&[(
18405                "last_updated__lte",
18406                &local_var_str
18407                    .into_iter()
18408                    .map(|p| p.to_string())
18409                    .collect::<Vec<String>>()
18410                    .join(",")
18411                    .to_string(),
18412            )]),
18413        };
18414    }
18415    if let Some(ref local_var_str) = last_updated__n {
18416        local_var_req_builder = match "multi" {
18417            "multi" => local_var_req_builder.query(
18418                &local_var_str
18419                    .into_iter()
18420                    .map(|p| ("last_updated__n".to_owned(), p.to_string()))
18421                    .collect::<Vec<(std::string::String, std::string::String)>>(),
18422            ),
18423            _ => local_var_req_builder.query(&[(
18424                "last_updated__n",
18425                &local_var_str
18426                    .into_iter()
18427                    .map(|p| p.to_string())
18428                    .collect::<Vec<String>>()
18429                    .join(",")
18430                    .to_string(),
18431            )]),
18432        };
18433    }
18434    if let Some(ref local_var_str) = limit {
18435        local_var_req_builder =
18436            local_var_req_builder.query(&[("limit", &local_var_str.to_string())]);
18437    }
18438    if let Some(ref local_var_str) = modified_by_request {
18439        local_var_req_builder =
18440            local_var_req_builder.query(&[("modified_by_request", &local_var_str.to_string())]);
18441    }
18442    if let Some(ref local_var_str) = name {
18443        local_var_req_builder = match "multi" {
18444            "multi" => local_var_req_builder.query(
18445                &local_var_str
18446                    .into_iter()
18447                    .map(|p| ("name".to_owned(), p.to_string()))
18448                    .collect::<Vec<(std::string::String, std::string::String)>>(),
18449            ),
18450            _ => local_var_req_builder.query(&[(
18451                "name",
18452                &local_var_str
18453                    .into_iter()
18454                    .map(|p| p.to_string())
18455                    .collect::<Vec<String>>()
18456                    .join(",")
18457                    .to_string(),
18458            )]),
18459        };
18460    }
18461    if let Some(ref local_var_str) = name__empty {
18462        local_var_req_builder =
18463            local_var_req_builder.query(&[("name__empty", &local_var_str.to_string())]);
18464    }
18465    if let Some(ref local_var_str) = name__ic {
18466        local_var_req_builder = match "multi" {
18467            "multi" => local_var_req_builder.query(
18468                &local_var_str
18469                    .into_iter()
18470                    .map(|p| ("name__ic".to_owned(), p.to_string()))
18471                    .collect::<Vec<(std::string::String, std::string::String)>>(),
18472            ),
18473            _ => local_var_req_builder.query(&[(
18474                "name__ic",
18475                &local_var_str
18476                    .into_iter()
18477                    .map(|p| p.to_string())
18478                    .collect::<Vec<String>>()
18479                    .join(",")
18480                    .to_string(),
18481            )]),
18482        };
18483    }
18484    if let Some(ref local_var_str) = name__ie {
18485        local_var_req_builder = match "multi" {
18486            "multi" => local_var_req_builder.query(
18487                &local_var_str
18488                    .into_iter()
18489                    .map(|p| ("name__ie".to_owned(), p.to_string()))
18490                    .collect::<Vec<(std::string::String, std::string::String)>>(),
18491            ),
18492            _ => local_var_req_builder.query(&[(
18493                "name__ie",
18494                &local_var_str
18495                    .into_iter()
18496                    .map(|p| p.to_string())
18497                    .collect::<Vec<String>>()
18498                    .join(",")
18499                    .to_string(),
18500            )]),
18501        };
18502    }
18503    if let Some(ref local_var_str) = name__iew {
18504        local_var_req_builder = match "multi" {
18505            "multi" => local_var_req_builder.query(
18506                &local_var_str
18507                    .into_iter()
18508                    .map(|p| ("name__iew".to_owned(), p.to_string()))
18509                    .collect::<Vec<(std::string::String, std::string::String)>>(),
18510            ),
18511            _ => local_var_req_builder.query(&[(
18512                "name__iew",
18513                &local_var_str
18514                    .into_iter()
18515                    .map(|p| p.to_string())
18516                    .collect::<Vec<String>>()
18517                    .join(",")
18518                    .to_string(),
18519            )]),
18520        };
18521    }
18522    if let Some(ref local_var_str) = name__iregex {
18523        local_var_req_builder = match "multi" {
18524            "multi" => local_var_req_builder.query(
18525                &local_var_str
18526                    .into_iter()
18527                    .map(|p| ("name__iregex".to_owned(), p.to_string()))
18528                    .collect::<Vec<(std::string::String, std::string::String)>>(),
18529            ),
18530            _ => local_var_req_builder.query(&[(
18531                "name__iregex",
18532                &local_var_str
18533                    .into_iter()
18534                    .map(|p| p.to_string())
18535                    .collect::<Vec<String>>()
18536                    .join(",")
18537                    .to_string(),
18538            )]),
18539        };
18540    }
18541    if let Some(ref local_var_str) = name__isw {
18542        local_var_req_builder = match "multi" {
18543            "multi" => local_var_req_builder.query(
18544                &local_var_str
18545                    .into_iter()
18546                    .map(|p| ("name__isw".to_owned(), p.to_string()))
18547                    .collect::<Vec<(std::string::String, std::string::String)>>(),
18548            ),
18549            _ => local_var_req_builder.query(&[(
18550                "name__isw",
18551                &local_var_str
18552                    .into_iter()
18553                    .map(|p| p.to_string())
18554                    .collect::<Vec<String>>()
18555                    .join(",")
18556                    .to_string(),
18557            )]),
18558        };
18559    }
18560    if let Some(ref local_var_str) = name__n {
18561        local_var_req_builder = match "multi" {
18562            "multi" => local_var_req_builder.query(
18563                &local_var_str
18564                    .into_iter()
18565                    .map(|p| ("name__n".to_owned(), p.to_string()))
18566                    .collect::<Vec<(std::string::String, std::string::String)>>(),
18567            ),
18568            _ => local_var_req_builder.query(&[(
18569                "name__n",
18570                &local_var_str
18571                    .into_iter()
18572                    .map(|p| p.to_string())
18573                    .collect::<Vec<String>>()
18574                    .join(",")
18575                    .to_string(),
18576            )]),
18577        };
18578    }
18579    if let Some(ref local_var_str) = name__nic {
18580        local_var_req_builder = match "multi" {
18581            "multi" => local_var_req_builder.query(
18582                &local_var_str
18583                    .into_iter()
18584                    .map(|p| ("name__nic".to_owned(), p.to_string()))
18585                    .collect::<Vec<(std::string::String, std::string::String)>>(),
18586            ),
18587            _ => local_var_req_builder.query(&[(
18588                "name__nic",
18589                &local_var_str
18590                    .into_iter()
18591                    .map(|p| p.to_string())
18592                    .collect::<Vec<String>>()
18593                    .join(",")
18594                    .to_string(),
18595            )]),
18596        };
18597    }
18598    if let Some(ref local_var_str) = name__nie {
18599        local_var_req_builder = match "multi" {
18600            "multi" => local_var_req_builder.query(
18601                &local_var_str
18602                    .into_iter()
18603                    .map(|p| ("name__nie".to_owned(), p.to_string()))
18604                    .collect::<Vec<(std::string::String, std::string::String)>>(),
18605            ),
18606            _ => local_var_req_builder.query(&[(
18607                "name__nie",
18608                &local_var_str
18609                    .into_iter()
18610                    .map(|p| p.to_string())
18611                    .collect::<Vec<String>>()
18612                    .join(",")
18613                    .to_string(),
18614            )]),
18615        };
18616    }
18617    if let Some(ref local_var_str) = name__niew {
18618        local_var_req_builder = match "multi" {
18619            "multi" => local_var_req_builder.query(
18620                &local_var_str
18621                    .into_iter()
18622                    .map(|p| ("name__niew".to_owned(), p.to_string()))
18623                    .collect::<Vec<(std::string::String, std::string::String)>>(),
18624            ),
18625            _ => local_var_req_builder.query(&[(
18626                "name__niew",
18627                &local_var_str
18628                    .into_iter()
18629                    .map(|p| p.to_string())
18630                    .collect::<Vec<String>>()
18631                    .join(",")
18632                    .to_string(),
18633            )]),
18634        };
18635    }
18636    if let Some(ref local_var_str) = name__nisw {
18637        local_var_req_builder = match "multi" {
18638            "multi" => local_var_req_builder.query(
18639                &local_var_str
18640                    .into_iter()
18641                    .map(|p| ("name__nisw".to_owned(), p.to_string()))
18642                    .collect::<Vec<(std::string::String, std::string::String)>>(),
18643            ),
18644            _ => local_var_req_builder.query(&[(
18645                "name__nisw",
18646                &local_var_str
18647                    .into_iter()
18648                    .map(|p| p.to_string())
18649                    .collect::<Vec<String>>()
18650                    .join(",")
18651                    .to_string(),
18652            )]),
18653        };
18654    }
18655    if let Some(ref local_var_str) = name__regex {
18656        local_var_req_builder = match "multi" {
18657            "multi" => local_var_req_builder.query(
18658                &local_var_str
18659                    .into_iter()
18660                    .map(|p| ("name__regex".to_owned(), p.to_string()))
18661                    .collect::<Vec<(std::string::String, std::string::String)>>(),
18662            ),
18663            _ => local_var_req_builder.query(&[(
18664                "name__regex",
18665                &local_var_str
18666                    .into_iter()
18667                    .map(|p| p.to_string())
18668                    .collect::<Vec<String>>()
18669                    .join(",")
18670                    .to_string(),
18671            )]),
18672        };
18673    }
18674    if let Some(ref local_var_str) = offset {
18675        local_var_req_builder =
18676            local_var_req_builder.query(&[("offset", &local_var_str.to_string())]);
18677    }
18678    if let Some(ref local_var_str) = ordering {
18679        local_var_req_builder =
18680            local_var_req_builder.query(&[("ordering", &local_var_str.to_string())]);
18681    }
18682    if let Some(ref local_var_str) = owner {
18683        local_var_req_builder = match "multi" {
18684            "multi" => local_var_req_builder.query(
18685                &local_var_str
18686                    .into_iter()
18687                    .map(|p| ("owner".to_owned(), p.to_string()))
18688                    .collect::<Vec<(std::string::String, std::string::String)>>(),
18689            ),
18690            _ => local_var_req_builder.query(&[(
18691                "owner",
18692                &local_var_str
18693                    .into_iter()
18694                    .map(|p| p.to_string())
18695                    .collect::<Vec<String>>()
18696                    .join(",")
18697                    .to_string(),
18698            )]),
18699        };
18700    }
18701    if let Some(ref local_var_str) = owner__n {
18702        local_var_req_builder = match "multi" {
18703            "multi" => local_var_req_builder.query(
18704                &local_var_str
18705                    .into_iter()
18706                    .map(|p| ("owner__n".to_owned(), p.to_string()))
18707                    .collect::<Vec<(std::string::String, std::string::String)>>(),
18708            ),
18709            _ => local_var_req_builder.query(&[(
18710                "owner__n",
18711                &local_var_str
18712                    .into_iter()
18713                    .map(|p| p.to_string())
18714                    .collect::<Vec<String>>()
18715                    .join(",")
18716                    .to_string(),
18717            )]),
18718        };
18719    }
18720    if let Some(ref local_var_str) = owner_group {
18721        local_var_req_builder = match "multi" {
18722            "multi" => local_var_req_builder.query(
18723                &local_var_str
18724                    .into_iter()
18725                    .map(|p| ("owner_group".to_owned(), p.to_string()))
18726                    .collect::<Vec<(std::string::String, std::string::String)>>(),
18727            ),
18728            _ => local_var_req_builder.query(&[(
18729                "owner_group",
18730                &local_var_str
18731                    .into_iter()
18732                    .map(|p| p.to_string())
18733                    .collect::<Vec<String>>()
18734                    .join(",")
18735                    .to_string(),
18736            )]),
18737        };
18738    }
18739    if let Some(ref local_var_str) = owner_group__n {
18740        local_var_req_builder = match "multi" {
18741            "multi" => local_var_req_builder.query(
18742                &local_var_str
18743                    .into_iter()
18744                    .map(|p| ("owner_group__n".to_owned(), p.to_string()))
18745                    .collect::<Vec<(std::string::String, std::string::String)>>(),
18746            ),
18747            _ => local_var_req_builder.query(&[(
18748                "owner_group__n",
18749                &local_var_str
18750                    .into_iter()
18751                    .map(|p| p.to_string())
18752                    .collect::<Vec<String>>()
18753                    .join(",")
18754                    .to_string(),
18755            )]),
18756        };
18757    }
18758    if let Some(ref local_var_str) = owner_group_id {
18759        local_var_req_builder = match "multi" {
18760            "multi" => local_var_req_builder.query(
18761                &local_var_str
18762                    .into_iter()
18763                    .map(|p| ("owner_group_id".to_owned(), p.to_string()))
18764                    .collect::<Vec<(std::string::String, std::string::String)>>(),
18765            ),
18766            _ => local_var_req_builder.query(&[(
18767                "owner_group_id",
18768                &local_var_str
18769                    .into_iter()
18770                    .map(|p| p.to_string())
18771                    .collect::<Vec<String>>()
18772                    .join(",")
18773                    .to_string(),
18774            )]),
18775        };
18776    }
18777    if let Some(ref local_var_str) = owner_group_id__n {
18778        local_var_req_builder = match "multi" {
18779            "multi" => local_var_req_builder.query(
18780                &local_var_str
18781                    .into_iter()
18782                    .map(|p| ("owner_group_id__n".to_owned(), p.to_string()))
18783                    .collect::<Vec<(std::string::String, std::string::String)>>(),
18784            ),
18785            _ => local_var_req_builder.query(&[(
18786                "owner_group_id__n",
18787                &local_var_str
18788                    .into_iter()
18789                    .map(|p| p.to_string())
18790                    .collect::<Vec<String>>()
18791                    .join(",")
18792                    .to_string(),
18793            )]),
18794        };
18795    }
18796    if let Some(ref local_var_str) = owner_id {
18797        local_var_req_builder = match "multi" {
18798            "multi" => local_var_req_builder.query(
18799                &local_var_str
18800                    .into_iter()
18801                    .map(|p| ("owner_id".to_owned(), p.to_string()))
18802                    .collect::<Vec<(std::string::String, std::string::String)>>(),
18803            ),
18804            _ => local_var_req_builder.query(&[(
18805                "owner_id",
18806                &local_var_str
18807                    .into_iter()
18808                    .map(|p| p.to_string())
18809                    .collect::<Vec<String>>()
18810                    .join(",")
18811                    .to_string(),
18812            )]),
18813        };
18814    }
18815    if let Some(ref local_var_str) = owner_id__n {
18816        local_var_req_builder = match "multi" {
18817            "multi" => local_var_req_builder.query(
18818                &local_var_str
18819                    .into_iter()
18820                    .map(|p| ("owner_id__n".to_owned(), p.to_string()))
18821                    .collect::<Vec<(std::string::String, std::string::String)>>(),
18822            ),
18823            _ => local_var_req_builder.query(&[(
18824                "owner_id__n",
18825                &local_var_str
18826                    .into_iter()
18827                    .map(|p| p.to_string())
18828                    .collect::<Vec<String>>()
18829                    .join(",")
18830                    .to_string(),
18831            )]),
18832        };
18833    }
18834    if let Some(ref local_var_str) = q {
18835        local_var_req_builder = local_var_req_builder.query(&[("q", &local_var_str.to_string())]);
18836    }
18837    if let Some(ref local_var_str) = region {
18838        local_var_req_builder = match "multi" {
18839            "multi" => local_var_req_builder.query(
18840                &local_var_str
18841                    .into_iter()
18842                    .map(|p| ("region".to_owned(), p.to_string()))
18843                    .collect::<Vec<(std::string::String, std::string::String)>>(),
18844            ),
18845            _ => local_var_req_builder.query(&[(
18846                "region",
18847                &local_var_str
18848                    .into_iter()
18849                    .map(|p| p.to_string())
18850                    .collect::<Vec<String>>()
18851                    .join(",")
18852                    .to_string(),
18853            )]),
18854        };
18855    }
18856    if let Some(ref local_var_str) = region__n {
18857        local_var_req_builder = match "multi" {
18858            "multi" => local_var_req_builder.query(
18859                &local_var_str
18860                    .into_iter()
18861                    .map(|p| ("region__n".to_owned(), p.to_string()))
18862                    .collect::<Vec<(std::string::String, std::string::String)>>(),
18863            ),
18864            _ => local_var_req_builder.query(&[(
18865                "region__n",
18866                &local_var_str
18867                    .into_iter()
18868                    .map(|p| p.to_string())
18869                    .collect::<Vec<String>>()
18870                    .join(",")
18871                    .to_string(),
18872            )]),
18873        };
18874    }
18875    if let Some(ref local_var_str) = region_id {
18876        local_var_req_builder = match "multi" {
18877            "multi" => local_var_req_builder.query(
18878                &local_var_str
18879                    .into_iter()
18880                    .map(|p| ("region_id".to_owned(), p.to_string()))
18881                    .collect::<Vec<(std::string::String, std::string::String)>>(),
18882            ),
18883            _ => local_var_req_builder.query(&[(
18884                "region_id",
18885                &local_var_str
18886                    .into_iter()
18887                    .map(|p| p.to_string())
18888                    .collect::<Vec<String>>()
18889                    .join(",")
18890                    .to_string(),
18891            )]),
18892        };
18893    }
18894    if let Some(ref local_var_str) = region_id__n {
18895        local_var_req_builder = match "multi" {
18896            "multi" => local_var_req_builder.query(
18897                &local_var_str
18898                    .into_iter()
18899                    .map(|p| ("region_id__n".to_owned(), p.to_string()))
18900                    .collect::<Vec<(std::string::String, std::string::String)>>(),
18901            ),
18902            _ => local_var_req_builder.query(&[(
18903                "region_id__n",
18904                &local_var_str
18905                    .into_iter()
18906                    .map(|p| p.to_string())
18907                    .collect::<Vec<String>>()
18908                    .join(",")
18909                    .to_string(),
18910            )]),
18911        };
18912    }
18913    if let Some(ref local_var_str) = site {
18914        local_var_req_builder = match "multi" {
18915            "multi" => local_var_req_builder.query(
18916                &local_var_str
18917                    .into_iter()
18918                    .map(|p| ("site".to_owned(), p.to_string()))
18919                    .collect::<Vec<(std::string::String, std::string::String)>>(),
18920            ),
18921            _ => local_var_req_builder.query(&[(
18922                "site",
18923                &local_var_str
18924                    .into_iter()
18925                    .map(|p| p.to_string())
18926                    .collect::<Vec<String>>()
18927                    .join(",")
18928                    .to_string(),
18929            )]),
18930        };
18931    }
18932    if let Some(ref local_var_str) = site__n {
18933        local_var_req_builder = match "multi" {
18934            "multi" => local_var_req_builder.query(
18935                &local_var_str
18936                    .into_iter()
18937                    .map(|p| ("site__n".to_owned(), p.to_string()))
18938                    .collect::<Vec<(std::string::String, std::string::String)>>(),
18939            ),
18940            _ => local_var_req_builder.query(&[(
18941                "site__n",
18942                &local_var_str
18943                    .into_iter()
18944                    .map(|p| p.to_string())
18945                    .collect::<Vec<String>>()
18946                    .join(",")
18947                    .to_string(),
18948            )]),
18949        };
18950    }
18951    if let Some(ref local_var_str) = site_group {
18952        local_var_req_builder = match "multi" {
18953            "multi" => local_var_req_builder.query(
18954                &local_var_str
18955                    .into_iter()
18956                    .map(|p| ("site_group".to_owned(), p.to_string()))
18957                    .collect::<Vec<(std::string::String, std::string::String)>>(),
18958            ),
18959            _ => local_var_req_builder.query(&[(
18960                "site_group",
18961                &local_var_str
18962                    .into_iter()
18963                    .map(|p| p.to_string())
18964                    .collect::<Vec<String>>()
18965                    .join(",")
18966                    .to_string(),
18967            )]),
18968        };
18969    }
18970    if let Some(ref local_var_str) = site_group__n {
18971        local_var_req_builder = match "multi" {
18972            "multi" => local_var_req_builder.query(
18973                &local_var_str
18974                    .into_iter()
18975                    .map(|p| ("site_group__n".to_owned(), p.to_string()))
18976                    .collect::<Vec<(std::string::String, std::string::String)>>(),
18977            ),
18978            _ => local_var_req_builder.query(&[(
18979                "site_group__n",
18980                &local_var_str
18981                    .into_iter()
18982                    .map(|p| p.to_string())
18983                    .collect::<Vec<String>>()
18984                    .join(",")
18985                    .to_string(),
18986            )]),
18987        };
18988    }
18989    if let Some(ref local_var_str) = site_group_id {
18990        local_var_req_builder = match "multi" {
18991            "multi" => local_var_req_builder.query(
18992                &local_var_str
18993                    .into_iter()
18994                    .map(|p| ("site_group_id".to_owned(), p.to_string()))
18995                    .collect::<Vec<(std::string::String, std::string::String)>>(),
18996            ),
18997            _ => local_var_req_builder.query(&[(
18998                "site_group_id",
18999                &local_var_str
19000                    .into_iter()
19001                    .map(|p| p.to_string())
19002                    .collect::<Vec<String>>()
19003                    .join(",")
19004                    .to_string(),
19005            )]),
19006        };
19007    }
19008    if let Some(ref local_var_str) = site_group_id__n {
19009        local_var_req_builder = match "multi" {
19010            "multi" => local_var_req_builder.query(
19011                &local_var_str
19012                    .into_iter()
19013                    .map(|p| ("site_group_id__n".to_owned(), p.to_string()))
19014                    .collect::<Vec<(std::string::String, std::string::String)>>(),
19015            ),
19016            _ => local_var_req_builder.query(&[(
19017                "site_group_id__n",
19018                &local_var_str
19019                    .into_iter()
19020                    .map(|p| p.to_string())
19021                    .collect::<Vec<String>>()
19022                    .join(",")
19023                    .to_string(),
19024            )]),
19025        };
19026    }
19027    if let Some(ref local_var_str) = site_id {
19028        local_var_req_builder = match "multi" {
19029            "multi" => local_var_req_builder.query(
19030                &local_var_str
19031                    .into_iter()
19032                    .map(|p| ("site_id".to_owned(), p.to_string()))
19033                    .collect::<Vec<(std::string::String, std::string::String)>>(),
19034            ),
19035            _ => local_var_req_builder.query(&[(
19036                "site_id",
19037                &local_var_str
19038                    .into_iter()
19039                    .map(|p| p.to_string())
19040                    .collect::<Vec<String>>()
19041                    .join(",")
19042                    .to_string(),
19043            )]),
19044        };
19045    }
19046    if let Some(ref local_var_str) = site_id__n {
19047        local_var_req_builder = match "multi" {
19048            "multi" => local_var_req_builder.query(
19049                &local_var_str
19050                    .into_iter()
19051                    .map(|p| ("site_id__n".to_owned(), p.to_string()))
19052                    .collect::<Vec<(std::string::String, std::string::String)>>(),
19053            ),
19054            _ => local_var_req_builder.query(&[(
19055                "site_id__n",
19056                &local_var_str
19057                    .into_iter()
19058                    .map(|p| p.to_string())
19059                    .collect::<Vec<String>>()
19060                    .join(",")
19061                    .to_string(),
19062            )]),
19063        };
19064    }
19065    if let Some(ref local_var_str) = slug {
19066        local_var_req_builder = match "multi" {
19067            "multi" => local_var_req_builder.query(
19068                &local_var_str
19069                    .into_iter()
19070                    .map(|p| ("slug".to_owned(), p.to_string()))
19071                    .collect::<Vec<(std::string::String, std::string::String)>>(),
19072            ),
19073            _ => local_var_req_builder.query(&[(
19074                "slug",
19075                &local_var_str
19076                    .into_iter()
19077                    .map(|p| p.to_string())
19078                    .collect::<Vec<String>>()
19079                    .join(",")
19080                    .to_string(),
19081            )]),
19082        };
19083    }
19084    if let Some(ref local_var_str) = slug__empty {
19085        local_var_req_builder =
19086            local_var_req_builder.query(&[("slug__empty", &local_var_str.to_string())]);
19087    }
19088    if let Some(ref local_var_str) = slug__ic {
19089        local_var_req_builder = match "multi" {
19090            "multi" => local_var_req_builder.query(
19091                &local_var_str
19092                    .into_iter()
19093                    .map(|p| ("slug__ic".to_owned(), p.to_string()))
19094                    .collect::<Vec<(std::string::String, std::string::String)>>(),
19095            ),
19096            _ => local_var_req_builder.query(&[(
19097                "slug__ic",
19098                &local_var_str
19099                    .into_iter()
19100                    .map(|p| p.to_string())
19101                    .collect::<Vec<String>>()
19102                    .join(",")
19103                    .to_string(),
19104            )]),
19105        };
19106    }
19107    if let Some(ref local_var_str) = slug__ie {
19108        local_var_req_builder = match "multi" {
19109            "multi" => local_var_req_builder.query(
19110                &local_var_str
19111                    .into_iter()
19112                    .map(|p| ("slug__ie".to_owned(), p.to_string()))
19113                    .collect::<Vec<(std::string::String, std::string::String)>>(),
19114            ),
19115            _ => local_var_req_builder.query(&[(
19116                "slug__ie",
19117                &local_var_str
19118                    .into_iter()
19119                    .map(|p| p.to_string())
19120                    .collect::<Vec<String>>()
19121                    .join(",")
19122                    .to_string(),
19123            )]),
19124        };
19125    }
19126    if let Some(ref local_var_str) = slug__iew {
19127        local_var_req_builder = match "multi" {
19128            "multi" => local_var_req_builder.query(
19129                &local_var_str
19130                    .into_iter()
19131                    .map(|p| ("slug__iew".to_owned(), p.to_string()))
19132                    .collect::<Vec<(std::string::String, std::string::String)>>(),
19133            ),
19134            _ => local_var_req_builder.query(&[(
19135                "slug__iew",
19136                &local_var_str
19137                    .into_iter()
19138                    .map(|p| p.to_string())
19139                    .collect::<Vec<String>>()
19140                    .join(",")
19141                    .to_string(),
19142            )]),
19143        };
19144    }
19145    if let Some(ref local_var_str) = slug__iregex {
19146        local_var_req_builder = match "multi" {
19147            "multi" => local_var_req_builder.query(
19148                &local_var_str
19149                    .into_iter()
19150                    .map(|p| ("slug__iregex".to_owned(), p.to_string()))
19151                    .collect::<Vec<(std::string::String, std::string::String)>>(),
19152            ),
19153            _ => local_var_req_builder.query(&[(
19154                "slug__iregex",
19155                &local_var_str
19156                    .into_iter()
19157                    .map(|p| p.to_string())
19158                    .collect::<Vec<String>>()
19159                    .join(",")
19160                    .to_string(),
19161            )]),
19162        };
19163    }
19164    if let Some(ref local_var_str) = slug__isw {
19165        local_var_req_builder = match "multi" {
19166            "multi" => local_var_req_builder.query(
19167                &local_var_str
19168                    .into_iter()
19169                    .map(|p| ("slug__isw".to_owned(), p.to_string()))
19170                    .collect::<Vec<(std::string::String, std::string::String)>>(),
19171            ),
19172            _ => local_var_req_builder.query(&[(
19173                "slug__isw",
19174                &local_var_str
19175                    .into_iter()
19176                    .map(|p| p.to_string())
19177                    .collect::<Vec<String>>()
19178                    .join(",")
19179                    .to_string(),
19180            )]),
19181        };
19182    }
19183    if let Some(ref local_var_str) = slug__n {
19184        local_var_req_builder = match "multi" {
19185            "multi" => local_var_req_builder.query(
19186                &local_var_str
19187                    .into_iter()
19188                    .map(|p| ("slug__n".to_owned(), p.to_string()))
19189                    .collect::<Vec<(std::string::String, std::string::String)>>(),
19190            ),
19191            _ => local_var_req_builder.query(&[(
19192                "slug__n",
19193                &local_var_str
19194                    .into_iter()
19195                    .map(|p| p.to_string())
19196                    .collect::<Vec<String>>()
19197                    .join(",")
19198                    .to_string(),
19199            )]),
19200        };
19201    }
19202    if let Some(ref local_var_str) = slug__nic {
19203        local_var_req_builder = match "multi" {
19204            "multi" => local_var_req_builder.query(
19205                &local_var_str
19206                    .into_iter()
19207                    .map(|p| ("slug__nic".to_owned(), p.to_string()))
19208                    .collect::<Vec<(std::string::String, std::string::String)>>(),
19209            ),
19210            _ => local_var_req_builder.query(&[(
19211                "slug__nic",
19212                &local_var_str
19213                    .into_iter()
19214                    .map(|p| p.to_string())
19215                    .collect::<Vec<String>>()
19216                    .join(",")
19217                    .to_string(),
19218            )]),
19219        };
19220    }
19221    if let Some(ref local_var_str) = slug__nie {
19222        local_var_req_builder = match "multi" {
19223            "multi" => local_var_req_builder.query(
19224                &local_var_str
19225                    .into_iter()
19226                    .map(|p| ("slug__nie".to_owned(), p.to_string()))
19227                    .collect::<Vec<(std::string::String, std::string::String)>>(),
19228            ),
19229            _ => local_var_req_builder.query(&[(
19230                "slug__nie",
19231                &local_var_str
19232                    .into_iter()
19233                    .map(|p| p.to_string())
19234                    .collect::<Vec<String>>()
19235                    .join(",")
19236                    .to_string(),
19237            )]),
19238        };
19239    }
19240    if let Some(ref local_var_str) = slug__niew {
19241        local_var_req_builder = match "multi" {
19242            "multi" => local_var_req_builder.query(
19243                &local_var_str
19244                    .into_iter()
19245                    .map(|p| ("slug__niew".to_owned(), p.to_string()))
19246                    .collect::<Vec<(std::string::String, std::string::String)>>(),
19247            ),
19248            _ => local_var_req_builder.query(&[(
19249                "slug__niew",
19250                &local_var_str
19251                    .into_iter()
19252                    .map(|p| p.to_string())
19253                    .collect::<Vec<String>>()
19254                    .join(",")
19255                    .to_string(),
19256            )]),
19257        };
19258    }
19259    if let Some(ref local_var_str) = slug__nisw {
19260        local_var_req_builder = match "multi" {
19261            "multi" => local_var_req_builder.query(
19262                &local_var_str
19263                    .into_iter()
19264                    .map(|p| ("slug__nisw".to_owned(), p.to_string()))
19265                    .collect::<Vec<(std::string::String, std::string::String)>>(),
19266            ),
19267            _ => local_var_req_builder.query(&[(
19268                "slug__nisw",
19269                &local_var_str
19270                    .into_iter()
19271                    .map(|p| p.to_string())
19272                    .collect::<Vec<String>>()
19273                    .join(",")
19274                    .to_string(),
19275            )]),
19276        };
19277    }
19278    if let Some(ref local_var_str) = slug__regex {
19279        local_var_req_builder = match "multi" {
19280            "multi" => local_var_req_builder.query(
19281                &local_var_str
19282                    .into_iter()
19283                    .map(|p| ("slug__regex".to_owned(), p.to_string()))
19284                    .collect::<Vec<(std::string::String, std::string::String)>>(),
19285            ),
19286            _ => local_var_req_builder.query(&[(
19287                "slug__regex",
19288                &local_var_str
19289                    .into_iter()
19290                    .map(|p| p.to_string())
19291                    .collect::<Vec<String>>()
19292                    .join(",")
19293                    .to_string(),
19294            )]),
19295        };
19296    }
19297    if let Some(ref local_var_str) = start {
19298        local_var_req_builder =
19299            local_var_req_builder.query(&[("start", &local_var_str.to_string())]);
19300    }
19301    if let Some(ref local_var_str) = tag {
19302        local_var_req_builder = match "multi" {
19303            "multi" => local_var_req_builder.query(
19304                &local_var_str
19305                    .into_iter()
19306                    .map(|p| ("tag".to_owned(), p.to_string()))
19307                    .collect::<Vec<(std::string::String, std::string::String)>>(),
19308            ),
19309            _ => local_var_req_builder.query(&[(
19310                "tag",
19311                &local_var_str
19312                    .into_iter()
19313                    .map(|p| p.to_string())
19314                    .collect::<Vec<String>>()
19315                    .join(",")
19316                    .to_string(),
19317            )]),
19318        };
19319    }
19320    if let Some(ref local_var_str) = tag__n {
19321        local_var_req_builder = match "multi" {
19322            "multi" => local_var_req_builder.query(
19323                &local_var_str
19324                    .into_iter()
19325                    .map(|p| ("tag__n".to_owned(), p.to_string()))
19326                    .collect::<Vec<(std::string::String, std::string::String)>>(),
19327            ),
19328            _ => local_var_req_builder.query(&[(
19329                "tag__n",
19330                &local_var_str
19331                    .into_iter()
19332                    .map(|p| p.to_string())
19333                    .collect::<Vec<String>>()
19334                    .join(",")
19335                    .to_string(),
19336            )]),
19337        };
19338    }
19339    if let Some(ref local_var_str) = tag_id {
19340        local_var_req_builder = match "multi" {
19341            "multi" => local_var_req_builder.query(
19342                &local_var_str
19343                    .into_iter()
19344                    .map(|p| ("tag_id".to_owned(), p.to_string()))
19345                    .collect::<Vec<(std::string::String, std::string::String)>>(),
19346            ),
19347            _ => local_var_req_builder.query(&[(
19348                "tag_id",
19349                &local_var_str
19350                    .into_iter()
19351                    .map(|p| p.to_string())
19352                    .collect::<Vec<String>>()
19353                    .join(",")
19354                    .to_string(),
19355            )]),
19356        };
19357    }
19358    if let Some(ref local_var_str) = tag_id__n {
19359        local_var_req_builder = match "multi" {
19360            "multi" => local_var_req_builder.query(
19361                &local_var_str
19362                    .into_iter()
19363                    .map(|p| ("tag_id__n".to_owned(), p.to_string()))
19364                    .collect::<Vec<(std::string::String, std::string::String)>>(),
19365            ),
19366            _ => local_var_req_builder.query(&[(
19367                "tag_id__n",
19368                &local_var_str
19369                    .into_iter()
19370                    .map(|p| p.to_string())
19371                    .collect::<Vec<String>>()
19372                    .join(",")
19373                    .to_string(),
19374            )]),
19375        };
19376    }
19377    if let Some(ref local_var_str) = updated_by_request {
19378        local_var_req_builder =
19379            local_var_req_builder.query(&[("updated_by_request", &local_var_str.to_string())]);
19380    }
19381    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
19382        local_var_req_builder =
19383            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
19384    }
19385    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
19386        let local_var_key = local_var_apikey.key.clone();
19387        let local_var_value = match local_var_apikey.prefix {
19388            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
19389            None => local_var_key,
19390        };
19391        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
19392    };
19393
19394    let local_var_req = local_var_req_builder.build()?;
19395    let local_var_resp = local_var_client.execute(local_var_req).await?;
19396
19397    let local_var_status = local_var_resp.status();
19398    let local_var_content = local_var_resp.text().await?;
19399
19400    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
19401        serde_json::from_str(&local_var_content).map_err(Error::from)
19402    } else {
19403        let local_var_entity: Option<CircuitsProvidersListError> =
19404            serde_json::from_str(&local_var_content).ok();
19405        let local_var_error = ResponseContent {
19406            status: local_var_status,
19407            content: local_var_content,
19408            entity: local_var_entity,
19409        };
19410        Err(Error::ResponseError(local_var_error))
19411    }
19412}
19413
19414/// Patch a provider object.
19415pub async fn circuits_providers_partial_update(
19416    configuration: &configuration::Configuration,
19417    id: i32,
19418    patched_provider_request: Option<crate::models::PatchedProviderRequest>,
19419) -> Result<crate::models::Provider, Error<CircuitsProvidersPartialUpdateError>> {
19420    let local_var_configuration = configuration;
19421
19422    let local_var_client = &local_var_configuration.client;
19423
19424    let local_var_uri_str = format!(
19425        "{}/api/circuits/providers/{id}/",
19426        local_var_configuration.base_path,
19427        id = id
19428    );
19429    let mut local_var_req_builder =
19430        local_var_client.request(reqwest::Method::PATCH, local_var_uri_str.as_str());
19431
19432    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
19433        local_var_req_builder =
19434            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
19435    }
19436    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
19437        let local_var_key = local_var_apikey.key.clone();
19438        let local_var_value = match local_var_apikey.prefix {
19439            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
19440            None => local_var_key,
19441        };
19442        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
19443    };
19444    local_var_req_builder = local_var_req_builder.json(&patched_provider_request);
19445
19446    let local_var_req = local_var_req_builder.build()?;
19447    let local_var_resp = local_var_client.execute(local_var_req).await?;
19448
19449    let local_var_status = local_var_resp.status();
19450    let local_var_content = local_var_resp.text().await?;
19451
19452    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
19453        serde_json::from_str(&local_var_content).map_err(Error::from)
19454    } else {
19455        let local_var_entity: Option<CircuitsProvidersPartialUpdateError> =
19456            serde_json::from_str(&local_var_content).ok();
19457        let local_var_error = ResponseContent {
19458            status: local_var_status,
19459            content: local_var_content,
19460            entity: local_var_entity,
19461        };
19462        Err(Error::ResponseError(local_var_error))
19463    }
19464}
19465
19466/// Get a provider object.
19467pub async fn circuits_providers_retrieve(
19468    configuration: &configuration::Configuration,
19469    id: i32,
19470) -> Result<crate::models::Provider, Error<CircuitsProvidersRetrieveError>> {
19471    let local_var_configuration = configuration;
19472
19473    let local_var_client = &local_var_configuration.client;
19474
19475    let local_var_uri_str = format!(
19476        "{}/api/circuits/providers/{id}/",
19477        local_var_configuration.base_path,
19478        id = id
19479    );
19480    let mut local_var_req_builder =
19481        local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
19482
19483    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
19484        local_var_req_builder =
19485            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
19486    }
19487    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
19488        let local_var_key = local_var_apikey.key.clone();
19489        let local_var_value = match local_var_apikey.prefix {
19490            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
19491            None => local_var_key,
19492        };
19493        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
19494    };
19495
19496    let local_var_req = local_var_req_builder.build()?;
19497    let local_var_resp = local_var_client.execute(local_var_req).await?;
19498
19499    let local_var_status = local_var_resp.status();
19500    let local_var_content = local_var_resp.text().await?;
19501
19502    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
19503        serde_json::from_str(&local_var_content).map_err(Error::from)
19504    } else {
19505        let local_var_entity: Option<CircuitsProvidersRetrieveError> =
19506            serde_json::from_str(&local_var_content).ok();
19507        let local_var_error = ResponseContent {
19508            status: local_var_status,
19509            content: local_var_content,
19510            entity: local_var_entity,
19511        };
19512        Err(Error::ResponseError(local_var_error))
19513    }
19514}
19515
19516/// Put a provider object.
19517pub async fn circuits_providers_update(
19518    configuration: &configuration::Configuration,
19519    id: i32,
19520    provider_request: crate::models::ProviderRequest,
19521) -> Result<crate::models::Provider, Error<CircuitsProvidersUpdateError>> {
19522    let local_var_configuration = configuration;
19523
19524    let local_var_client = &local_var_configuration.client;
19525
19526    let local_var_uri_str = format!(
19527        "{}/api/circuits/providers/{id}/",
19528        local_var_configuration.base_path,
19529        id = id
19530    );
19531    let mut local_var_req_builder =
19532        local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());
19533
19534    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
19535        local_var_req_builder =
19536            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
19537    }
19538    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
19539        let local_var_key = local_var_apikey.key.clone();
19540        let local_var_value = match local_var_apikey.prefix {
19541            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
19542            None => local_var_key,
19543        };
19544        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
19545    };
19546    local_var_req_builder = local_var_req_builder.json(&provider_request);
19547
19548    let local_var_req = local_var_req_builder.build()?;
19549    let local_var_resp = local_var_client.execute(local_var_req).await?;
19550
19551    let local_var_status = local_var_resp.status();
19552    let local_var_content = local_var_resp.text().await?;
19553
19554    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
19555        serde_json::from_str(&local_var_content).map_err(Error::from)
19556    } else {
19557        let local_var_entity: Option<CircuitsProvidersUpdateError> =
19558            serde_json::from_str(&local_var_content).ok();
19559        let local_var_error = ResponseContent {
19560            status: local_var_status,
19561            content: local_var_content,
19562            entity: local_var_entity,
19563        };
19564        Err(Error::ResponseError(local_var_error))
19565    }
19566}
19567
19568/// Delete a list of virtual circuit termination objects.
19569pub async fn circuits_virtual_circuit_terminations_bulk_destroy(
19570    configuration: &configuration::Configuration,
19571    virtual_circuit_termination_request: Vec<crate::models::VirtualCircuitTerminationRequest>,
19572) -> Result<(), Error<CircuitsVirtualCircuitTerminationsBulkDestroyError>> {
19573    let local_var_configuration = configuration;
19574
19575    let local_var_client = &local_var_configuration.client;
19576
19577    let local_var_uri_str = format!(
19578        "{}/api/circuits/virtual-circuit-terminations/",
19579        local_var_configuration.base_path
19580    );
19581    let mut local_var_req_builder =
19582        local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());
19583
19584    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
19585        local_var_req_builder =
19586            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
19587    }
19588    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
19589        let local_var_key = local_var_apikey.key.clone();
19590        let local_var_value = match local_var_apikey.prefix {
19591            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
19592            None => local_var_key,
19593        };
19594        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
19595    };
19596    local_var_req_builder = local_var_req_builder.json(&virtual_circuit_termination_request);
19597
19598    let local_var_req = local_var_req_builder.build()?;
19599    let local_var_resp = local_var_client.execute(local_var_req).await?;
19600
19601    let local_var_status = local_var_resp.status();
19602    let local_var_content = local_var_resp.text().await?;
19603
19604    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
19605        Ok(())
19606    } else {
19607        let local_var_entity: Option<CircuitsVirtualCircuitTerminationsBulkDestroyError> =
19608            serde_json::from_str(&local_var_content).ok();
19609        let local_var_error = ResponseContent {
19610            status: local_var_status,
19611            content: local_var_content,
19612            entity: local_var_entity,
19613        };
19614        Err(Error::ResponseError(local_var_error))
19615    }
19616}
19617
19618/// Patch a list of virtual circuit termination objects.
19619pub async fn circuits_virtual_circuit_terminations_bulk_partial_update(
19620    configuration: &configuration::Configuration,
19621    virtual_circuit_termination_request: Vec<crate::models::VirtualCircuitTerminationRequest>,
19622) -> Result<
19623    Vec<crate::models::VirtualCircuitTermination>,
19624    Error<CircuitsVirtualCircuitTerminationsBulkPartialUpdateError>,
19625> {
19626    let local_var_configuration = configuration;
19627
19628    let local_var_client = &local_var_configuration.client;
19629
19630    let local_var_uri_str = format!(
19631        "{}/api/circuits/virtual-circuit-terminations/",
19632        local_var_configuration.base_path
19633    );
19634    let mut local_var_req_builder =
19635        local_var_client.request(reqwest::Method::PATCH, local_var_uri_str.as_str());
19636
19637    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
19638        local_var_req_builder =
19639            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
19640    }
19641    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
19642        let local_var_key = local_var_apikey.key.clone();
19643        let local_var_value = match local_var_apikey.prefix {
19644            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
19645            None => local_var_key,
19646        };
19647        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
19648    };
19649    local_var_req_builder = local_var_req_builder.json(&virtual_circuit_termination_request);
19650
19651    let local_var_req = local_var_req_builder.build()?;
19652    let local_var_resp = local_var_client.execute(local_var_req).await?;
19653
19654    let local_var_status = local_var_resp.status();
19655    let local_var_content = local_var_resp.text().await?;
19656
19657    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
19658        serde_json::from_str(&local_var_content).map_err(Error::from)
19659    } else {
19660        let local_var_entity: Option<CircuitsVirtualCircuitTerminationsBulkPartialUpdateError> =
19661            serde_json::from_str(&local_var_content).ok();
19662        let local_var_error = ResponseContent {
19663            status: local_var_status,
19664            content: local_var_content,
19665            entity: local_var_entity,
19666        };
19667        Err(Error::ResponseError(local_var_error))
19668    }
19669}
19670
19671/// Put a list of virtual circuit termination objects.
19672pub async fn circuits_virtual_circuit_terminations_bulk_update(
19673    configuration: &configuration::Configuration,
19674    virtual_circuit_termination_request: Vec<crate::models::VirtualCircuitTerminationRequest>,
19675) -> Result<
19676    Vec<crate::models::VirtualCircuitTermination>,
19677    Error<CircuitsVirtualCircuitTerminationsBulkUpdateError>,
19678> {
19679    let local_var_configuration = configuration;
19680
19681    let local_var_client = &local_var_configuration.client;
19682
19683    let local_var_uri_str = format!(
19684        "{}/api/circuits/virtual-circuit-terminations/",
19685        local_var_configuration.base_path
19686    );
19687    let mut local_var_req_builder =
19688        local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());
19689
19690    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
19691        local_var_req_builder =
19692            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
19693    }
19694    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
19695        let local_var_key = local_var_apikey.key.clone();
19696        let local_var_value = match local_var_apikey.prefix {
19697            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
19698            None => local_var_key,
19699        };
19700        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
19701    };
19702    local_var_req_builder = local_var_req_builder.json(&virtual_circuit_termination_request);
19703
19704    let local_var_req = local_var_req_builder.build()?;
19705    let local_var_resp = local_var_client.execute(local_var_req).await?;
19706
19707    let local_var_status = local_var_resp.status();
19708    let local_var_content = local_var_resp.text().await?;
19709
19710    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
19711        serde_json::from_str(&local_var_content).map_err(Error::from)
19712    } else {
19713        let local_var_entity: Option<CircuitsVirtualCircuitTerminationsBulkUpdateError> =
19714            serde_json::from_str(&local_var_content).ok();
19715        let local_var_error = ResponseContent {
19716            status: local_var_status,
19717            content: local_var_content,
19718            entity: local_var_entity,
19719        };
19720        Err(Error::ResponseError(local_var_error))
19721    }
19722}
19723
19724/// Post a list of virtual circuit termination objects.
19725pub async fn circuits_virtual_circuit_terminations_create(
19726    configuration: &configuration::Configuration,
19727    circuits_virtual_circuit_terminations_create_request: crate::models::CircuitsVirtualCircuitTerminationsCreateRequest,
19728) -> Result<
19729    crate::models::VirtualCircuitTermination,
19730    Error<CircuitsVirtualCircuitTerminationsCreateError>,
19731> {
19732    let local_var_configuration = configuration;
19733
19734    let local_var_client = &local_var_configuration.client;
19735
19736    let local_var_uri_str = format!(
19737        "{}/api/circuits/virtual-circuit-terminations/",
19738        local_var_configuration.base_path
19739    );
19740    let mut local_var_req_builder =
19741        local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
19742
19743    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
19744        local_var_req_builder =
19745            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
19746    }
19747    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
19748        let local_var_key = local_var_apikey.key.clone();
19749        let local_var_value = match local_var_apikey.prefix {
19750            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
19751            None => local_var_key,
19752        };
19753        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
19754    };
19755    local_var_req_builder =
19756        local_var_req_builder.json(&circuits_virtual_circuit_terminations_create_request);
19757
19758    let local_var_req = local_var_req_builder.build()?;
19759    let local_var_resp = local_var_client.execute(local_var_req).await?;
19760
19761    let local_var_status = local_var_resp.status();
19762    let local_var_content = local_var_resp.text().await?;
19763
19764    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
19765        serde_json::from_str(&local_var_content).map_err(Error::from)
19766    } else {
19767        let local_var_entity: Option<CircuitsVirtualCircuitTerminationsCreateError> =
19768            serde_json::from_str(&local_var_content).ok();
19769        let local_var_error = ResponseContent {
19770            status: local_var_status,
19771            content: local_var_content,
19772            entity: local_var_entity,
19773        };
19774        Err(Error::ResponseError(local_var_error))
19775    }
19776}
19777
19778/// Delete a virtual circuit termination object.
19779pub async fn circuits_virtual_circuit_terminations_destroy(
19780    configuration: &configuration::Configuration,
19781    id: i32,
19782) -> Result<(), Error<CircuitsVirtualCircuitTerminationsDestroyError>> {
19783    let local_var_configuration = configuration;
19784
19785    let local_var_client = &local_var_configuration.client;
19786
19787    let local_var_uri_str = format!(
19788        "{}/api/circuits/virtual-circuit-terminations/{id}/",
19789        local_var_configuration.base_path,
19790        id = id
19791    );
19792    let mut local_var_req_builder =
19793        local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());
19794
19795    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
19796        local_var_req_builder =
19797            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
19798    }
19799    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
19800        let local_var_key = local_var_apikey.key.clone();
19801        let local_var_value = match local_var_apikey.prefix {
19802            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
19803            None => local_var_key,
19804        };
19805        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
19806    };
19807
19808    let local_var_req = local_var_req_builder.build()?;
19809    let local_var_resp = local_var_client.execute(local_var_req).await?;
19810
19811    let local_var_status = local_var_resp.status();
19812    let local_var_content = local_var_resp.text().await?;
19813
19814    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
19815        Ok(())
19816    } else {
19817        let local_var_entity: Option<CircuitsVirtualCircuitTerminationsDestroyError> =
19818            serde_json::from_str(&local_var_content).ok();
19819        let local_var_error = ResponseContent {
19820            status: local_var_status,
19821            content: local_var_content,
19822            entity: local_var_entity,
19823        };
19824        Err(Error::ResponseError(local_var_error))
19825    }
19826}
19827
19828/// Get a list of virtual circuit termination objects.
19829pub async fn circuits_virtual_circuit_terminations_list(
19830    configuration: &configuration::Configuration,
19831    created: Option<Vec<String>>,
19832    created__empty: Option<Vec<String>>,
19833    created__gt: Option<Vec<String>>,
19834    created__gte: Option<Vec<String>>,
19835    created__lt: Option<Vec<String>>,
19836    created__lte: Option<Vec<String>>,
19837    created__n: Option<Vec<String>>,
19838    created_by_request: Option<&str>,
19839    description: Option<Vec<String>>,
19840    description__empty: Option<bool>,
19841    description__ic: Option<Vec<String>>,
19842    description__ie: Option<Vec<String>>,
19843    description__iew: Option<Vec<String>>,
19844    description__iregex: Option<Vec<String>>,
19845    description__isw: Option<Vec<String>>,
19846    description__n: Option<Vec<String>>,
19847    description__nic: Option<Vec<String>>,
19848    description__nie: Option<Vec<String>>,
19849    description__niew: Option<Vec<String>>,
19850    description__nisw: Option<Vec<String>>,
19851    description__regex: Option<Vec<String>>,
19852    id: Option<Vec<i32>>,
19853    id__empty: Option<bool>,
19854    id__gt: Option<Vec<i32>>,
19855    id__gte: Option<Vec<i32>>,
19856    id__lt: Option<Vec<i32>>,
19857    id__lte: Option<Vec<i32>>,
19858    id__n: Option<Vec<i32>>,
19859    interface_id: Option<Vec<i32>>,
19860    interface_id__n: Option<Vec<i32>>,
19861    last_updated: Option<Vec<String>>,
19862    last_updated__empty: Option<Vec<String>>,
19863    last_updated__gt: Option<Vec<String>>,
19864    last_updated__gte: Option<Vec<String>>,
19865    last_updated__lt: Option<Vec<String>>,
19866    last_updated__lte: Option<Vec<String>>,
19867    last_updated__n: Option<Vec<String>>,
19868    limit: Option<i32>,
19869    modified_by_request: Option<&str>,
19870    offset: Option<i32>,
19871    ordering: Option<&str>,
19872    provider: Option<Vec<String>>,
19873    provider__n: Option<Vec<String>>,
19874    provider_account: Option<Vec<String>>,
19875    provider_account__n: Option<Vec<String>>,
19876    provider_account_id: Option<Vec<i32>>,
19877    provider_account_id__n: Option<Vec<i32>>,
19878    provider_id: Option<Vec<i32>>,
19879    provider_id__n: Option<Vec<i32>>,
19880    provider_network_id: Option<Vec<i32>>,
19881    provider_network_id__n: Option<Vec<i32>>,
19882    q: Option<&str>,
19883    role: Option<Vec<String>>,
19884    role__empty: Option<bool>,
19885    role__ic: Option<Vec<String>>,
19886    role__ie: Option<Vec<String>>,
19887    role__iew: Option<Vec<String>>,
19888    role__iregex: Option<Vec<String>>,
19889    role__isw: Option<Vec<String>>,
19890    role__n: Option<Vec<String>>,
19891    role__nic: Option<Vec<String>>,
19892    role__nie: Option<Vec<String>>,
19893    role__niew: Option<Vec<String>>,
19894    role__nisw: Option<Vec<String>>,
19895    role__regex: Option<Vec<String>>,
19896    start: Option<i32>,
19897    tag: Option<Vec<String>>,
19898    tag__n: Option<Vec<String>>,
19899    tag_id: Option<Vec<i32>>,
19900    tag_id__n: Option<Vec<i32>>,
19901    updated_by_request: Option<&str>,
19902    virtual_circuit_id: Option<Vec<i32>>,
19903    virtual_circuit_id__n: Option<Vec<i32>>,
19904) -> Result<
19905    crate::models::PaginatedVirtualCircuitTerminationList,
19906    Error<CircuitsVirtualCircuitTerminationsListError>,
19907> {
19908    let local_var_configuration = configuration;
19909
19910    let local_var_client = &local_var_configuration.client;
19911
19912    let local_var_uri_str = format!(
19913        "{}/api/circuits/virtual-circuit-terminations/",
19914        local_var_configuration.base_path
19915    );
19916    let mut local_var_req_builder =
19917        local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
19918
19919    if let Some(ref local_var_str) = created {
19920        local_var_req_builder = match "multi" {
19921            "multi" => local_var_req_builder.query(
19922                &local_var_str
19923                    .into_iter()
19924                    .map(|p| ("created".to_owned(), p.to_string()))
19925                    .collect::<Vec<(std::string::String, std::string::String)>>(),
19926            ),
19927            _ => local_var_req_builder.query(&[(
19928                "created",
19929                &local_var_str
19930                    .into_iter()
19931                    .map(|p| p.to_string())
19932                    .collect::<Vec<String>>()
19933                    .join(",")
19934                    .to_string(),
19935            )]),
19936        };
19937    }
19938    if let Some(ref local_var_str) = created__empty {
19939        local_var_req_builder = match "multi" {
19940            "multi" => local_var_req_builder.query(
19941                &local_var_str
19942                    .into_iter()
19943                    .map(|p| ("created__empty".to_owned(), p.to_string()))
19944                    .collect::<Vec<(std::string::String, std::string::String)>>(),
19945            ),
19946            _ => local_var_req_builder.query(&[(
19947                "created__empty",
19948                &local_var_str
19949                    .into_iter()
19950                    .map(|p| p.to_string())
19951                    .collect::<Vec<String>>()
19952                    .join(",")
19953                    .to_string(),
19954            )]),
19955        };
19956    }
19957    if let Some(ref local_var_str) = created__gt {
19958        local_var_req_builder = match "multi" {
19959            "multi" => local_var_req_builder.query(
19960                &local_var_str
19961                    .into_iter()
19962                    .map(|p| ("created__gt".to_owned(), p.to_string()))
19963                    .collect::<Vec<(std::string::String, std::string::String)>>(),
19964            ),
19965            _ => local_var_req_builder.query(&[(
19966                "created__gt",
19967                &local_var_str
19968                    .into_iter()
19969                    .map(|p| p.to_string())
19970                    .collect::<Vec<String>>()
19971                    .join(",")
19972                    .to_string(),
19973            )]),
19974        };
19975    }
19976    if let Some(ref local_var_str) = created__gte {
19977        local_var_req_builder = match "multi" {
19978            "multi" => local_var_req_builder.query(
19979                &local_var_str
19980                    .into_iter()
19981                    .map(|p| ("created__gte".to_owned(), p.to_string()))
19982                    .collect::<Vec<(std::string::String, std::string::String)>>(),
19983            ),
19984            _ => local_var_req_builder.query(&[(
19985                "created__gte",
19986                &local_var_str
19987                    .into_iter()
19988                    .map(|p| p.to_string())
19989                    .collect::<Vec<String>>()
19990                    .join(",")
19991                    .to_string(),
19992            )]),
19993        };
19994    }
19995    if let Some(ref local_var_str) = created__lt {
19996        local_var_req_builder = match "multi" {
19997            "multi" => local_var_req_builder.query(
19998                &local_var_str
19999                    .into_iter()
20000                    .map(|p| ("created__lt".to_owned(), p.to_string()))
20001                    .collect::<Vec<(std::string::String, std::string::String)>>(),
20002            ),
20003            _ => local_var_req_builder.query(&[(
20004                "created__lt",
20005                &local_var_str
20006                    .into_iter()
20007                    .map(|p| p.to_string())
20008                    .collect::<Vec<String>>()
20009                    .join(",")
20010                    .to_string(),
20011            )]),
20012        };
20013    }
20014    if let Some(ref local_var_str) = created__lte {
20015        local_var_req_builder = match "multi" {
20016            "multi" => local_var_req_builder.query(
20017                &local_var_str
20018                    .into_iter()
20019                    .map(|p| ("created__lte".to_owned(), p.to_string()))
20020                    .collect::<Vec<(std::string::String, std::string::String)>>(),
20021            ),
20022            _ => local_var_req_builder.query(&[(
20023                "created__lte",
20024                &local_var_str
20025                    .into_iter()
20026                    .map(|p| p.to_string())
20027                    .collect::<Vec<String>>()
20028                    .join(",")
20029                    .to_string(),
20030            )]),
20031        };
20032    }
20033    if let Some(ref local_var_str) = created__n {
20034        local_var_req_builder = match "multi" {
20035            "multi" => local_var_req_builder.query(
20036                &local_var_str
20037                    .into_iter()
20038                    .map(|p| ("created__n".to_owned(), p.to_string()))
20039                    .collect::<Vec<(std::string::String, std::string::String)>>(),
20040            ),
20041            _ => local_var_req_builder.query(&[(
20042                "created__n",
20043                &local_var_str
20044                    .into_iter()
20045                    .map(|p| p.to_string())
20046                    .collect::<Vec<String>>()
20047                    .join(",")
20048                    .to_string(),
20049            )]),
20050        };
20051    }
20052    if let Some(ref local_var_str) = created_by_request {
20053        local_var_req_builder =
20054            local_var_req_builder.query(&[("created_by_request", &local_var_str.to_string())]);
20055    }
20056    if let Some(ref local_var_str) = description {
20057        local_var_req_builder = match "multi" {
20058            "multi" => local_var_req_builder.query(
20059                &local_var_str
20060                    .into_iter()
20061                    .map(|p| ("description".to_owned(), p.to_string()))
20062                    .collect::<Vec<(std::string::String, std::string::String)>>(),
20063            ),
20064            _ => local_var_req_builder.query(&[(
20065                "description",
20066                &local_var_str
20067                    .into_iter()
20068                    .map(|p| p.to_string())
20069                    .collect::<Vec<String>>()
20070                    .join(",")
20071                    .to_string(),
20072            )]),
20073        };
20074    }
20075    if let Some(ref local_var_str) = description__empty {
20076        local_var_req_builder =
20077            local_var_req_builder.query(&[("description__empty", &local_var_str.to_string())]);
20078    }
20079    if let Some(ref local_var_str) = description__ic {
20080        local_var_req_builder = match "multi" {
20081            "multi" => local_var_req_builder.query(
20082                &local_var_str
20083                    .into_iter()
20084                    .map(|p| ("description__ic".to_owned(), p.to_string()))
20085                    .collect::<Vec<(std::string::String, std::string::String)>>(),
20086            ),
20087            _ => local_var_req_builder.query(&[(
20088                "description__ic",
20089                &local_var_str
20090                    .into_iter()
20091                    .map(|p| p.to_string())
20092                    .collect::<Vec<String>>()
20093                    .join(",")
20094                    .to_string(),
20095            )]),
20096        };
20097    }
20098    if let Some(ref local_var_str) = description__ie {
20099        local_var_req_builder = match "multi" {
20100            "multi" => local_var_req_builder.query(
20101                &local_var_str
20102                    .into_iter()
20103                    .map(|p| ("description__ie".to_owned(), p.to_string()))
20104                    .collect::<Vec<(std::string::String, std::string::String)>>(),
20105            ),
20106            _ => local_var_req_builder.query(&[(
20107                "description__ie",
20108                &local_var_str
20109                    .into_iter()
20110                    .map(|p| p.to_string())
20111                    .collect::<Vec<String>>()
20112                    .join(",")
20113                    .to_string(),
20114            )]),
20115        };
20116    }
20117    if let Some(ref local_var_str) = description__iew {
20118        local_var_req_builder = match "multi" {
20119            "multi" => local_var_req_builder.query(
20120                &local_var_str
20121                    .into_iter()
20122                    .map(|p| ("description__iew".to_owned(), p.to_string()))
20123                    .collect::<Vec<(std::string::String, std::string::String)>>(),
20124            ),
20125            _ => local_var_req_builder.query(&[(
20126                "description__iew",
20127                &local_var_str
20128                    .into_iter()
20129                    .map(|p| p.to_string())
20130                    .collect::<Vec<String>>()
20131                    .join(",")
20132                    .to_string(),
20133            )]),
20134        };
20135    }
20136    if let Some(ref local_var_str) = description__iregex {
20137        local_var_req_builder = match "multi" {
20138            "multi" => local_var_req_builder.query(
20139                &local_var_str
20140                    .into_iter()
20141                    .map(|p| ("description__iregex".to_owned(), p.to_string()))
20142                    .collect::<Vec<(std::string::String, std::string::String)>>(),
20143            ),
20144            _ => local_var_req_builder.query(&[(
20145                "description__iregex",
20146                &local_var_str
20147                    .into_iter()
20148                    .map(|p| p.to_string())
20149                    .collect::<Vec<String>>()
20150                    .join(",")
20151                    .to_string(),
20152            )]),
20153        };
20154    }
20155    if let Some(ref local_var_str) = description__isw {
20156        local_var_req_builder = match "multi" {
20157            "multi" => local_var_req_builder.query(
20158                &local_var_str
20159                    .into_iter()
20160                    .map(|p| ("description__isw".to_owned(), p.to_string()))
20161                    .collect::<Vec<(std::string::String, std::string::String)>>(),
20162            ),
20163            _ => local_var_req_builder.query(&[(
20164                "description__isw",
20165                &local_var_str
20166                    .into_iter()
20167                    .map(|p| p.to_string())
20168                    .collect::<Vec<String>>()
20169                    .join(",")
20170                    .to_string(),
20171            )]),
20172        };
20173    }
20174    if let Some(ref local_var_str) = description__n {
20175        local_var_req_builder = match "multi" {
20176            "multi" => local_var_req_builder.query(
20177                &local_var_str
20178                    .into_iter()
20179                    .map(|p| ("description__n".to_owned(), p.to_string()))
20180                    .collect::<Vec<(std::string::String, std::string::String)>>(),
20181            ),
20182            _ => local_var_req_builder.query(&[(
20183                "description__n",
20184                &local_var_str
20185                    .into_iter()
20186                    .map(|p| p.to_string())
20187                    .collect::<Vec<String>>()
20188                    .join(",")
20189                    .to_string(),
20190            )]),
20191        };
20192    }
20193    if let Some(ref local_var_str) = description__nic {
20194        local_var_req_builder = match "multi" {
20195            "multi" => local_var_req_builder.query(
20196                &local_var_str
20197                    .into_iter()
20198                    .map(|p| ("description__nic".to_owned(), p.to_string()))
20199                    .collect::<Vec<(std::string::String, std::string::String)>>(),
20200            ),
20201            _ => local_var_req_builder.query(&[(
20202                "description__nic",
20203                &local_var_str
20204                    .into_iter()
20205                    .map(|p| p.to_string())
20206                    .collect::<Vec<String>>()
20207                    .join(",")
20208                    .to_string(),
20209            )]),
20210        };
20211    }
20212    if let Some(ref local_var_str) = description__nie {
20213        local_var_req_builder = match "multi" {
20214            "multi" => local_var_req_builder.query(
20215                &local_var_str
20216                    .into_iter()
20217                    .map(|p| ("description__nie".to_owned(), p.to_string()))
20218                    .collect::<Vec<(std::string::String, std::string::String)>>(),
20219            ),
20220            _ => local_var_req_builder.query(&[(
20221                "description__nie",
20222                &local_var_str
20223                    .into_iter()
20224                    .map(|p| p.to_string())
20225                    .collect::<Vec<String>>()
20226                    .join(",")
20227                    .to_string(),
20228            )]),
20229        };
20230    }
20231    if let Some(ref local_var_str) = description__niew {
20232        local_var_req_builder = match "multi" {
20233            "multi" => local_var_req_builder.query(
20234                &local_var_str
20235                    .into_iter()
20236                    .map(|p| ("description__niew".to_owned(), p.to_string()))
20237                    .collect::<Vec<(std::string::String, std::string::String)>>(),
20238            ),
20239            _ => local_var_req_builder.query(&[(
20240                "description__niew",
20241                &local_var_str
20242                    .into_iter()
20243                    .map(|p| p.to_string())
20244                    .collect::<Vec<String>>()
20245                    .join(",")
20246                    .to_string(),
20247            )]),
20248        };
20249    }
20250    if let Some(ref local_var_str) = description__nisw {
20251        local_var_req_builder = match "multi" {
20252            "multi" => local_var_req_builder.query(
20253                &local_var_str
20254                    .into_iter()
20255                    .map(|p| ("description__nisw".to_owned(), p.to_string()))
20256                    .collect::<Vec<(std::string::String, std::string::String)>>(),
20257            ),
20258            _ => local_var_req_builder.query(&[(
20259                "description__nisw",
20260                &local_var_str
20261                    .into_iter()
20262                    .map(|p| p.to_string())
20263                    .collect::<Vec<String>>()
20264                    .join(",")
20265                    .to_string(),
20266            )]),
20267        };
20268    }
20269    if let Some(ref local_var_str) = description__regex {
20270        local_var_req_builder = match "multi" {
20271            "multi" => local_var_req_builder.query(
20272                &local_var_str
20273                    .into_iter()
20274                    .map(|p| ("description__regex".to_owned(), p.to_string()))
20275                    .collect::<Vec<(std::string::String, std::string::String)>>(),
20276            ),
20277            _ => local_var_req_builder.query(&[(
20278                "description__regex",
20279                &local_var_str
20280                    .into_iter()
20281                    .map(|p| p.to_string())
20282                    .collect::<Vec<String>>()
20283                    .join(",")
20284                    .to_string(),
20285            )]),
20286        };
20287    }
20288    if let Some(ref local_var_str) = id {
20289        local_var_req_builder = match "multi" {
20290            "multi" => local_var_req_builder.query(
20291                &local_var_str
20292                    .into_iter()
20293                    .map(|p| ("id".to_owned(), p.to_string()))
20294                    .collect::<Vec<(std::string::String, std::string::String)>>(),
20295            ),
20296            _ => local_var_req_builder.query(&[(
20297                "id",
20298                &local_var_str
20299                    .into_iter()
20300                    .map(|p| p.to_string())
20301                    .collect::<Vec<String>>()
20302                    .join(",")
20303                    .to_string(),
20304            )]),
20305        };
20306    }
20307    if let Some(ref local_var_str) = id__empty {
20308        local_var_req_builder =
20309            local_var_req_builder.query(&[("id__empty", &local_var_str.to_string())]);
20310    }
20311    if let Some(ref local_var_str) = id__gt {
20312        local_var_req_builder = match "multi" {
20313            "multi" => local_var_req_builder.query(
20314                &local_var_str
20315                    .into_iter()
20316                    .map(|p| ("id__gt".to_owned(), p.to_string()))
20317                    .collect::<Vec<(std::string::String, std::string::String)>>(),
20318            ),
20319            _ => local_var_req_builder.query(&[(
20320                "id__gt",
20321                &local_var_str
20322                    .into_iter()
20323                    .map(|p| p.to_string())
20324                    .collect::<Vec<String>>()
20325                    .join(",")
20326                    .to_string(),
20327            )]),
20328        };
20329    }
20330    if let Some(ref local_var_str) = id__gte {
20331        local_var_req_builder = match "multi" {
20332            "multi" => local_var_req_builder.query(
20333                &local_var_str
20334                    .into_iter()
20335                    .map(|p| ("id__gte".to_owned(), p.to_string()))
20336                    .collect::<Vec<(std::string::String, std::string::String)>>(),
20337            ),
20338            _ => local_var_req_builder.query(&[(
20339                "id__gte",
20340                &local_var_str
20341                    .into_iter()
20342                    .map(|p| p.to_string())
20343                    .collect::<Vec<String>>()
20344                    .join(",")
20345                    .to_string(),
20346            )]),
20347        };
20348    }
20349    if let Some(ref local_var_str) = id__lt {
20350        local_var_req_builder = match "multi" {
20351            "multi" => local_var_req_builder.query(
20352                &local_var_str
20353                    .into_iter()
20354                    .map(|p| ("id__lt".to_owned(), p.to_string()))
20355                    .collect::<Vec<(std::string::String, std::string::String)>>(),
20356            ),
20357            _ => local_var_req_builder.query(&[(
20358                "id__lt",
20359                &local_var_str
20360                    .into_iter()
20361                    .map(|p| p.to_string())
20362                    .collect::<Vec<String>>()
20363                    .join(",")
20364                    .to_string(),
20365            )]),
20366        };
20367    }
20368    if let Some(ref local_var_str) = id__lte {
20369        local_var_req_builder = match "multi" {
20370            "multi" => local_var_req_builder.query(
20371                &local_var_str
20372                    .into_iter()
20373                    .map(|p| ("id__lte".to_owned(), p.to_string()))
20374                    .collect::<Vec<(std::string::String, std::string::String)>>(),
20375            ),
20376            _ => local_var_req_builder.query(&[(
20377                "id__lte",
20378                &local_var_str
20379                    .into_iter()
20380                    .map(|p| p.to_string())
20381                    .collect::<Vec<String>>()
20382                    .join(",")
20383                    .to_string(),
20384            )]),
20385        };
20386    }
20387    if let Some(ref local_var_str) = id__n {
20388        local_var_req_builder = match "multi" {
20389            "multi" => local_var_req_builder.query(
20390                &local_var_str
20391                    .into_iter()
20392                    .map(|p| ("id__n".to_owned(), p.to_string()))
20393                    .collect::<Vec<(std::string::String, std::string::String)>>(),
20394            ),
20395            _ => local_var_req_builder.query(&[(
20396                "id__n",
20397                &local_var_str
20398                    .into_iter()
20399                    .map(|p| p.to_string())
20400                    .collect::<Vec<String>>()
20401                    .join(",")
20402                    .to_string(),
20403            )]),
20404        };
20405    }
20406    if let Some(ref local_var_str) = interface_id {
20407        local_var_req_builder = match "multi" {
20408            "multi" => local_var_req_builder.query(
20409                &local_var_str
20410                    .into_iter()
20411                    .map(|p| ("interface_id".to_owned(), p.to_string()))
20412                    .collect::<Vec<(std::string::String, std::string::String)>>(),
20413            ),
20414            _ => local_var_req_builder.query(&[(
20415                "interface_id",
20416                &local_var_str
20417                    .into_iter()
20418                    .map(|p| p.to_string())
20419                    .collect::<Vec<String>>()
20420                    .join(",")
20421                    .to_string(),
20422            )]),
20423        };
20424    }
20425    if let Some(ref local_var_str) = interface_id__n {
20426        local_var_req_builder = match "multi" {
20427            "multi" => local_var_req_builder.query(
20428                &local_var_str
20429                    .into_iter()
20430                    .map(|p| ("interface_id__n".to_owned(), p.to_string()))
20431                    .collect::<Vec<(std::string::String, std::string::String)>>(),
20432            ),
20433            _ => local_var_req_builder.query(&[(
20434                "interface_id__n",
20435                &local_var_str
20436                    .into_iter()
20437                    .map(|p| p.to_string())
20438                    .collect::<Vec<String>>()
20439                    .join(",")
20440                    .to_string(),
20441            )]),
20442        };
20443    }
20444    if let Some(ref local_var_str) = last_updated {
20445        local_var_req_builder = match "multi" {
20446            "multi" => local_var_req_builder.query(
20447                &local_var_str
20448                    .into_iter()
20449                    .map(|p| ("last_updated".to_owned(), p.to_string()))
20450                    .collect::<Vec<(std::string::String, std::string::String)>>(),
20451            ),
20452            _ => local_var_req_builder.query(&[(
20453                "last_updated",
20454                &local_var_str
20455                    .into_iter()
20456                    .map(|p| p.to_string())
20457                    .collect::<Vec<String>>()
20458                    .join(",")
20459                    .to_string(),
20460            )]),
20461        };
20462    }
20463    if let Some(ref local_var_str) = last_updated__empty {
20464        local_var_req_builder = match "multi" {
20465            "multi" => local_var_req_builder.query(
20466                &local_var_str
20467                    .into_iter()
20468                    .map(|p| ("last_updated__empty".to_owned(), p.to_string()))
20469                    .collect::<Vec<(std::string::String, std::string::String)>>(),
20470            ),
20471            _ => local_var_req_builder.query(&[(
20472                "last_updated__empty",
20473                &local_var_str
20474                    .into_iter()
20475                    .map(|p| p.to_string())
20476                    .collect::<Vec<String>>()
20477                    .join(",")
20478                    .to_string(),
20479            )]),
20480        };
20481    }
20482    if let Some(ref local_var_str) = last_updated__gt {
20483        local_var_req_builder = match "multi" {
20484            "multi" => local_var_req_builder.query(
20485                &local_var_str
20486                    .into_iter()
20487                    .map(|p| ("last_updated__gt".to_owned(), p.to_string()))
20488                    .collect::<Vec<(std::string::String, std::string::String)>>(),
20489            ),
20490            _ => local_var_req_builder.query(&[(
20491                "last_updated__gt",
20492                &local_var_str
20493                    .into_iter()
20494                    .map(|p| p.to_string())
20495                    .collect::<Vec<String>>()
20496                    .join(",")
20497                    .to_string(),
20498            )]),
20499        };
20500    }
20501    if let Some(ref local_var_str) = last_updated__gte {
20502        local_var_req_builder = match "multi" {
20503            "multi" => local_var_req_builder.query(
20504                &local_var_str
20505                    .into_iter()
20506                    .map(|p| ("last_updated__gte".to_owned(), p.to_string()))
20507                    .collect::<Vec<(std::string::String, std::string::String)>>(),
20508            ),
20509            _ => local_var_req_builder.query(&[(
20510                "last_updated__gte",
20511                &local_var_str
20512                    .into_iter()
20513                    .map(|p| p.to_string())
20514                    .collect::<Vec<String>>()
20515                    .join(",")
20516                    .to_string(),
20517            )]),
20518        };
20519    }
20520    if let Some(ref local_var_str) = last_updated__lt {
20521        local_var_req_builder = match "multi" {
20522            "multi" => local_var_req_builder.query(
20523                &local_var_str
20524                    .into_iter()
20525                    .map(|p| ("last_updated__lt".to_owned(), p.to_string()))
20526                    .collect::<Vec<(std::string::String, std::string::String)>>(),
20527            ),
20528            _ => local_var_req_builder.query(&[(
20529                "last_updated__lt",
20530                &local_var_str
20531                    .into_iter()
20532                    .map(|p| p.to_string())
20533                    .collect::<Vec<String>>()
20534                    .join(",")
20535                    .to_string(),
20536            )]),
20537        };
20538    }
20539    if let Some(ref local_var_str) = last_updated__lte {
20540        local_var_req_builder = match "multi" {
20541            "multi" => local_var_req_builder.query(
20542                &local_var_str
20543                    .into_iter()
20544                    .map(|p| ("last_updated__lte".to_owned(), p.to_string()))
20545                    .collect::<Vec<(std::string::String, std::string::String)>>(),
20546            ),
20547            _ => local_var_req_builder.query(&[(
20548                "last_updated__lte",
20549                &local_var_str
20550                    .into_iter()
20551                    .map(|p| p.to_string())
20552                    .collect::<Vec<String>>()
20553                    .join(",")
20554                    .to_string(),
20555            )]),
20556        };
20557    }
20558    if let Some(ref local_var_str) = last_updated__n {
20559        local_var_req_builder = match "multi" {
20560            "multi" => local_var_req_builder.query(
20561                &local_var_str
20562                    .into_iter()
20563                    .map(|p| ("last_updated__n".to_owned(), p.to_string()))
20564                    .collect::<Vec<(std::string::String, std::string::String)>>(),
20565            ),
20566            _ => local_var_req_builder.query(&[(
20567                "last_updated__n",
20568                &local_var_str
20569                    .into_iter()
20570                    .map(|p| p.to_string())
20571                    .collect::<Vec<String>>()
20572                    .join(",")
20573                    .to_string(),
20574            )]),
20575        };
20576    }
20577    if let Some(ref local_var_str) = limit {
20578        local_var_req_builder =
20579            local_var_req_builder.query(&[("limit", &local_var_str.to_string())]);
20580    }
20581    if let Some(ref local_var_str) = modified_by_request {
20582        local_var_req_builder =
20583            local_var_req_builder.query(&[("modified_by_request", &local_var_str.to_string())]);
20584    }
20585    if let Some(ref local_var_str) = offset {
20586        local_var_req_builder =
20587            local_var_req_builder.query(&[("offset", &local_var_str.to_string())]);
20588    }
20589    if let Some(ref local_var_str) = ordering {
20590        local_var_req_builder =
20591            local_var_req_builder.query(&[("ordering", &local_var_str.to_string())]);
20592    }
20593    if let Some(ref local_var_str) = provider {
20594        local_var_req_builder = match "multi" {
20595            "multi" => local_var_req_builder.query(
20596                &local_var_str
20597                    .into_iter()
20598                    .map(|p| ("provider".to_owned(), p.to_string()))
20599                    .collect::<Vec<(std::string::String, std::string::String)>>(),
20600            ),
20601            _ => local_var_req_builder.query(&[(
20602                "provider",
20603                &local_var_str
20604                    .into_iter()
20605                    .map(|p| p.to_string())
20606                    .collect::<Vec<String>>()
20607                    .join(",")
20608                    .to_string(),
20609            )]),
20610        };
20611    }
20612    if let Some(ref local_var_str) = provider__n {
20613        local_var_req_builder = match "multi" {
20614            "multi" => local_var_req_builder.query(
20615                &local_var_str
20616                    .into_iter()
20617                    .map(|p| ("provider__n".to_owned(), p.to_string()))
20618                    .collect::<Vec<(std::string::String, std::string::String)>>(),
20619            ),
20620            _ => local_var_req_builder.query(&[(
20621                "provider__n",
20622                &local_var_str
20623                    .into_iter()
20624                    .map(|p| p.to_string())
20625                    .collect::<Vec<String>>()
20626                    .join(",")
20627                    .to_string(),
20628            )]),
20629        };
20630    }
20631    if let Some(ref local_var_str) = provider_account {
20632        local_var_req_builder = match "multi" {
20633            "multi" => local_var_req_builder.query(
20634                &local_var_str
20635                    .into_iter()
20636                    .map(|p| ("provider_account".to_owned(), p.to_string()))
20637                    .collect::<Vec<(std::string::String, std::string::String)>>(),
20638            ),
20639            _ => local_var_req_builder.query(&[(
20640                "provider_account",
20641                &local_var_str
20642                    .into_iter()
20643                    .map(|p| p.to_string())
20644                    .collect::<Vec<String>>()
20645                    .join(",")
20646                    .to_string(),
20647            )]),
20648        };
20649    }
20650    if let Some(ref local_var_str) = provider_account__n {
20651        local_var_req_builder = match "multi" {
20652            "multi" => local_var_req_builder.query(
20653                &local_var_str
20654                    .into_iter()
20655                    .map(|p| ("provider_account__n".to_owned(), p.to_string()))
20656                    .collect::<Vec<(std::string::String, std::string::String)>>(),
20657            ),
20658            _ => local_var_req_builder.query(&[(
20659                "provider_account__n",
20660                &local_var_str
20661                    .into_iter()
20662                    .map(|p| p.to_string())
20663                    .collect::<Vec<String>>()
20664                    .join(",")
20665                    .to_string(),
20666            )]),
20667        };
20668    }
20669    if let Some(ref local_var_str) = provider_account_id {
20670        local_var_req_builder = match "multi" {
20671            "multi" => local_var_req_builder.query(
20672                &local_var_str
20673                    .into_iter()
20674                    .map(|p| ("provider_account_id".to_owned(), p.to_string()))
20675                    .collect::<Vec<(std::string::String, std::string::String)>>(),
20676            ),
20677            _ => local_var_req_builder.query(&[(
20678                "provider_account_id",
20679                &local_var_str
20680                    .into_iter()
20681                    .map(|p| p.to_string())
20682                    .collect::<Vec<String>>()
20683                    .join(",")
20684                    .to_string(),
20685            )]),
20686        };
20687    }
20688    if let Some(ref local_var_str) = provider_account_id__n {
20689        local_var_req_builder = match "multi" {
20690            "multi" => local_var_req_builder.query(
20691                &local_var_str
20692                    .into_iter()
20693                    .map(|p| ("provider_account_id__n".to_owned(), p.to_string()))
20694                    .collect::<Vec<(std::string::String, std::string::String)>>(),
20695            ),
20696            _ => local_var_req_builder.query(&[(
20697                "provider_account_id__n",
20698                &local_var_str
20699                    .into_iter()
20700                    .map(|p| p.to_string())
20701                    .collect::<Vec<String>>()
20702                    .join(",")
20703                    .to_string(),
20704            )]),
20705        };
20706    }
20707    if let Some(ref local_var_str) = provider_id {
20708        local_var_req_builder = match "multi" {
20709            "multi" => local_var_req_builder.query(
20710                &local_var_str
20711                    .into_iter()
20712                    .map(|p| ("provider_id".to_owned(), p.to_string()))
20713                    .collect::<Vec<(std::string::String, std::string::String)>>(),
20714            ),
20715            _ => local_var_req_builder.query(&[(
20716                "provider_id",
20717                &local_var_str
20718                    .into_iter()
20719                    .map(|p| p.to_string())
20720                    .collect::<Vec<String>>()
20721                    .join(",")
20722                    .to_string(),
20723            )]),
20724        };
20725    }
20726    if let Some(ref local_var_str) = provider_id__n {
20727        local_var_req_builder = match "multi" {
20728            "multi" => local_var_req_builder.query(
20729                &local_var_str
20730                    .into_iter()
20731                    .map(|p| ("provider_id__n".to_owned(), p.to_string()))
20732                    .collect::<Vec<(std::string::String, std::string::String)>>(),
20733            ),
20734            _ => local_var_req_builder.query(&[(
20735                "provider_id__n",
20736                &local_var_str
20737                    .into_iter()
20738                    .map(|p| p.to_string())
20739                    .collect::<Vec<String>>()
20740                    .join(",")
20741                    .to_string(),
20742            )]),
20743        };
20744    }
20745    if let Some(ref local_var_str) = provider_network_id {
20746        local_var_req_builder = match "multi" {
20747            "multi" => local_var_req_builder.query(
20748                &local_var_str
20749                    .into_iter()
20750                    .map(|p| ("provider_network_id".to_owned(), p.to_string()))
20751                    .collect::<Vec<(std::string::String, std::string::String)>>(),
20752            ),
20753            _ => local_var_req_builder.query(&[(
20754                "provider_network_id",
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) = provider_network_id__n {
20765        local_var_req_builder = match "multi" {
20766            "multi" => local_var_req_builder.query(
20767                &local_var_str
20768                    .into_iter()
20769                    .map(|p| ("provider_network_id__n".to_owned(), p.to_string()))
20770                    .collect::<Vec<(std::string::String, std::string::String)>>(),
20771            ),
20772            _ => local_var_req_builder.query(&[(
20773                "provider_network_id__n",
20774                &local_var_str
20775                    .into_iter()
20776                    .map(|p| p.to_string())
20777                    .collect::<Vec<String>>()
20778                    .join(",")
20779                    .to_string(),
20780            )]),
20781        };
20782    }
20783    if let Some(ref local_var_str) = q {
20784        local_var_req_builder = local_var_req_builder.query(&[("q", &local_var_str.to_string())]);
20785    }
20786    if let Some(ref local_var_str) = role {
20787        local_var_req_builder = match "multi" {
20788            "multi" => local_var_req_builder.query(
20789                &local_var_str
20790                    .into_iter()
20791                    .map(|p| ("role".to_owned(), p.to_string()))
20792                    .collect::<Vec<(std::string::String, std::string::String)>>(),
20793            ),
20794            _ => local_var_req_builder.query(&[(
20795                "role",
20796                &local_var_str
20797                    .into_iter()
20798                    .map(|p| p.to_string())
20799                    .collect::<Vec<String>>()
20800                    .join(",")
20801                    .to_string(),
20802            )]),
20803        };
20804    }
20805    if let Some(ref local_var_str) = role__empty {
20806        local_var_req_builder =
20807            local_var_req_builder.query(&[("role__empty", &local_var_str.to_string())]);
20808    }
20809    if let Some(ref local_var_str) = role__ic {
20810        local_var_req_builder = match "multi" {
20811            "multi" => local_var_req_builder.query(
20812                &local_var_str
20813                    .into_iter()
20814                    .map(|p| ("role__ic".to_owned(), p.to_string()))
20815                    .collect::<Vec<(std::string::String, std::string::String)>>(),
20816            ),
20817            _ => local_var_req_builder.query(&[(
20818                "role__ic",
20819                &local_var_str
20820                    .into_iter()
20821                    .map(|p| p.to_string())
20822                    .collect::<Vec<String>>()
20823                    .join(",")
20824                    .to_string(),
20825            )]),
20826        };
20827    }
20828    if let Some(ref local_var_str) = role__ie {
20829        local_var_req_builder = match "multi" {
20830            "multi" => local_var_req_builder.query(
20831                &local_var_str
20832                    .into_iter()
20833                    .map(|p| ("role__ie".to_owned(), p.to_string()))
20834                    .collect::<Vec<(std::string::String, std::string::String)>>(),
20835            ),
20836            _ => local_var_req_builder.query(&[(
20837                "role__ie",
20838                &local_var_str
20839                    .into_iter()
20840                    .map(|p| p.to_string())
20841                    .collect::<Vec<String>>()
20842                    .join(",")
20843                    .to_string(),
20844            )]),
20845        };
20846    }
20847    if let Some(ref local_var_str) = role__iew {
20848        local_var_req_builder = match "multi" {
20849            "multi" => local_var_req_builder.query(
20850                &local_var_str
20851                    .into_iter()
20852                    .map(|p| ("role__iew".to_owned(), p.to_string()))
20853                    .collect::<Vec<(std::string::String, std::string::String)>>(),
20854            ),
20855            _ => local_var_req_builder.query(&[(
20856                "role__iew",
20857                &local_var_str
20858                    .into_iter()
20859                    .map(|p| p.to_string())
20860                    .collect::<Vec<String>>()
20861                    .join(",")
20862                    .to_string(),
20863            )]),
20864        };
20865    }
20866    if let Some(ref local_var_str) = role__iregex {
20867        local_var_req_builder = match "multi" {
20868            "multi" => local_var_req_builder.query(
20869                &local_var_str
20870                    .into_iter()
20871                    .map(|p| ("role__iregex".to_owned(), p.to_string()))
20872                    .collect::<Vec<(std::string::String, std::string::String)>>(),
20873            ),
20874            _ => local_var_req_builder.query(&[(
20875                "role__iregex",
20876                &local_var_str
20877                    .into_iter()
20878                    .map(|p| p.to_string())
20879                    .collect::<Vec<String>>()
20880                    .join(",")
20881                    .to_string(),
20882            )]),
20883        };
20884    }
20885    if let Some(ref local_var_str) = role__isw {
20886        local_var_req_builder = match "multi" {
20887            "multi" => local_var_req_builder.query(
20888                &local_var_str
20889                    .into_iter()
20890                    .map(|p| ("role__isw".to_owned(), p.to_string()))
20891                    .collect::<Vec<(std::string::String, std::string::String)>>(),
20892            ),
20893            _ => local_var_req_builder.query(&[(
20894                "role__isw",
20895                &local_var_str
20896                    .into_iter()
20897                    .map(|p| p.to_string())
20898                    .collect::<Vec<String>>()
20899                    .join(",")
20900                    .to_string(),
20901            )]),
20902        };
20903    }
20904    if let Some(ref local_var_str) = role__n {
20905        local_var_req_builder = match "multi" {
20906            "multi" => local_var_req_builder.query(
20907                &local_var_str
20908                    .into_iter()
20909                    .map(|p| ("role__n".to_owned(), p.to_string()))
20910                    .collect::<Vec<(std::string::String, std::string::String)>>(),
20911            ),
20912            _ => local_var_req_builder.query(&[(
20913                "role__n",
20914                &local_var_str
20915                    .into_iter()
20916                    .map(|p| p.to_string())
20917                    .collect::<Vec<String>>()
20918                    .join(",")
20919                    .to_string(),
20920            )]),
20921        };
20922    }
20923    if let Some(ref local_var_str) = role__nic {
20924        local_var_req_builder = match "multi" {
20925            "multi" => local_var_req_builder.query(
20926                &local_var_str
20927                    .into_iter()
20928                    .map(|p| ("role__nic".to_owned(), p.to_string()))
20929                    .collect::<Vec<(std::string::String, std::string::String)>>(),
20930            ),
20931            _ => local_var_req_builder.query(&[(
20932                "role__nic",
20933                &local_var_str
20934                    .into_iter()
20935                    .map(|p| p.to_string())
20936                    .collect::<Vec<String>>()
20937                    .join(",")
20938                    .to_string(),
20939            )]),
20940        };
20941    }
20942    if let Some(ref local_var_str) = role__nie {
20943        local_var_req_builder = match "multi" {
20944            "multi" => local_var_req_builder.query(
20945                &local_var_str
20946                    .into_iter()
20947                    .map(|p| ("role__nie".to_owned(), p.to_string()))
20948                    .collect::<Vec<(std::string::String, std::string::String)>>(),
20949            ),
20950            _ => local_var_req_builder.query(&[(
20951                "role__nie",
20952                &local_var_str
20953                    .into_iter()
20954                    .map(|p| p.to_string())
20955                    .collect::<Vec<String>>()
20956                    .join(",")
20957                    .to_string(),
20958            )]),
20959        };
20960    }
20961    if let Some(ref local_var_str) = role__niew {
20962        local_var_req_builder = match "multi" {
20963            "multi" => local_var_req_builder.query(
20964                &local_var_str
20965                    .into_iter()
20966                    .map(|p| ("role__niew".to_owned(), p.to_string()))
20967                    .collect::<Vec<(std::string::String, std::string::String)>>(),
20968            ),
20969            _ => local_var_req_builder.query(&[(
20970                "role__niew",
20971                &local_var_str
20972                    .into_iter()
20973                    .map(|p| p.to_string())
20974                    .collect::<Vec<String>>()
20975                    .join(",")
20976                    .to_string(),
20977            )]),
20978        };
20979    }
20980    if let Some(ref local_var_str) = role__nisw {
20981        local_var_req_builder = match "multi" {
20982            "multi" => local_var_req_builder.query(
20983                &local_var_str
20984                    .into_iter()
20985                    .map(|p| ("role__nisw".to_owned(), p.to_string()))
20986                    .collect::<Vec<(std::string::String, std::string::String)>>(),
20987            ),
20988            _ => local_var_req_builder.query(&[(
20989                "role__nisw",
20990                &local_var_str
20991                    .into_iter()
20992                    .map(|p| p.to_string())
20993                    .collect::<Vec<String>>()
20994                    .join(",")
20995                    .to_string(),
20996            )]),
20997        };
20998    }
20999    if let Some(ref local_var_str) = role__regex {
21000        local_var_req_builder = match "multi" {
21001            "multi" => local_var_req_builder.query(
21002                &local_var_str
21003                    .into_iter()
21004                    .map(|p| ("role__regex".to_owned(), p.to_string()))
21005                    .collect::<Vec<(std::string::String, std::string::String)>>(),
21006            ),
21007            _ => local_var_req_builder.query(&[(
21008                "role__regex",
21009                &local_var_str
21010                    .into_iter()
21011                    .map(|p| p.to_string())
21012                    .collect::<Vec<String>>()
21013                    .join(",")
21014                    .to_string(),
21015            )]),
21016        };
21017    }
21018    if let Some(ref local_var_str) = start {
21019        local_var_req_builder =
21020            local_var_req_builder.query(&[("start", &local_var_str.to_string())]);
21021    }
21022    if let Some(ref local_var_str) = tag {
21023        local_var_req_builder = match "multi" {
21024            "multi" => local_var_req_builder.query(
21025                &local_var_str
21026                    .into_iter()
21027                    .map(|p| ("tag".to_owned(), p.to_string()))
21028                    .collect::<Vec<(std::string::String, std::string::String)>>(),
21029            ),
21030            _ => local_var_req_builder.query(&[(
21031                "tag",
21032                &local_var_str
21033                    .into_iter()
21034                    .map(|p| p.to_string())
21035                    .collect::<Vec<String>>()
21036                    .join(",")
21037                    .to_string(),
21038            )]),
21039        };
21040    }
21041    if let Some(ref local_var_str) = tag__n {
21042        local_var_req_builder = match "multi" {
21043            "multi" => local_var_req_builder.query(
21044                &local_var_str
21045                    .into_iter()
21046                    .map(|p| ("tag__n".to_owned(), p.to_string()))
21047                    .collect::<Vec<(std::string::String, std::string::String)>>(),
21048            ),
21049            _ => local_var_req_builder.query(&[(
21050                "tag__n",
21051                &local_var_str
21052                    .into_iter()
21053                    .map(|p| p.to_string())
21054                    .collect::<Vec<String>>()
21055                    .join(",")
21056                    .to_string(),
21057            )]),
21058        };
21059    }
21060    if let Some(ref local_var_str) = tag_id {
21061        local_var_req_builder = match "multi" {
21062            "multi" => local_var_req_builder.query(
21063                &local_var_str
21064                    .into_iter()
21065                    .map(|p| ("tag_id".to_owned(), p.to_string()))
21066                    .collect::<Vec<(std::string::String, std::string::String)>>(),
21067            ),
21068            _ => local_var_req_builder.query(&[(
21069                "tag_id",
21070                &local_var_str
21071                    .into_iter()
21072                    .map(|p| p.to_string())
21073                    .collect::<Vec<String>>()
21074                    .join(",")
21075                    .to_string(),
21076            )]),
21077        };
21078    }
21079    if let Some(ref local_var_str) = tag_id__n {
21080        local_var_req_builder = match "multi" {
21081            "multi" => local_var_req_builder.query(
21082                &local_var_str
21083                    .into_iter()
21084                    .map(|p| ("tag_id__n".to_owned(), p.to_string()))
21085                    .collect::<Vec<(std::string::String, std::string::String)>>(),
21086            ),
21087            _ => local_var_req_builder.query(&[(
21088                "tag_id__n",
21089                &local_var_str
21090                    .into_iter()
21091                    .map(|p| p.to_string())
21092                    .collect::<Vec<String>>()
21093                    .join(",")
21094                    .to_string(),
21095            )]),
21096        };
21097    }
21098    if let Some(ref local_var_str) = updated_by_request {
21099        local_var_req_builder =
21100            local_var_req_builder.query(&[("updated_by_request", &local_var_str.to_string())]);
21101    }
21102    if let Some(ref local_var_str) = virtual_circuit_id {
21103        local_var_req_builder = match "multi" {
21104            "multi" => local_var_req_builder.query(
21105                &local_var_str
21106                    .into_iter()
21107                    .map(|p| ("virtual_circuit_id".to_owned(), p.to_string()))
21108                    .collect::<Vec<(std::string::String, std::string::String)>>(),
21109            ),
21110            _ => local_var_req_builder.query(&[(
21111                "virtual_circuit_id",
21112                &local_var_str
21113                    .into_iter()
21114                    .map(|p| p.to_string())
21115                    .collect::<Vec<String>>()
21116                    .join(",")
21117                    .to_string(),
21118            )]),
21119        };
21120    }
21121    if let Some(ref local_var_str) = virtual_circuit_id__n {
21122        local_var_req_builder = match "multi" {
21123            "multi" => local_var_req_builder.query(
21124                &local_var_str
21125                    .into_iter()
21126                    .map(|p| ("virtual_circuit_id__n".to_owned(), p.to_string()))
21127                    .collect::<Vec<(std::string::String, std::string::String)>>(),
21128            ),
21129            _ => local_var_req_builder.query(&[(
21130                "virtual_circuit_id__n",
21131                &local_var_str
21132                    .into_iter()
21133                    .map(|p| p.to_string())
21134                    .collect::<Vec<String>>()
21135                    .join(",")
21136                    .to_string(),
21137            )]),
21138        };
21139    }
21140    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
21141        local_var_req_builder =
21142            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
21143    }
21144    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
21145        let local_var_key = local_var_apikey.key.clone();
21146        let local_var_value = match local_var_apikey.prefix {
21147            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
21148            None => local_var_key,
21149        };
21150        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
21151    };
21152
21153    let local_var_req = local_var_req_builder.build()?;
21154    let local_var_resp = local_var_client.execute(local_var_req).await?;
21155
21156    let local_var_status = local_var_resp.status();
21157    let local_var_content = local_var_resp.text().await?;
21158
21159    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
21160        serde_json::from_str(&local_var_content).map_err(Error::from)
21161    } else {
21162        let local_var_entity: Option<CircuitsVirtualCircuitTerminationsListError> =
21163            serde_json::from_str(&local_var_content).ok();
21164        let local_var_error = ResponseContent {
21165            status: local_var_status,
21166            content: local_var_content,
21167            entity: local_var_entity,
21168        };
21169        Err(Error::ResponseError(local_var_error))
21170    }
21171}
21172
21173/// Patch a virtual circuit termination object.
21174pub async fn circuits_virtual_circuit_terminations_partial_update(
21175    configuration: &configuration::Configuration,
21176    id: i32,
21177    patched_writable_virtual_circuit_termination_request: Option<
21178        crate::models::PatchedWritableVirtualCircuitTerminationRequest,
21179    >,
21180) -> Result<
21181    crate::models::VirtualCircuitTermination,
21182    Error<CircuitsVirtualCircuitTerminationsPartialUpdateError>,
21183> {
21184    let local_var_configuration = configuration;
21185
21186    let local_var_client = &local_var_configuration.client;
21187
21188    let local_var_uri_str = format!(
21189        "{}/api/circuits/virtual-circuit-terminations/{id}/",
21190        local_var_configuration.base_path,
21191        id = id
21192    );
21193    let mut local_var_req_builder =
21194        local_var_client.request(reqwest::Method::PATCH, local_var_uri_str.as_str());
21195
21196    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
21197        local_var_req_builder =
21198            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
21199    }
21200    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
21201        let local_var_key = local_var_apikey.key.clone();
21202        let local_var_value = match local_var_apikey.prefix {
21203            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
21204            None => local_var_key,
21205        };
21206        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
21207    };
21208    local_var_req_builder =
21209        local_var_req_builder.json(&patched_writable_virtual_circuit_termination_request);
21210
21211    let local_var_req = local_var_req_builder.build()?;
21212    let local_var_resp = local_var_client.execute(local_var_req).await?;
21213
21214    let local_var_status = local_var_resp.status();
21215    let local_var_content = local_var_resp.text().await?;
21216
21217    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
21218        serde_json::from_str(&local_var_content).map_err(Error::from)
21219    } else {
21220        let local_var_entity: Option<CircuitsVirtualCircuitTerminationsPartialUpdateError> =
21221            serde_json::from_str(&local_var_content).ok();
21222        let local_var_error = ResponseContent {
21223            status: local_var_status,
21224            content: local_var_content,
21225            entity: local_var_entity,
21226        };
21227        Err(Error::ResponseError(local_var_error))
21228    }
21229}
21230
21231/// Return all CablePaths which traverse a given pass-through port.
21232pub async fn circuits_virtual_circuit_terminations_paths_retrieve(
21233    configuration: &configuration::Configuration,
21234    id: i32,
21235) -> Result<
21236    crate::models::VirtualCircuitTermination,
21237    Error<CircuitsVirtualCircuitTerminationsPathsRetrieveError>,
21238> {
21239    let local_var_configuration = configuration;
21240
21241    let local_var_client = &local_var_configuration.client;
21242
21243    let local_var_uri_str = format!(
21244        "{}/api/circuits/virtual-circuit-terminations/{id}/paths/",
21245        local_var_configuration.base_path,
21246        id = id
21247    );
21248    let mut local_var_req_builder =
21249        local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
21250
21251    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
21252        local_var_req_builder =
21253            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
21254    }
21255    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
21256        let local_var_key = local_var_apikey.key.clone();
21257        let local_var_value = match local_var_apikey.prefix {
21258            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
21259            None => local_var_key,
21260        };
21261        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
21262    };
21263
21264    let local_var_req = local_var_req_builder.build()?;
21265    let local_var_resp = local_var_client.execute(local_var_req).await?;
21266
21267    let local_var_status = local_var_resp.status();
21268    let local_var_content = local_var_resp.text().await?;
21269
21270    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
21271        serde_json::from_str(&local_var_content).map_err(Error::from)
21272    } else {
21273        let local_var_entity: Option<CircuitsVirtualCircuitTerminationsPathsRetrieveError> =
21274            serde_json::from_str(&local_var_content).ok();
21275        let local_var_error = ResponseContent {
21276            status: local_var_status,
21277            content: local_var_content,
21278            entity: local_var_entity,
21279        };
21280        Err(Error::ResponseError(local_var_error))
21281    }
21282}
21283
21284/// Get a virtual circuit termination object.
21285pub async fn circuits_virtual_circuit_terminations_retrieve(
21286    configuration: &configuration::Configuration,
21287    id: i32,
21288) -> Result<
21289    crate::models::VirtualCircuitTermination,
21290    Error<CircuitsVirtualCircuitTerminationsRetrieveError>,
21291> {
21292    let local_var_configuration = configuration;
21293
21294    let local_var_client = &local_var_configuration.client;
21295
21296    let local_var_uri_str = format!(
21297        "{}/api/circuits/virtual-circuit-terminations/{id}/",
21298        local_var_configuration.base_path,
21299        id = id
21300    );
21301    let mut local_var_req_builder =
21302        local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
21303
21304    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
21305        local_var_req_builder =
21306            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
21307    }
21308    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
21309        let local_var_key = local_var_apikey.key.clone();
21310        let local_var_value = match local_var_apikey.prefix {
21311            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
21312            None => local_var_key,
21313        };
21314        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
21315    };
21316
21317    let local_var_req = local_var_req_builder.build()?;
21318    let local_var_resp = local_var_client.execute(local_var_req).await?;
21319
21320    let local_var_status = local_var_resp.status();
21321    let local_var_content = local_var_resp.text().await?;
21322
21323    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
21324        serde_json::from_str(&local_var_content).map_err(Error::from)
21325    } else {
21326        let local_var_entity: Option<CircuitsVirtualCircuitTerminationsRetrieveError> =
21327            serde_json::from_str(&local_var_content).ok();
21328        let local_var_error = ResponseContent {
21329            status: local_var_status,
21330            content: local_var_content,
21331            entity: local_var_entity,
21332        };
21333        Err(Error::ResponseError(local_var_error))
21334    }
21335}
21336
21337/// Put a virtual circuit termination object.
21338pub async fn circuits_virtual_circuit_terminations_update(
21339    configuration: &configuration::Configuration,
21340    id: i32,
21341    writable_virtual_circuit_termination_request: crate::models::WritableVirtualCircuitTerminationRequest,
21342) -> Result<
21343    crate::models::VirtualCircuitTermination,
21344    Error<CircuitsVirtualCircuitTerminationsUpdateError>,
21345> {
21346    let local_var_configuration = configuration;
21347
21348    let local_var_client = &local_var_configuration.client;
21349
21350    let local_var_uri_str = format!(
21351        "{}/api/circuits/virtual-circuit-terminations/{id}/",
21352        local_var_configuration.base_path,
21353        id = id
21354    );
21355    let mut local_var_req_builder =
21356        local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());
21357
21358    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
21359        local_var_req_builder =
21360            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
21361    }
21362    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
21363        let local_var_key = local_var_apikey.key.clone();
21364        let local_var_value = match local_var_apikey.prefix {
21365            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
21366            None => local_var_key,
21367        };
21368        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
21369    };
21370    local_var_req_builder =
21371        local_var_req_builder.json(&writable_virtual_circuit_termination_request);
21372
21373    let local_var_req = local_var_req_builder.build()?;
21374    let local_var_resp = local_var_client.execute(local_var_req).await?;
21375
21376    let local_var_status = local_var_resp.status();
21377    let local_var_content = local_var_resp.text().await?;
21378
21379    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
21380        serde_json::from_str(&local_var_content).map_err(Error::from)
21381    } else {
21382        let local_var_entity: Option<CircuitsVirtualCircuitTerminationsUpdateError> =
21383            serde_json::from_str(&local_var_content).ok();
21384        let local_var_error = ResponseContent {
21385            status: local_var_status,
21386            content: local_var_content,
21387            entity: local_var_entity,
21388        };
21389        Err(Error::ResponseError(local_var_error))
21390    }
21391}
21392
21393/// Delete a list of virtual circuit type objects.
21394pub async fn circuits_virtual_circuit_types_bulk_destroy(
21395    configuration: &configuration::Configuration,
21396    virtual_circuit_type_request: Vec<crate::models::VirtualCircuitTypeRequest>,
21397) -> Result<(), Error<CircuitsVirtualCircuitTypesBulkDestroyError>> {
21398    let local_var_configuration = configuration;
21399
21400    let local_var_client = &local_var_configuration.client;
21401
21402    let local_var_uri_str = format!(
21403        "{}/api/circuits/virtual-circuit-types/",
21404        local_var_configuration.base_path
21405    );
21406    let mut local_var_req_builder =
21407        local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());
21408
21409    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
21410        local_var_req_builder =
21411            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
21412    }
21413    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
21414        let local_var_key = local_var_apikey.key.clone();
21415        let local_var_value = match local_var_apikey.prefix {
21416            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
21417            None => local_var_key,
21418        };
21419        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
21420    };
21421    local_var_req_builder = local_var_req_builder.json(&virtual_circuit_type_request);
21422
21423    let local_var_req = local_var_req_builder.build()?;
21424    let local_var_resp = local_var_client.execute(local_var_req).await?;
21425
21426    let local_var_status = local_var_resp.status();
21427    let local_var_content = local_var_resp.text().await?;
21428
21429    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
21430        Ok(())
21431    } else {
21432        let local_var_entity: Option<CircuitsVirtualCircuitTypesBulkDestroyError> =
21433            serde_json::from_str(&local_var_content).ok();
21434        let local_var_error = ResponseContent {
21435            status: local_var_status,
21436            content: local_var_content,
21437            entity: local_var_entity,
21438        };
21439        Err(Error::ResponseError(local_var_error))
21440    }
21441}
21442
21443/// Patch a list of virtual circuit type objects.
21444pub async fn circuits_virtual_circuit_types_bulk_partial_update(
21445    configuration: &configuration::Configuration,
21446    virtual_circuit_type_request: Vec<crate::models::VirtualCircuitTypeRequest>,
21447) -> Result<
21448    Vec<crate::models::VirtualCircuitType>,
21449    Error<CircuitsVirtualCircuitTypesBulkPartialUpdateError>,
21450> {
21451    let local_var_configuration = configuration;
21452
21453    let local_var_client = &local_var_configuration.client;
21454
21455    let local_var_uri_str = format!(
21456        "{}/api/circuits/virtual-circuit-types/",
21457        local_var_configuration.base_path
21458    );
21459    let mut local_var_req_builder =
21460        local_var_client.request(reqwest::Method::PATCH, local_var_uri_str.as_str());
21461
21462    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
21463        local_var_req_builder =
21464            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
21465    }
21466    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
21467        let local_var_key = local_var_apikey.key.clone();
21468        let local_var_value = match local_var_apikey.prefix {
21469            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
21470            None => local_var_key,
21471        };
21472        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
21473    };
21474    local_var_req_builder = local_var_req_builder.json(&virtual_circuit_type_request);
21475
21476    let local_var_req = local_var_req_builder.build()?;
21477    let local_var_resp = local_var_client.execute(local_var_req).await?;
21478
21479    let local_var_status = local_var_resp.status();
21480    let local_var_content = local_var_resp.text().await?;
21481
21482    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
21483        serde_json::from_str(&local_var_content).map_err(Error::from)
21484    } else {
21485        let local_var_entity: Option<CircuitsVirtualCircuitTypesBulkPartialUpdateError> =
21486            serde_json::from_str(&local_var_content).ok();
21487        let local_var_error = ResponseContent {
21488            status: local_var_status,
21489            content: local_var_content,
21490            entity: local_var_entity,
21491        };
21492        Err(Error::ResponseError(local_var_error))
21493    }
21494}
21495
21496/// Put a list of virtual circuit type objects.
21497pub async fn circuits_virtual_circuit_types_bulk_update(
21498    configuration: &configuration::Configuration,
21499    virtual_circuit_type_request: Vec<crate::models::VirtualCircuitTypeRequest>,
21500) -> Result<Vec<crate::models::VirtualCircuitType>, Error<CircuitsVirtualCircuitTypesBulkUpdateError>>
21501{
21502    let local_var_configuration = configuration;
21503
21504    let local_var_client = &local_var_configuration.client;
21505
21506    let local_var_uri_str = format!(
21507        "{}/api/circuits/virtual-circuit-types/",
21508        local_var_configuration.base_path
21509    );
21510    let mut local_var_req_builder =
21511        local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());
21512
21513    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
21514        local_var_req_builder =
21515            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
21516    }
21517    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
21518        let local_var_key = local_var_apikey.key.clone();
21519        let local_var_value = match local_var_apikey.prefix {
21520            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
21521            None => local_var_key,
21522        };
21523        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
21524    };
21525    local_var_req_builder = local_var_req_builder.json(&virtual_circuit_type_request);
21526
21527    let local_var_req = local_var_req_builder.build()?;
21528    let local_var_resp = local_var_client.execute(local_var_req).await?;
21529
21530    let local_var_status = local_var_resp.status();
21531    let local_var_content = local_var_resp.text().await?;
21532
21533    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
21534        serde_json::from_str(&local_var_content).map_err(Error::from)
21535    } else {
21536        let local_var_entity: Option<CircuitsVirtualCircuitTypesBulkUpdateError> =
21537            serde_json::from_str(&local_var_content).ok();
21538        let local_var_error = ResponseContent {
21539            status: local_var_status,
21540            content: local_var_content,
21541            entity: local_var_entity,
21542        };
21543        Err(Error::ResponseError(local_var_error))
21544    }
21545}
21546
21547/// Post a list of virtual circuit type objects.
21548pub async fn circuits_virtual_circuit_types_create(
21549    configuration: &configuration::Configuration,
21550    circuits_virtual_circuit_types_create_request: crate::models::CircuitsVirtualCircuitTypesCreateRequest,
21551) -> Result<crate::models::VirtualCircuitType, Error<CircuitsVirtualCircuitTypesCreateError>> {
21552    let local_var_configuration = configuration;
21553
21554    let local_var_client = &local_var_configuration.client;
21555
21556    let local_var_uri_str = format!(
21557        "{}/api/circuits/virtual-circuit-types/",
21558        local_var_configuration.base_path
21559    );
21560    let mut local_var_req_builder =
21561        local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
21562
21563    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
21564        local_var_req_builder =
21565            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
21566    }
21567    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
21568        let local_var_key = local_var_apikey.key.clone();
21569        let local_var_value = match local_var_apikey.prefix {
21570            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
21571            None => local_var_key,
21572        };
21573        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
21574    };
21575    local_var_req_builder =
21576        local_var_req_builder.json(&circuits_virtual_circuit_types_create_request);
21577
21578    let local_var_req = local_var_req_builder.build()?;
21579    let local_var_resp = local_var_client.execute(local_var_req).await?;
21580
21581    let local_var_status = local_var_resp.status();
21582    let local_var_content = local_var_resp.text().await?;
21583
21584    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
21585        serde_json::from_str(&local_var_content).map_err(Error::from)
21586    } else {
21587        let local_var_entity: Option<CircuitsVirtualCircuitTypesCreateError> =
21588            serde_json::from_str(&local_var_content).ok();
21589        let local_var_error = ResponseContent {
21590            status: local_var_status,
21591            content: local_var_content,
21592            entity: local_var_entity,
21593        };
21594        Err(Error::ResponseError(local_var_error))
21595    }
21596}
21597
21598/// Delete a virtual circuit type object.
21599pub async fn circuits_virtual_circuit_types_destroy(
21600    configuration: &configuration::Configuration,
21601    id: i32,
21602) -> Result<(), Error<CircuitsVirtualCircuitTypesDestroyError>> {
21603    let local_var_configuration = configuration;
21604
21605    let local_var_client = &local_var_configuration.client;
21606
21607    let local_var_uri_str = format!(
21608        "{}/api/circuits/virtual-circuit-types/{id}/",
21609        local_var_configuration.base_path,
21610        id = id
21611    );
21612    let mut local_var_req_builder =
21613        local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());
21614
21615    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
21616        local_var_req_builder =
21617            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
21618    }
21619    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
21620        let local_var_key = local_var_apikey.key.clone();
21621        let local_var_value = match local_var_apikey.prefix {
21622            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
21623            None => local_var_key,
21624        };
21625        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
21626    };
21627
21628    let local_var_req = local_var_req_builder.build()?;
21629    let local_var_resp = local_var_client.execute(local_var_req).await?;
21630
21631    let local_var_status = local_var_resp.status();
21632    let local_var_content = local_var_resp.text().await?;
21633
21634    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
21635        Ok(())
21636    } else {
21637        let local_var_entity: Option<CircuitsVirtualCircuitTypesDestroyError> =
21638            serde_json::from_str(&local_var_content).ok();
21639        let local_var_error = ResponseContent {
21640            status: local_var_status,
21641            content: local_var_content,
21642            entity: local_var_entity,
21643        };
21644        Err(Error::ResponseError(local_var_error))
21645    }
21646}
21647
21648/// Get a list of virtual circuit type objects.
21649pub async fn circuits_virtual_circuit_types_list(
21650    configuration: &configuration::Configuration,
21651    color: Option<Vec<String>>,
21652    color__empty: Option<bool>,
21653    color__ic: Option<Vec<String>>,
21654    color__ie: Option<Vec<String>>,
21655    color__iew: Option<Vec<String>>,
21656    color__iregex: Option<Vec<String>>,
21657    color__isw: Option<Vec<String>>,
21658    color__n: Option<Vec<String>>,
21659    color__nic: Option<Vec<String>>,
21660    color__nie: Option<Vec<String>>,
21661    color__niew: Option<Vec<String>>,
21662    color__nisw: Option<Vec<String>>,
21663    color__regex: Option<Vec<String>>,
21664    created: Option<Vec<String>>,
21665    created__empty: Option<Vec<String>>,
21666    created__gt: Option<Vec<String>>,
21667    created__gte: Option<Vec<String>>,
21668    created__lt: Option<Vec<String>>,
21669    created__lte: Option<Vec<String>>,
21670    created__n: Option<Vec<String>>,
21671    created_by_request: Option<&str>,
21672    description: Option<Vec<String>>,
21673    description__empty: Option<bool>,
21674    description__ic: Option<Vec<String>>,
21675    description__ie: Option<Vec<String>>,
21676    description__iew: Option<Vec<String>>,
21677    description__iregex: Option<Vec<String>>,
21678    description__isw: Option<Vec<String>>,
21679    description__n: Option<Vec<String>>,
21680    description__nic: Option<Vec<String>>,
21681    description__nie: Option<Vec<String>>,
21682    description__niew: Option<Vec<String>>,
21683    description__nisw: Option<Vec<String>>,
21684    description__regex: Option<Vec<String>>,
21685    id: Option<Vec<i32>>,
21686    id__empty: Option<bool>,
21687    id__gt: Option<Vec<i32>>,
21688    id__gte: Option<Vec<i32>>,
21689    id__lt: Option<Vec<i32>>,
21690    id__lte: Option<Vec<i32>>,
21691    id__n: Option<Vec<i32>>,
21692    last_updated: Option<Vec<String>>,
21693    last_updated__empty: Option<Vec<String>>,
21694    last_updated__gt: Option<Vec<String>>,
21695    last_updated__gte: Option<Vec<String>>,
21696    last_updated__lt: Option<Vec<String>>,
21697    last_updated__lte: Option<Vec<String>>,
21698    last_updated__n: Option<Vec<String>>,
21699    limit: Option<i32>,
21700    modified_by_request: Option<&str>,
21701    name: Option<Vec<String>>,
21702    name__empty: Option<bool>,
21703    name__ic: Option<Vec<String>>,
21704    name__ie: Option<Vec<String>>,
21705    name__iew: Option<Vec<String>>,
21706    name__iregex: Option<Vec<String>>,
21707    name__isw: Option<Vec<String>>,
21708    name__n: Option<Vec<String>>,
21709    name__nic: Option<Vec<String>>,
21710    name__nie: Option<Vec<String>>,
21711    name__niew: Option<Vec<String>>,
21712    name__nisw: Option<Vec<String>>,
21713    name__regex: Option<Vec<String>>,
21714    offset: Option<i32>,
21715    ordering: Option<&str>,
21716    owner: Option<Vec<String>>,
21717    owner__n: Option<Vec<String>>,
21718    owner_group: Option<Vec<String>>,
21719    owner_group__n: Option<Vec<String>>,
21720    owner_group_id: Option<Vec<i32>>,
21721    owner_group_id__n: Option<Vec<i32>>,
21722    owner_id: Option<Vec<i32>>,
21723    owner_id__n: Option<Vec<i32>>,
21724    q: Option<&str>,
21725    slug: Option<Vec<String>>,
21726    slug__empty: Option<bool>,
21727    slug__ic: Option<Vec<String>>,
21728    slug__ie: Option<Vec<String>>,
21729    slug__iew: Option<Vec<String>>,
21730    slug__iregex: Option<Vec<String>>,
21731    slug__isw: Option<Vec<String>>,
21732    slug__n: Option<Vec<String>>,
21733    slug__nic: Option<Vec<String>>,
21734    slug__nie: Option<Vec<String>>,
21735    slug__niew: Option<Vec<String>>,
21736    slug__nisw: Option<Vec<String>>,
21737    slug__regex: Option<Vec<String>>,
21738    start: Option<i32>,
21739    tag: Option<Vec<String>>,
21740    tag__n: Option<Vec<String>>,
21741    tag_id: Option<Vec<i32>>,
21742    tag_id__n: Option<Vec<i32>>,
21743    updated_by_request: Option<&str>,
21744) -> Result<
21745    crate::models::PaginatedVirtualCircuitTypeList,
21746    Error<CircuitsVirtualCircuitTypesListError>,
21747> {
21748    let local_var_configuration = configuration;
21749
21750    let local_var_client = &local_var_configuration.client;
21751
21752    let local_var_uri_str = format!(
21753        "{}/api/circuits/virtual-circuit-types/",
21754        local_var_configuration.base_path
21755    );
21756    let mut local_var_req_builder =
21757        local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
21758
21759    if let Some(ref local_var_str) = color {
21760        local_var_req_builder = match "multi" {
21761            "multi" => local_var_req_builder.query(
21762                &local_var_str
21763                    .into_iter()
21764                    .map(|p| ("color".to_owned(), p.to_string()))
21765                    .collect::<Vec<(std::string::String, std::string::String)>>(),
21766            ),
21767            _ => local_var_req_builder.query(&[(
21768                "color",
21769                &local_var_str
21770                    .into_iter()
21771                    .map(|p| p.to_string())
21772                    .collect::<Vec<String>>()
21773                    .join(",")
21774                    .to_string(),
21775            )]),
21776        };
21777    }
21778    if let Some(ref local_var_str) = color__empty {
21779        local_var_req_builder =
21780            local_var_req_builder.query(&[("color__empty", &local_var_str.to_string())]);
21781    }
21782    if let Some(ref local_var_str) = color__ic {
21783        local_var_req_builder = match "multi" {
21784            "multi" => local_var_req_builder.query(
21785                &local_var_str
21786                    .into_iter()
21787                    .map(|p| ("color__ic".to_owned(), p.to_string()))
21788                    .collect::<Vec<(std::string::String, std::string::String)>>(),
21789            ),
21790            _ => local_var_req_builder.query(&[(
21791                "color__ic",
21792                &local_var_str
21793                    .into_iter()
21794                    .map(|p| p.to_string())
21795                    .collect::<Vec<String>>()
21796                    .join(",")
21797                    .to_string(),
21798            )]),
21799        };
21800    }
21801    if let Some(ref local_var_str) = color__ie {
21802        local_var_req_builder = match "multi" {
21803            "multi" => local_var_req_builder.query(
21804                &local_var_str
21805                    .into_iter()
21806                    .map(|p| ("color__ie".to_owned(), p.to_string()))
21807                    .collect::<Vec<(std::string::String, std::string::String)>>(),
21808            ),
21809            _ => local_var_req_builder.query(&[(
21810                "color__ie",
21811                &local_var_str
21812                    .into_iter()
21813                    .map(|p| p.to_string())
21814                    .collect::<Vec<String>>()
21815                    .join(",")
21816                    .to_string(),
21817            )]),
21818        };
21819    }
21820    if let Some(ref local_var_str) = color__iew {
21821        local_var_req_builder = match "multi" {
21822            "multi" => local_var_req_builder.query(
21823                &local_var_str
21824                    .into_iter()
21825                    .map(|p| ("color__iew".to_owned(), p.to_string()))
21826                    .collect::<Vec<(std::string::String, std::string::String)>>(),
21827            ),
21828            _ => local_var_req_builder.query(&[(
21829                "color__iew",
21830                &local_var_str
21831                    .into_iter()
21832                    .map(|p| p.to_string())
21833                    .collect::<Vec<String>>()
21834                    .join(",")
21835                    .to_string(),
21836            )]),
21837        };
21838    }
21839    if let Some(ref local_var_str) = color__iregex {
21840        local_var_req_builder = match "multi" {
21841            "multi" => local_var_req_builder.query(
21842                &local_var_str
21843                    .into_iter()
21844                    .map(|p| ("color__iregex".to_owned(), p.to_string()))
21845                    .collect::<Vec<(std::string::String, std::string::String)>>(),
21846            ),
21847            _ => local_var_req_builder.query(&[(
21848                "color__iregex",
21849                &local_var_str
21850                    .into_iter()
21851                    .map(|p| p.to_string())
21852                    .collect::<Vec<String>>()
21853                    .join(",")
21854                    .to_string(),
21855            )]),
21856        };
21857    }
21858    if let Some(ref local_var_str) = color__isw {
21859        local_var_req_builder = match "multi" {
21860            "multi" => local_var_req_builder.query(
21861                &local_var_str
21862                    .into_iter()
21863                    .map(|p| ("color__isw".to_owned(), p.to_string()))
21864                    .collect::<Vec<(std::string::String, std::string::String)>>(),
21865            ),
21866            _ => local_var_req_builder.query(&[(
21867                "color__isw",
21868                &local_var_str
21869                    .into_iter()
21870                    .map(|p| p.to_string())
21871                    .collect::<Vec<String>>()
21872                    .join(",")
21873                    .to_string(),
21874            )]),
21875        };
21876    }
21877    if let Some(ref local_var_str) = color__n {
21878        local_var_req_builder = match "multi" {
21879            "multi" => local_var_req_builder.query(
21880                &local_var_str
21881                    .into_iter()
21882                    .map(|p| ("color__n".to_owned(), p.to_string()))
21883                    .collect::<Vec<(std::string::String, std::string::String)>>(),
21884            ),
21885            _ => local_var_req_builder.query(&[(
21886                "color__n",
21887                &local_var_str
21888                    .into_iter()
21889                    .map(|p| p.to_string())
21890                    .collect::<Vec<String>>()
21891                    .join(",")
21892                    .to_string(),
21893            )]),
21894        };
21895    }
21896    if let Some(ref local_var_str) = color__nic {
21897        local_var_req_builder = match "multi" {
21898            "multi" => local_var_req_builder.query(
21899                &local_var_str
21900                    .into_iter()
21901                    .map(|p| ("color__nic".to_owned(), p.to_string()))
21902                    .collect::<Vec<(std::string::String, std::string::String)>>(),
21903            ),
21904            _ => local_var_req_builder.query(&[(
21905                "color__nic",
21906                &local_var_str
21907                    .into_iter()
21908                    .map(|p| p.to_string())
21909                    .collect::<Vec<String>>()
21910                    .join(",")
21911                    .to_string(),
21912            )]),
21913        };
21914    }
21915    if let Some(ref local_var_str) = color__nie {
21916        local_var_req_builder = match "multi" {
21917            "multi" => local_var_req_builder.query(
21918                &local_var_str
21919                    .into_iter()
21920                    .map(|p| ("color__nie".to_owned(), p.to_string()))
21921                    .collect::<Vec<(std::string::String, std::string::String)>>(),
21922            ),
21923            _ => local_var_req_builder.query(&[(
21924                "color__nie",
21925                &local_var_str
21926                    .into_iter()
21927                    .map(|p| p.to_string())
21928                    .collect::<Vec<String>>()
21929                    .join(",")
21930                    .to_string(),
21931            )]),
21932        };
21933    }
21934    if let Some(ref local_var_str) = color__niew {
21935        local_var_req_builder = match "multi" {
21936            "multi" => local_var_req_builder.query(
21937                &local_var_str
21938                    .into_iter()
21939                    .map(|p| ("color__niew".to_owned(), p.to_string()))
21940                    .collect::<Vec<(std::string::String, std::string::String)>>(),
21941            ),
21942            _ => local_var_req_builder.query(&[(
21943                "color__niew",
21944                &local_var_str
21945                    .into_iter()
21946                    .map(|p| p.to_string())
21947                    .collect::<Vec<String>>()
21948                    .join(",")
21949                    .to_string(),
21950            )]),
21951        };
21952    }
21953    if let Some(ref local_var_str) = color__nisw {
21954        local_var_req_builder = match "multi" {
21955            "multi" => local_var_req_builder.query(
21956                &local_var_str
21957                    .into_iter()
21958                    .map(|p| ("color__nisw".to_owned(), p.to_string()))
21959                    .collect::<Vec<(std::string::String, std::string::String)>>(),
21960            ),
21961            _ => local_var_req_builder.query(&[(
21962                "color__nisw",
21963                &local_var_str
21964                    .into_iter()
21965                    .map(|p| p.to_string())
21966                    .collect::<Vec<String>>()
21967                    .join(",")
21968                    .to_string(),
21969            )]),
21970        };
21971    }
21972    if let Some(ref local_var_str) = color__regex {
21973        local_var_req_builder = match "multi" {
21974            "multi" => local_var_req_builder.query(
21975                &local_var_str
21976                    .into_iter()
21977                    .map(|p| ("color__regex".to_owned(), p.to_string()))
21978                    .collect::<Vec<(std::string::String, std::string::String)>>(),
21979            ),
21980            _ => local_var_req_builder.query(&[(
21981                "color__regex",
21982                &local_var_str
21983                    .into_iter()
21984                    .map(|p| p.to_string())
21985                    .collect::<Vec<String>>()
21986                    .join(",")
21987                    .to_string(),
21988            )]),
21989        };
21990    }
21991    if let Some(ref local_var_str) = created {
21992        local_var_req_builder = match "multi" {
21993            "multi" => local_var_req_builder.query(
21994                &local_var_str
21995                    .into_iter()
21996                    .map(|p| ("created".to_owned(), p.to_string()))
21997                    .collect::<Vec<(std::string::String, std::string::String)>>(),
21998            ),
21999            _ => local_var_req_builder.query(&[(
22000                "created",
22001                &local_var_str
22002                    .into_iter()
22003                    .map(|p| p.to_string())
22004                    .collect::<Vec<String>>()
22005                    .join(",")
22006                    .to_string(),
22007            )]),
22008        };
22009    }
22010    if let Some(ref local_var_str) = created__empty {
22011        local_var_req_builder = match "multi" {
22012            "multi" => local_var_req_builder.query(
22013                &local_var_str
22014                    .into_iter()
22015                    .map(|p| ("created__empty".to_owned(), p.to_string()))
22016                    .collect::<Vec<(std::string::String, std::string::String)>>(),
22017            ),
22018            _ => local_var_req_builder.query(&[(
22019                "created__empty",
22020                &local_var_str
22021                    .into_iter()
22022                    .map(|p| p.to_string())
22023                    .collect::<Vec<String>>()
22024                    .join(",")
22025                    .to_string(),
22026            )]),
22027        };
22028    }
22029    if let Some(ref local_var_str) = created__gt {
22030        local_var_req_builder = match "multi" {
22031            "multi" => local_var_req_builder.query(
22032                &local_var_str
22033                    .into_iter()
22034                    .map(|p| ("created__gt".to_owned(), p.to_string()))
22035                    .collect::<Vec<(std::string::String, std::string::String)>>(),
22036            ),
22037            _ => local_var_req_builder.query(&[(
22038                "created__gt",
22039                &local_var_str
22040                    .into_iter()
22041                    .map(|p| p.to_string())
22042                    .collect::<Vec<String>>()
22043                    .join(",")
22044                    .to_string(),
22045            )]),
22046        };
22047    }
22048    if let Some(ref local_var_str) = created__gte {
22049        local_var_req_builder = match "multi" {
22050            "multi" => local_var_req_builder.query(
22051                &local_var_str
22052                    .into_iter()
22053                    .map(|p| ("created__gte".to_owned(), p.to_string()))
22054                    .collect::<Vec<(std::string::String, std::string::String)>>(),
22055            ),
22056            _ => local_var_req_builder.query(&[(
22057                "created__gte",
22058                &local_var_str
22059                    .into_iter()
22060                    .map(|p| p.to_string())
22061                    .collect::<Vec<String>>()
22062                    .join(",")
22063                    .to_string(),
22064            )]),
22065        };
22066    }
22067    if let Some(ref local_var_str) = created__lt {
22068        local_var_req_builder = match "multi" {
22069            "multi" => local_var_req_builder.query(
22070                &local_var_str
22071                    .into_iter()
22072                    .map(|p| ("created__lt".to_owned(), p.to_string()))
22073                    .collect::<Vec<(std::string::String, std::string::String)>>(),
22074            ),
22075            _ => local_var_req_builder.query(&[(
22076                "created__lt",
22077                &local_var_str
22078                    .into_iter()
22079                    .map(|p| p.to_string())
22080                    .collect::<Vec<String>>()
22081                    .join(",")
22082                    .to_string(),
22083            )]),
22084        };
22085    }
22086    if let Some(ref local_var_str) = created__lte {
22087        local_var_req_builder = match "multi" {
22088            "multi" => local_var_req_builder.query(
22089                &local_var_str
22090                    .into_iter()
22091                    .map(|p| ("created__lte".to_owned(), p.to_string()))
22092                    .collect::<Vec<(std::string::String, std::string::String)>>(),
22093            ),
22094            _ => local_var_req_builder.query(&[(
22095                "created__lte",
22096                &local_var_str
22097                    .into_iter()
22098                    .map(|p| p.to_string())
22099                    .collect::<Vec<String>>()
22100                    .join(",")
22101                    .to_string(),
22102            )]),
22103        };
22104    }
22105    if let Some(ref local_var_str) = created__n {
22106        local_var_req_builder = match "multi" {
22107            "multi" => local_var_req_builder.query(
22108                &local_var_str
22109                    .into_iter()
22110                    .map(|p| ("created__n".to_owned(), p.to_string()))
22111                    .collect::<Vec<(std::string::String, std::string::String)>>(),
22112            ),
22113            _ => local_var_req_builder.query(&[(
22114                "created__n",
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) = created_by_request {
22125        local_var_req_builder =
22126            local_var_req_builder.query(&[("created_by_request", &local_var_str.to_string())]);
22127    }
22128    if let Some(ref local_var_str) = description {
22129        local_var_req_builder = match "multi" {
22130            "multi" => local_var_req_builder.query(
22131                &local_var_str
22132                    .into_iter()
22133                    .map(|p| ("description".to_owned(), p.to_string()))
22134                    .collect::<Vec<(std::string::String, std::string::String)>>(),
22135            ),
22136            _ => local_var_req_builder.query(&[(
22137                "description",
22138                &local_var_str
22139                    .into_iter()
22140                    .map(|p| p.to_string())
22141                    .collect::<Vec<String>>()
22142                    .join(",")
22143                    .to_string(),
22144            )]),
22145        };
22146    }
22147    if let Some(ref local_var_str) = description__empty {
22148        local_var_req_builder =
22149            local_var_req_builder.query(&[("description__empty", &local_var_str.to_string())]);
22150    }
22151    if let Some(ref local_var_str) = description__ic {
22152        local_var_req_builder = match "multi" {
22153            "multi" => local_var_req_builder.query(
22154                &local_var_str
22155                    .into_iter()
22156                    .map(|p| ("description__ic".to_owned(), p.to_string()))
22157                    .collect::<Vec<(std::string::String, std::string::String)>>(),
22158            ),
22159            _ => local_var_req_builder.query(&[(
22160                "description__ic",
22161                &local_var_str
22162                    .into_iter()
22163                    .map(|p| p.to_string())
22164                    .collect::<Vec<String>>()
22165                    .join(",")
22166                    .to_string(),
22167            )]),
22168        };
22169    }
22170    if let Some(ref local_var_str) = description__ie {
22171        local_var_req_builder = match "multi" {
22172            "multi" => local_var_req_builder.query(
22173                &local_var_str
22174                    .into_iter()
22175                    .map(|p| ("description__ie".to_owned(), p.to_string()))
22176                    .collect::<Vec<(std::string::String, std::string::String)>>(),
22177            ),
22178            _ => local_var_req_builder.query(&[(
22179                "description__ie",
22180                &local_var_str
22181                    .into_iter()
22182                    .map(|p| p.to_string())
22183                    .collect::<Vec<String>>()
22184                    .join(",")
22185                    .to_string(),
22186            )]),
22187        };
22188    }
22189    if let Some(ref local_var_str) = description__iew {
22190        local_var_req_builder = match "multi" {
22191            "multi" => local_var_req_builder.query(
22192                &local_var_str
22193                    .into_iter()
22194                    .map(|p| ("description__iew".to_owned(), p.to_string()))
22195                    .collect::<Vec<(std::string::String, std::string::String)>>(),
22196            ),
22197            _ => local_var_req_builder.query(&[(
22198                "description__iew",
22199                &local_var_str
22200                    .into_iter()
22201                    .map(|p| p.to_string())
22202                    .collect::<Vec<String>>()
22203                    .join(",")
22204                    .to_string(),
22205            )]),
22206        };
22207    }
22208    if let Some(ref local_var_str) = description__iregex {
22209        local_var_req_builder = match "multi" {
22210            "multi" => local_var_req_builder.query(
22211                &local_var_str
22212                    .into_iter()
22213                    .map(|p| ("description__iregex".to_owned(), p.to_string()))
22214                    .collect::<Vec<(std::string::String, std::string::String)>>(),
22215            ),
22216            _ => local_var_req_builder.query(&[(
22217                "description__iregex",
22218                &local_var_str
22219                    .into_iter()
22220                    .map(|p| p.to_string())
22221                    .collect::<Vec<String>>()
22222                    .join(",")
22223                    .to_string(),
22224            )]),
22225        };
22226    }
22227    if let Some(ref local_var_str) = description__isw {
22228        local_var_req_builder = match "multi" {
22229            "multi" => local_var_req_builder.query(
22230                &local_var_str
22231                    .into_iter()
22232                    .map(|p| ("description__isw".to_owned(), p.to_string()))
22233                    .collect::<Vec<(std::string::String, std::string::String)>>(),
22234            ),
22235            _ => local_var_req_builder.query(&[(
22236                "description__isw",
22237                &local_var_str
22238                    .into_iter()
22239                    .map(|p| p.to_string())
22240                    .collect::<Vec<String>>()
22241                    .join(",")
22242                    .to_string(),
22243            )]),
22244        };
22245    }
22246    if let Some(ref local_var_str) = description__n {
22247        local_var_req_builder = match "multi" {
22248            "multi" => local_var_req_builder.query(
22249                &local_var_str
22250                    .into_iter()
22251                    .map(|p| ("description__n".to_owned(), p.to_string()))
22252                    .collect::<Vec<(std::string::String, std::string::String)>>(),
22253            ),
22254            _ => local_var_req_builder.query(&[(
22255                "description__n",
22256                &local_var_str
22257                    .into_iter()
22258                    .map(|p| p.to_string())
22259                    .collect::<Vec<String>>()
22260                    .join(",")
22261                    .to_string(),
22262            )]),
22263        };
22264    }
22265    if let Some(ref local_var_str) = description__nic {
22266        local_var_req_builder = match "multi" {
22267            "multi" => local_var_req_builder.query(
22268                &local_var_str
22269                    .into_iter()
22270                    .map(|p| ("description__nic".to_owned(), p.to_string()))
22271                    .collect::<Vec<(std::string::String, std::string::String)>>(),
22272            ),
22273            _ => local_var_req_builder.query(&[(
22274                "description__nic",
22275                &local_var_str
22276                    .into_iter()
22277                    .map(|p| p.to_string())
22278                    .collect::<Vec<String>>()
22279                    .join(",")
22280                    .to_string(),
22281            )]),
22282        };
22283    }
22284    if let Some(ref local_var_str) = description__nie {
22285        local_var_req_builder = match "multi" {
22286            "multi" => local_var_req_builder.query(
22287                &local_var_str
22288                    .into_iter()
22289                    .map(|p| ("description__nie".to_owned(), p.to_string()))
22290                    .collect::<Vec<(std::string::String, std::string::String)>>(),
22291            ),
22292            _ => local_var_req_builder.query(&[(
22293                "description__nie",
22294                &local_var_str
22295                    .into_iter()
22296                    .map(|p| p.to_string())
22297                    .collect::<Vec<String>>()
22298                    .join(",")
22299                    .to_string(),
22300            )]),
22301        };
22302    }
22303    if let Some(ref local_var_str) = description__niew {
22304        local_var_req_builder = match "multi" {
22305            "multi" => local_var_req_builder.query(
22306                &local_var_str
22307                    .into_iter()
22308                    .map(|p| ("description__niew".to_owned(), p.to_string()))
22309                    .collect::<Vec<(std::string::String, std::string::String)>>(),
22310            ),
22311            _ => local_var_req_builder.query(&[(
22312                "description__niew",
22313                &local_var_str
22314                    .into_iter()
22315                    .map(|p| p.to_string())
22316                    .collect::<Vec<String>>()
22317                    .join(",")
22318                    .to_string(),
22319            )]),
22320        };
22321    }
22322    if let Some(ref local_var_str) = description__nisw {
22323        local_var_req_builder = match "multi" {
22324            "multi" => local_var_req_builder.query(
22325                &local_var_str
22326                    .into_iter()
22327                    .map(|p| ("description__nisw".to_owned(), p.to_string()))
22328                    .collect::<Vec<(std::string::String, std::string::String)>>(),
22329            ),
22330            _ => local_var_req_builder.query(&[(
22331                "description__nisw",
22332                &local_var_str
22333                    .into_iter()
22334                    .map(|p| p.to_string())
22335                    .collect::<Vec<String>>()
22336                    .join(",")
22337                    .to_string(),
22338            )]),
22339        };
22340    }
22341    if let Some(ref local_var_str) = description__regex {
22342        local_var_req_builder = match "multi" {
22343            "multi" => local_var_req_builder.query(
22344                &local_var_str
22345                    .into_iter()
22346                    .map(|p| ("description__regex".to_owned(), p.to_string()))
22347                    .collect::<Vec<(std::string::String, std::string::String)>>(),
22348            ),
22349            _ => local_var_req_builder.query(&[(
22350                "description__regex",
22351                &local_var_str
22352                    .into_iter()
22353                    .map(|p| p.to_string())
22354                    .collect::<Vec<String>>()
22355                    .join(",")
22356                    .to_string(),
22357            )]),
22358        };
22359    }
22360    if let Some(ref local_var_str) = id {
22361        local_var_req_builder = match "multi" {
22362            "multi" => local_var_req_builder.query(
22363                &local_var_str
22364                    .into_iter()
22365                    .map(|p| ("id".to_owned(), p.to_string()))
22366                    .collect::<Vec<(std::string::String, std::string::String)>>(),
22367            ),
22368            _ => local_var_req_builder.query(&[(
22369                "id",
22370                &local_var_str
22371                    .into_iter()
22372                    .map(|p| p.to_string())
22373                    .collect::<Vec<String>>()
22374                    .join(",")
22375                    .to_string(),
22376            )]),
22377        };
22378    }
22379    if let Some(ref local_var_str) = id__empty {
22380        local_var_req_builder =
22381            local_var_req_builder.query(&[("id__empty", &local_var_str.to_string())]);
22382    }
22383    if let Some(ref local_var_str) = id__gt {
22384        local_var_req_builder = match "multi" {
22385            "multi" => local_var_req_builder.query(
22386                &local_var_str
22387                    .into_iter()
22388                    .map(|p| ("id__gt".to_owned(), p.to_string()))
22389                    .collect::<Vec<(std::string::String, std::string::String)>>(),
22390            ),
22391            _ => local_var_req_builder.query(&[(
22392                "id__gt",
22393                &local_var_str
22394                    .into_iter()
22395                    .map(|p| p.to_string())
22396                    .collect::<Vec<String>>()
22397                    .join(",")
22398                    .to_string(),
22399            )]),
22400        };
22401    }
22402    if let Some(ref local_var_str) = id__gte {
22403        local_var_req_builder = match "multi" {
22404            "multi" => local_var_req_builder.query(
22405                &local_var_str
22406                    .into_iter()
22407                    .map(|p| ("id__gte".to_owned(), p.to_string()))
22408                    .collect::<Vec<(std::string::String, std::string::String)>>(),
22409            ),
22410            _ => local_var_req_builder.query(&[(
22411                "id__gte",
22412                &local_var_str
22413                    .into_iter()
22414                    .map(|p| p.to_string())
22415                    .collect::<Vec<String>>()
22416                    .join(",")
22417                    .to_string(),
22418            )]),
22419        };
22420    }
22421    if let Some(ref local_var_str) = id__lt {
22422        local_var_req_builder = match "multi" {
22423            "multi" => local_var_req_builder.query(
22424                &local_var_str
22425                    .into_iter()
22426                    .map(|p| ("id__lt".to_owned(), p.to_string()))
22427                    .collect::<Vec<(std::string::String, std::string::String)>>(),
22428            ),
22429            _ => local_var_req_builder.query(&[(
22430                "id__lt",
22431                &local_var_str
22432                    .into_iter()
22433                    .map(|p| p.to_string())
22434                    .collect::<Vec<String>>()
22435                    .join(",")
22436                    .to_string(),
22437            )]),
22438        };
22439    }
22440    if let Some(ref local_var_str) = id__lte {
22441        local_var_req_builder = match "multi" {
22442            "multi" => local_var_req_builder.query(
22443                &local_var_str
22444                    .into_iter()
22445                    .map(|p| ("id__lte".to_owned(), p.to_string()))
22446                    .collect::<Vec<(std::string::String, std::string::String)>>(),
22447            ),
22448            _ => local_var_req_builder.query(&[(
22449                "id__lte",
22450                &local_var_str
22451                    .into_iter()
22452                    .map(|p| p.to_string())
22453                    .collect::<Vec<String>>()
22454                    .join(",")
22455                    .to_string(),
22456            )]),
22457        };
22458    }
22459    if let Some(ref local_var_str) = id__n {
22460        local_var_req_builder = match "multi" {
22461            "multi" => local_var_req_builder.query(
22462                &local_var_str
22463                    .into_iter()
22464                    .map(|p| ("id__n".to_owned(), p.to_string()))
22465                    .collect::<Vec<(std::string::String, std::string::String)>>(),
22466            ),
22467            _ => local_var_req_builder.query(&[(
22468                "id__n",
22469                &local_var_str
22470                    .into_iter()
22471                    .map(|p| p.to_string())
22472                    .collect::<Vec<String>>()
22473                    .join(",")
22474                    .to_string(),
22475            )]),
22476        };
22477    }
22478    if let Some(ref local_var_str) = last_updated {
22479        local_var_req_builder = match "multi" {
22480            "multi" => local_var_req_builder.query(
22481                &local_var_str
22482                    .into_iter()
22483                    .map(|p| ("last_updated".to_owned(), p.to_string()))
22484                    .collect::<Vec<(std::string::String, std::string::String)>>(),
22485            ),
22486            _ => local_var_req_builder.query(&[(
22487                "last_updated",
22488                &local_var_str
22489                    .into_iter()
22490                    .map(|p| p.to_string())
22491                    .collect::<Vec<String>>()
22492                    .join(",")
22493                    .to_string(),
22494            )]),
22495        };
22496    }
22497    if let Some(ref local_var_str) = last_updated__empty {
22498        local_var_req_builder = match "multi" {
22499            "multi" => local_var_req_builder.query(
22500                &local_var_str
22501                    .into_iter()
22502                    .map(|p| ("last_updated__empty".to_owned(), p.to_string()))
22503                    .collect::<Vec<(std::string::String, std::string::String)>>(),
22504            ),
22505            _ => local_var_req_builder.query(&[(
22506                "last_updated__empty",
22507                &local_var_str
22508                    .into_iter()
22509                    .map(|p| p.to_string())
22510                    .collect::<Vec<String>>()
22511                    .join(",")
22512                    .to_string(),
22513            )]),
22514        };
22515    }
22516    if let Some(ref local_var_str) = last_updated__gt {
22517        local_var_req_builder = match "multi" {
22518            "multi" => local_var_req_builder.query(
22519                &local_var_str
22520                    .into_iter()
22521                    .map(|p| ("last_updated__gt".to_owned(), p.to_string()))
22522                    .collect::<Vec<(std::string::String, std::string::String)>>(),
22523            ),
22524            _ => local_var_req_builder.query(&[(
22525                "last_updated__gt",
22526                &local_var_str
22527                    .into_iter()
22528                    .map(|p| p.to_string())
22529                    .collect::<Vec<String>>()
22530                    .join(",")
22531                    .to_string(),
22532            )]),
22533        };
22534    }
22535    if let Some(ref local_var_str) = last_updated__gte {
22536        local_var_req_builder = match "multi" {
22537            "multi" => local_var_req_builder.query(
22538                &local_var_str
22539                    .into_iter()
22540                    .map(|p| ("last_updated__gte".to_owned(), p.to_string()))
22541                    .collect::<Vec<(std::string::String, std::string::String)>>(),
22542            ),
22543            _ => local_var_req_builder.query(&[(
22544                "last_updated__gte",
22545                &local_var_str
22546                    .into_iter()
22547                    .map(|p| p.to_string())
22548                    .collect::<Vec<String>>()
22549                    .join(",")
22550                    .to_string(),
22551            )]),
22552        };
22553    }
22554    if let Some(ref local_var_str) = last_updated__lt {
22555        local_var_req_builder = match "multi" {
22556            "multi" => local_var_req_builder.query(
22557                &local_var_str
22558                    .into_iter()
22559                    .map(|p| ("last_updated__lt".to_owned(), p.to_string()))
22560                    .collect::<Vec<(std::string::String, std::string::String)>>(),
22561            ),
22562            _ => local_var_req_builder.query(&[(
22563                "last_updated__lt",
22564                &local_var_str
22565                    .into_iter()
22566                    .map(|p| p.to_string())
22567                    .collect::<Vec<String>>()
22568                    .join(",")
22569                    .to_string(),
22570            )]),
22571        };
22572    }
22573    if let Some(ref local_var_str) = last_updated__lte {
22574        local_var_req_builder = match "multi" {
22575            "multi" => local_var_req_builder.query(
22576                &local_var_str
22577                    .into_iter()
22578                    .map(|p| ("last_updated__lte".to_owned(), p.to_string()))
22579                    .collect::<Vec<(std::string::String, std::string::String)>>(),
22580            ),
22581            _ => local_var_req_builder.query(&[(
22582                "last_updated__lte",
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) = last_updated__n {
22593        local_var_req_builder = match "multi" {
22594            "multi" => local_var_req_builder.query(
22595                &local_var_str
22596                    .into_iter()
22597                    .map(|p| ("last_updated__n".to_owned(), p.to_string()))
22598                    .collect::<Vec<(std::string::String, std::string::String)>>(),
22599            ),
22600            _ => local_var_req_builder.query(&[(
22601                "last_updated__n",
22602                &local_var_str
22603                    .into_iter()
22604                    .map(|p| p.to_string())
22605                    .collect::<Vec<String>>()
22606                    .join(",")
22607                    .to_string(),
22608            )]),
22609        };
22610    }
22611    if let Some(ref local_var_str) = limit {
22612        local_var_req_builder =
22613            local_var_req_builder.query(&[("limit", &local_var_str.to_string())]);
22614    }
22615    if let Some(ref local_var_str) = modified_by_request {
22616        local_var_req_builder =
22617            local_var_req_builder.query(&[("modified_by_request", &local_var_str.to_string())]);
22618    }
22619    if let Some(ref local_var_str) = name {
22620        local_var_req_builder = match "multi" {
22621            "multi" => local_var_req_builder.query(
22622                &local_var_str
22623                    .into_iter()
22624                    .map(|p| ("name".to_owned(), p.to_string()))
22625                    .collect::<Vec<(std::string::String, std::string::String)>>(),
22626            ),
22627            _ => local_var_req_builder.query(&[(
22628                "name",
22629                &local_var_str
22630                    .into_iter()
22631                    .map(|p| p.to_string())
22632                    .collect::<Vec<String>>()
22633                    .join(",")
22634                    .to_string(),
22635            )]),
22636        };
22637    }
22638    if let Some(ref local_var_str) = name__empty {
22639        local_var_req_builder =
22640            local_var_req_builder.query(&[("name__empty", &local_var_str.to_string())]);
22641    }
22642    if let Some(ref local_var_str) = name__ic {
22643        local_var_req_builder = match "multi" {
22644            "multi" => local_var_req_builder.query(
22645                &local_var_str
22646                    .into_iter()
22647                    .map(|p| ("name__ic".to_owned(), p.to_string()))
22648                    .collect::<Vec<(std::string::String, std::string::String)>>(),
22649            ),
22650            _ => local_var_req_builder.query(&[(
22651                "name__ic",
22652                &local_var_str
22653                    .into_iter()
22654                    .map(|p| p.to_string())
22655                    .collect::<Vec<String>>()
22656                    .join(",")
22657                    .to_string(),
22658            )]),
22659        };
22660    }
22661    if let Some(ref local_var_str) = name__ie {
22662        local_var_req_builder = match "multi" {
22663            "multi" => local_var_req_builder.query(
22664                &local_var_str
22665                    .into_iter()
22666                    .map(|p| ("name__ie".to_owned(), p.to_string()))
22667                    .collect::<Vec<(std::string::String, std::string::String)>>(),
22668            ),
22669            _ => local_var_req_builder.query(&[(
22670                "name__ie",
22671                &local_var_str
22672                    .into_iter()
22673                    .map(|p| p.to_string())
22674                    .collect::<Vec<String>>()
22675                    .join(",")
22676                    .to_string(),
22677            )]),
22678        };
22679    }
22680    if let Some(ref local_var_str) = name__iew {
22681        local_var_req_builder = match "multi" {
22682            "multi" => local_var_req_builder.query(
22683                &local_var_str
22684                    .into_iter()
22685                    .map(|p| ("name__iew".to_owned(), p.to_string()))
22686                    .collect::<Vec<(std::string::String, std::string::String)>>(),
22687            ),
22688            _ => local_var_req_builder.query(&[(
22689                "name__iew",
22690                &local_var_str
22691                    .into_iter()
22692                    .map(|p| p.to_string())
22693                    .collect::<Vec<String>>()
22694                    .join(",")
22695                    .to_string(),
22696            )]),
22697        };
22698    }
22699    if let Some(ref local_var_str) = name__iregex {
22700        local_var_req_builder = match "multi" {
22701            "multi" => local_var_req_builder.query(
22702                &local_var_str
22703                    .into_iter()
22704                    .map(|p| ("name__iregex".to_owned(), p.to_string()))
22705                    .collect::<Vec<(std::string::String, std::string::String)>>(),
22706            ),
22707            _ => local_var_req_builder.query(&[(
22708                "name__iregex",
22709                &local_var_str
22710                    .into_iter()
22711                    .map(|p| p.to_string())
22712                    .collect::<Vec<String>>()
22713                    .join(",")
22714                    .to_string(),
22715            )]),
22716        };
22717    }
22718    if let Some(ref local_var_str) = name__isw {
22719        local_var_req_builder = match "multi" {
22720            "multi" => local_var_req_builder.query(
22721                &local_var_str
22722                    .into_iter()
22723                    .map(|p| ("name__isw".to_owned(), p.to_string()))
22724                    .collect::<Vec<(std::string::String, std::string::String)>>(),
22725            ),
22726            _ => local_var_req_builder.query(&[(
22727                "name__isw",
22728                &local_var_str
22729                    .into_iter()
22730                    .map(|p| p.to_string())
22731                    .collect::<Vec<String>>()
22732                    .join(",")
22733                    .to_string(),
22734            )]),
22735        };
22736    }
22737    if let Some(ref local_var_str) = name__n {
22738        local_var_req_builder = match "multi" {
22739            "multi" => local_var_req_builder.query(
22740                &local_var_str
22741                    .into_iter()
22742                    .map(|p| ("name__n".to_owned(), p.to_string()))
22743                    .collect::<Vec<(std::string::String, std::string::String)>>(),
22744            ),
22745            _ => local_var_req_builder.query(&[(
22746                "name__n",
22747                &local_var_str
22748                    .into_iter()
22749                    .map(|p| p.to_string())
22750                    .collect::<Vec<String>>()
22751                    .join(",")
22752                    .to_string(),
22753            )]),
22754        };
22755    }
22756    if let Some(ref local_var_str) = name__nic {
22757        local_var_req_builder = match "multi" {
22758            "multi" => local_var_req_builder.query(
22759                &local_var_str
22760                    .into_iter()
22761                    .map(|p| ("name__nic".to_owned(), p.to_string()))
22762                    .collect::<Vec<(std::string::String, std::string::String)>>(),
22763            ),
22764            _ => local_var_req_builder.query(&[(
22765                "name__nic",
22766                &local_var_str
22767                    .into_iter()
22768                    .map(|p| p.to_string())
22769                    .collect::<Vec<String>>()
22770                    .join(",")
22771                    .to_string(),
22772            )]),
22773        };
22774    }
22775    if let Some(ref local_var_str) = name__nie {
22776        local_var_req_builder = match "multi" {
22777            "multi" => local_var_req_builder.query(
22778                &local_var_str
22779                    .into_iter()
22780                    .map(|p| ("name__nie".to_owned(), p.to_string()))
22781                    .collect::<Vec<(std::string::String, std::string::String)>>(),
22782            ),
22783            _ => local_var_req_builder.query(&[(
22784                "name__nie",
22785                &local_var_str
22786                    .into_iter()
22787                    .map(|p| p.to_string())
22788                    .collect::<Vec<String>>()
22789                    .join(",")
22790                    .to_string(),
22791            )]),
22792        };
22793    }
22794    if let Some(ref local_var_str) = name__niew {
22795        local_var_req_builder = match "multi" {
22796            "multi" => local_var_req_builder.query(
22797                &local_var_str
22798                    .into_iter()
22799                    .map(|p| ("name__niew".to_owned(), p.to_string()))
22800                    .collect::<Vec<(std::string::String, std::string::String)>>(),
22801            ),
22802            _ => local_var_req_builder.query(&[(
22803                "name__niew",
22804                &local_var_str
22805                    .into_iter()
22806                    .map(|p| p.to_string())
22807                    .collect::<Vec<String>>()
22808                    .join(",")
22809                    .to_string(),
22810            )]),
22811        };
22812    }
22813    if let Some(ref local_var_str) = name__nisw {
22814        local_var_req_builder = match "multi" {
22815            "multi" => local_var_req_builder.query(
22816                &local_var_str
22817                    .into_iter()
22818                    .map(|p| ("name__nisw".to_owned(), p.to_string()))
22819                    .collect::<Vec<(std::string::String, std::string::String)>>(),
22820            ),
22821            _ => local_var_req_builder.query(&[(
22822                "name__nisw",
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) = name__regex {
22833        local_var_req_builder = match "multi" {
22834            "multi" => local_var_req_builder.query(
22835                &local_var_str
22836                    .into_iter()
22837                    .map(|p| ("name__regex".to_owned(), p.to_string()))
22838                    .collect::<Vec<(std::string::String, std::string::String)>>(),
22839            ),
22840            _ => local_var_req_builder.query(&[(
22841                "name__regex",
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) = offset {
22852        local_var_req_builder =
22853            local_var_req_builder.query(&[("offset", &local_var_str.to_string())]);
22854    }
22855    if let Some(ref local_var_str) = ordering {
22856        local_var_req_builder =
22857            local_var_req_builder.query(&[("ordering", &local_var_str.to_string())]);
22858    }
22859    if let Some(ref local_var_str) = owner {
22860        local_var_req_builder = match "multi" {
22861            "multi" => local_var_req_builder.query(
22862                &local_var_str
22863                    .into_iter()
22864                    .map(|p| ("owner".to_owned(), p.to_string()))
22865                    .collect::<Vec<(std::string::String, std::string::String)>>(),
22866            ),
22867            _ => local_var_req_builder.query(&[(
22868                "owner",
22869                &local_var_str
22870                    .into_iter()
22871                    .map(|p| p.to_string())
22872                    .collect::<Vec<String>>()
22873                    .join(",")
22874                    .to_string(),
22875            )]),
22876        };
22877    }
22878    if let Some(ref local_var_str) = owner__n {
22879        local_var_req_builder = match "multi" {
22880            "multi" => local_var_req_builder.query(
22881                &local_var_str
22882                    .into_iter()
22883                    .map(|p| ("owner__n".to_owned(), p.to_string()))
22884                    .collect::<Vec<(std::string::String, std::string::String)>>(),
22885            ),
22886            _ => local_var_req_builder.query(&[(
22887                "owner__n",
22888                &local_var_str
22889                    .into_iter()
22890                    .map(|p| p.to_string())
22891                    .collect::<Vec<String>>()
22892                    .join(",")
22893                    .to_string(),
22894            )]),
22895        };
22896    }
22897    if let Some(ref local_var_str) = owner_group {
22898        local_var_req_builder = match "multi" {
22899            "multi" => local_var_req_builder.query(
22900                &local_var_str
22901                    .into_iter()
22902                    .map(|p| ("owner_group".to_owned(), p.to_string()))
22903                    .collect::<Vec<(std::string::String, std::string::String)>>(),
22904            ),
22905            _ => local_var_req_builder.query(&[(
22906                "owner_group",
22907                &local_var_str
22908                    .into_iter()
22909                    .map(|p| p.to_string())
22910                    .collect::<Vec<String>>()
22911                    .join(",")
22912                    .to_string(),
22913            )]),
22914        };
22915    }
22916    if let Some(ref local_var_str) = owner_group__n {
22917        local_var_req_builder = match "multi" {
22918            "multi" => local_var_req_builder.query(
22919                &local_var_str
22920                    .into_iter()
22921                    .map(|p| ("owner_group__n".to_owned(), p.to_string()))
22922                    .collect::<Vec<(std::string::String, std::string::String)>>(),
22923            ),
22924            _ => local_var_req_builder.query(&[(
22925                "owner_group__n",
22926                &local_var_str
22927                    .into_iter()
22928                    .map(|p| p.to_string())
22929                    .collect::<Vec<String>>()
22930                    .join(",")
22931                    .to_string(),
22932            )]),
22933        };
22934    }
22935    if let Some(ref local_var_str) = owner_group_id {
22936        local_var_req_builder = match "multi" {
22937            "multi" => local_var_req_builder.query(
22938                &local_var_str
22939                    .into_iter()
22940                    .map(|p| ("owner_group_id".to_owned(), p.to_string()))
22941                    .collect::<Vec<(std::string::String, std::string::String)>>(),
22942            ),
22943            _ => local_var_req_builder.query(&[(
22944                "owner_group_id",
22945                &local_var_str
22946                    .into_iter()
22947                    .map(|p| p.to_string())
22948                    .collect::<Vec<String>>()
22949                    .join(",")
22950                    .to_string(),
22951            )]),
22952        };
22953    }
22954    if let Some(ref local_var_str) = owner_group_id__n {
22955        local_var_req_builder = match "multi" {
22956            "multi" => local_var_req_builder.query(
22957                &local_var_str
22958                    .into_iter()
22959                    .map(|p| ("owner_group_id__n".to_owned(), p.to_string()))
22960                    .collect::<Vec<(std::string::String, std::string::String)>>(),
22961            ),
22962            _ => local_var_req_builder.query(&[(
22963                "owner_group_id__n",
22964                &local_var_str
22965                    .into_iter()
22966                    .map(|p| p.to_string())
22967                    .collect::<Vec<String>>()
22968                    .join(",")
22969                    .to_string(),
22970            )]),
22971        };
22972    }
22973    if let Some(ref local_var_str) = owner_id {
22974        local_var_req_builder = match "multi" {
22975            "multi" => local_var_req_builder.query(
22976                &local_var_str
22977                    .into_iter()
22978                    .map(|p| ("owner_id".to_owned(), p.to_string()))
22979                    .collect::<Vec<(std::string::String, std::string::String)>>(),
22980            ),
22981            _ => local_var_req_builder.query(&[(
22982                "owner_id",
22983                &local_var_str
22984                    .into_iter()
22985                    .map(|p| p.to_string())
22986                    .collect::<Vec<String>>()
22987                    .join(",")
22988                    .to_string(),
22989            )]),
22990        };
22991    }
22992    if let Some(ref local_var_str) = owner_id__n {
22993        local_var_req_builder = match "multi" {
22994            "multi" => local_var_req_builder.query(
22995                &local_var_str
22996                    .into_iter()
22997                    .map(|p| ("owner_id__n".to_owned(), p.to_string()))
22998                    .collect::<Vec<(std::string::String, std::string::String)>>(),
22999            ),
23000            _ => local_var_req_builder.query(&[(
23001                "owner_id__n",
23002                &local_var_str
23003                    .into_iter()
23004                    .map(|p| p.to_string())
23005                    .collect::<Vec<String>>()
23006                    .join(",")
23007                    .to_string(),
23008            )]),
23009        };
23010    }
23011    if let Some(ref local_var_str) = q {
23012        local_var_req_builder = local_var_req_builder.query(&[("q", &local_var_str.to_string())]);
23013    }
23014    if let Some(ref local_var_str) = slug {
23015        local_var_req_builder = match "multi" {
23016            "multi" => local_var_req_builder.query(
23017                &local_var_str
23018                    .into_iter()
23019                    .map(|p| ("slug".to_owned(), p.to_string()))
23020                    .collect::<Vec<(std::string::String, std::string::String)>>(),
23021            ),
23022            _ => local_var_req_builder.query(&[(
23023                "slug",
23024                &local_var_str
23025                    .into_iter()
23026                    .map(|p| p.to_string())
23027                    .collect::<Vec<String>>()
23028                    .join(",")
23029                    .to_string(),
23030            )]),
23031        };
23032    }
23033    if let Some(ref local_var_str) = slug__empty {
23034        local_var_req_builder =
23035            local_var_req_builder.query(&[("slug__empty", &local_var_str.to_string())]);
23036    }
23037    if let Some(ref local_var_str) = slug__ic {
23038        local_var_req_builder = match "multi" {
23039            "multi" => local_var_req_builder.query(
23040                &local_var_str
23041                    .into_iter()
23042                    .map(|p| ("slug__ic".to_owned(), p.to_string()))
23043                    .collect::<Vec<(std::string::String, std::string::String)>>(),
23044            ),
23045            _ => local_var_req_builder.query(&[(
23046                "slug__ic",
23047                &local_var_str
23048                    .into_iter()
23049                    .map(|p| p.to_string())
23050                    .collect::<Vec<String>>()
23051                    .join(",")
23052                    .to_string(),
23053            )]),
23054        };
23055    }
23056    if let Some(ref local_var_str) = slug__ie {
23057        local_var_req_builder = match "multi" {
23058            "multi" => local_var_req_builder.query(
23059                &local_var_str
23060                    .into_iter()
23061                    .map(|p| ("slug__ie".to_owned(), p.to_string()))
23062                    .collect::<Vec<(std::string::String, std::string::String)>>(),
23063            ),
23064            _ => local_var_req_builder.query(&[(
23065                "slug__ie",
23066                &local_var_str
23067                    .into_iter()
23068                    .map(|p| p.to_string())
23069                    .collect::<Vec<String>>()
23070                    .join(",")
23071                    .to_string(),
23072            )]),
23073        };
23074    }
23075    if let Some(ref local_var_str) = slug__iew {
23076        local_var_req_builder = match "multi" {
23077            "multi" => local_var_req_builder.query(
23078                &local_var_str
23079                    .into_iter()
23080                    .map(|p| ("slug__iew".to_owned(), p.to_string()))
23081                    .collect::<Vec<(std::string::String, std::string::String)>>(),
23082            ),
23083            _ => local_var_req_builder.query(&[(
23084                "slug__iew",
23085                &local_var_str
23086                    .into_iter()
23087                    .map(|p| p.to_string())
23088                    .collect::<Vec<String>>()
23089                    .join(",")
23090                    .to_string(),
23091            )]),
23092        };
23093    }
23094    if let Some(ref local_var_str) = slug__iregex {
23095        local_var_req_builder = match "multi" {
23096            "multi" => local_var_req_builder.query(
23097                &local_var_str
23098                    .into_iter()
23099                    .map(|p| ("slug__iregex".to_owned(), p.to_string()))
23100                    .collect::<Vec<(std::string::String, std::string::String)>>(),
23101            ),
23102            _ => local_var_req_builder.query(&[(
23103                "slug__iregex",
23104                &local_var_str
23105                    .into_iter()
23106                    .map(|p| p.to_string())
23107                    .collect::<Vec<String>>()
23108                    .join(",")
23109                    .to_string(),
23110            )]),
23111        };
23112    }
23113    if let Some(ref local_var_str) = slug__isw {
23114        local_var_req_builder = match "multi" {
23115            "multi" => local_var_req_builder.query(
23116                &local_var_str
23117                    .into_iter()
23118                    .map(|p| ("slug__isw".to_owned(), p.to_string()))
23119                    .collect::<Vec<(std::string::String, std::string::String)>>(),
23120            ),
23121            _ => local_var_req_builder.query(&[(
23122                "slug__isw",
23123                &local_var_str
23124                    .into_iter()
23125                    .map(|p| p.to_string())
23126                    .collect::<Vec<String>>()
23127                    .join(",")
23128                    .to_string(),
23129            )]),
23130        };
23131    }
23132    if let Some(ref local_var_str) = slug__n {
23133        local_var_req_builder = match "multi" {
23134            "multi" => local_var_req_builder.query(
23135                &local_var_str
23136                    .into_iter()
23137                    .map(|p| ("slug__n".to_owned(), p.to_string()))
23138                    .collect::<Vec<(std::string::String, std::string::String)>>(),
23139            ),
23140            _ => local_var_req_builder.query(&[(
23141                "slug__n",
23142                &local_var_str
23143                    .into_iter()
23144                    .map(|p| p.to_string())
23145                    .collect::<Vec<String>>()
23146                    .join(",")
23147                    .to_string(),
23148            )]),
23149        };
23150    }
23151    if let Some(ref local_var_str) = slug__nic {
23152        local_var_req_builder = match "multi" {
23153            "multi" => local_var_req_builder.query(
23154                &local_var_str
23155                    .into_iter()
23156                    .map(|p| ("slug__nic".to_owned(), p.to_string()))
23157                    .collect::<Vec<(std::string::String, std::string::String)>>(),
23158            ),
23159            _ => local_var_req_builder.query(&[(
23160                "slug__nic",
23161                &local_var_str
23162                    .into_iter()
23163                    .map(|p| p.to_string())
23164                    .collect::<Vec<String>>()
23165                    .join(",")
23166                    .to_string(),
23167            )]),
23168        };
23169    }
23170    if let Some(ref local_var_str) = slug__nie {
23171        local_var_req_builder = match "multi" {
23172            "multi" => local_var_req_builder.query(
23173                &local_var_str
23174                    .into_iter()
23175                    .map(|p| ("slug__nie".to_owned(), p.to_string()))
23176                    .collect::<Vec<(std::string::String, std::string::String)>>(),
23177            ),
23178            _ => local_var_req_builder.query(&[(
23179                "slug__nie",
23180                &local_var_str
23181                    .into_iter()
23182                    .map(|p| p.to_string())
23183                    .collect::<Vec<String>>()
23184                    .join(",")
23185                    .to_string(),
23186            )]),
23187        };
23188    }
23189    if let Some(ref local_var_str) = slug__niew {
23190        local_var_req_builder = match "multi" {
23191            "multi" => local_var_req_builder.query(
23192                &local_var_str
23193                    .into_iter()
23194                    .map(|p| ("slug__niew".to_owned(), p.to_string()))
23195                    .collect::<Vec<(std::string::String, std::string::String)>>(),
23196            ),
23197            _ => local_var_req_builder.query(&[(
23198                "slug__niew",
23199                &local_var_str
23200                    .into_iter()
23201                    .map(|p| p.to_string())
23202                    .collect::<Vec<String>>()
23203                    .join(",")
23204                    .to_string(),
23205            )]),
23206        };
23207    }
23208    if let Some(ref local_var_str) = slug__nisw {
23209        local_var_req_builder = match "multi" {
23210            "multi" => local_var_req_builder.query(
23211                &local_var_str
23212                    .into_iter()
23213                    .map(|p| ("slug__nisw".to_owned(), p.to_string()))
23214                    .collect::<Vec<(std::string::String, std::string::String)>>(),
23215            ),
23216            _ => local_var_req_builder.query(&[(
23217                "slug__nisw",
23218                &local_var_str
23219                    .into_iter()
23220                    .map(|p| p.to_string())
23221                    .collect::<Vec<String>>()
23222                    .join(",")
23223                    .to_string(),
23224            )]),
23225        };
23226    }
23227    if let Some(ref local_var_str) = slug__regex {
23228        local_var_req_builder = match "multi" {
23229            "multi" => local_var_req_builder.query(
23230                &local_var_str
23231                    .into_iter()
23232                    .map(|p| ("slug__regex".to_owned(), p.to_string()))
23233                    .collect::<Vec<(std::string::String, std::string::String)>>(),
23234            ),
23235            _ => local_var_req_builder.query(&[(
23236                "slug__regex",
23237                &local_var_str
23238                    .into_iter()
23239                    .map(|p| p.to_string())
23240                    .collect::<Vec<String>>()
23241                    .join(",")
23242                    .to_string(),
23243            )]),
23244        };
23245    }
23246    if let Some(ref local_var_str) = start {
23247        local_var_req_builder =
23248            local_var_req_builder.query(&[("start", &local_var_str.to_string())]);
23249    }
23250    if let Some(ref local_var_str) = tag {
23251        local_var_req_builder = match "multi" {
23252            "multi" => local_var_req_builder.query(
23253                &local_var_str
23254                    .into_iter()
23255                    .map(|p| ("tag".to_owned(), p.to_string()))
23256                    .collect::<Vec<(std::string::String, std::string::String)>>(),
23257            ),
23258            _ => local_var_req_builder.query(&[(
23259                "tag",
23260                &local_var_str
23261                    .into_iter()
23262                    .map(|p| p.to_string())
23263                    .collect::<Vec<String>>()
23264                    .join(",")
23265                    .to_string(),
23266            )]),
23267        };
23268    }
23269    if let Some(ref local_var_str) = tag__n {
23270        local_var_req_builder = match "multi" {
23271            "multi" => local_var_req_builder.query(
23272                &local_var_str
23273                    .into_iter()
23274                    .map(|p| ("tag__n".to_owned(), p.to_string()))
23275                    .collect::<Vec<(std::string::String, std::string::String)>>(),
23276            ),
23277            _ => local_var_req_builder.query(&[(
23278                "tag__n",
23279                &local_var_str
23280                    .into_iter()
23281                    .map(|p| p.to_string())
23282                    .collect::<Vec<String>>()
23283                    .join(",")
23284                    .to_string(),
23285            )]),
23286        };
23287    }
23288    if let Some(ref local_var_str) = tag_id {
23289        local_var_req_builder = match "multi" {
23290            "multi" => local_var_req_builder.query(
23291                &local_var_str
23292                    .into_iter()
23293                    .map(|p| ("tag_id".to_owned(), p.to_string()))
23294                    .collect::<Vec<(std::string::String, std::string::String)>>(),
23295            ),
23296            _ => local_var_req_builder.query(&[(
23297                "tag_id",
23298                &local_var_str
23299                    .into_iter()
23300                    .map(|p| p.to_string())
23301                    .collect::<Vec<String>>()
23302                    .join(",")
23303                    .to_string(),
23304            )]),
23305        };
23306    }
23307    if let Some(ref local_var_str) = tag_id__n {
23308        local_var_req_builder = match "multi" {
23309            "multi" => local_var_req_builder.query(
23310                &local_var_str
23311                    .into_iter()
23312                    .map(|p| ("tag_id__n".to_owned(), p.to_string()))
23313                    .collect::<Vec<(std::string::String, std::string::String)>>(),
23314            ),
23315            _ => local_var_req_builder.query(&[(
23316                "tag_id__n",
23317                &local_var_str
23318                    .into_iter()
23319                    .map(|p| p.to_string())
23320                    .collect::<Vec<String>>()
23321                    .join(",")
23322                    .to_string(),
23323            )]),
23324        };
23325    }
23326    if let Some(ref local_var_str) = updated_by_request {
23327        local_var_req_builder =
23328            local_var_req_builder.query(&[("updated_by_request", &local_var_str.to_string())]);
23329    }
23330    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
23331        local_var_req_builder =
23332            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
23333    }
23334    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
23335        let local_var_key = local_var_apikey.key.clone();
23336        let local_var_value = match local_var_apikey.prefix {
23337            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
23338            None => local_var_key,
23339        };
23340        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
23341    };
23342
23343    let local_var_req = local_var_req_builder.build()?;
23344    let local_var_resp = local_var_client.execute(local_var_req).await?;
23345
23346    let local_var_status = local_var_resp.status();
23347    let local_var_content = local_var_resp.text().await?;
23348
23349    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
23350        serde_json::from_str(&local_var_content).map_err(Error::from)
23351    } else {
23352        let local_var_entity: Option<CircuitsVirtualCircuitTypesListError> =
23353            serde_json::from_str(&local_var_content).ok();
23354        let local_var_error = ResponseContent {
23355            status: local_var_status,
23356            content: local_var_content,
23357            entity: local_var_entity,
23358        };
23359        Err(Error::ResponseError(local_var_error))
23360    }
23361}
23362
23363/// Patch a virtual circuit type object.
23364pub async fn circuits_virtual_circuit_types_partial_update(
23365    configuration: &configuration::Configuration,
23366    id: i32,
23367    patched_virtual_circuit_type_request: Option<crate::models::PatchedVirtualCircuitTypeRequest>,
23368) -> Result<crate::models::VirtualCircuitType, Error<CircuitsVirtualCircuitTypesPartialUpdateError>>
23369{
23370    let local_var_configuration = configuration;
23371
23372    let local_var_client = &local_var_configuration.client;
23373
23374    let local_var_uri_str = format!(
23375        "{}/api/circuits/virtual-circuit-types/{id}/",
23376        local_var_configuration.base_path,
23377        id = id
23378    );
23379    let mut local_var_req_builder =
23380        local_var_client.request(reqwest::Method::PATCH, local_var_uri_str.as_str());
23381
23382    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
23383        local_var_req_builder =
23384            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
23385    }
23386    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
23387        let local_var_key = local_var_apikey.key.clone();
23388        let local_var_value = match local_var_apikey.prefix {
23389            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
23390            None => local_var_key,
23391        };
23392        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
23393    };
23394    local_var_req_builder = local_var_req_builder.json(&patched_virtual_circuit_type_request);
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<CircuitsVirtualCircuitTypesPartialUpdateError> =
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/// Get a virtual circuit type object.
23417pub async fn circuits_virtual_circuit_types_retrieve(
23418    configuration: &configuration::Configuration,
23419    id: i32,
23420) -> Result<crate::models::VirtualCircuitType, Error<CircuitsVirtualCircuitTypesRetrieveError>> {
23421    let local_var_configuration = configuration;
23422
23423    let local_var_client = &local_var_configuration.client;
23424
23425    let local_var_uri_str = format!(
23426        "{}/api/circuits/virtual-circuit-types/{id}/",
23427        local_var_configuration.base_path,
23428        id = id
23429    );
23430    let mut local_var_req_builder =
23431        local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
23432
23433    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
23434        local_var_req_builder =
23435            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
23436    }
23437    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
23438        let local_var_key = local_var_apikey.key.clone();
23439        let local_var_value = match local_var_apikey.prefix {
23440            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
23441            None => local_var_key,
23442        };
23443        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
23444    };
23445
23446    let local_var_req = local_var_req_builder.build()?;
23447    let local_var_resp = local_var_client.execute(local_var_req).await?;
23448
23449    let local_var_status = local_var_resp.status();
23450    let local_var_content = local_var_resp.text().await?;
23451
23452    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
23453        serde_json::from_str(&local_var_content).map_err(Error::from)
23454    } else {
23455        let local_var_entity: Option<CircuitsVirtualCircuitTypesRetrieveError> =
23456            serde_json::from_str(&local_var_content).ok();
23457        let local_var_error = ResponseContent {
23458            status: local_var_status,
23459            content: local_var_content,
23460            entity: local_var_entity,
23461        };
23462        Err(Error::ResponseError(local_var_error))
23463    }
23464}
23465
23466/// Put a virtual circuit type object.
23467pub async fn circuits_virtual_circuit_types_update(
23468    configuration: &configuration::Configuration,
23469    id: i32,
23470    virtual_circuit_type_request: crate::models::VirtualCircuitTypeRequest,
23471) -> Result<crate::models::VirtualCircuitType, Error<CircuitsVirtualCircuitTypesUpdateError>> {
23472    let local_var_configuration = configuration;
23473
23474    let local_var_client = &local_var_configuration.client;
23475
23476    let local_var_uri_str = format!(
23477        "{}/api/circuits/virtual-circuit-types/{id}/",
23478        local_var_configuration.base_path,
23479        id = id
23480    );
23481    let mut local_var_req_builder =
23482        local_var_client.request(reqwest::Method::PUT, 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_type_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        serde_json::from_str(&local_var_content).map_err(Error::from)
23506    } else {
23507        let local_var_entity: Option<CircuitsVirtualCircuitTypesUpdateError> =
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/// Delete a list of virtual circuit objects.
23519pub async fn circuits_virtual_circuits_bulk_destroy(
23520    configuration: &configuration::Configuration,
23521    virtual_circuit_request: Vec<crate::models::VirtualCircuitRequest>,
23522) -> Result<(), Error<CircuitsVirtualCircuitsBulkDestroyError>> {
23523    let local_var_configuration = configuration;
23524
23525    let local_var_client = &local_var_configuration.client;
23526
23527    let local_var_uri_str = format!(
23528        "{}/api/circuits/virtual-circuits/",
23529        local_var_configuration.base_path
23530    );
23531    let mut local_var_req_builder =
23532        local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());
23533
23534    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
23535        local_var_req_builder =
23536            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
23537    }
23538    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
23539        let local_var_key = local_var_apikey.key.clone();
23540        let local_var_value = match local_var_apikey.prefix {
23541            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
23542            None => local_var_key,
23543        };
23544        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
23545    };
23546    local_var_req_builder = local_var_req_builder.json(&virtual_circuit_request);
23547
23548    let local_var_req = local_var_req_builder.build()?;
23549    let local_var_resp = local_var_client.execute(local_var_req).await?;
23550
23551    let local_var_status = local_var_resp.status();
23552    let local_var_content = local_var_resp.text().await?;
23553
23554    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
23555        Ok(())
23556    } else {
23557        let local_var_entity: Option<CircuitsVirtualCircuitsBulkDestroyError> =
23558            serde_json::from_str(&local_var_content).ok();
23559        let local_var_error = ResponseContent {
23560            status: local_var_status,
23561            content: local_var_content,
23562            entity: local_var_entity,
23563        };
23564        Err(Error::ResponseError(local_var_error))
23565    }
23566}
23567
23568/// Patch a list of virtual circuit objects.
23569pub async fn circuits_virtual_circuits_bulk_partial_update(
23570    configuration: &configuration::Configuration,
23571    virtual_circuit_request: Vec<crate::models::VirtualCircuitRequest>,
23572) -> Result<Vec<crate::models::VirtualCircuit>, Error<CircuitsVirtualCircuitsBulkPartialUpdateError>>
23573{
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::PATCH, 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<CircuitsVirtualCircuitsBulkPartialUpdateError> =
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/// Put a list of virtual circuit objects.
23620pub async fn circuits_virtual_circuits_bulk_update(
23621    configuration: &configuration::Configuration,
23622    virtual_circuit_request: Vec<crate::models::VirtualCircuitRequest>,
23623) -> Result<Vec<crate::models::VirtualCircuit>, Error<CircuitsVirtualCircuitsBulkUpdateError>> {
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::PUT, 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(&virtual_circuit_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<CircuitsVirtualCircuitsBulkUpdateError> =
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/// Post a list of virtual circuit objects.
23670pub async fn circuits_virtual_circuits_create(
23671    configuration: &configuration::Configuration,
23672    circuits_virtual_circuits_create_request: crate::models::CircuitsVirtualCircuitsCreateRequest,
23673) -> Result<crate::models::VirtualCircuit, Error<CircuitsVirtualCircuitsCreateError>> {
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/",
23680        local_var_configuration.base_path
23681    );
23682    let mut local_var_req_builder =
23683        local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
23684
23685    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
23686        local_var_req_builder =
23687            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
23688    }
23689    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
23690        let local_var_key = local_var_apikey.key.clone();
23691        let local_var_value = match local_var_apikey.prefix {
23692            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
23693            None => local_var_key,
23694        };
23695        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
23696    };
23697    local_var_req_builder = local_var_req_builder.json(&circuits_virtual_circuits_create_request);
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        serde_json::from_str(&local_var_content).map_err(Error::from)
23707    } else {
23708        let local_var_entity: Option<CircuitsVirtualCircuitsCreateError> =
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/// Delete a virtual circuit object.
23720pub async fn circuits_virtual_circuits_destroy(
23721    configuration: &configuration::Configuration,
23722    id: i32,
23723) -> Result<(), Error<CircuitsVirtualCircuitsDestroyError>> {
23724    let local_var_configuration = configuration;
23725
23726    let local_var_client = &local_var_configuration.client;
23727
23728    let local_var_uri_str = format!(
23729        "{}/api/circuits/virtual-circuits/{id}/",
23730        local_var_configuration.base_path,
23731        id = id
23732    );
23733    let mut local_var_req_builder =
23734        local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());
23735
23736    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
23737        local_var_req_builder =
23738            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
23739    }
23740    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
23741        let local_var_key = local_var_apikey.key.clone();
23742        let local_var_value = match local_var_apikey.prefix {
23743            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
23744            None => local_var_key,
23745        };
23746        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
23747    };
23748
23749    let local_var_req = local_var_req_builder.build()?;
23750    let local_var_resp = local_var_client.execute(local_var_req).await?;
23751
23752    let local_var_status = local_var_resp.status();
23753    let local_var_content = local_var_resp.text().await?;
23754
23755    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
23756        Ok(())
23757    } else {
23758        let local_var_entity: Option<CircuitsVirtualCircuitsDestroyError> =
23759            serde_json::from_str(&local_var_content).ok();
23760        let local_var_error = ResponseContent {
23761            status: local_var_status,
23762            content: local_var_content,
23763            entity: local_var_entity,
23764        };
23765        Err(Error::ResponseError(local_var_error))
23766    }
23767}
23768
23769/// Get a list of virtual circuit objects.
23770pub async fn circuits_virtual_circuits_list(
23771    configuration: &configuration::Configuration,
23772    cid: Option<Vec<String>>,
23773    cid__empty: Option<bool>,
23774    cid__ic: Option<Vec<String>>,
23775    cid__ie: Option<Vec<String>>,
23776    cid__iew: Option<Vec<String>>,
23777    cid__iregex: Option<Vec<String>>,
23778    cid__isw: Option<Vec<String>>,
23779    cid__n: Option<Vec<String>>,
23780    cid__nic: Option<Vec<String>>,
23781    cid__nie: Option<Vec<String>>,
23782    cid__niew: Option<Vec<String>>,
23783    cid__nisw: Option<Vec<String>>,
23784    cid__regex: Option<Vec<String>>,
23785    created: Option<Vec<String>>,
23786    created__empty: Option<Vec<String>>,
23787    created__gt: Option<Vec<String>>,
23788    created__gte: Option<Vec<String>>,
23789    created__lt: Option<Vec<String>>,
23790    created__lte: Option<Vec<String>>,
23791    created__n: Option<Vec<String>>,
23792    created_by_request: Option<&str>,
23793    description: Option<Vec<String>>,
23794    description__empty: Option<bool>,
23795    description__ic: Option<Vec<String>>,
23796    description__ie: Option<Vec<String>>,
23797    description__iew: Option<Vec<String>>,
23798    description__iregex: Option<Vec<String>>,
23799    description__isw: Option<Vec<String>>,
23800    description__n: Option<Vec<String>>,
23801    description__nic: Option<Vec<String>>,
23802    description__nie: Option<Vec<String>>,
23803    description__niew: Option<Vec<String>>,
23804    description__nisw: Option<Vec<String>>,
23805    description__regex: Option<Vec<String>>,
23806    id: Option<Vec<i32>>,
23807    id__empty: Option<bool>,
23808    id__gt: Option<Vec<i32>>,
23809    id__gte: Option<Vec<i32>>,
23810    id__lt: Option<Vec<i32>>,
23811    id__lte: Option<Vec<i32>>,
23812    id__n: Option<Vec<i32>>,
23813    last_updated: Option<Vec<String>>,
23814    last_updated__empty: Option<Vec<String>>,
23815    last_updated__gt: Option<Vec<String>>,
23816    last_updated__gte: Option<Vec<String>>,
23817    last_updated__lt: Option<Vec<String>>,
23818    last_updated__lte: Option<Vec<String>>,
23819    last_updated__n: Option<Vec<String>>,
23820    limit: Option<i32>,
23821    modified_by_request: Option<&str>,
23822    offset: Option<i32>,
23823    ordering: Option<&str>,
23824    owner: Option<Vec<String>>,
23825    owner__n: Option<Vec<String>>,
23826    owner_group: Option<Vec<String>>,
23827    owner_group__n: Option<Vec<String>>,
23828    owner_group_id: Option<Vec<i32>>,
23829    owner_group_id__n: Option<Vec<i32>>,
23830    owner_id: Option<Vec<i32>>,
23831    owner_id__n: Option<Vec<i32>>,
23832    provider: Option<Vec<String>>,
23833    provider__n: Option<Vec<String>>,
23834    provider_account: Option<Vec<String>>,
23835    provider_account__n: Option<Vec<String>>,
23836    provider_account_id: Option<Vec<i32>>,
23837    provider_account_id__n: Option<Vec<i32>>,
23838    provider_id: Option<Vec<i32>>,
23839    provider_id__n: Option<Vec<i32>>,
23840    provider_network_id: Option<Vec<i32>>,
23841    provider_network_id__n: Option<Vec<i32>>,
23842    q: Option<&str>,
23843    start: Option<i32>,
23844    status: Option<Vec<String>>,
23845    status__empty: Option<bool>,
23846    status__ic: Option<Vec<String>>,
23847    status__ie: Option<Vec<String>>,
23848    status__iew: Option<Vec<String>>,
23849    status__iregex: Option<Vec<String>>,
23850    status__isw: Option<Vec<String>>,
23851    status__n: Option<Vec<String>>,
23852    status__nic: Option<Vec<String>>,
23853    status__nie: Option<Vec<String>>,
23854    status__niew: Option<Vec<String>>,
23855    status__nisw: Option<Vec<String>>,
23856    status__regex: Option<Vec<String>>,
23857    tag: Option<Vec<String>>,
23858    tag__n: Option<Vec<String>>,
23859    tag_id: Option<Vec<i32>>,
23860    tag_id__n: Option<Vec<i32>>,
23861    tenant: Option<Vec<String>>,
23862    tenant__n: Option<Vec<String>>,
23863    tenant_group: Option<Vec<String>>,
23864    tenant_group__n: Option<Vec<String>>,
23865    tenant_group_id: Option<Vec<String>>,
23866    tenant_group_id__n: Option<Vec<String>>,
23867    tenant_id: Option<Vec<i32>>,
23868    tenant_id__n: Option<Vec<i32>>,
23869    r#type: Option<Vec<String>>,
23870    type__n: Option<Vec<String>>,
23871    type_id: Option<Vec<i32>>,
23872    type_id__n: Option<Vec<i32>>,
23873    updated_by_request: Option<&str>,
23874) -> Result<crate::models::PaginatedVirtualCircuitList, Error<CircuitsVirtualCircuitsListError>> {
23875    let local_var_configuration = configuration;
23876
23877    let local_var_client = &local_var_configuration.client;
23878
23879    let local_var_uri_str = format!(
23880        "{}/api/circuits/virtual-circuits/",
23881        local_var_configuration.base_path
23882    );
23883    let mut local_var_req_builder =
23884        local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
23885
23886    if let Some(ref local_var_str) = cid {
23887        local_var_req_builder = match "multi" {
23888            "multi" => local_var_req_builder.query(
23889                &local_var_str
23890                    .into_iter()
23891                    .map(|p| ("cid".to_owned(), p.to_string()))
23892                    .collect::<Vec<(std::string::String, std::string::String)>>(),
23893            ),
23894            _ => local_var_req_builder.query(&[(
23895                "cid",
23896                &local_var_str
23897                    .into_iter()
23898                    .map(|p| p.to_string())
23899                    .collect::<Vec<String>>()
23900                    .join(",")
23901                    .to_string(),
23902            )]),
23903        };
23904    }
23905    if let Some(ref local_var_str) = cid__empty {
23906        local_var_req_builder =
23907            local_var_req_builder.query(&[("cid__empty", &local_var_str.to_string())]);
23908    }
23909    if let Some(ref local_var_str) = cid__ic {
23910        local_var_req_builder = match "multi" {
23911            "multi" => local_var_req_builder.query(
23912                &local_var_str
23913                    .into_iter()
23914                    .map(|p| ("cid__ic".to_owned(), p.to_string()))
23915                    .collect::<Vec<(std::string::String, std::string::String)>>(),
23916            ),
23917            _ => local_var_req_builder.query(&[(
23918                "cid__ic",
23919                &local_var_str
23920                    .into_iter()
23921                    .map(|p| p.to_string())
23922                    .collect::<Vec<String>>()
23923                    .join(",")
23924                    .to_string(),
23925            )]),
23926        };
23927    }
23928    if let Some(ref local_var_str) = cid__ie {
23929        local_var_req_builder = match "multi" {
23930            "multi" => local_var_req_builder.query(
23931                &local_var_str
23932                    .into_iter()
23933                    .map(|p| ("cid__ie".to_owned(), p.to_string()))
23934                    .collect::<Vec<(std::string::String, std::string::String)>>(),
23935            ),
23936            _ => local_var_req_builder.query(&[(
23937                "cid__ie",
23938                &local_var_str
23939                    .into_iter()
23940                    .map(|p| p.to_string())
23941                    .collect::<Vec<String>>()
23942                    .join(",")
23943                    .to_string(),
23944            )]),
23945        };
23946    }
23947    if let Some(ref local_var_str) = cid__iew {
23948        local_var_req_builder = match "multi" {
23949            "multi" => local_var_req_builder.query(
23950                &local_var_str
23951                    .into_iter()
23952                    .map(|p| ("cid__iew".to_owned(), p.to_string()))
23953                    .collect::<Vec<(std::string::String, std::string::String)>>(),
23954            ),
23955            _ => local_var_req_builder.query(&[(
23956                "cid__iew",
23957                &local_var_str
23958                    .into_iter()
23959                    .map(|p| p.to_string())
23960                    .collect::<Vec<String>>()
23961                    .join(",")
23962                    .to_string(),
23963            )]),
23964        };
23965    }
23966    if let Some(ref local_var_str) = cid__iregex {
23967        local_var_req_builder = match "multi" {
23968            "multi" => local_var_req_builder.query(
23969                &local_var_str
23970                    .into_iter()
23971                    .map(|p| ("cid__iregex".to_owned(), p.to_string()))
23972                    .collect::<Vec<(std::string::String, std::string::String)>>(),
23973            ),
23974            _ => local_var_req_builder.query(&[(
23975                "cid__iregex",
23976                &local_var_str
23977                    .into_iter()
23978                    .map(|p| p.to_string())
23979                    .collect::<Vec<String>>()
23980                    .join(",")
23981                    .to_string(),
23982            )]),
23983        };
23984    }
23985    if let Some(ref local_var_str) = cid__isw {
23986        local_var_req_builder = match "multi" {
23987            "multi" => local_var_req_builder.query(
23988                &local_var_str
23989                    .into_iter()
23990                    .map(|p| ("cid__isw".to_owned(), p.to_string()))
23991                    .collect::<Vec<(std::string::String, std::string::String)>>(),
23992            ),
23993            _ => local_var_req_builder.query(&[(
23994                "cid__isw",
23995                &local_var_str
23996                    .into_iter()
23997                    .map(|p| p.to_string())
23998                    .collect::<Vec<String>>()
23999                    .join(",")
24000                    .to_string(),
24001            )]),
24002        };
24003    }
24004    if let Some(ref local_var_str) = cid__n {
24005        local_var_req_builder = match "multi" {
24006            "multi" => local_var_req_builder.query(
24007                &local_var_str
24008                    .into_iter()
24009                    .map(|p| ("cid__n".to_owned(), p.to_string()))
24010                    .collect::<Vec<(std::string::String, std::string::String)>>(),
24011            ),
24012            _ => local_var_req_builder.query(&[(
24013                "cid__n",
24014                &local_var_str
24015                    .into_iter()
24016                    .map(|p| p.to_string())
24017                    .collect::<Vec<String>>()
24018                    .join(",")
24019                    .to_string(),
24020            )]),
24021        };
24022    }
24023    if let Some(ref local_var_str) = cid__nic {
24024        local_var_req_builder = match "multi" {
24025            "multi" => local_var_req_builder.query(
24026                &local_var_str
24027                    .into_iter()
24028                    .map(|p| ("cid__nic".to_owned(), p.to_string()))
24029                    .collect::<Vec<(std::string::String, std::string::String)>>(),
24030            ),
24031            _ => local_var_req_builder.query(&[(
24032                "cid__nic",
24033                &local_var_str
24034                    .into_iter()
24035                    .map(|p| p.to_string())
24036                    .collect::<Vec<String>>()
24037                    .join(",")
24038                    .to_string(),
24039            )]),
24040        };
24041    }
24042    if let Some(ref local_var_str) = cid__nie {
24043        local_var_req_builder = match "multi" {
24044            "multi" => local_var_req_builder.query(
24045                &local_var_str
24046                    .into_iter()
24047                    .map(|p| ("cid__nie".to_owned(), p.to_string()))
24048                    .collect::<Vec<(std::string::String, std::string::String)>>(),
24049            ),
24050            _ => local_var_req_builder.query(&[(
24051                "cid__nie",
24052                &local_var_str
24053                    .into_iter()
24054                    .map(|p| p.to_string())
24055                    .collect::<Vec<String>>()
24056                    .join(",")
24057                    .to_string(),
24058            )]),
24059        };
24060    }
24061    if let Some(ref local_var_str) = cid__niew {
24062        local_var_req_builder = match "multi" {
24063            "multi" => local_var_req_builder.query(
24064                &local_var_str
24065                    .into_iter()
24066                    .map(|p| ("cid__niew".to_owned(), p.to_string()))
24067                    .collect::<Vec<(std::string::String, std::string::String)>>(),
24068            ),
24069            _ => local_var_req_builder.query(&[(
24070                "cid__niew",
24071                &local_var_str
24072                    .into_iter()
24073                    .map(|p| p.to_string())
24074                    .collect::<Vec<String>>()
24075                    .join(",")
24076                    .to_string(),
24077            )]),
24078        };
24079    }
24080    if let Some(ref local_var_str) = cid__nisw {
24081        local_var_req_builder = match "multi" {
24082            "multi" => local_var_req_builder.query(
24083                &local_var_str
24084                    .into_iter()
24085                    .map(|p| ("cid__nisw".to_owned(), p.to_string()))
24086                    .collect::<Vec<(std::string::String, std::string::String)>>(),
24087            ),
24088            _ => local_var_req_builder.query(&[(
24089                "cid__nisw",
24090                &local_var_str
24091                    .into_iter()
24092                    .map(|p| p.to_string())
24093                    .collect::<Vec<String>>()
24094                    .join(",")
24095                    .to_string(),
24096            )]),
24097        };
24098    }
24099    if let Some(ref local_var_str) = cid__regex {
24100        local_var_req_builder = match "multi" {
24101            "multi" => local_var_req_builder.query(
24102                &local_var_str
24103                    .into_iter()
24104                    .map(|p| ("cid__regex".to_owned(), p.to_string()))
24105                    .collect::<Vec<(std::string::String, std::string::String)>>(),
24106            ),
24107            _ => local_var_req_builder.query(&[(
24108                "cid__regex",
24109                &local_var_str
24110                    .into_iter()
24111                    .map(|p| p.to_string())
24112                    .collect::<Vec<String>>()
24113                    .join(",")
24114                    .to_string(),
24115            )]),
24116        };
24117    }
24118    if let Some(ref local_var_str) = created {
24119        local_var_req_builder = match "multi" {
24120            "multi" => local_var_req_builder.query(
24121                &local_var_str
24122                    .into_iter()
24123                    .map(|p| ("created".to_owned(), p.to_string()))
24124                    .collect::<Vec<(std::string::String, std::string::String)>>(),
24125            ),
24126            _ => local_var_req_builder.query(&[(
24127                "created",
24128                &local_var_str
24129                    .into_iter()
24130                    .map(|p| p.to_string())
24131                    .collect::<Vec<String>>()
24132                    .join(",")
24133                    .to_string(),
24134            )]),
24135        };
24136    }
24137    if let Some(ref local_var_str) = created__empty {
24138        local_var_req_builder = match "multi" {
24139            "multi" => local_var_req_builder.query(
24140                &local_var_str
24141                    .into_iter()
24142                    .map(|p| ("created__empty".to_owned(), p.to_string()))
24143                    .collect::<Vec<(std::string::String, std::string::String)>>(),
24144            ),
24145            _ => local_var_req_builder.query(&[(
24146                "created__empty",
24147                &local_var_str
24148                    .into_iter()
24149                    .map(|p| p.to_string())
24150                    .collect::<Vec<String>>()
24151                    .join(",")
24152                    .to_string(),
24153            )]),
24154        };
24155    }
24156    if let Some(ref local_var_str) = created__gt {
24157        local_var_req_builder = match "multi" {
24158            "multi" => local_var_req_builder.query(
24159                &local_var_str
24160                    .into_iter()
24161                    .map(|p| ("created__gt".to_owned(), p.to_string()))
24162                    .collect::<Vec<(std::string::String, std::string::String)>>(),
24163            ),
24164            _ => local_var_req_builder.query(&[(
24165                "created__gt",
24166                &local_var_str
24167                    .into_iter()
24168                    .map(|p| p.to_string())
24169                    .collect::<Vec<String>>()
24170                    .join(",")
24171                    .to_string(),
24172            )]),
24173        };
24174    }
24175    if let Some(ref local_var_str) = created__gte {
24176        local_var_req_builder = match "multi" {
24177            "multi" => local_var_req_builder.query(
24178                &local_var_str
24179                    .into_iter()
24180                    .map(|p| ("created__gte".to_owned(), p.to_string()))
24181                    .collect::<Vec<(std::string::String, std::string::String)>>(),
24182            ),
24183            _ => local_var_req_builder.query(&[(
24184                "created__gte",
24185                &local_var_str
24186                    .into_iter()
24187                    .map(|p| p.to_string())
24188                    .collect::<Vec<String>>()
24189                    .join(",")
24190                    .to_string(),
24191            )]),
24192        };
24193    }
24194    if let Some(ref local_var_str) = created__lt {
24195        local_var_req_builder = match "multi" {
24196            "multi" => local_var_req_builder.query(
24197                &local_var_str
24198                    .into_iter()
24199                    .map(|p| ("created__lt".to_owned(), p.to_string()))
24200                    .collect::<Vec<(std::string::String, std::string::String)>>(),
24201            ),
24202            _ => local_var_req_builder.query(&[(
24203                "created__lt",
24204                &local_var_str
24205                    .into_iter()
24206                    .map(|p| p.to_string())
24207                    .collect::<Vec<String>>()
24208                    .join(",")
24209                    .to_string(),
24210            )]),
24211        };
24212    }
24213    if let Some(ref local_var_str) = created__lte {
24214        local_var_req_builder = match "multi" {
24215            "multi" => local_var_req_builder.query(
24216                &local_var_str
24217                    .into_iter()
24218                    .map(|p| ("created__lte".to_owned(), p.to_string()))
24219                    .collect::<Vec<(std::string::String, std::string::String)>>(),
24220            ),
24221            _ => local_var_req_builder.query(&[(
24222                "created__lte",
24223                &local_var_str
24224                    .into_iter()
24225                    .map(|p| p.to_string())
24226                    .collect::<Vec<String>>()
24227                    .join(",")
24228                    .to_string(),
24229            )]),
24230        };
24231    }
24232    if let Some(ref local_var_str) = created__n {
24233        local_var_req_builder = match "multi" {
24234            "multi" => local_var_req_builder.query(
24235                &local_var_str
24236                    .into_iter()
24237                    .map(|p| ("created__n".to_owned(), p.to_string()))
24238                    .collect::<Vec<(std::string::String, std::string::String)>>(),
24239            ),
24240            _ => local_var_req_builder.query(&[(
24241                "created__n",
24242                &local_var_str
24243                    .into_iter()
24244                    .map(|p| p.to_string())
24245                    .collect::<Vec<String>>()
24246                    .join(",")
24247                    .to_string(),
24248            )]),
24249        };
24250    }
24251    if let Some(ref local_var_str) = created_by_request {
24252        local_var_req_builder =
24253            local_var_req_builder.query(&[("created_by_request", &local_var_str.to_string())]);
24254    }
24255    if let Some(ref local_var_str) = description {
24256        local_var_req_builder = match "multi" {
24257            "multi" => local_var_req_builder.query(
24258                &local_var_str
24259                    .into_iter()
24260                    .map(|p| ("description".to_owned(), p.to_string()))
24261                    .collect::<Vec<(std::string::String, std::string::String)>>(),
24262            ),
24263            _ => local_var_req_builder.query(&[(
24264                "description",
24265                &local_var_str
24266                    .into_iter()
24267                    .map(|p| p.to_string())
24268                    .collect::<Vec<String>>()
24269                    .join(",")
24270                    .to_string(),
24271            )]),
24272        };
24273    }
24274    if let Some(ref local_var_str) = description__empty {
24275        local_var_req_builder =
24276            local_var_req_builder.query(&[("description__empty", &local_var_str.to_string())]);
24277    }
24278    if let Some(ref local_var_str) = description__ic {
24279        local_var_req_builder = match "multi" {
24280            "multi" => local_var_req_builder.query(
24281                &local_var_str
24282                    .into_iter()
24283                    .map(|p| ("description__ic".to_owned(), p.to_string()))
24284                    .collect::<Vec<(std::string::String, std::string::String)>>(),
24285            ),
24286            _ => local_var_req_builder.query(&[(
24287                "description__ic",
24288                &local_var_str
24289                    .into_iter()
24290                    .map(|p| p.to_string())
24291                    .collect::<Vec<String>>()
24292                    .join(",")
24293                    .to_string(),
24294            )]),
24295        };
24296    }
24297    if let Some(ref local_var_str) = description__ie {
24298        local_var_req_builder = match "multi" {
24299            "multi" => local_var_req_builder.query(
24300                &local_var_str
24301                    .into_iter()
24302                    .map(|p| ("description__ie".to_owned(), p.to_string()))
24303                    .collect::<Vec<(std::string::String, std::string::String)>>(),
24304            ),
24305            _ => local_var_req_builder.query(&[(
24306                "description__ie",
24307                &local_var_str
24308                    .into_iter()
24309                    .map(|p| p.to_string())
24310                    .collect::<Vec<String>>()
24311                    .join(",")
24312                    .to_string(),
24313            )]),
24314        };
24315    }
24316    if let Some(ref local_var_str) = description__iew {
24317        local_var_req_builder = match "multi" {
24318            "multi" => local_var_req_builder.query(
24319                &local_var_str
24320                    .into_iter()
24321                    .map(|p| ("description__iew".to_owned(), p.to_string()))
24322                    .collect::<Vec<(std::string::String, std::string::String)>>(),
24323            ),
24324            _ => local_var_req_builder.query(&[(
24325                "description__iew",
24326                &local_var_str
24327                    .into_iter()
24328                    .map(|p| p.to_string())
24329                    .collect::<Vec<String>>()
24330                    .join(",")
24331                    .to_string(),
24332            )]),
24333        };
24334    }
24335    if let Some(ref local_var_str) = description__iregex {
24336        local_var_req_builder = match "multi" {
24337            "multi" => local_var_req_builder.query(
24338                &local_var_str
24339                    .into_iter()
24340                    .map(|p| ("description__iregex".to_owned(), p.to_string()))
24341                    .collect::<Vec<(std::string::String, std::string::String)>>(),
24342            ),
24343            _ => local_var_req_builder.query(&[(
24344                "description__iregex",
24345                &local_var_str
24346                    .into_iter()
24347                    .map(|p| p.to_string())
24348                    .collect::<Vec<String>>()
24349                    .join(",")
24350                    .to_string(),
24351            )]),
24352        };
24353    }
24354    if let Some(ref local_var_str) = description__isw {
24355        local_var_req_builder = match "multi" {
24356            "multi" => local_var_req_builder.query(
24357                &local_var_str
24358                    .into_iter()
24359                    .map(|p| ("description__isw".to_owned(), p.to_string()))
24360                    .collect::<Vec<(std::string::String, std::string::String)>>(),
24361            ),
24362            _ => local_var_req_builder.query(&[(
24363                "description__isw",
24364                &local_var_str
24365                    .into_iter()
24366                    .map(|p| p.to_string())
24367                    .collect::<Vec<String>>()
24368                    .join(",")
24369                    .to_string(),
24370            )]),
24371        };
24372    }
24373    if let Some(ref local_var_str) = description__n {
24374        local_var_req_builder = match "multi" {
24375            "multi" => local_var_req_builder.query(
24376                &local_var_str
24377                    .into_iter()
24378                    .map(|p| ("description__n".to_owned(), p.to_string()))
24379                    .collect::<Vec<(std::string::String, std::string::String)>>(),
24380            ),
24381            _ => local_var_req_builder.query(&[(
24382                "description__n",
24383                &local_var_str
24384                    .into_iter()
24385                    .map(|p| p.to_string())
24386                    .collect::<Vec<String>>()
24387                    .join(",")
24388                    .to_string(),
24389            )]),
24390        };
24391    }
24392    if let Some(ref local_var_str) = description__nic {
24393        local_var_req_builder = match "multi" {
24394            "multi" => local_var_req_builder.query(
24395                &local_var_str
24396                    .into_iter()
24397                    .map(|p| ("description__nic".to_owned(), p.to_string()))
24398                    .collect::<Vec<(std::string::String, std::string::String)>>(),
24399            ),
24400            _ => local_var_req_builder.query(&[(
24401                "description__nic",
24402                &local_var_str
24403                    .into_iter()
24404                    .map(|p| p.to_string())
24405                    .collect::<Vec<String>>()
24406                    .join(",")
24407                    .to_string(),
24408            )]),
24409        };
24410    }
24411    if let Some(ref local_var_str) = description__nie {
24412        local_var_req_builder = match "multi" {
24413            "multi" => local_var_req_builder.query(
24414                &local_var_str
24415                    .into_iter()
24416                    .map(|p| ("description__nie".to_owned(), p.to_string()))
24417                    .collect::<Vec<(std::string::String, std::string::String)>>(),
24418            ),
24419            _ => local_var_req_builder.query(&[(
24420                "description__nie",
24421                &local_var_str
24422                    .into_iter()
24423                    .map(|p| p.to_string())
24424                    .collect::<Vec<String>>()
24425                    .join(",")
24426                    .to_string(),
24427            )]),
24428        };
24429    }
24430    if let Some(ref local_var_str) = description__niew {
24431        local_var_req_builder = match "multi" {
24432            "multi" => local_var_req_builder.query(
24433                &local_var_str
24434                    .into_iter()
24435                    .map(|p| ("description__niew".to_owned(), p.to_string()))
24436                    .collect::<Vec<(std::string::String, std::string::String)>>(),
24437            ),
24438            _ => local_var_req_builder.query(&[(
24439                "description__niew",
24440                &local_var_str
24441                    .into_iter()
24442                    .map(|p| p.to_string())
24443                    .collect::<Vec<String>>()
24444                    .join(",")
24445                    .to_string(),
24446            )]),
24447        };
24448    }
24449    if let Some(ref local_var_str) = description__nisw {
24450        local_var_req_builder = match "multi" {
24451            "multi" => local_var_req_builder.query(
24452                &local_var_str
24453                    .into_iter()
24454                    .map(|p| ("description__nisw".to_owned(), p.to_string()))
24455                    .collect::<Vec<(std::string::String, std::string::String)>>(),
24456            ),
24457            _ => local_var_req_builder.query(&[(
24458                "description__nisw",
24459                &local_var_str
24460                    .into_iter()
24461                    .map(|p| p.to_string())
24462                    .collect::<Vec<String>>()
24463                    .join(",")
24464                    .to_string(),
24465            )]),
24466        };
24467    }
24468    if let Some(ref local_var_str) = description__regex {
24469        local_var_req_builder = match "multi" {
24470            "multi" => local_var_req_builder.query(
24471                &local_var_str
24472                    .into_iter()
24473                    .map(|p| ("description__regex".to_owned(), p.to_string()))
24474                    .collect::<Vec<(std::string::String, std::string::String)>>(),
24475            ),
24476            _ => local_var_req_builder.query(&[(
24477                "description__regex",
24478                &local_var_str
24479                    .into_iter()
24480                    .map(|p| p.to_string())
24481                    .collect::<Vec<String>>()
24482                    .join(",")
24483                    .to_string(),
24484            )]),
24485        };
24486    }
24487    if let Some(ref local_var_str) = id {
24488        local_var_req_builder = match "multi" {
24489            "multi" => local_var_req_builder.query(
24490                &local_var_str
24491                    .into_iter()
24492                    .map(|p| ("id".to_owned(), p.to_string()))
24493                    .collect::<Vec<(std::string::String, std::string::String)>>(),
24494            ),
24495            _ => local_var_req_builder.query(&[(
24496                "id",
24497                &local_var_str
24498                    .into_iter()
24499                    .map(|p| p.to_string())
24500                    .collect::<Vec<String>>()
24501                    .join(",")
24502                    .to_string(),
24503            )]),
24504        };
24505    }
24506    if let Some(ref local_var_str) = id__empty {
24507        local_var_req_builder =
24508            local_var_req_builder.query(&[("id__empty", &local_var_str.to_string())]);
24509    }
24510    if let Some(ref local_var_str) = id__gt {
24511        local_var_req_builder = match "multi" {
24512            "multi" => local_var_req_builder.query(
24513                &local_var_str
24514                    .into_iter()
24515                    .map(|p| ("id__gt".to_owned(), p.to_string()))
24516                    .collect::<Vec<(std::string::String, std::string::String)>>(),
24517            ),
24518            _ => local_var_req_builder.query(&[(
24519                "id__gt",
24520                &local_var_str
24521                    .into_iter()
24522                    .map(|p| p.to_string())
24523                    .collect::<Vec<String>>()
24524                    .join(",")
24525                    .to_string(),
24526            )]),
24527        };
24528    }
24529    if let Some(ref local_var_str) = id__gte {
24530        local_var_req_builder = match "multi" {
24531            "multi" => local_var_req_builder.query(
24532                &local_var_str
24533                    .into_iter()
24534                    .map(|p| ("id__gte".to_owned(), p.to_string()))
24535                    .collect::<Vec<(std::string::String, std::string::String)>>(),
24536            ),
24537            _ => local_var_req_builder.query(&[(
24538                "id__gte",
24539                &local_var_str
24540                    .into_iter()
24541                    .map(|p| p.to_string())
24542                    .collect::<Vec<String>>()
24543                    .join(",")
24544                    .to_string(),
24545            )]),
24546        };
24547    }
24548    if let Some(ref local_var_str) = id__lt {
24549        local_var_req_builder = match "multi" {
24550            "multi" => local_var_req_builder.query(
24551                &local_var_str
24552                    .into_iter()
24553                    .map(|p| ("id__lt".to_owned(), p.to_string()))
24554                    .collect::<Vec<(std::string::String, std::string::String)>>(),
24555            ),
24556            _ => local_var_req_builder.query(&[(
24557                "id__lt",
24558                &local_var_str
24559                    .into_iter()
24560                    .map(|p| p.to_string())
24561                    .collect::<Vec<String>>()
24562                    .join(",")
24563                    .to_string(),
24564            )]),
24565        };
24566    }
24567    if let Some(ref local_var_str) = id__lte {
24568        local_var_req_builder = match "multi" {
24569            "multi" => local_var_req_builder.query(
24570                &local_var_str
24571                    .into_iter()
24572                    .map(|p| ("id__lte".to_owned(), p.to_string()))
24573                    .collect::<Vec<(std::string::String, std::string::String)>>(),
24574            ),
24575            _ => local_var_req_builder.query(&[(
24576                "id__lte",
24577                &local_var_str
24578                    .into_iter()
24579                    .map(|p| p.to_string())
24580                    .collect::<Vec<String>>()
24581                    .join(",")
24582                    .to_string(),
24583            )]),
24584        };
24585    }
24586    if let Some(ref local_var_str) = id__n {
24587        local_var_req_builder = match "multi" {
24588            "multi" => local_var_req_builder.query(
24589                &local_var_str
24590                    .into_iter()
24591                    .map(|p| ("id__n".to_owned(), p.to_string()))
24592                    .collect::<Vec<(std::string::String, std::string::String)>>(),
24593            ),
24594            _ => local_var_req_builder.query(&[(
24595                "id__n",
24596                &local_var_str
24597                    .into_iter()
24598                    .map(|p| p.to_string())
24599                    .collect::<Vec<String>>()
24600                    .join(",")
24601                    .to_string(),
24602            )]),
24603        };
24604    }
24605    if let Some(ref local_var_str) = last_updated {
24606        local_var_req_builder = match "multi" {
24607            "multi" => local_var_req_builder.query(
24608                &local_var_str
24609                    .into_iter()
24610                    .map(|p| ("last_updated".to_owned(), p.to_string()))
24611                    .collect::<Vec<(std::string::String, std::string::String)>>(),
24612            ),
24613            _ => local_var_req_builder.query(&[(
24614                "last_updated",
24615                &local_var_str
24616                    .into_iter()
24617                    .map(|p| p.to_string())
24618                    .collect::<Vec<String>>()
24619                    .join(",")
24620                    .to_string(),
24621            )]),
24622        };
24623    }
24624    if let Some(ref local_var_str) = last_updated__empty {
24625        local_var_req_builder = match "multi" {
24626            "multi" => local_var_req_builder.query(
24627                &local_var_str
24628                    .into_iter()
24629                    .map(|p| ("last_updated__empty".to_owned(), p.to_string()))
24630                    .collect::<Vec<(std::string::String, std::string::String)>>(),
24631            ),
24632            _ => local_var_req_builder.query(&[(
24633                "last_updated__empty",
24634                &local_var_str
24635                    .into_iter()
24636                    .map(|p| p.to_string())
24637                    .collect::<Vec<String>>()
24638                    .join(",")
24639                    .to_string(),
24640            )]),
24641        };
24642    }
24643    if let Some(ref local_var_str) = last_updated__gt {
24644        local_var_req_builder = match "multi" {
24645            "multi" => local_var_req_builder.query(
24646                &local_var_str
24647                    .into_iter()
24648                    .map(|p| ("last_updated__gt".to_owned(), p.to_string()))
24649                    .collect::<Vec<(std::string::String, std::string::String)>>(),
24650            ),
24651            _ => local_var_req_builder.query(&[(
24652                "last_updated__gt",
24653                &local_var_str
24654                    .into_iter()
24655                    .map(|p| p.to_string())
24656                    .collect::<Vec<String>>()
24657                    .join(",")
24658                    .to_string(),
24659            )]),
24660        };
24661    }
24662    if let Some(ref local_var_str) = last_updated__gte {
24663        local_var_req_builder = match "multi" {
24664            "multi" => local_var_req_builder.query(
24665                &local_var_str
24666                    .into_iter()
24667                    .map(|p| ("last_updated__gte".to_owned(), p.to_string()))
24668                    .collect::<Vec<(std::string::String, std::string::String)>>(),
24669            ),
24670            _ => local_var_req_builder.query(&[(
24671                "last_updated__gte",
24672                &local_var_str
24673                    .into_iter()
24674                    .map(|p| p.to_string())
24675                    .collect::<Vec<String>>()
24676                    .join(",")
24677                    .to_string(),
24678            )]),
24679        };
24680    }
24681    if let Some(ref local_var_str) = last_updated__lt {
24682        local_var_req_builder = match "multi" {
24683            "multi" => local_var_req_builder.query(
24684                &local_var_str
24685                    .into_iter()
24686                    .map(|p| ("last_updated__lt".to_owned(), p.to_string()))
24687                    .collect::<Vec<(std::string::String, std::string::String)>>(),
24688            ),
24689            _ => local_var_req_builder.query(&[(
24690                "last_updated__lt",
24691                &local_var_str
24692                    .into_iter()
24693                    .map(|p| p.to_string())
24694                    .collect::<Vec<String>>()
24695                    .join(",")
24696                    .to_string(),
24697            )]),
24698        };
24699    }
24700    if let Some(ref local_var_str) = last_updated__lte {
24701        local_var_req_builder = match "multi" {
24702            "multi" => local_var_req_builder.query(
24703                &local_var_str
24704                    .into_iter()
24705                    .map(|p| ("last_updated__lte".to_owned(), p.to_string()))
24706                    .collect::<Vec<(std::string::String, std::string::String)>>(),
24707            ),
24708            _ => local_var_req_builder.query(&[(
24709                "last_updated__lte",
24710                &local_var_str
24711                    .into_iter()
24712                    .map(|p| p.to_string())
24713                    .collect::<Vec<String>>()
24714                    .join(",")
24715                    .to_string(),
24716            )]),
24717        };
24718    }
24719    if let Some(ref local_var_str) = last_updated__n {
24720        local_var_req_builder = match "multi" {
24721            "multi" => local_var_req_builder.query(
24722                &local_var_str
24723                    .into_iter()
24724                    .map(|p| ("last_updated__n".to_owned(), p.to_string()))
24725                    .collect::<Vec<(std::string::String, std::string::String)>>(),
24726            ),
24727            _ => local_var_req_builder.query(&[(
24728                "last_updated__n",
24729                &local_var_str
24730                    .into_iter()
24731                    .map(|p| p.to_string())
24732                    .collect::<Vec<String>>()
24733                    .join(",")
24734                    .to_string(),
24735            )]),
24736        };
24737    }
24738    if let Some(ref local_var_str) = limit {
24739        local_var_req_builder =
24740            local_var_req_builder.query(&[("limit", &local_var_str.to_string())]);
24741    }
24742    if let Some(ref local_var_str) = modified_by_request {
24743        local_var_req_builder =
24744            local_var_req_builder.query(&[("modified_by_request", &local_var_str.to_string())]);
24745    }
24746    if let Some(ref local_var_str) = offset {
24747        local_var_req_builder =
24748            local_var_req_builder.query(&[("offset", &local_var_str.to_string())]);
24749    }
24750    if let Some(ref local_var_str) = ordering {
24751        local_var_req_builder =
24752            local_var_req_builder.query(&[("ordering", &local_var_str.to_string())]);
24753    }
24754    if let Some(ref local_var_str) = owner {
24755        local_var_req_builder = match "multi" {
24756            "multi" => local_var_req_builder.query(
24757                &local_var_str
24758                    .into_iter()
24759                    .map(|p| ("owner".to_owned(), p.to_string()))
24760                    .collect::<Vec<(std::string::String, std::string::String)>>(),
24761            ),
24762            _ => local_var_req_builder.query(&[(
24763                "owner",
24764                &local_var_str
24765                    .into_iter()
24766                    .map(|p| p.to_string())
24767                    .collect::<Vec<String>>()
24768                    .join(",")
24769                    .to_string(),
24770            )]),
24771        };
24772    }
24773    if let Some(ref local_var_str) = owner__n {
24774        local_var_req_builder = match "multi" {
24775            "multi" => local_var_req_builder.query(
24776                &local_var_str
24777                    .into_iter()
24778                    .map(|p| ("owner__n".to_owned(), p.to_string()))
24779                    .collect::<Vec<(std::string::String, std::string::String)>>(),
24780            ),
24781            _ => local_var_req_builder.query(&[(
24782                "owner__n",
24783                &local_var_str
24784                    .into_iter()
24785                    .map(|p| p.to_string())
24786                    .collect::<Vec<String>>()
24787                    .join(",")
24788                    .to_string(),
24789            )]),
24790        };
24791    }
24792    if let Some(ref local_var_str) = owner_group {
24793        local_var_req_builder = match "multi" {
24794            "multi" => local_var_req_builder.query(
24795                &local_var_str
24796                    .into_iter()
24797                    .map(|p| ("owner_group".to_owned(), p.to_string()))
24798                    .collect::<Vec<(std::string::String, std::string::String)>>(),
24799            ),
24800            _ => local_var_req_builder.query(&[(
24801                "owner_group",
24802                &local_var_str
24803                    .into_iter()
24804                    .map(|p| p.to_string())
24805                    .collect::<Vec<String>>()
24806                    .join(",")
24807                    .to_string(),
24808            )]),
24809        };
24810    }
24811    if let Some(ref local_var_str) = owner_group__n {
24812        local_var_req_builder = match "multi" {
24813            "multi" => local_var_req_builder.query(
24814                &local_var_str
24815                    .into_iter()
24816                    .map(|p| ("owner_group__n".to_owned(), p.to_string()))
24817                    .collect::<Vec<(std::string::String, std::string::String)>>(),
24818            ),
24819            _ => local_var_req_builder.query(&[(
24820                "owner_group__n",
24821                &local_var_str
24822                    .into_iter()
24823                    .map(|p| p.to_string())
24824                    .collect::<Vec<String>>()
24825                    .join(",")
24826                    .to_string(),
24827            )]),
24828        };
24829    }
24830    if let Some(ref local_var_str) = owner_group_id {
24831        local_var_req_builder = match "multi" {
24832            "multi" => local_var_req_builder.query(
24833                &local_var_str
24834                    .into_iter()
24835                    .map(|p| ("owner_group_id".to_owned(), p.to_string()))
24836                    .collect::<Vec<(std::string::String, std::string::String)>>(),
24837            ),
24838            _ => local_var_req_builder.query(&[(
24839                "owner_group_id",
24840                &local_var_str
24841                    .into_iter()
24842                    .map(|p| p.to_string())
24843                    .collect::<Vec<String>>()
24844                    .join(",")
24845                    .to_string(),
24846            )]),
24847        };
24848    }
24849    if let Some(ref local_var_str) = owner_group_id__n {
24850        local_var_req_builder = match "multi" {
24851            "multi" => local_var_req_builder.query(
24852                &local_var_str
24853                    .into_iter()
24854                    .map(|p| ("owner_group_id__n".to_owned(), p.to_string()))
24855                    .collect::<Vec<(std::string::String, std::string::String)>>(),
24856            ),
24857            _ => local_var_req_builder.query(&[(
24858                "owner_group_id__n",
24859                &local_var_str
24860                    .into_iter()
24861                    .map(|p| p.to_string())
24862                    .collect::<Vec<String>>()
24863                    .join(",")
24864                    .to_string(),
24865            )]),
24866        };
24867    }
24868    if let Some(ref local_var_str) = owner_id {
24869        local_var_req_builder = match "multi" {
24870            "multi" => local_var_req_builder.query(
24871                &local_var_str
24872                    .into_iter()
24873                    .map(|p| ("owner_id".to_owned(), p.to_string()))
24874                    .collect::<Vec<(std::string::String, std::string::String)>>(),
24875            ),
24876            _ => local_var_req_builder.query(&[(
24877                "owner_id",
24878                &local_var_str
24879                    .into_iter()
24880                    .map(|p| p.to_string())
24881                    .collect::<Vec<String>>()
24882                    .join(",")
24883                    .to_string(),
24884            )]),
24885        };
24886    }
24887    if let Some(ref local_var_str) = owner_id__n {
24888        local_var_req_builder = match "multi" {
24889            "multi" => local_var_req_builder.query(
24890                &local_var_str
24891                    .into_iter()
24892                    .map(|p| ("owner_id__n".to_owned(), p.to_string()))
24893                    .collect::<Vec<(std::string::String, std::string::String)>>(),
24894            ),
24895            _ => local_var_req_builder.query(&[(
24896                "owner_id__n",
24897                &local_var_str
24898                    .into_iter()
24899                    .map(|p| p.to_string())
24900                    .collect::<Vec<String>>()
24901                    .join(",")
24902                    .to_string(),
24903            )]),
24904        };
24905    }
24906    if let Some(ref local_var_str) = provider {
24907        local_var_req_builder = match "multi" {
24908            "multi" => local_var_req_builder.query(
24909                &local_var_str
24910                    .into_iter()
24911                    .map(|p| ("provider".to_owned(), p.to_string()))
24912                    .collect::<Vec<(std::string::String, std::string::String)>>(),
24913            ),
24914            _ => local_var_req_builder.query(&[(
24915                "provider",
24916                &local_var_str
24917                    .into_iter()
24918                    .map(|p| p.to_string())
24919                    .collect::<Vec<String>>()
24920                    .join(",")
24921                    .to_string(),
24922            )]),
24923        };
24924    }
24925    if let Some(ref local_var_str) = provider__n {
24926        local_var_req_builder = match "multi" {
24927            "multi" => local_var_req_builder.query(
24928                &local_var_str
24929                    .into_iter()
24930                    .map(|p| ("provider__n".to_owned(), p.to_string()))
24931                    .collect::<Vec<(std::string::String, std::string::String)>>(),
24932            ),
24933            _ => local_var_req_builder.query(&[(
24934                "provider__n",
24935                &local_var_str
24936                    .into_iter()
24937                    .map(|p| p.to_string())
24938                    .collect::<Vec<String>>()
24939                    .join(",")
24940                    .to_string(),
24941            )]),
24942        };
24943    }
24944    if let Some(ref local_var_str) = provider_account {
24945        local_var_req_builder = match "multi" {
24946            "multi" => local_var_req_builder.query(
24947                &local_var_str
24948                    .into_iter()
24949                    .map(|p| ("provider_account".to_owned(), p.to_string()))
24950                    .collect::<Vec<(std::string::String, std::string::String)>>(),
24951            ),
24952            _ => local_var_req_builder.query(&[(
24953                "provider_account",
24954                &local_var_str
24955                    .into_iter()
24956                    .map(|p| p.to_string())
24957                    .collect::<Vec<String>>()
24958                    .join(",")
24959                    .to_string(),
24960            )]),
24961        };
24962    }
24963    if let Some(ref local_var_str) = provider_account__n {
24964        local_var_req_builder = match "multi" {
24965            "multi" => local_var_req_builder.query(
24966                &local_var_str
24967                    .into_iter()
24968                    .map(|p| ("provider_account__n".to_owned(), p.to_string()))
24969                    .collect::<Vec<(std::string::String, std::string::String)>>(),
24970            ),
24971            _ => local_var_req_builder.query(&[(
24972                "provider_account__n",
24973                &local_var_str
24974                    .into_iter()
24975                    .map(|p| p.to_string())
24976                    .collect::<Vec<String>>()
24977                    .join(",")
24978                    .to_string(),
24979            )]),
24980        };
24981    }
24982    if let Some(ref local_var_str) = provider_account_id {
24983        local_var_req_builder = match "multi" {
24984            "multi" => local_var_req_builder.query(
24985                &local_var_str
24986                    .into_iter()
24987                    .map(|p| ("provider_account_id".to_owned(), p.to_string()))
24988                    .collect::<Vec<(std::string::String, std::string::String)>>(),
24989            ),
24990            _ => local_var_req_builder.query(&[(
24991                "provider_account_id",
24992                &local_var_str
24993                    .into_iter()
24994                    .map(|p| p.to_string())
24995                    .collect::<Vec<String>>()
24996                    .join(",")
24997                    .to_string(),
24998            )]),
24999        };
25000    }
25001    if let Some(ref local_var_str) = provider_account_id__n {
25002        local_var_req_builder = match "multi" {
25003            "multi" => local_var_req_builder.query(
25004                &local_var_str
25005                    .into_iter()
25006                    .map(|p| ("provider_account_id__n".to_owned(), p.to_string()))
25007                    .collect::<Vec<(std::string::String, std::string::String)>>(),
25008            ),
25009            _ => local_var_req_builder.query(&[(
25010                "provider_account_id__n",
25011                &local_var_str
25012                    .into_iter()
25013                    .map(|p| p.to_string())
25014                    .collect::<Vec<String>>()
25015                    .join(",")
25016                    .to_string(),
25017            )]),
25018        };
25019    }
25020    if let Some(ref local_var_str) = provider_id {
25021        local_var_req_builder = match "multi" {
25022            "multi" => local_var_req_builder.query(
25023                &local_var_str
25024                    .into_iter()
25025                    .map(|p| ("provider_id".to_owned(), p.to_string()))
25026                    .collect::<Vec<(std::string::String, std::string::String)>>(),
25027            ),
25028            _ => local_var_req_builder.query(&[(
25029                "provider_id",
25030                &local_var_str
25031                    .into_iter()
25032                    .map(|p| p.to_string())
25033                    .collect::<Vec<String>>()
25034                    .join(",")
25035                    .to_string(),
25036            )]),
25037        };
25038    }
25039    if let Some(ref local_var_str) = provider_id__n {
25040        local_var_req_builder = match "multi" {
25041            "multi" => local_var_req_builder.query(
25042                &local_var_str
25043                    .into_iter()
25044                    .map(|p| ("provider_id__n".to_owned(), p.to_string()))
25045                    .collect::<Vec<(std::string::String, std::string::String)>>(),
25046            ),
25047            _ => local_var_req_builder.query(&[(
25048                "provider_id__n",
25049                &local_var_str
25050                    .into_iter()
25051                    .map(|p| p.to_string())
25052                    .collect::<Vec<String>>()
25053                    .join(",")
25054                    .to_string(),
25055            )]),
25056        };
25057    }
25058    if let Some(ref local_var_str) = provider_network_id {
25059        local_var_req_builder = match "multi" {
25060            "multi" => local_var_req_builder.query(
25061                &local_var_str
25062                    .into_iter()
25063                    .map(|p| ("provider_network_id".to_owned(), p.to_string()))
25064                    .collect::<Vec<(std::string::String, std::string::String)>>(),
25065            ),
25066            _ => local_var_req_builder.query(&[(
25067                "provider_network_id",
25068                &local_var_str
25069                    .into_iter()
25070                    .map(|p| p.to_string())
25071                    .collect::<Vec<String>>()
25072                    .join(",")
25073                    .to_string(),
25074            )]),
25075        };
25076    }
25077    if let Some(ref local_var_str) = provider_network_id__n {
25078        local_var_req_builder = match "multi" {
25079            "multi" => local_var_req_builder.query(
25080                &local_var_str
25081                    .into_iter()
25082                    .map(|p| ("provider_network_id__n".to_owned(), p.to_string()))
25083                    .collect::<Vec<(std::string::String, std::string::String)>>(),
25084            ),
25085            _ => local_var_req_builder.query(&[(
25086                "provider_network_id__n",
25087                &local_var_str
25088                    .into_iter()
25089                    .map(|p| p.to_string())
25090                    .collect::<Vec<String>>()
25091                    .join(",")
25092                    .to_string(),
25093            )]),
25094        };
25095    }
25096    if let Some(ref local_var_str) = q {
25097        local_var_req_builder = local_var_req_builder.query(&[("q", &local_var_str.to_string())]);
25098    }
25099    if let Some(ref local_var_str) = start {
25100        local_var_req_builder =
25101            local_var_req_builder.query(&[("start", &local_var_str.to_string())]);
25102    }
25103    if let Some(ref local_var_str) = status {
25104        local_var_req_builder = match "multi" {
25105            "multi" => local_var_req_builder.query(
25106                &local_var_str
25107                    .into_iter()
25108                    .map(|p| ("status".to_owned(), p.to_string()))
25109                    .collect::<Vec<(std::string::String, std::string::String)>>(),
25110            ),
25111            _ => local_var_req_builder.query(&[(
25112                "status",
25113                &local_var_str
25114                    .into_iter()
25115                    .map(|p| p.to_string())
25116                    .collect::<Vec<String>>()
25117                    .join(",")
25118                    .to_string(),
25119            )]),
25120        };
25121    }
25122    if let Some(ref local_var_str) = status__empty {
25123        local_var_req_builder =
25124            local_var_req_builder.query(&[("status__empty", &local_var_str.to_string())]);
25125    }
25126    if let Some(ref local_var_str) = status__ic {
25127        local_var_req_builder = match "multi" {
25128            "multi" => local_var_req_builder.query(
25129                &local_var_str
25130                    .into_iter()
25131                    .map(|p| ("status__ic".to_owned(), p.to_string()))
25132                    .collect::<Vec<(std::string::String, std::string::String)>>(),
25133            ),
25134            _ => local_var_req_builder.query(&[(
25135                "status__ic",
25136                &local_var_str
25137                    .into_iter()
25138                    .map(|p| p.to_string())
25139                    .collect::<Vec<String>>()
25140                    .join(",")
25141                    .to_string(),
25142            )]),
25143        };
25144    }
25145    if let Some(ref local_var_str) = status__ie {
25146        local_var_req_builder = match "multi" {
25147            "multi" => local_var_req_builder.query(
25148                &local_var_str
25149                    .into_iter()
25150                    .map(|p| ("status__ie".to_owned(), p.to_string()))
25151                    .collect::<Vec<(std::string::String, std::string::String)>>(),
25152            ),
25153            _ => local_var_req_builder.query(&[(
25154                "status__ie",
25155                &local_var_str
25156                    .into_iter()
25157                    .map(|p| p.to_string())
25158                    .collect::<Vec<String>>()
25159                    .join(",")
25160                    .to_string(),
25161            )]),
25162        };
25163    }
25164    if let Some(ref local_var_str) = status__iew {
25165        local_var_req_builder = match "multi" {
25166            "multi" => local_var_req_builder.query(
25167                &local_var_str
25168                    .into_iter()
25169                    .map(|p| ("status__iew".to_owned(), p.to_string()))
25170                    .collect::<Vec<(std::string::String, std::string::String)>>(),
25171            ),
25172            _ => local_var_req_builder.query(&[(
25173                "status__iew",
25174                &local_var_str
25175                    .into_iter()
25176                    .map(|p| p.to_string())
25177                    .collect::<Vec<String>>()
25178                    .join(",")
25179                    .to_string(),
25180            )]),
25181        };
25182    }
25183    if let Some(ref local_var_str) = status__iregex {
25184        local_var_req_builder = match "multi" {
25185            "multi" => local_var_req_builder.query(
25186                &local_var_str
25187                    .into_iter()
25188                    .map(|p| ("status__iregex".to_owned(), p.to_string()))
25189                    .collect::<Vec<(std::string::String, std::string::String)>>(),
25190            ),
25191            _ => local_var_req_builder.query(&[(
25192                "status__iregex",
25193                &local_var_str
25194                    .into_iter()
25195                    .map(|p| p.to_string())
25196                    .collect::<Vec<String>>()
25197                    .join(",")
25198                    .to_string(),
25199            )]),
25200        };
25201    }
25202    if let Some(ref local_var_str) = status__isw {
25203        local_var_req_builder = match "multi" {
25204            "multi" => local_var_req_builder.query(
25205                &local_var_str
25206                    .into_iter()
25207                    .map(|p| ("status__isw".to_owned(), p.to_string()))
25208                    .collect::<Vec<(std::string::String, std::string::String)>>(),
25209            ),
25210            _ => local_var_req_builder.query(&[(
25211                "status__isw",
25212                &local_var_str
25213                    .into_iter()
25214                    .map(|p| p.to_string())
25215                    .collect::<Vec<String>>()
25216                    .join(",")
25217                    .to_string(),
25218            )]),
25219        };
25220    }
25221    if let Some(ref local_var_str) = status__n {
25222        local_var_req_builder = match "multi" {
25223            "multi" => local_var_req_builder.query(
25224                &local_var_str
25225                    .into_iter()
25226                    .map(|p| ("status__n".to_owned(), p.to_string()))
25227                    .collect::<Vec<(std::string::String, std::string::String)>>(),
25228            ),
25229            _ => local_var_req_builder.query(&[(
25230                "status__n",
25231                &local_var_str
25232                    .into_iter()
25233                    .map(|p| p.to_string())
25234                    .collect::<Vec<String>>()
25235                    .join(",")
25236                    .to_string(),
25237            )]),
25238        };
25239    }
25240    if let Some(ref local_var_str) = status__nic {
25241        local_var_req_builder = match "multi" {
25242            "multi" => local_var_req_builder.query(
25243                &local_var_str
25244                    .into_iter()
25245                    .map(|p| ("status__nic".to_owned(), p.to_string()))
25246                    .collect::<Vec<(std::string::String, std::string::String)>>(),
25247            ),
25248            _ => local_var_req_builder.query(&[(
25249                "status__nic",
25250                &local_var_str
25251                    .into_iter()
25252                    .map(|p| p.to_string())
25253                    .collect::<Vec<String>>()
25254                    .join(",")
25255                    .to_string(),
25256            )]),
25257        };
25258    }
25259    if let Some(ref local_var_str) = status__nie {
25260        local_var_req_builder = match "multi" {
25261            "multi" => local_var_req_builder.query(
25262                &local_var_str
25263                    .into_iter()
25264                    .map(|p| ("status__nie".to_owned(), p.to_string()))
25265                    .collect::<Vec<(std::string::String, std::string::String)>>(),
25266            ),
25267            _ => local_var_req_builder.query(&[(
25268                "status__nie",
25269                &local_var_str
25270                    .into_iter()
25271                    .map(|p| p.to_string())
25272                    .collect::<Vec<String>>()
25273                    .join(",")
25274                    .to_string(),
25275            )]),
25276        };
25277    }
25278    if let Some(ref local_var_str) = status__niew {
25279        local_var_req_builder = match "multi" {
25280            "multi" => local_var_req_builder.query(
25281                &local_var_str
25282                    .into_iter()
25283                    .map(|p| ("status__niew".to_owned(), p.to_string()))
25284                    .collect::<Vec<(std::string::String, std::string::String)>>(),
25285            ),
25286            _ => local_var_req_builder.query(&[(
25287                "status__niew",
25288                &local_var_str
25289                    .into_iter()
25290                    .map(|p| p.to_string())
25291                    .collect::<Vec<String>>()
25292                    .join(",")
25293                    .to_string(),
25294            )]),
25295        };
25296    }
25297    if let Some(ref local_var_str) = status__nisw {
25298        local_var_req_builder = match "multi" {
25299            "multi" => local_var_req_builder.query(
25300                &local_var_str
25301                    .into_iter()
25302                    .map(|p| ("status__nisw".to_owned(), p.to_string()))
25303                    .collect::<Vec<(std::string::String, std::string::String)>>(),
25304            ),
25305            _ => local_var_req_builder.query(&[(
25306                "status__nisw",
25307                &local_var_str
25308                    .into_iter()
25309                    .map(|p| p.to_string())
25310                    .collect::<Vec<String>>()
25311                    .join(",")
25312                    .to_string(),
25313            )]),
25314        };
25315    }
25316    if let Some(ref local_var_str) = status__regex {
25317        local_var_req_builder = match "multi" {
25318            "multi" => local_var_req_builder.query(
25319                &local_var_str
25320                    .into_iter()
25321                    .map(|p| ("status__regex".to_owned(), p.to_string()))
25322                    .collect::<Vec<(std::string::String, std::string::String)>>(),
25323            ),
25324            _ => local_var_req_builder.query(&[(
25325                "status__regex",
25326                &local_var_str
25327                    .into_iter()
25328                    .map(|p| p.to_string())
25329                    .collect::<Vec<String>>()
25330                    .join(",")
25331                    .to_string(),
25332            )]),
25333        };
25334    }
25335    if let Some(ref local_var_str) = tag {
25336        local_var_req_builder = match "multi" {
25337            "multi" => local_var_req_builder.query(
25338                &local_var_str
25339                    .into_iter()
25340                    .map(|p| ("tag".to_owned(), p.to_string()))
25341                    .collect::<Vec<(std::string::String, std::string::String)>>(),
25342            ),
25343            _ => local_var_req_builder.query(&[(
25344                "tag",
25345                &local_var_str
25346                    .into_iter()
25347                    .map(|p| p.to_string())
25348                    .collect::<Vec<String>>()
25349                    .join(",")
25350                    .to_string(),
25351            )]),
25352        };
25353    }
25354    if let Some(ref local_var_str) = tag__n {
25355        local_var_req_builder = match "multi" {
25356            "multi" => local_var_req_builder.query(
25357                &local_var_str
25358                    .into_iter()
25359                    .map(|p| ("tag__n".to_owned(), p.to_string()))
25360                    .collect::<Vec<(std::string::String, std::string::String)>>(),
25361            ),
25362            _ => local_var_req_builder.query(&[(
25363                "tag__n",
25364                &local_var_str
25365                    .into_iter()
25366                    .map(|p| p.to_string())
25367                    .collect::<Vec<String>>()
25368                    .join(",")
25369                    .to_string(),
25370            )]),
25371        };
25372    }
25373    if let Some(ref local_var_str) = tag_id {
25374        local_var_req_builder = match "multi" {
25375            "multi" => local_var_req_builder.query(
25376                &local_var_str
25377                    .into_iter()
25378                    .map(|p| ("tag_id".to_owned(), p.to_string()))
25379                    .collect::<Vec<(std::string::String, std::string::String)>>(),
25380            ),
25381            _ => local_var_req_builder.query(&[(
25382                "tag_id",
25383                &local_var_str
25384                    .into_iter()
25385                    .map(|p| p.to_string())
25386                    .collect::<Vec<String>>()
25387                    .join(",")
25388                    .to_string(),
25389            )]),
25390        };
25391    }
25392    if let Some(ref local_var_str) = tag_id__n {
25393        local_var_req_builder = match "multi" {
25394            "multi" => local_var_req_builder.query(
25395                &local_var_str
25396                    .into_iter()
25397                    .map(|p| ("tag_id__n".to_owned(), p.to_string()))
25398                    .collect::<Vec<(std::string::String, std::string::String)>>(),
25399            ),
25400            _ => local_var_req_builder.query(&[(
25401                "tag_id__n",
25402                &local_var_str
25403                    .into_iter()
25404                    .map(|p| p.to_string())
25405                    .collect::<Vec<String>>()
25406                    .join(",")
25407                    .to_string(),
25408            )]),
25409        };
25410    }
25411    if let Some(ref local_var_str) = tenant {
25412        local_var_req_builder = match "multi" {
25413            "multi" => local_var_req_builder.query(
25414                &local_var_str
25415                    .into_iter()
25416                    .map(|p| ("tenant".to_owned(), p.to_string()))
25417                    .collect::<Vec<(std::string::String, std::string::String)>>(),
25418            ),
25419            _ => local_var_req_builder.query(&[(
25420                "tenant",
25421                &local_var_str
25422                    .into_iter()
25423                    .map(|p| p.to_string())
25424                    .collect::<Vec<String>>()
25425                    .join(",")
25426                    .to_string(),
25427            )]),
25428        };
25429    }
25430    if let Some(ref local_var_str) = tenant__n {
25431        local_var_req_builder = match "multi" {
25432            "multi" => local_var_req_builder.query(
25433                &local_var_str
25434                    .into_iter()
25435                    .map(|p| ("tenant__n".to_owned(), p.to_string()))
25436                    .collect::<Vec<(std::string::String, std::string::String)>>(),
25437            ),
25438            _ => local_var_req_builder.query(&[(
25439                "tenant__n",
25440                &local_var_str
25441                    .into_iter()
25442                    .map(|p| p.to_string())
25443                    .collect::<Vec<String>>()
25444                    .join(",")
25445                    .to_string(),
25446            )]),
25447        };
25448    }
25449    if let Some(ref local_var_str) = tenant_group {
25450        local_var_req_builder = match "multi" {
25451            "multi" => local_var_req_builder.query(
25452                &local_var_str
25453                    .into_iter()
25454                    .map(|p| ("tenant_group".to_owned(), p.to_string()))
25455                    .collect::<Vec<(std::string::String, std::string::String)>>(),
25456            ),
25457            _ => local_var_req_builder.query(&[(
25458                "tenant_group",
25459                &local_var_str
25460                    .into_iter()
25461                    .map(|p| p.to_string())
25462                    .collect::<Vec<String>>()
25463                    .join(",")
25464                    .to_string(),
25465            )]),
25466        };
25467    }
25468    if let Some(ref local_var_str) = tenant_group__n {
25469        local_var_req_builder = match "multi" {
25470            "multi" => local_var_req_builder.query(
25471                &local_var_str
25472                    .into_iter()
25473                    .map(|p| ("tenant_group__n".to_owned(), p.to_string()))
25474                    .collect::<Vec<(std::string::String, std::string::String)>>(),
25475            ),
25476            _ => local_var_req_builder.query(&[(
25477                "tenant_group__n",
25478                &local_var_str
25479                    .into_iter()
25480                    .map(|p| p.to_string())
25481                    .collect::<Vec<String>>()
25482                    .join(",")
25483                    .to_string(),
25484            )]),
25485        };
25486    }
25487    if let Some(ref local_var_str) = tenant_group_id {
25488        local_var_req_builder = match "multi" {
25489            "multi" => local_var_req_builder.query(
25490                &local_var_str
25491                    .into_iter()
25492                    .map(|p| ("tenant_group_id".to_owned(), p.to_string()))
25493                    .collect::<Vec<(std::string::String, std::string::String)>>(),
25494            ),
25495            _ => local_var_req_builder.query(&[(
25496                "tenant_group_id",
25497                &local_var_str
25498                    .into_iter()
25499                    .map(|p| p.to_string())
25500                    .collect::<Vec<String>>()
25501                    .join(",")
25502                    .to_string(),
25503            )]),
25504        };
25505    }
25506    if let Some(ref local_var_str) = tenant_group_id__n {
25507        local_var_req_builder = match "multi" {
25508            "multi" => local_var_req_builder.query(
25509                &local_var_str
25510                    .into_iter()
25511                    .map(|p| ("tenant_group_id__n".to_owned(), p.to_string()))
25512                    .collect::<Vec<(std::string::String, std::string::String)>>(),
25513            ),
25514            _ => local_var_req_builder.query(&[(
25515                "tenant_group_id__n",
25516                &local_var_str
25517                    .into_iter()
25518                    .map(|p| p.to_string())
25519                    .collect::<Vec<String>>()
25520                    .join(",")
25521                    .to_string(),
25522            )]),
25523        };
25524    }
25525    if let Some(ref local_var_str) = tenant_id {
25526        local_var_req_builder = match "multi" {
25527            "multi" => local_var_req_builder.query(
25528                &local_var_str
25529                    .into_iter()
25530                    .map(|p| ("tenant_id".to_owned(), p.to_string()))
25531                    .collect::<Vec<(std::string::String, std::string::String)>>(),
25532            ),
25533            _ => local_var_req_builder.query(&[(
25534                "tenant_id",
25535                &local_var_str
25536                    .into_iter()
25537                    .map(|p| p.to_string())
25538                    .collect::<Vec<String>>()
25539                    .join(",")
25540                    .to_string(),
25541            )]),
25542        };
25543    }
25544    if let Some(ref local_var_str) = tenant_id__n {
25545        local_var_req_builder = match "multi" {
25546            "multi" => local_var_req_builder.query(
25547                &local_var_str
25548                    .into_iter()
25549                    .map(|p| ("tenant_id__n".to_owned(), p.to_string()))
25550                    .collect::<Vec<(std::string::String, std::string::String)>>(),
25551            ),
25552            _ => local_var_req_builder.query(&[(
25553                "tenant_id__n",
25554                &local_var_str
25555                    .into_iter()
25556                    .map(|p| p.to_string())
25557                    .collect::<Vec<String>>()
25558                    .join(",")
25559                    .to_string(),
25560            )]),
25561        };
25562    }
25563    if let Some(ref local_var_str) = r#type {
25564        local_var_req_builder = match "multi" {
25565            "multi" => local_var_req_builder.query(
25566                &local_var_str
25567                    .into_iter()
25568                    .map(|p| ("type".to_owned(), p.to_string()))
25569                    .collect::<Vec<(std::string::String, std::string::String)>>(),
25570            ),
25571            _ => local_var_req_builder.query(&[(
25572                "type",
25573                &local_var_str
25574                    .into_iter()
25575                    .map(|p| p.to_string())
25576                    .collect::<Vec<String>>()
25577                    .join(",")
25578                    .to_string(),
25579            )]),
25580        };
25581    }
25582    if let Some(ref local_var_str) = type__n {
25583        local_var_req_builder = match "multi" {
25584            "multi" => local_var_req_builder.query(
25585                &local_var_str
25586                    .into_iter()
25587                    .map(|p| ("type__n".to_owned(), p.to_string()))
25588                    .collect::<Vec<(std::string::String, std::string::String)>>(),
25589            ),
25590            _ => local_var_req_builder.query(&[(
25591                "type__n",
25592                &local_var_str
25593                    .into_iter()
25594                    .map(|p| p.to_string())
25595                    .collect::<Vec<String>>()
25596                    .join(",")
25597                    .to_string(),
25598            )]),
25599        };
25600    }
25601    if let Some(ref local_var_str) = type_id {
25602        local_var_req_builder = match "multi" {
25603            "multi" => local_var_req_builder.query(
25604                &local_var_str
25605                    .into_iter()
25606                    .map(|p| ("type_id".to_owned(), p.to_string()))
25607                    .collect::<Vec<(std::string::String, std::string::String)>>(),
25608            ),
25609            _ => local_var_req_builder.query(&[(
25610                "type_id",
25611                &local_var_str
25612                    .into_iter()
25613                    .map(|p| p.to_string())
25614                    .collect::<Vec<String>>()
25615                    .join(",")
25616                    .to_string(),
25617            )]),
25618        };
25619    }
25620    if let Some(ref local_var_str) = type_id__n {
25621        local_var_req_builder = match "multi" {
25622            "multi" => local_var_req_builder.query(
25623                &local_var_str
25624                    .into_iter()
25625                    .map(|p| ("type_id__n".to_owned(), p.to_string()))
25626                    .collect::<Vec<(std::string::String, std::string::String)>>(),
25627            ),
25628            _ => local_var_req_builder.query(&[(
25629                "type_id__n",
25630                &local_var_str
25631                    .into_iter()
25632                    .map(|p| p.to_string())
25633                    .collect::<Vec<String>>()
25634                    .join(",")
25635                    .to_string(),
25636            )]),
25637        };
25638    }
25639    if let Some(ref local_var_str) = updated_by_request {
25640        local_var_req_builder =
25641            local_var_req_builder.query(&[("updated_by_request", &local_var_str.to_string())]);
25642    }
25643    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
25644        local_var_req_builder =
25645            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
25646    }
25647    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
25648        let local_var_key = local_var_apikey.key.clone();
25649        let local_var_value = match local_var_apikey.prefix {
25650            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
25651            None => local_var_key,
25652        };
25653        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
25654    };
25655
25656    let local_var_req = local_var_req_builder.build()?;
25657    let local_var_resp = local_var_client.execute(local_var_req).await?;
25658
25659    let local_var_status = local_var_resp.status();
25660    let local_var_content = local_var_resp.text().await?;
25661
25662    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
25663        serde_json::from_str(&local_var_content).map_err(Error::from)
25664    } else {
25665        let local_var_entity: Option<CircuitsVirtualCircuitsListError> =
25666            serde_json::from_str(&local_var_content).ok();
25667        let local_var_error = ResponseContent {
25668            status: local_var_status,
25669            content: local_var_content,
25670            entity: local_var_entity,
25671        };
25672        Err(Error::ResponseError(local_var_error))
25673    }
25674}
25675
25676/// Patch a virtual circuit object.
25677pub async fn circuits_virtual_circuits_partial_update(
25678    configuration: &configuration::Configuration,
25679    id: i32,
25680    patched_writable_virtual_circuit_request: Option<
25681        crate::models::PatchedWritableVirtualCircuitRequest,
25682    >,
25683) -> Result<crate::models::VirtualCircuit, Error<CircuitsVirtualCircuitsPartialUpdateError>> {
25684    let local_var_configuration = configuration;
25685
25686    let local_var_client = &local_var_configuration.client;
25687
25688    let local_var_uri_str = format!(
25689        "{}/api/circuits/virtual-circuits/{id}/",
25690        local_var_configuration.base_path,
25691        id = id
25692    );
25693    let mut local_var_req_builder =
25694        local_var_client.request(reqwest::Method::PATCH, local_var_uri_str.as_str());
25695
25696    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
25697        local_var_req_builder =
25698            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
25699    }
25700    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
25701        let local_var_key = local_var_apikey.key.clone();
25702        let local_var_value = match local_var_apikey.prefix {
25703            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
25704            None => local_var_key,
25705        };
25706        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
25707    };
25708    local_var_req_builder = local_var_req_builder.json(&patched_writable_virtual_circuit_request);
25709
25710    let local_var_req = local_var_req_builder.build()?;
25711    let local_var_resp = local_var_client.execute(local_var_req).await?;
25712
25713    let local_var_status = local_var_resp.status();
25714    let local_var_content = local_var_resp.text().await?;
25715
25716    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
25717        serde_json::from_str(&local_var_content).map_err(Error::from)
25718    } else {
25719        let local_var_entity: Option<CircuitsVirtualCircuitsPartialUpdateError> =
25720            serde_json::from_str(&local_var_content).ok();
25721        let local_var_error = ResponseContent {
25722            status: local_var_status,
25723            content: local_var_content,
25724            entity: local_var_entity,
25725        };
25726        Err(Error::ResponseError(local_var_error))
25727    }
25728}
25729
25730/// Get a virtual circuit object.
25731pub async fn circuits_virtual_circuits_retrieve(
25732    configuration: &configuration::Configuration,
25733    id: i32,
25734) -> Result<crate::models::VirtualCircuit, Error<CircuitsVirtualCircuitsRetrieveError>> {
25735    let local_var_configuration = configuration;
25736
25737    let local_var_client = &local_var_configuration.client;
25738
25739    let local_var_uri_str = format!(
25740        "{}/api/circuits/virtual-circuits/{id}/",
25741        local_var_configuration.base_path,
25742        id = id
25743    );
25744    let mut local_var_req_builder =
25745        local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
25746
25747    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
25748        local_var_req_builder =
25749            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
25750    }
25751    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
25752        let local_var_key = local_var_apikey.key.clone();
25753        let local_var_value = match local_var_apikey.prefix {
25754            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
25755            None => local_var_key,
25756        };
25757        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
25758    };
25759
25760    let local_var_req = local_var_req_builder.build()?;
25761    let local_var_resp = local_var_client.execute(local_var_req).await?;
25762
25763    let local_var_status = local_var_resp.status();
25764    let local_var_content = local_var_resp.text().await?;
25765
25766    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
25767        serde_json::from_str(&local_var_content).map_err(Error::from)
25768    } else {
25769        let local_var_entity: Option<CircuitsVirtualCircuitsRetrieveError> =
25770            serde_json::from_str(&local_var_content).ok();
25771        let local_var_error = ResponseContent {
25772            status: local_var_status,
25773            content: local_var_content,
25774            entity: local_var_entity,
25775        };
25776        Err(Error::ResponseError(local_var_error))
25777    }
25778}
25779
25780/// Put a virtual circuit object.
25781pub async fn circuits_virtual_circuits_update(
25782    configuration: &configuration::Configuration,
25783    id: i32,
25784    writable_virtual_circuit_request: crate::models::WritableVirtualCircuitRequest,
25785) -> Result<crate::models::VirtualCircuit, Error<CircuitsVirtualCircuitsUpdateError>> {
25786    let local_var_configuration = configuration;
25787
25788    let local_var_client = &local_var_configuration.client;
25789
25790    let local_var_uri_str = format!(
25791        "{}/api/circuits/virtual-circuits/{id}/",
25792        local_var_configuration.base_path,
25793        id = id
25794    );
25795    let mut local_var_req_builder =
25796        local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());
25797
25798    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
25799        local_var_req_builder =
25800            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
25801    }
25802    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
25803        let local_var_key = local_var_apikey.key.clone();
25804        let local_var_value = match local_var_apikey.prefix {
25805            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
25806            None => local_var_key,
25807        };
25808        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
25809    };
25810    local_var_req_builder = local_var_req_builder.json(&writable_virtual_circuit_request);
25811
25812    let local_var_req = local_var_req_builder.build()?;
25813    let local_var_resp = local_var_client.execute(local_var_req).await?;
25814
25815    let local_var_status = local_var_resp.status();
25816    let local_var_content = local_var_resp.text().await?;
25817
25818    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
25819        serde_json::from_str(&local_var_content).map_err(Error::from)
25820    } else {
25821        let local_var_entity: Option<CircuitsVirtualCircuitsUpdateError> =
25822            serde_json::from_str(&local_var_content).ok();
25823        let local_var_error = ResponseContent {
25824            status: local_var_status,
25825            content: local_var_content,
25826            entity: local_var_entity,
25827        };
25828        Err(Error::ResponseError(local_var_error))
25829    }
25830}
netbox_openapi/apis/circuits_api.rs

netbox_openapi/apis/
circuits_api.rs
