netbox_openapi/apis/
vpn_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.4.2-Docker-3.4.1 (4.4)
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 [`vpn_ike_policies_bulk_destroy`]
17#[derive(Debug, Clone, Serialize, Deserialize)]
18#[serde(untagged)]
19pub enum VpnIkePoliciesBulkDestroyError {
20    UnknownValue(serde_json::Value),
21}
22
23/// struct for typed errors of method [`vpn_ike_policies_bulk_partial_update`]
24#[derive(Debug, Clone, Serialize, Deserialize)]
25#[serde(untagged)]
26pub enum VpnIkePoliciesBulkPartialUpdateError {
27    UnknownValue(serde_json::Value),
28}
29
30/// struct for typed errors of method [`vpn_ike_policies_bulk_update`]
31#[derive(Debug, Clone, Serialize, Deserialize)]
32#[serde(untagged)]
33pub enum VpnIkePoliciesBulkUpdateError {
34    UnknownValue(serde_json::Value),
35}
36
37/// struct for typed errors of method [`vpn_ike_policies_create`]
38#[derive(Debug, Clone, Serialize, Deserialize)]
39#[serde(untagged)]
40pub enum VpnIkePoliciesCreateError {
41    UnknownValue(serde_json::Value),
42}
43
44/// struct for typed errors of method [`vpn_ike_policies_destroy`]
45#[derive(Debug, Clone, Serialize, Deserialize)]
46#[serde(untagged)]
47pub enum VpnIkePoliciesDestroyError {
48    UnknownValue(serde_json::Value),
49}
50
51/// struct for typed errors of method [`vpn_ike_policies_list`]
52#[derive(Debug, Clone, Serialize, Deserialize)]
53#[serde(untagged)]
54pub enum VpnIkePoliciesListError {
55    UnknownValue(serde_json::Value),
56}
57
58/// struct for typed errors of method [`vpn_ike_policies_partial_update`]
59#[derive(Debug, Clone, Serialize, Deserialize)]
60#[serde(untagged)]
61pub enum VpnIkePoliciesPartialUpdateError {
62    UnknownValue(serde_json::Value),
63}
64
65/// struct for typed errors of method [`vpn_ike_policies_retrieve`]
66#[derive(Debug, Clone, Serialize, Deserialize)]
67#[serde(untagged)]
68pub enum VpnIkePoliciesRetrieveError {
69    UnknownValue(serde_json::Value),
70}
71
72/// struct for typed errors of method [`vpn_ike_policies_update`]
73#[derive(Debug, Clone, Serialize, Deserialize)]
74#[serde(untagged)]
75pub enum VpnIkePoliciesUpdateError {
76    UnknownValue(serde_json::Value),
77}
78
79/// struct for typed errors of method [`vpn_ike_proposals_bulk_destroy`]
80#[derive(Debug, Clone, Serialize, Deserialize)]
81#[serde(untagged)]
82pub enum VpnIkeProposalsBulkDestroyError {
83    UnknownValue(serde_json::Value),
84}
85
86/// struct for typed errors of method [`vpn_ike_proposals_bulk_partial_update`]
87#[derive(Debug, Clone, Serialize, Deserialize)]
88#[serde(untagged)]
89pub enum VpnIkeProposalsBulkPartialUpdateError {
90    UnknownValue(serde_json::Value),
91}
92
93/// struct for typed errors of method [`vpn_ike_proposals_bulk_update`]
94#[derive(Debug, Clone, Serialize, Deserialize)]
95#[serde(untagged)]
96pub enum VpnIkeProposalsBulkUpdateError {
97    UnknownValue(serde_json::Value),
98}
99
100/// struct for typed errors of method [`vpn_ike_proposals_create`]
101#[derive(Debug, Clone, Serialize, Deserialize)]
102#[serde(untagged)]
103pub enum VpnIkeProposalsCreateError {
104    UnknownValue(serde_json::Value),
105}
106
107/// struct for typed errors of method [`vpn_ike_proposals_destroy`]
108#[derive(Debug, Clone, Serialize, Deserialize)]
109#[serde(untagged)]
110pub enum VpnIkeProposalsDestroyError {
111    UnknownValue(serde_json::Value),
112}
113
114/// struct for typed errors of method [`vpn_ike_proposals_list`]
115#[derive(Debug, Clone, Serialize, Deserialize)]
116#[serde(untagged)]
117pub enum VpnIkeProposalsListError {
118    UnknownValue(serde_json::Value),
119}
120
121/// struct for typed errors of method [`vpn_ike_proposals_partial_update`]
122#[derive(Debug, Clone, Serialize, Deserialize)]
123#[serde(untagged)]
124pub enum VpnIkeProposalsPartialUpdateError {
125    UnknownValue(serde_json::Value),
126}
127
128/// struct for typed errors of method [`vpn_ike_proposals_retrieve`]
129#[derive(Debug, Clone, Serialize, Deserialize)]
130#[serde(untagged)]
131pub enum VpnIkeProposalsRetrieveError {
132    UnknownValue(serde_json::Value),
133}
134
135/// struct for typed errors of method [`vpn_ike_proposals_update`]
136#[derive(Debug, Clone, Serialize, Deserialize)]
137#[serde(untagged)]
138pub enum VpnIkeProposalsUpdateError {
139    UnknownValue(serde_json::Value),
140}
141
142/// struct for typed errors of method [`vpn_ipsec_policies_bulk_destroy`]
143#[derive(Debug, Clone, Serialize, Deserialize)]
144#[serde(untagged)]
145pub enum VpnIpsecPoliciesBulkDestroyError {
146    UnknownValue(serde_json::Value),
147}
148
149/// struct for typed errors of method [`vpn_ipsec_policies_bulk_partial_update`]
150#[derive(Debug, Clone, Serialize, Deserialize)]
151#[serde(untagged)]
152pub enum VpnIpsecPoliciesBulkPartialUpdateError {
153    UnknownValue(serde_json::Value),
154}
155
156/// struct for typed errors of method [`vpn_ipsec_policies_bulk_update`]
157#[derive(Debug, Clone, Serialize, Deserialize)]
158#[serde(untagged)]
159pub enum VpnIpsecPoliciesBulkUpdateError {
160    UnknownValue(serde_json::Value),
161}
162
163/// struct for typed errors of method [`vpn_ipsec_policies_create`]
164#[derive(Debug, Clone, Serialize, Deserialize)]
165#[serde(untagged)]
166pub enum VpnIpsecPoliciesCreateError {
167    UnknownValue(serde_json::Value),
168}
169
170/// struct for typed errors of method [`vpn_ipsec_policies_destroy`]
171#[derive(Debug, Clone, Serialize, Deserialize)]
172#[serde(untagged)]
173pub enum VpnIpsecPoliciesDestroyError {
174    UnknownValue(serde_json::Value),
175}
176
177/// struct for typed errors of method [`vpn_ipsec_policies_list`]
178#[derive(Debug, Clone, Serialize, Deserialize)]
179#[serde(untagged)]
180pub enum VpnIpsecPoliciesListError {
181    UnknownValue(serde_json::Value),
182}
183
184/// struct for typed errors of method [`vpn_ipsec_policies_partial_update`]
185#[derive(Debug, Clone, Serialize, Deserialize)]
186#[serde(untagged)]
187pub enum VpnIpsecPoliciesPartialUpdateError {
188    UnknownValue(serde_json::Value),
189}
190
191/// struct for typed errors of method [`vpn_ipsec_policies_retrieve`]
192#[derive(Debug, Clone, Serialize, Deserialize)]
193#[serde(untagged)]
194pub enum VpnIpsecPoliciesRetrieveError {
195    UnknownValue(serde_json::Value),
196}
197
198/// struct for typed errors of method [`vpn_ipsec_policies_update`]
199#[derive(Debug, Clone, Serialize, Deserialize)]
200#[serde(untagged)]
201pub enum VpnIpsecPoliciesUpdateError {
202    UnknownValue(serde_json::Value),
203}
204
205/// struct for typed errors of method [`vpn_ipsec_profiles_bulk_destroy`]
206#[derive(Debug, Clone, Serialize, Deserialize)]
207#[serde(untagged)]
208pub enum VpnIpsecProfilesBulkDestroyError {
209    UnknownValue(serde_json::Value),
210}
211
212/// struct for typed errors of method [`vpn_ipsec_profiles_bulk_partial_update`]
213#[derive(Debug, Clone, Serialize, Deserialize)]
214#[serde(untagged)]
215pub enum VpnIpsecProfilesBulkPartialUpdateError {
216    UnknownValue(serde_json::Value),
217}
218
219/// struct for typed errors of method [`vpn_ipsec_profiles_bulk_update`]
220#[derive(Debug, Clone, Serialize, Deserialize)]
221#[serde(untagged)]
222pub enum VpnIpsecProfilesBulkUpdateError {
223    UnknownValue(serde_json::Value),
224}
225
226/// struct for typed errors of method [`vpn_ipsec_profiles_create`]
227#[derive(Debug, Clone, Serialize, Deserialize)]
228#[serde(untagged)]
229pub enum VpnIpsecProfilesCreateError {
230    UnknownValue(serde_json::Value),
231}
232
233/// struct for typed errors of method [`vpn_ipsec_profiles_destroy`]
234#[derive(Debug, Clone, Serialize, Deserialize)]
235#[serde(untagged)]
236pub enum VpnIpsecProfilesDestroyError {
237    UnknownValue(serde_json::Value),
238}
239
240/// struct for typed errors of method [`vpn_ipsec_profiles_list`]
241#[derive(Debug, Clone, Serialize, Deserialize)]
242#[serde(untagged)]
243pub enum VpnIpsecProfilesListError {
244    UnknownValue(serde_json::Value),
245}
246
247/// struct for typed errors of method [`vpn_ipsec_profiles_partial_update`]
248#[derive(Debug, Clone, Serialize, Deserialize)]
249#[serde(untagged)]
250pub enum VpnIpsecProfilesPartialUpdateError {
251    UnknownValue(serde_json::Value),
252}
253
254/// struct for typed errors of method [`vpn_ipsec_profiles_retrieve`]
255#[derive(Debug, Clone, Serialize, Deserialize)]
256#[serde(untagged)]
257pub enum VpnIpsecProfilesRetrieveError {
258    UnknownValue(serde_json::Value),
259}
260
261/// struct for typed errors of method [`vpn_ipsec_profiles_update`]
262#[derive(Debug, Clone, Serialize, Deserialize)]
263#[serde(untagged)]
264pub enum VpnIpsecProfilesUpdateError {
265    UnknownValue(serde_json::Value),
266}
267
268/// struct for typed errors of method [`vpn_ipsec_proposals_bulk_destroy`]
269#[derive(Debug, Clone, Serialize, Deserialize)]
270#[serde(untagged)]
271pub enum VpnIpsecProposalsBulkDestroyError {
272    UnknownValue(serde_json::Value),
273}
274
275/// struct for typed errors of method [`vpn_ipsec_proposals_bulk_partial_update`]
276#[derive(Debug, Clone, Serialize, Deserialize)]
277#[serde(untagged)]
278pub enum VpnIpsecProposalsBulkPartialUpdateError {
279    UnknownValue(serde_json::Value),
280}
281
282/// struct for typed errors of method [`vpn_ipsec_proposals_bulk_update`]
283#[derive(Debug, Clone, Serialize, Deserialize)]
284#[serde(untagged)]
285pub enum VpnIpsecProposalsBulkUpdateError {
286    UnknownValue(serde_json::Value),
287}
288
289/// struct for typed errors of method [`vpn_ipsec_proposals_create`]
290#[derive(Debug, Clone, Serialize, Deserialize)]
291#[serde(untagged)]
292pub enum VpnIpsecProposalsCreateError {
293    UnknownValue(serde_json::Value),
294}
295
296/// struct for typed errors of method [`vpn_ipsec_proposals_destroy`]
297#[derive(Debug, Clone, Serialize, Deserialize)]
298#[serde(untagged)]
299pub enum VpnIpsecProposalsDestroyError {
300    UnknownValue(serde_json::Value),
301}
302
303/// struct for typed errors of method [`vpn_ipsec_proposals_list`]
304#[derive(Debug, Clone, Serialize, Deserialize)]
305#[serde(untagged)]
306pub enum VpnIpsecProposalsListError {
307    UnknownValue(serde_json::Value),
308}
309
310/// struct for typed errors of method [`vpn_ipsec_proposals_partial_update`]
311#[derive(Debug, Clone, Serialize, Deserialize)]
312#[serde(untagged)]
313pub enum VpnIpsecProposalsPartialUpdateError {
314    UnknownValue(serde_json::Value),
315}
316
317/// struct for typed errors of method [`vpn_ipsec_proposals_retrieve`]
318#[derive(Debug, Clone, Serialize, Deserialize)]
319#[serde(untagged)]
320pub enum VpnIpsecProposalsRetrieveError {
321    UnknownValue(serde_json::Value),
322}
323
324/// struct for typed errors of method [`vpn_ipsec_proposals_update`]
325#[derive(Debug, Clone, Serialize, Deserialize)]
326#[serde(untagged)]
327pub enum VpnIpsecProposalsUpdateError {
328    UnknownValue(serde_json::Value),
329}
330
331/// struct for typed errors of method [`vpn_l2vpn_terminations_bulk_destroy`]
332#[derive(Debug, Clone, Serialize, Deserialize)]
333#[serde(untagged)]
334pub enum VpnL2vpnTerminationsBulkDestroyError {
335    UnknownValue(serde_json::Value),
336}
337
338/// struct for typed errors of method [`vpn_l2vpn_terminations_bulk_partial_update`]
339#[derive(Debug, Clone, Serialize, Deserialize)]
340#[serde(untagged)]
341pub enum VpnL2vpnTerminationsBulkPartialUpdateError {
342    UnknownValue(serde_json::Value),
343}
344
345/// struct for typed errors of method [`vpn_l2vpn_terminations_bulk_update`]
346#[derive(Debug, Clone, Serialize, Deserialize)]
347#[serde(untagged)]
348pub enum VpnL2vpnTerminationsBulkUpdateError {
349    UnknownValue(serde_json::Value),
350}
351
352/// struct for typed errors of method [`vpn_l2vpn_terminations_create`]
353#[derive(Debug, Clone, Serialize, Deserialize)]
354#[serde(untagged)]
355pub enum VpnL2vpnTerminationsCreateError {
356    UnknownValue(serde_json::Value),
357}
358
359/// struct for typed errors of method [`vpn_l2vpn_terminations_destroy`]
360#[derive(Debug, Clone, Serialize, Deserialize)]
361#[serde(untagged)]
362pub enum VpnL2vpnTerminationsDestroyError {
363    UnknownValue(serde_json::Value),
364}
365
366/// struct for typed errors of method [`vpn_l2vpn_terminations_list`]
367#[derive(Debug, Clone, Serialize, Deserialize)]
368#[serde(untagged)]
369pub enum VpnL2vpnTerminationsListError {
370    UnknownValue(serde_json::Value),
371}
372
373/// struct for typed errors of method [`vpn_l2vpn_terminations_partial_update`]
374#[derive(Debug, Clone, Serialize, Deserialize)]
375#[serde(untagged)]
376pub enum VpnL2vpnTerminationsPartialUpdateError {
377    UnknownValue(serde_json::Value),
378}
379
380/// struct for typed errors of method [`vpn_l2vpn_terminations_retrieve`]
381#[derive(Debug, Clone, Serialize, Deserialize)]
382#[serde(untagged)]
383pub enum VpnL2vpnTerminationsRetrieveError {
384    UnknownValue(serde_json::Value),
385}
386
387/// struct for typed errors of method [`vpn_l2vpn_terminations_update`]
388#[derive(Debug, Clone, Serialize, Deserialize)]
389#[serde(untagged)]
390pub enum VpnL2vpnTerminationsUpdateError {
391    UnknownValue(serde_json::Value),
392}
393
394/// struct for typed errors of method [`vpn_l2vpns_bulk_destroy`]
395#[derive(Debug, Clone, Serialize, Deserialize)]
396#[serde(untagged)]
397pub enum VpnL2vpnsBulkDestroyError {
398    UnknownValue(serde_json::Value),
399}
400
401/// struct for typed errors of method [`vpn_l2vpns_bulk_partial_update`]
402#[derive(Debug, Clone, Serialize, Deserialize)]
403#[serde(untagged)]
404pub enum VpnL2vpnsBulkPartialUpdateError {
405    UnknownValue(serde_json::Value),
406}
407
408/// struct for typed errors of method [`vpn_l2vpns_bulk_update`]
409#[derive(Debug, Clone, Serialize, Deserialize)]
410#[serde(untagged)]
411pub enum VpnL2vpnsBulkUpdateError {
412    UnknownValue(serde_json::Value),
413}
414
415/// struct for typed errors of method [`vpn_l2vpns_create`]
416#[derive(Debug, Clone, Serialize, Deserialize)]
417#[serde(untagged)]
418pub enum VpnL2vpnsCreateError {
419    UnknownValue(serde_json::Value),
420}
421
422/// struct for typed errors of method [`vpn_l2vpns_destroy`]
423#[derive(Debug, Clone, Serialize, Deserialize)]
424#[serde(untagged)]
425pub enum VpnL2vpnsDestroyError {
426    UnknownValue(serde_json::Value),
427}
428
429/// struct for typed errors of method [`vpn_l2vpns_list`]
430#[derive(Debug, Clone, Serialize, Deserialize)]
431#[serde(untagged)]
432pub enum VpnL2vpnsListError {
433    UnknownValue(serde_json::Value),
434}
435
436/// struct for typed errors of method [`vpn_l2vpns_partial_update`]
437#[derive(Debug, Clone, Serialize, Deserialize)]
438#[serde(untagged)]
439pub enum VpnL2vpnsPartialUpdateError {
440    UnknownValue(serde_json::Value),
441}
442
443/// struct for typed errors of method [`vpn_l2vpns_retrieve`]
444#[derive(Debug, Clone, Serialize, Deserialize)]
445#[serde(untagged)]
446pub enum VpnL2vpnsRetrieveError {
447    UnknownValue(serde_json::Value),
448}
449
450/// struct for typed errors of method [`vpn_l2vpns_update`]
451#[derive(Debug, Clone, Serialize, Deserialize)]
452#[serde(untagged)]
453pub enum VpnL2vpnsUpdateError {
454    UnknownValue(serde_json::Value),
455}
456
457/// struct for typed errors of method [`vpn_tunnel_groups_bulk_destroy`]
458#[derive(Debug, Clone, Serialize, Deserialize)]
459#[serde(untagged)]
460pub enum VpnTunnelGroupsBulkDestroyError {
461    UnknownValue(serde_json::Value),
462}
463
464/// struct for typed errors of method [`vpn_tunnel_groups_bulk_partial_update`]
465#[derive(Debug, Clone, Serialize, Deserialize)]
466#[serde(untagged)]
467pub enum VpnTunnelGroupsBulkPartialUpdateError {
468    UnknownValue(serde_json::Value),
469}
470
471/// struct for typed errors of method [`vpn_tunnel_groups_bulk_update`]
472#[derive(Debug, Clone, Serialize, Deserialize)]
473#[serde(untagged)]
474pub enum VpnTunnelGroupsBulkUpdateError {
475    UnknownValue(serde_json::Value),
476}
477
478/// struct for typed errors of method [`vpn_tunnel_groups_create`]
479#[derive(Debug, Clone, Serialize, Deserialize)]
480#[serde(untagged)]
481pub enum VpnTunnelGroupsCreateError {
482    UnknownValue(serde_json::Value),
483}
484
485/// struct for typed errors of method [`vpn_tunnel_groups_destroy`]
486#[derive(Debug, Clone, Serialize, Deserialize)]
487#[serde(untagged)]
488pub enum VpnTunnelGroupsDestroyError {
489    UnknownValue(serde_json::Value),
490}
491
492/// struct for typed errors of method [`vpn_tunnel_groups_list`]
493#[derive(Debug, Clone, Serialize, Deserialize)]
494#[serde(untagged)]
495pub enum VpnTunnelGroupsListError {
496    UnknownValue(serde_json::Value),
497}
498
499/// struct for typed errors of method [`vpn_tunnel_groups_partial_update`]
500#[derive(Debug, Clone, Serialize, Deserialize)]
501#[serde(untagged)]
502pub enum VpnTunnelGroupsPartialUpdateError {
503    UnknownValue(serde_json::Value),
504}
505
506/// struct for typed errors of method [`vpn_tunnel_groups_retrieve`]
507#[derive(Debug, Clone, Serialize, Deserialize)]
508#[serde(untagged)]
509pub enum VpnTunnelGroupsRetrieveError {
510    UnknownValue(serde_json::Value),
511}
512
513/// struct for typed errors of method [`vpn_tunnel_groups_update`]
514#[derive(Debug, Clone, Serialize, Deserialize)]
515#[serde(untagged)]
516pub enum VpnTunnelGroupsUpdateError {
517    UnknownValue(serde_json::Value),
518}
519
520/// struct for typed errors of method [`vpn_tunnel_terminations_bulk_destroy`]
521#[derive(Debug, Clone, Serialize, Deserialize)]
522#[serde(untagged)]
523pub enum VpnTunnelTerminationsBulkDestroyError {
524    UnknownValue(serde_json::Value),
525}
526
527/// struct for typed errors of method [`vpn_tunnel_terminations_bulk_partial_update`]
528#[derive(Debug, Clone, Serialize, Deserialize)]
529#[serde(untagged)]
530pub enum VpnTunnelTerminationsBulkPartialUpdateError {
531    UnknownValue(serde_json::Value),
532}
533
534/// struct for typed errors of method [`vpn_tunnel_terminations_bulk_update`]
535#[derive(Debug, Clone, Serialize, Deserialize)]
536#[serde(untagged)]
537pub enum VpnTunnelTerminationsBulkUpdateError {
538    UnknownValue(serde_json::Value),
539}
540
541/// struct for typed errors of method [`vpn_tunnel_terminations_create`]
542#[derive(Debug, Clone, Serialize, Deserialize)]
543#[serde(untagged)]
544pub enum VpnTunnelTerminationsCreateError {
545    UnknownValue(serde_json::Value),
546}
547
548/// struct for typed errors of method [`vpn_tunnel_terminations_destroy`]
549#[derive(Debug, Clone, Serialize, Deserialize)]
550#[serde(untagged)]
551pub enum VpnTunnelTerminationsDestroyError {
552    UnknownValue(serde_json::Value),
553}
554
555/// struct for typed errors of method [`vpn_tunnel_terminations_list`]
556#[derive(Debug, Clone, Serialize, Deserialize)]
557#[serde(untagged)]
558pub enum VpnTunnelTerminationsListError {
559    UnknownValue(serde_json::Value),
560}
561
562/// struct for typed errors of method [`vpn_tunnel_terminations_partial_update`]
563#[derive(Debug, Clone, Serialize, Deserialize)]
564#[serde(untagged)]
565pub enum VpnTunnelTerminationsPartialUpdateError {
566    UnknownValue(serde_json::Value),
567}
568
569/// struct for typed errors of method [`vpn_tunnel_terminations_retrieve`]
570#[derive(Debug, Clone, Serialize, Deserialize)]
571#[serde(untagged)]
572pub enum VpnTunnelTerminationsRetrieveError {
573    UnknownValue(serde_json::Value),
574}
575
576/// struct for typed errors of method [`vpn_tunnel_terminations_update`]
577#[derive(Debug, Clone, Serialize, Deserialize)]
578#[serde(untagged)]
579pub enum VpnTunnelTerminationsUpdateError {
580    UnknownValue(serde_json::Value),
581}
582
583/// struct for typed errors of method [`vpn_tunnels_bulk_destroy`]
584#[derive(Debug, Clone, Serialize, Deserialize)]
585#[serde(untagged)]
586pub enum VpnTunnelsBulkDestroyError {
587    UnknownValue(serde_json::Value),
588}
589
590/// struct for typed errors of method [`vpn_tunnels_bulk_partial_update`]
591#[derive(Debug, Clone, Serialize, Deserialize)]
592#[serde(untagged)]
593pub enum VpnTunnelsBulkPartialUpdateError {
594    UnknownValue(serde_json::Value),
595}
596
597/// struct for typed errors of method [`vpn_tunnels_bulk_update`]
598#[derive(Debug, Clone, Serialize, Deserialize)]
599#[serde(untagged)]
600pub enum VpnTunnelsBulkUpdateError {
601    UnknownValue(serde_json::Value),
602}
603
604/// struct for typed errors of method [`vpn_tunnels_create`]
605#[derive(Debug, Clone, Serialize, Deserialize)]
606#[serde(untagged)]
607pub enum VpnTunnelsCreateError {
608    UnknownValue(serde_json::Value),
609}
610
611/// struct for typed errors of method [`vpn_tunnels_destroy`]
612#[derive(Debug, Clone, Serialize, Deserialize)]
613#[serde(untagged)]
614pub enum VpnTunnelsDestroyError {
615    UnknownValue(serde_json::Value),
616}
617
618/// struct for typed errors of method [`vpn_tunnels_list`]
619#[derive(Debug, Clone, Serialize, Deserialize)]
620#[serde(untagged)]
621pub enum VpnTunnelsListError {
622    UnknownValue(serde_json::Value),
623}
624
625/// struct for typed errors of method [`vpn_tunnels_partial_update`]
626#[derive(Debug, Clone, Serialize, Deserialize)]
627#[serde(untagged)]
628pub enum VpnTunnelsPartialUpdateError {
629    UnknownValue(serde_json::Value),
630}
631
632/// struct for typed errors of method [`vpn_tunnels_retrieve`]
633#[derive(Debug, Clone, Serialize, Deserialize)]
634#[serde(untagged)]
635pub enum VpnTunnelsRetrieveError {
636    UnknownValue(serde_json::Value),
637}
638
639/// struct for typed errors of method [`vpn_tunnels_update`]
640#[derive(Debug, Clone, Serialize, Deserialize)]
641#[serde(untagged)]
642pub enum VpnTunnelsUpdateError {
643    UnknownValue(serde_json::Value),
644}
645
646/// Delete a list of IKE policy objects.
647pub async fn vpn_ike_policies_bulk_destroy(
648    configuration: &configuration::Configuration,
649    ike_policy_request: Vec<crate::models::IkePolicyRequest>,
650) -> Result<(), Error<VpnIkePoliciesBulkDestroyError>> {
651    let local_var_configuration = configuration;
652
653    let local_var_client = &local_var_configuration.client;
654
655    let local_var_uri_str = format!(
656        "{}/api/vpn/ike-policies/",
657        local_var_configuration.base_path
658    );
659    let mut local_var_req_builder =
660        local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());
661
662    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
663        local_var_req_builder =
664            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
665    }
666    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
667        let local_var_key = local_var_apikey.key.clone();
668        let local_var_value = match local_var_apikey.prefix {
669            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
670            None => local_var_key,
671        };
672        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
673    };
674    local_var_req_builder = local_var_req_builder.json(&ike_policy_request);
675
676    let local_var_req = local_var_req_builder.build()?;
677    let local_var_resp = local_var_client.execute(local_var_req).await?;
678
679    let local_var_status = local_var_resp.status();
680    let local_var_content = local_var_resp.text().await?;
681
682    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
683        Ok(())
684    } else {
685        let local_var_entity: Option<VpnIkePoliciesBulkDestroyError> =
686            serde_json::from_str(&local_var_content).ok();
687        let local_var_error = ResponseContent {
688            status: local_var_status,
689            content: local_var_content,
690            entity: local_var_entity,
691        };
692        Err(Error::ResponseError(local_var_error))
693    }
694}
695
696/// Patch a list of IKE policy objects.
697pub async fn vpn_ike_policies_bulk_partial_update(
698    configuration: &configuration::Configuration,
699    ike_policy_request: Vec<crate::models::IkePolicyRequest>,
700) -> Result<Vec<crate::models::IkePolicy>, Error<VpnIkePoliciesBulkPartialUpdateError>> {
701    let local_var_configuration = configuration;
702
703    let local_var_client = &local_var_configuration.client;
704
705    let local_var_uri_str = format!(
706        "{}/api/vpn/ike-policies/",
707        local_var_configuration.base_path
708    );
709    let mut local_var_req_builder =
710        local_var_client.request(reqwest::Method::PATCH, local_var_uri_str.as_str());
711
712    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
713        local_var_req_builder =
714            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
715    }
716    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
717        let local_var_key = local_var_apikey.key.clone();
718        let local_var_value = match local_var_apikey.prefix {
719            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
720            None => local_var_key,
721        };
722        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
723    };
724    local_var_req_builder = local_var_req_builder.json(&ike_policy_request);
725
726    let local_var_req = local_var_req_builder.build()?;
727    let local_var_resp = local_var_client.execute(local_var_req).await?;
728
729    let local_var_status = local_var_resp.status();
730    let local_var_content = local_var_resp.text().await?;
731
732    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
733        serde_json::from_str(&local_var_content).map_err(Error::from)
734    } else {
735        let local_var_entity: Option<VpnIkePoliciesBulkPartialUpdateError> =
736            serde_json::from_str(&local_var_content).ok();
737        let local_var_error = ResponseContent {
738            status: local_var_status,
739            content: local_var_content,
740            entity: local_var_entity,
741        };
742        Err(Error::ResponseError(local_var_error))
743    }
744}
745
746/// Put a list of IKE policy objects.
747pub async fn vpn_ike_policies_bulk_update(
748    configuration: &configuration::Configuration,
749    ike_policy_request: Vec<crate::models::IkePolicyRequest>,
750) -> Result<Vec<crate::models::IkePolicy>, Error<VpnIkePoliciesBulkUpdateError>> {
751    let local_var_configuration = configuration;
752
753    let local_var_client = &local_var_configuration.client;
754
755    let local_var_uri_str = format!(
756        "{}/api/vpn/ike-policies/",
757        local_var_configuration.base_path
758    );
759    let mut local_var_req_builder =
760        local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());
761
762    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
763        local_var_req_builder =
764            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
765    }
766    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
767        let local_var_key = local_var_apikey.key.clone();
768        let local_var_value = match local_var_apikey.prefix {
769            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
770            None => local_var_key,
771        };
772        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
773    };
774    local_var_req_builder = local_var_req_builder.json(&ike_policy_request);
775
776    let local_var_req = local_var_req_builder.build()?;
777    let local_var_resp = local_var_client.execute(local_var_req).await?;
778
779    let local_var_status = local_var_resp.status();
780    let local_var_content = local_var_resp.text().await?;
781
782    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
783        serde_json::from_str(&local_var_content).map_err(Error::from)
784    } else {
785        let local_var_entity: Option<VpnIkePoliciesBulkUpdateError> =
786            serde_json::from_str(&local_var_content).ok();
787        let local_var_error = ResponseContent {
788            status: local_var_status,
789            content: local_var_content,
790            entity: local_var_entity,
791        };
792        Err(Error::ResponseError(local_var_error))
793    }
794}
795
796/// Post a list of IKE policy objects.
797pub async fn vpn_ike_policies_create(
798    configuration: &configuration::Configuration,
799    writable_ike_policy_request: crate::models::WritableIkePolicyRequest,
800) -> Result<crate::models::IkePolicy, Error<VpnIkePoliciesCreateError>> {
801    let local_var_configuration = configuration;
802
803    let local_var_client = &local_var_configuration.client;
804
805    let local_var_uri_str = format!(
806        "{}/api/vpn/ike-policies/",
807        local_var_configuration.base_path
808    );
809    let mut local_var_req_builder =
810        local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
811
812    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
813        local_var_req_builder =
814            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
815    }
816    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
817        let local_var_key = local_var_apikey.key.clone();
818        let local_var_value = match local_var_apikey.prefix {
819            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
820            None => local_var_key,
821        };
822        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
823    };
824    local_var_req_builder = local_var_req_builder.json(&writable_ike_policy_request);
825
826    let local_var_req = local_var_req_builder.build()?;
827    let local_var_resp = local_var_client.execute(local_var_req).await?;
828
829    let local_var_status = local_var_resp.status();
830    let local_var_content = local_var_resp.text().await?;
831
832    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
833        serde_json::from_str(&local_var_content).map_err(Error::from)
834    } else {
835        let local_var_entity: Option<VpnIkePoliciesCreateError> =
836            serde_json::from_str(&local_var_content).ok();
837        let local_var_error = ResponseContent {
838            status: local_var_status,
839            content: local_var_content,
840            entity: local_var_entity,
841        };
842        Err(Error::ResponseError(local_var_error))
843    }
844}
845
846/// Delete a IKE policy object.
847pub async fn vpn_ike_policies_destroy(
848    configuration: &configuration::Configuration,
849    id: i32,
850) -> Result<(), Error<VpnIkePoliciesDestroyError>> {
851    let local_var_configuration = configuration;
852
853    let local_var_client = &local_var_configuration.client;
854
855    let local_var_uri_str = format!(
856        "{}/api/vpn/ike-policies/{id}/",
857        local_var_configuration.base_path,
858        id = id
859    );
860    let mut local_var_req_builder =
861        local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());
862
863    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
864        local_var_req_builder =
865            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
866    }
867    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
868        let local_var_key = local_var_apikey.key.clone();
869        let local_var_value = match local_var_apikey.prefix {
870            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
871            None => local_var_key,
872        };
873        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
874    };
875
876    let local_var_req = local_var_req_builder.build()?;
877    let local_var_resp = local_var_client.execute(local_var_req).await?;
878
879    let local_var_status = local_var_resp.status();
880    let local_var_content = local_var_resp.text().await?;
881
882    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
883        Ok(())
884    } else {
885        let local_var_entity: Option<VpnIkePoliciesDestroyError> =
886            serde_json::from_str(&local_var_content).ok();
887        let local_var_error = ResponseContent {
888            status: local_var_status,
889            content: local_var_content,
890            entity: local_var_entity,
891        };
892        Err(Error::ResponseError(local_var_error))
893    }
894}
895
896/// Get a list of IKE policy objects.
897pub async fn vpn_ike_policies_list(
898    configuration: &configuration::Configuration,
899    created: Option<Vec<String>>,
900    created__empty: Option<Vec<String>>,
901    created__gt: Option<Vec<String>>,
902    created__gte: Option<Vec<String>>,
903    created__lt: Option<Vec<String>>,
904    created__lte: Option<Vec<String>>,
905    created__n: Option<Vec<String>>,
906    created_by_request: Option<&str>,
907    description: Option<Vec<String>>,
908    description__empty: Option<bool>,
909    description__ic: Option<Vec<String>>,
910    description__ie: Option<Vec<String>>,
911    description__iew: Option<Vec<String>>,
912    description__iregex: Option<Vec<String>>,
913    description__isw: Option<Vec<String>>,
914    description__n: Option<Vec<String>>,
915    description__nic: Option<Vec<String>>,
916    description__nie: Option<Vec<String>>,
917    description__niew: Option<Vec<String>>,
918    description__nisw: Option<Vec<String>>,
919    description__regex: Option<Vec<String>>,
920    id: Option<Vec<i32>>,
921    id__empty: Option<bool>,
922    id__gt: Option<Vec<i32>>,
923    id__gte: Option<Vec<i32>>,
924    id__lt: Option<Vec<i32>>,
925    id__lte: Option<Vec<i32>>,
926    id__n: Option<Vec<i32>>,
927    ike_proposal: Option<Vec<String>>,
928    ike_proposal__n: Option<Vec<String>>,
929    ike_proposal_id: Option<Vec<i32>>,
930    ike_proposal_id__n: Option<Vec<i32>>,
931    last_updated: Option<Vec<String>>,
932    last_updated__empty: Option<Vec<String>>,
933    last_updated__gt: Option<Vec<String>>,
934    last_updated__gte: Option<Vec<String>>,
935    last_updated__lt: Option<Vec<String>>,
936    last_updated__lte: Option<Vec<String>>,
937    last_updated__n: Option<Vec<String>>,
938    limit: Option<i32>,
939    mode: Option<Vec<String>>,
940    mode__empty: Option<bool>,
941    mode__ic: Option<Vec<String>>,
942    mode__ie: Option<Vec<String>>,
943    mode__iew: Option<Vec<String>>,
944    mode__iregex: Option<Vec<String>>,
945    mode__isw: Option<Vec<String>>,
946    mode__n: Option<Vec<String>>,
947    mode__nic: Option<Vec<String>>,
948    mode__nie: Option<Vec<String>>,
949    mode__niew: Option<Vec<String>>,
950    mode__nisw: Option<Vec<String>>,
951    mode__regex: Option<Vec<String>>,
952    modified_by_request: Option<&str>,
953    name: Option<Vec<String>>,
954    name__empty: Option<bool>,
955    name__ic: Option<Vec<String>>,
956    name__ie: Option<Vec<String>>,
957    name__iew: Option<Vec<String>>,
958    name__iregex: Option<Vec<String>>,
959    name__isw: Option<Vec<String>>,
960    name__n: Option<Vec<String>>,
961    name__nic: Option<Vec<String>>,
962    name__nie: Option<Vec<String>>,
963    name__niew: Option<Vec<String>>,
964    name__nisw: Option<Vec<String>>,
965    name__regex: Option<Vec<String>>,
966    offset: Option<i32>,
967    ordering: Option<&str>,
968    preshared_key: Option<&str>,
969    preshared_key__ic: Option<&str>,
970    preshared_key__ie: Option<&str>,
971    preshared_key__iew: Option<&str>,
972    preshared_key__iregex: Option<&str>,
973    preshared_key__isw: Option<&str>,
974    preshared_key__n: Option<&str>,
975    preshared_key__nic: Option<&str>,
976    preshared_key__nie: Option<&str>,
977    preshared_key__niew: Option<&str>,
978    preshared_key__nisw: Option<&str>,
979    preshared_key__regex: Option<&str>,
980    q: Option<&str>,
981    tag: Option<Vec<String>>,
982    tag__n: Option<Vec<String>>,
983    tag_id: Option<Vec<i32>>,
984    tag_id__n: Option<Vec<i32>>,
985    updated_by_request: Option<&str>,
986    version: Option<Vec<i32>>,
987    version__ic: Option<Vec<i32>>,
988    version__ie: Option<Vec<i32>>,
989    version__iew: Option<Vec<i32>>,
990    version__iregex: Option<Vec<i32>>,
991    version__isw: Option<Vec<i32>>,
992    version__n: Option<Vec<i32>>,
993    version__nic: Option<Vec<i32>>,
994    version__nie: Option<Vec<i32>>,
995    version__niew: Option<Vec<i32>>,
996    version__nisw: Option<Vec<i32>>,
997    version__regex: Option<Vec<i32>>,
998) -> Result<crate::models::PaginatedIkePolicyList, Error<VpnIkePoliciesListError>> {
999    let local_var_configuration = configuration;
1000
1001    let local_var_client = &local_var_configuration.client;
1002
1003    let local_var_uri_str = format!(
1004        "{}/api/vpn/ike-policies/",
1005        local_var_configuration.base_path
1006    );
1007    let mut local_var_req_builder =
1008        local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
1009
1010    if let Some(ref local_var_str) = created {
1011        local_var_req_builder = match "multi" {
1012            "multi" => local_var_req_builder.query(
1013                &local_var_str
1014                    .into_iter()
1015                    .map(|p| ("created".to_owned(), p.to_string()))
1016                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1017            ),
1018            _ => local_var_req_builder.query(&[(
1019                "created",
1020                &local_var_str
1021                    .into_iter()
1022                    .map(|p| p.to_string())
1023                    .collect::<Vec<String>>()
1024                    .join(",")
1025                    .to_string(),
1026            )]),
1027        };
1028    }
1029    if let Some(ref local_var_str) = created__empty {
1030        local_var_req_builder = match "multi" {
1031            "multi" => local_var_req_builder.query(
1032                &local_var_str
1033                    .into_iter()
1034                    .map(|p| ("created__empty".to_owned(), p.to_string()))
1035                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1036            ),
1037            _ => local_var_req_builder.query(&[(
1038                "created__empty",
1039                &local_var_str
1040                    .into_iter()
1041                    .map(|p| p.to_string())
1042                    .collect::<Vec<String>>()
1043                    .join(",")
1044                    .to_string(),
1045            )]),
1046        };
1047    }
1048    if let Some(ref local_var_str) = created__gt {
1049        local_var_req_builder = match "multi" {
1050            "multi" => local_var_req_builder.query(
1051                &local_var_str
1052                    .into_iter()
1053                    .map(|p| ("created__gt".to_owned(), p.to_string()))
1054                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1055            ),
1056            _ => local_var_req_builder.query(&[(
1057                "created__gt",
1058                &local_var_str
1059                    .into_iter()
1060                    .map(|p| p.to_string())
1061                    .collect::<Vec<String>>()
1062                    .join(",")
1063                    .to_string(),
1064            )]),
1065        };
1066    }
1067    if let Some(ref local_var_str) = created__gte {
1068        local_var_req_builder = match "multi" {
1069            "multi" => local_var_req_builder.query(
1070                &local_var_str
1071                    .into_iter()
1072                    .map(|p| ("created__gte".to_owned(), p.to_string()))
1073                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1074            ),
1075            _ => local_var_req_builder.query(&[(
1076                "created__gte",
1077                &local_var_str
1078                    .into_iter()
1079                    .map(|p| p.to_string())
1080                    .collect::<Vec<String>>()
1081                    .join(",")
1082                    .to_string(),
1083            )]),
1084        };
1085    }
1086    if let Some(ref local_var_str) = created__lt {
1087        local_var_req_builder = match "multi" {
1088            "multi" => local_var_req_builder.query(
1089                &local_var_str
1090                    .into_iter()
1091                    .map(|p| ("created__lt".to_owned(), p.to_string()))
1092                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1093            ),
1094            _ => local_var_req_builder.query(&[(
1095                "created__lt",
1096                &local_var_str
1097                    .into_iter()
1098                    .map(|p| p.to_string())
1099                    .collect::<Vec<String>>()
1100                    .join(",")
1101                    .to_string(),
1102            )]),
1103        };
1104    }
1105    if let Some(ref local_var_str) = created__lte {
1106        local_var_req_builder = match "multi" {
1107            "multi" => local_var_req_builder.query(
1108                &local_var_str
1109                    .into_iter()
1110                    .map(|p| ("created__lte".to_owned(), p.to_string()))
1111                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1112            ),
1113            _ => local_var_req_builder.query(&[(
1114                "created__lte",
1115                &local_var_str
1116                    .into_iter()
1117                    .map(|p| p.to_string())
1118                    .collect::<Vec<String>>()
1119                    .join(",")
1120                    .to_string(),
1121            )]),
1122        };
1123    }
1124    if let Some(ref local_var_str) = created__n {
1125        local_var_req_builder = match "multi" {
1126            "multi" => local_var_req_builder.query(
1127                &local_var_str
1128                    .into_iter()
1129                    .map(|p| ("created__n".to_owned(), p.to_string()))
1130                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1131            ),
1132            _ => local_var_req_builder.query(&[(
1133                "created__n",
1134                &local_var_str
1135                    .into_iter()
1136                    .map(|p| p.to_string())
1137                    .collect::<Vec<String>>()
1138                    .join(",")
1139                    .to_string(),
1140            )]),
1141        };
1142    }
1143    if let Some(ref local_var_str) = created_by_request {
1144        local_var_req_builder =
1145            local_var_req_builder.query(&[("created_by_request", &local_var_str.to_string())]);
1146    }
1147    if let Some(ref local_var_str) = description {
1148        local_var_req_builder = match "multi" {
1149            "multi" => local_var_req_builder.query(
1150                &local_var_str
1151                    .into_iter()
1152                    .map(|p| ("description".to_owned(), p.to_string()))
1153                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1154            ),
1155            _ => local_var_req_builder.query(&[(
1156                "description",
1157                &local_var_str
1158                    .into_iter()
1159                    .map(|p| p.to_string())
1160                    .collect::<Vec<String>>()
1161                    .join(",")
1162                    .to_string(),
1163            )]),
1164        };
1165    }
1166    if let Some(ref local_var_str) = description__empty {
1167        local_var_req_builder =
1168            local_var_req_builder.query(&[("description__empty", &local_var_str.to_string())]);
1169    }
1170    if let Some(ref local_var_str) = description__ic {
1171        local_var_req_builder = match "multi" {
1172            "multi" => local_var_req_builder.query(
1173                &local_var_str
1174                    .into_iter()
1175                    .map(|p| ("description__ic".to_owned(), p.to_string()))
1176                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1177            ),
1178            _ => local_var_req_builder.query(&[(
1179                "description__ic",
1180                &local_var_str
1181                    .into_iter()
1182                    .map(|p| p.to_string())
1183                    .collect::<Vec<String>>()
1184                    .join(",")
1185                    .to_string(),
1186            )]),
1187        };
1188    }
1189    if let Some(ref local_var_str) = description__ie {
1190        local_var_req_builder = match "multi" {
1191            "multi" => local_var_req_builder.query(
1192                &local_var_str
1193                    .into_iter()
1194                    .map(|p| ("description__ie".to_owned(), p.to_string()))
1195                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1196            ),
1197            _ => local_var_req_builder.query(&[(
1198                "description__ie",
1199                &local_var_str
1200                    .into_iter()
1201                    .map(|p| p.to_string())
1202                    .collect::<Vec<String>>()
1203                    .join(",")
1204                    .to_string(),
1205            )]),
1206        };
1207    }
1208    if let Some(ref local_var_str) = description__iew {
1209        local_var_req_builder = match "multi" {
1210            "multi" => local_var_req_builder.query(
1211                &local_var_str
1212                    .into_iter()
1213                    .map(|p| ("description__iew".to_owned(), p.to_string()))
1214                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1215            ),
1216            _ => local_var_req_builder.query(&[(
1217                "description__iew",
1218                &local_var_str
1219                    .into_iter()
1220                    .map(|p| p.to_string())
1221                    .collect::<Vec<String>>()
1222                    .join(",")
1223                    .to_string(),
1224            )]),
1225        };
1226    }
1227    if let Some(ref local_var_str) = description__iregex {
1228        local_var_req_builder = match "multi" {
1229            "multi" => local_var_req_builder.query(
1230                &local_var_str
1231                    .into_iter()
1232                    .map(|p| ("description__iregex".to_owned(), p.to_string()))
1233                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1234            ),
1235            _ => local_var_req_builder.query(&[(
1236                "description__iregex",
1237                &local_var_str
1238                    .into_iter()
1239                    .map(|p| p.to_string())
1240                    .collect::<Vec<String>>()
1241                    .join(",")
1242                    .to_string(),
1243            )]),
1244        };
1245    }
1246    if let Some(ref local_var_str) = description__isw {
1247        local_var_req_builder = match "multi" {
1248            "multi" => local_var_req_builder.query(
1249                &local_var_str
1250                    .into_iter()
1251                    .map(|p| ("description__isw".to_owned(), p.to_string()))
1252                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1253            ),
1254            _ => local_var_req_builder.query(&[(
1255                "description__isw",
1256                &local_var_str
1257                    .into_iter()
1258                    .map(|p| p.to_string())
1259                    .collect::<Vec<String>>()
1260                    .join(",")
1261                    .to_string(),
1262            )]),
1263        };
1264    }
1265    if let Some(ref local_var_str) = description__n {
1266        local_var_req_builder = match "multi" {
1267            "multi" => local_var_req_builder.query(
1268                &local_var_str
1269                    .into_iter()
1270                    .map(|p| ("description__n".to_owned(), p.to_string()))
1271                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1272            ),
1273            _ => local_var_req_builder.query(&[(
1274                "description__n",
1275                &local_var_str
1276                    .into_iter()
1277                    .map(|p| p.to_string())
1278                    .collect::<Vec<String>>()
1279                    .join(",")
1280                    .to_string(),
1281            )]),
1282        };
1283    }
1284    if let Some(ref local_var_str) = description__nic {
1285        local_var_req_builder = match "multi" {
1286            "multi" => local_var_req_builder.query(
1287                &local_var_str
1288                    .into_iter()
1289                    .map(|p| ("description__nic".to_owned(), p.to_string()))
1290                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1291            ),
1292            _ => local_var_req_builder.query(&[(
1293                "description__nic",
1294                &local_var_str
1295                    .into_iter()
1296                    .map(|p| p.to_string())
1297                    .collect::<Vec<String>>()
1298                    .join(",")
1299                    .to_string(),
1300            )]),
1301        };
1302    }
1303    if let Some(ref local_var_str) = description__nie {
1304        local_var_req_builder = match "multi" {
1305            "multi" => local_var_req_builder.query(
1306                &local_var_str
1307                    .into_iter()
1308                    .map(|p| ("description__nie".to_owned(), p.to_string()))
1309                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1310            ),
1311            _ => local_var_req_builder.query(&[(
1312                "description__nie",
1313                &local_var_str
1314                    .into_iter()
1315                    .map(|p| p.to_string())
1316                    .collect::<Vec<String>>()
1317                    .join(",")
1318                    .to_string(),
1319            )]),
1320        };
1321    }
1322    if let Some(ref local_var_str) = description__niew {
1323        local_var_req_builder = match "multi" {
1324            "multi" => local_var_req_builder.query(
1325                &local_var_str
1326                    .into_iter()
1327                    .map(|p| ("description__niew".to_owned(), p.to_string()))
1328                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1329            ),
1330            _ => local_var_req_builder.query(&[(
1331                "description__niew",
1332                &local_var_str
1333                    .into_iter()
1334                    .map(|p| p.to_string())
1335                    .collect::<Vec<String>>()
1336                    .join(",")
1337                    .to_string(),
1338            )]),
1339        };
1340    }
1341    if let Some(ref local_var_str) = description__nisw {
1342        local_var_req_builder = match "multi" {
1343            "multi" => local_var_req_builder.query(
1344                &local_var_str
1345                    .into_iter()
1346                    .map(|p| ("description__nisw".to_owned(), p.to_string()))
1347                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1348            ),
1349            _ => local_var_req_builder.query(&[(
1350                "description__nisw",
1351                &local_var_str
1352                    .into_iter()
1353                    .map(|p| p.to_string())
1354                    .collect::<Vec<String>>()
1355                    .join(",")
1356                    .to_string(),
1357            )]),
1358        };
1359    }
1360    if let Some(ref local_var_str) = description__regex {
1361        local_var_req_builder = match "multi" {
1362            "multi" => local_var_req_builder.query(
1363                &local_var_str
1364                    .into_iter()
1365                    .map(|p| ("description__regex".to_owned(), p.to_string()))
1366                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1367            ),
1368            _ => local_var_req_builder.query(&[(
1369                "description__regex",
1370                &local_var_str
1371                    .into_iter()
1372                    .map(|p| p.to_string())
1373                    .collect::<Vec<String>>()
1374                    .join(",")
1375                    .to_string(),
1376            )]),
1377        };
1378    }
1379    if let Some(ref local_var_str) = id {
1380        local_var_req_builder = match "multi" {
1381            "multi" => local_var_req_builder.query(
1382                &local_var_str
1383                    .into_iter()
1384                    .map(|p| ("id".to_owned(), p.to_string()))
1385                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1386            ),
1387            _ => local_var_req_builder.query(&[(
1388                "id",
1389                &local_var_str
1390                    .into_iter()
1391                    .map(|p| p.to_string())
1392                    .collect::<Vec<String>>()
1393                    .join(",")
1394                    .to_string(),
1395            )]),
1396        };
1397    }
1398    if let Some(ref local_var_str) = id__empty {
1399        local_var_req_builder =
1400            local_var_req_builder.query(&[("id__empty", &local_var_str.to_string())]);
1401    }
1402    if let Some(ref local_var_str) = id__gt {
1403        local_var_req_builder = match "multi" {
1404            "multi" => local_var_req_builder.query(
1405                &local_var_str
1406                    .into_iter()
1407                    .map(|p| ("id__gt".to_owned(), p.to_string()))
1408                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1409            ),
1410            _ => local_var_req_builder.query(&[(
1411                "id__gt",
1412                &local_var_str
1413                    .into_iter()
1414                    .map(|p| p.to_string())
1415                    .collect::<Vec<String>>()
1416                    .join(",")
1417                    .to_string(),
1418            )]),
1419        };
1420    }
1421    if let Some(ref local_var_str) = id__gte {
1422        local_var_req_builder = match "multi" {
1423            "multi" => local_var_req_builder.query(
1424                &local_var_str
1425                    .into_iter()
1426                    .map(|p| ("id__gte".to_owned(), p.to_string()))
1427                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1428            ),
1429            _ => local_var_req_builder.query(&[(
1430                "id__gte",
1431                &local_var_str
1432                    .into_iter()
1433                    .map(|p| p.to_string())
1434                    .collect::<Vec<String>>()
1435                    .join(",")
1436                    .to_string(),
1437            )]),
1438        };
1439    }
1440    if let Some(ref local_var_str) = id__lt {
1441        local_var_req_builder = match "multi" {
1442            "multi" => local_var_req_builder.query(
1443                &local_var_str
1444                    .into_iter()
1445                    .map(|p| ("id__lt".to_owned(), p.to_string()))
1446                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1447            ),
1448            _ => local_var_req_builder.query(&[(
1449                "id__lt",
1450                &local_var_str
1451                    .into_iter()
1452                    .map(|p| p.to_string())
1453                    .collect::<Vec<String>>()
1454                    .join(",")
1455                    .to_string(),
1456            )]),
1457        };
1458    }
1459    if let Some(ref local_var_str) = id__lte {
1460        local_var_req_builder = match "multi" {
1461            "multi" => local_var_req_builder.query(
1462                &local_var_str
1463                    .into_iter()
1464                    .map(|p| ("id__lte".to_owned(), p.to_string()))
1465                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1466            ),
1467            _ => local_var_req_builder.query(&[(
1468                "id__lte",
1469                &local_var_str
1470                    .into_iter()
1471                    .map(|p| p.to_string())
1472                    .collect::<Vec<String>>()
1473                    .join(",")
1474                    .to_string(),
1475            )]),
1476        };
1477    }
1478    if let Some(ref local_var_str) = id__n {
1479        local_var_req_builder = match "multi" {
1480            "multi" => local_var_req_builder.query(
1481                &local_var_str
1482                    .into_iter()
1483                    .map(|p| ("id__n".to_owned(), p.to_string()))
1484                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1485            ),
1486            _ => local_var_req_builder.query(&[(
1487                "id__n",
1488                &local_var_str
1489                    .into_iter()
1490                    .map(|p| p.to_string())
1491                    .collect::<Vec<String>>()
1492                    .join(",")
1493                    .to_string(),
1494            )]),
1495        };
1496    }
1497    if let Some(ref local_var_str) = ike_proposal {
1498        local_var_req_builder = match "multi" {
1499            "multi" => local_var_req_builder.query(
1500                &local_var_str
1501                    .into_iter()
1502                    .map(|p| ("ike_proposal".to_owned(), p.to_string()))
1503                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1504            ),
1505            _ => local_var_req_builder.query(&[(
1506                "ike_proposal",
1507                &local_var_str
1508                    .into_iter()
1509                    .map(|p| p.to_string())
1510                    .collect::<Vec<String>>()
1511                    .join(",")
1512                    .to_string(),
1513            )]),
1514        };
1515    }
1516    if let Some(ref local_var_str) = ike_proposal__n {
1517        local_var_req_builder = match "multi" {
1518            "multi" => local_var_req_builder.query(
1519                &local_var_str
1520                    .into_iter()
1521                    .map(|p| ("ike_proposal__n".to_owned(), p.to_string()))
1522                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1523            ),
1524            _ => local_var_req_builder.query(&[(
1525                "ike_proposal__n",
1526                &local_var_str
1527                    .into_iter()
1528                    .map(|p| p.to_string())
1529                    .collect::<Vec<String>>()
1530                    .join(",")
1531                    .to_string(),
1532            )]),
1533        };
1534    }
1535    if let Some(ref local_var_str) = ike_proposal_id {
1536        local_var_req_builder = match "multi" {
1537            "multi" => local_var_req_builder.query(
1538                &local_var_str
1539                    .into_iter()
1540                    .map(|p| ("ike_proposal_id".to_owned(), p.to_string()))
1541                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1542            ),
1543            _ => local_var_req_builder.query(&[(
1544                "ike_proposal_id",
1545                &local_var_str
1546                    .into_iter()
1547                    .map(|p| p.to_string())
1548                    .collect::<Vec<String>>()
1549                    .join(",")
1550                    .to_string(),
1551            )]),
1552        };
1553    }
1554    if let Some(ref local_var_str) = ike_proposal_id__n {
1555        local_var_req_builder = match "multi" {
1556            "multi" => local_var_req_builder.query(
1557                &local_var_str
1558                    .into_iter()
1559                    .map(|p| ("ike_proposal_id__n".to_owned(), p.to_string()))
1560                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1561            ),
1562            _ => local_var_req_builder.query(&[(
1563                "ike_proposal_id__n",
1564                &local_var_str
1565                    .into_iter()
1566                    .map(|p| p.to_string())
1567                    .collect::<Vec<String>>()
1568                    .join(",")
1569                    .to_string(),
1570            )]),
1571        };
1572    }
1573    if let Some(ref local_var_str) = last_updated {
1574        local_var_req_builder = match "multi" {
1575            "multi" => local_var_req_builder.query(
1576                &local_var_str
1577                    .into_iter()
1578                    .map(|p| ("last_updated".to_owned(), p.to_string()))
1579                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1580            ),
1581            _ => local_var_req_builder.query(&[(
1582                "last_updated",
1583                &local_var_str
1584                    .into_iter()
1585                    .map(|p| p.to_string())
1586                    .collect::<Vec<String>>()
1587                    .join(",")
1588                    .to_string(),
1589            )]),
1590        };
1591    }
1592    if let Some(ref local_var_str) = last_updated__empty {
1593        local_var_req_builder = match "multi" {
1594            "multi" => local_var_req_builder.query(
1595                &local_var_str
1596                    .into_iter()
1597                    .map(|p| ("last_updated__empty".to_owned(), p.to_string()))
1598                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1599            ),
1600            _ => local_var_req_builder.query(&[(
1601                "last_updated__empty",
1602                &local_var_str
1603                    .into_iter()
1604                    .map(|p| p.to_string())
1605                    .collect::<Vec<String>>()
1606                    .join(",")
1607                    .to_string(),
1608            )]),
1609        };
1610    }
1611    if let Some(ref local_var_str) = last_updated__gt {
1612        local_var_req_builder = match "multi" {
1613            "multi" => local_var_req_builder.query(
1614                &local_var_str
1615                    .into_iter()
1616                    .map(|p| ("last_updated__gt".to_owned(), p.to_string()))
1617                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1618            ),
1619            _ => local_var_req_builder.query(&[(
1620                "last_updated__gt",
1621                &local_var_str
1622                    .into_iter()
1623                    .map(|p| p.to_string())
1624                    .collect::<Vec<String>>()
1625                    .join(",")
1626                    .to_string(),
1627            )]),
1628        };
1629    }
1630    if let Some(ref local_var_str) = last_updated__gte {
1631        local_var_req_builder = match "multi" {
1632            "multi" => local_var_req_builder.query(
1633                &local_var_str
1634                    .into_iter()
1635                    .map(|p| ("last_updated__gte".to_owned(), p.to_string()))
1636                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1637            ),
1638            _ => local_var_req_builder.query(&[(
1639                "last_updated__gte",
1640                &local_var_str
1641                    .into_iter()
1642                    .map(|p| p.to_string())
1643                    .collect::<Vec<String>>()
1644                    .join(",")
1645                    .to_string(),
1646            )]),
1647        };
1648    }
1649    if let Some(ref local_var_str) = last_updated__lt {
1650        local_var_req_builder = match "multi" {
1651            "multi" => local_var_req_builder.query(
1652                &local_var_str
1653                    .into_iter()
1654                    .map(|p| ("last_updated__lt".to_owned(), p.to_string()))
1655                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1656            ),
1657            _ => local_var_req_builder.query(&[(
1658                "last_updated__lt",
1659                &local_var_str
1660                    .into_iter()
1661                    .map(|p| p.to_string())
1662                    .collect::<Vec<String>>()
1663                    .join(",")
1664                    .to_string(),
1665            )]),
1666        };
1667    }
1668    if let Some(ref local_var_str) = last_updated__lte {
1669        local_var_req_builder = match "multi" {
1670            "multi" => local_var_req_builder.query(
1671                &local_var_str
1672                    .into_iter()
1673                    .map(|p| ("last_updated__lte".to_owned(), p.to_string()))
1674                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1675            ),
1676            _ => local_var_req_builder.query(&[(
1677                "last_updated__lte",
1678                &local_var_str
1679                    .into_iter()
1680                    .map(|p| p.to_string())
1681                    .collect::<Vec<String>>()
1682                    .join(",")
1683                    .to_string(),
1684            )]),
1685        };
1686    }
1687    if let Some(ref local_var_str) = last_updated__n {
1688        local_var_req_builder = match "multi" {
1689            "multi" => local_var_req_builder.query(
1690                &local_var_str
1691                    .into_iter()
1692                    .map(|p| ("last_updated__n".to_owned(), p.to_string()))
1693                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1694            ),
1695            _ => local_var_req_builder.query(&[(
1696                "last_updated__n",
1697                &local_var_str
1698                    .into_iter()
1699                    .map(|p| p.to_string())
1700                    .collect::<Vec<String>>()
1701                    .join(",")
1702                    .to_string(),
1703            )]),
1704        };
1705    }
1706    if let Some(ref local_var_str) = limit {
1707        local_var_req_builder =
1708            local_var_req_builder.query(&[("limit", &local_var_str.to_string())]);
1709    }
1710    if let Some(ref local_var_str) = mode {
1711        local_var_req_builder = match "multi" {
1712            "multi" => local_var_req_builder.query(
1713                &local_var_str
1714                    .into_iter()
1715                    .map(|p| ("mode".to_owned(), p.to_string()))
1716                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1717            ),
1718            _ => local_var_req_builder.query(&[(
1719                "mode",
1720                &local_var_str
1721                    .into_iter()
1722                    .map(|p| p.to_string())
1723                    .collect::<Vec<String>>()
1724                    .join(",")
1725                    .to_string(),
1726            )]),
1727        };
1728    }
1729    if let Some(ref local_var_str) = mode__empty {
1730        local_var_req_builder =
1731            local_var_req_builder.query(&[("mode__empty", &local_var_str.to_string())]);
1732    }
1733    if let Some(ref local_var_str) = mode__ic {
1734        local_var_req_builder = match "multi" {
1735            "multi" => local_var_req_builder.query(
1736                &local_var_str
1737                    .into_iter()
1738                    .map(|p| ("mode__ic".to_owned(), p.to_string()))
1739                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1740            ),
1741            _ => local_var_req_builder.query(&[(
1742                "mode__ic",
1743                &local_var_str
1744                    .into_iter()
1745                    .map(|p| p.to_string())
1746                    .collect::<Vec<String>>()
1747                    .join(",")
1748                    .to_string(),
1749            )]),
1750        };
1751    }
1752    if let Some(ref local_var_str) = mode__ie {
1753        local_var_req_builder = match "multi" {
1754            "multi" => local_var_req_builder.query(
1755                &local_var_str
1756                    .into_iter()
1757                    .map(|p| ("mode__ie".to_owned(), p.to_string()))
1758                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1759            ),
1760            _ => local_var_req_builder.query(&[(
1761                "mode__ie",
1762                &local_var_str
1763                    .into_iter()
1764                    .map(|p| p.to_string())
1765                    .collect::<Vec<String>>()
1766                    .join(",")
1767                    .to_string(),
1768            )]),
1769        };
1770    }
1771    if let Some(ref local_var_str) = mode__iew {
1772        local_var_req_builder = match "multi" {
1773            "multi" => local_var_req_builder.query(
1774                &local_var_str
1775                    .into_iter()
1776                    .map(|p| ("mode__iew".to_owned(), p.to_string()))
1777                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1778            ),
1779            _ => local_var_req_builder.query(&[(
1780                "mode__iew",
1781                &local_var_str
1782                    .into_iter()
1783                    .map(|p| p.to_string())
1784                    .collect::<Vec<String>>()
1785                    .join(",")
1786                    .to_string(),
1787            )]),
1788        };
1789    }
1790    if let Some(ref local_var_str) = mode__iregex {
1791        local_var_req_builder = match "multi" {
1792            "multi" => local_var_req_builder.query(
1793                &local_var_str
1794                    .into_iter()
1795                    .map(|p| ("mode__iregex".to_owned(), p.to_string()))
1796                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1797            ),
1798            _ => local_var_req_builder.query(&[(
1799                "mode__iregex",
1800                &local_var_str
1801                    .into_iter()
1802                    .map(|p| p.to_string())
1803                    .collect::<Vec<String>>()
1804                    .join(",")
1805                    .to_string(),
1806            )]),
1807        };
1808    }
1809    if let Some(ref local_var_str) = mode__isw {
1810        local_var_req_builder = match "multi" {
1811            "multi" => local_var_req_builder.query(
1812                &local_var_str
1813                    .into_iter()
1814                    .map(|p| ("mode__isw".to_owned(), p.to_string()))
1815                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1816            ),
1817            _ => local_var_req_builder.query(&[(
1818                "mode__isw",
1819                &local_var_str
1820                    .into_iter()
1821                    .map(|p| p.to_string())
1822                    .collect::<Vec<String>>()
1823                    .join(",")
1824                    .to_string(),
1825            )]),
1826        };
1827    }
1828    if let Some(ref local_var_str) = mode__n {
1829        local_var_req_builder = match "multi" {
1830            "multi" => local_var_req_builder.query(
1831                &local_var_str
1832                    .into_iter()
1833                    .map(|p| ("mode__n".to_owned(), p.to_string()))
1834                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1835            ),
1836            _ => local_var_req_builder.query(&[(
1837                "mode__n",
1838                &local_var_str
1839                    .into_iter()
1840                    .map(|p| p.to_string())
1841                    .collect::<Vec<String>>()
1842                    .join(",")
1843                    .to_string(),
1844            )]),
1845        };
1846    }
1847    if let Some(ref local_var_str) = mode__nic {
1848        local_var_req_builder = match "multi" {
1849            "multi" => local_var_req_builder.query(
1850                &local_var_str
1851                    .into_iter()
1852                    .map(|p| ("mode__nic".to_owned(), p.to_string()))
1853                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1854            ),
1855            _ => local_var_req_builder.query(&[(
1856                "mode__nic",
1857                &local_var_str
1858                    .into_iter()
1859                    .map(|p| p.to_string())
1860                    .collect::<Vec<String>>()
1861                    .join(",")
1862                    .to_string(),
1863            )]),
1864        };
1865    }
1866    if let Some(ref local_var_str) = mode__nie {
1867        local_var_req_builder = match "multi" {
1868            "multi" => local_var_req_builder.query(
1869                &local_var_str
1870                    .into_iter()
1871                    .map(|p| ("mode__nie".to_owned(), p.to_string()))
1872                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1873            ),
1874            _ => local_var_req_builder.query(&[(
1875                "mode__nie",
1876                &local_var_str
1877                    .into_iter()
1878                    .map(|p| p.to_string())
1879                    .collect::<Vec<String>>()
1880                    .join(",")
1881                    .to_string(),
1882            )]),
1883        };
1884    }
1885    if let Some(ref local_var_str) = mode__niew {
1886        local_var_req_builder = match "multi" {
1887            "multi" => local_var_req_builder.query(
1888                &local_var_str
1889                    .into_iter()
1890                    .map(|p| ("mode__niew".to_owned(), p.to_string()))
1891                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1892            ),
1893            _ => local_var_req_builder.query(&[(
1894                "mode__niew",
1895                &local_var_str
1896                    .into_iter()
1897                    .map(|p| p.to_string())
1898                    .collect::<Vec<String>>()
1899                    .join(",")
1900                    .to_string(),
1901            )]),
1902        };
1903    }
1904    if let Some(ref local_var_str) = mode__nisw {
1905        local_var_req_builder = match "multi" {
1906            "multi" => local_var_req_builder.query(
1907                &local_var_str
1908                    .into_iter()
1909                    .map(|p| ("mode__nisw".to_owned(), p.to_string()))
1910                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1911            ),
1912            _ => local_var_req_builder.query(&[(
1913                "mode__nisw",
1914                &local_var_str
1915                    .into_iter()
1916                    .map(|p| p.to_string())
1917                    .collect::<Vec<String>>()
1918                    .join(",")
1919                    .to_string(),
1920            )]),
1921        };
1922    }
1923    if let Some(ref local_var_str) = mode__regex {
1924        local_var_req_builder = match "multi" {
1925            "multi" => local_var_req_builder.query(
1926                &local_var_str
1927                    .into_iter()
1928                    .map(|p| ("mode__regex".to_owned(), p.to_string()))
1929                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1930            ),
1931            _ => local_var_req_builder.query(&[(
1932                "mode__regex",
1933                &local_var_str
1934                    .into_iter()
1935                    .map(|p| p.to_string())
1936                    .collect::<Vec<String>>()
1937                    .join(",")
1938                    .to_string(),
1939            )]),
1940        };
1941    }
1942    if let Some(ref local_var_str) = modified_by_request {
1943        local_var_req_builder =
1944            local_var_req_builder.query(&[("modified_by_request", &local_var_str.to_string())]);
1945    }
1946    if let Some(ref local_var_str) = name {
1947        local_var_req_builder = match "multi" {
1948            "multi" => local_var_req_builder.query(
1949                &local_var_str
1950                    .into_iter()
1951                    .map(|p| ("name".to_owned(), p.to_string()))
1952                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1953            ),
1954            _ => local_var_req_builder.query(&[(
1955                "name",
1956                &local_var_str
1957                    .into_iter()
1958                    .map(|p| p.to_string())
1959                    .collect::<Vec<String>>()
1960                    .join(",")
1961                    .to_string(),
1962            )]),
1963        };
1964    }
1965    if let Some(ref local_var_str) = name__empty {
1966        local_var_req_builder =
1967            local_var_req_builder.query(&[("name__empty", &local_var_str.to_string())]);
1968    }
1969    if let Some(ref local_var_str) = name__ic {
1970        local_var_req_builder = match "multi" {
1971            "multi" => local_var_req_builder.query(
1972                &local_var_str
1973                    .into_iter()
1974                    .map(|p| ("name__ic".to_owned(), p.to_string()))
1975                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1976            ),
1977            _ => local_var_req_builder.query(&[(
1978                "name__ic",
1979                &local_var_str
1980                    .into_iter()
1981                    .map(|p| p.to_string())
1982                    .collect::<Vec<String>>()
1983                    .join(",")
1984                    .to_string(),
1985            )]),
1986        };
1987    }
1988    if let Some(ref local_var_str) = name__ie {
1989        local_var_req_builder = match "multi" {
1990            "multi" => local_var_req_builder.query(
1991                &local_var_str
1992                    .into_iter()
1993                    .map(|p| ("name__ie".to_owned(), p.to_string()))
1994                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1995            ),
1996            _ => local_var_req_builder.query(&[(
1997                "name__ie",
1998                &local_var_str
1999                    .into_iter()
2000                    .map(|p| p.to_string())
2001                    .collect::<Vec<String>>()
2002                    .join(",")
2003                    .to_string(),
2004            )]),
2005        };
2006    }
2007    if let Some(ref local_var_str) = name__iew {
2008        local_var_req_builder = match "multi" {
2009            "multi" => local_var_req_builder.query(
2010                &local_var_str
2011                    .into_iter()
2012                    .map(|p| ("name__iew".to_owned(), p.to_string()))
2013                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2014            ),
2015            _ => local_var_req_builder.query(&[(
2016                "name__iew",
2017                &local_var_str
2018                    .into_iter()
2019                    .map(|p| p.to_string())
2020                    .collect::<Vec<String>>()
2021                    .join(",")
2022                    .to_string(),
2023            )]),
2024        };
2025    }
2026    if let Some(ref local_var_str) = name__iregex {
2027        local_var_req_builder = match "multi" {
2028            "multi" => local_var_req_builder.query(
2029                &local_var_str
2030                    .into_iter()
2031                    .map(|p| ("name__iregex".to_owned(), p.to_string()))
2032                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2033            ),
2034            _ => local_var_req_builder.query(&[(
2035                "name__iregex",
2036                &local_var_str
2037                    .into_iter()
2038                    .map(|p| p.to_string())
2039                    .collect::<Vec<String>>()
2040                    .join(",")
2041                    .to_string(),
2042            )]),
2043        };
2044    }
2045    if let Some(ref local_var_str) = name__isw {
2046        local_var_req_builder = match "multi" {
2047            "multi" => local_var_req_builder.query(
2048                &local_var_str
2049                    .into_iter()
2050                    .map(|p| ("name__isw".to_owned(), p.to_string()))
2051                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2052            ),
2053            _ => local_var_req_builder.query(&[(
2054                "name__isw",
2055                &local_var_str
2056                    .into_iter()
2057                    .map(|p| p.to_string())
2058                    .collect::<Vec<String>>()
2059                    .join(",")
2060                    .to_string(),
2061            )]),
2062        };
2063    }
2064    if let Some(ref local_var_str) = name__n {
2065        local_var_req_builder = match "multi" {
2066            "multi" => local_var_req_builder.query(
2067                &local_var_str
2068                    .into_iter()
2069                    .map(|p| ("name__n".to_owned(), p.to_string()))
2070                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2071            ),
2072            _ => local_var_req_builder.query(&[(
2073                "name__n",
2074                &local_var_str
2075                    .into_iter()
2076                    .map(|p| p.to_string())
2077                    .collect::<Vec<String>>()
2078                    .join(",")
2079                    .to_string(),
2080            )]),
2081        };
2082    }
2083    if let Some(ref local_var_str) = name__nic {
2084        local_var_req_builder = match "multi" {
2085            "multi" => local_var_req_builder.query(
2086                &local_var_str
2087                    .into_iter()
2088                    .map(|p| ("name__nic".to_owned(), p.to_string()))
2089                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2090            ),
2091            _ => local_var_req_builder.query(&[(
2092                "name__nic",
2093                &local_var_str
2094                    .into_iter()
2095                    .map(|p| p.to_string())
2096                    .collect::<Vec<String>>()
2097                    .join(",")
2098                    .to_string(),
2099            )]),
2100        };
2101    }
2102    if let Some(ref local_var_str) = name__nie {
2103        local_var_req_builder = match "multi" {
2104            "multi" => local_var_req_builder.query(
2105                &local_var_str
2106                    .into_iter()
2107                    .map(|p| ("name__nie".to_owned(), p.to_string()))
2108                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2109            ),
2110            _ => local_var_req_builder.query(&[(
2111                "name__nie",
2112                &local_var_str
2113                    .into_iter()
2114                    .map(|p| p.to_string())
2115                    .collect::<Vec<String>>()
2116                    .join(",")
2117                    .to_string(),
2118            )]),
2119        };
2120    }
2121    if let Some(ref local_var_str) = name__niew {
2122        local_var_req_builder = match "multi" {
2123            "multi" => local_var_req_builder.query(
2124                &local_var_str
2125                    .into_iter()
2126                    .map(|p| ("name__niew".to_owned(), p.to_string()))
2127                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2128            ),
2129            _ => local_var_req_builder.query(&[(
2130                "name__niew",
2131                &local_var_str
2132                    .into_iter()
2133                    .map(|p| p.to_string())
2134                    .collect::<Vec<String>>()
2135                    .join(",")
2136                    .to_string(),
2137            )]),
2138        };
2139    }
2140    if let Some(ref local_var_str) = name__nisw {
2141        local_var_req_builder = match "multi" {
2142            "multi" => local_var_req_builder.query(
2143                &local_var_str
2144                    .into_iter()
2145                    .map(|p| ("name__nisw".to_owned(), p.to_string()))
2146                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2147            ),
2148            _ => local_var_req_builder.query(&[(
2149                "name__nisw",
2150                &local_var_str
2151                    .into_iter()
2152                    .map(|p| p.to_string())
2153                    .collect::<Vec<String>>()
2154                    .join(",")
2155                    .to_string(),
2156            )]),
2157        };
2158    }
2159    if let Some(ref local_var_str) = name__regex {
2160        local_var_req_builder = match "multi" {
2161            "multi" => local_var_req_builder.query(
2162                &local_var_str
2163                    .into_iter()
2164                    .map(|p| ("name__regex".to_owned(), p.to_string()))
2165                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2166            ),
2167            _ => local_var_req_builder.query(&[(
2168                "name__regex",
2169                &local_var_str
2170                    .into_iter()
2171                    .map(|p| p.to_string())
2172                    .collect::<Vec<String>>()
2173                    .join(",")
2174                    .to_string(),
2175            )]),
2176        };
2177    }
2178    if let Some(ref local_var_str) = offset {
2179        local_var_req_builder =
2180            local_var_req_builder.query(&[("offset", &local_var_str.to_string())]);
2181    }
2182    if let Some(ref local_var_str) = ordering {
2183        local_var_req_builder =
2184            local_var_req_builder.query(&[("ordering", &local_var_str.to_string())]);
2185    }
2186    if let Some(ref local_var_str) = preshared_key {
2187        local_var_req_builder =
2188            local_var_req_builder.query(&[("preshared_key", &local_var_str.to_string())]);
2189    }
2190    if let Some(ref local_var_str) = preshared_key__ic {
2191        local_var_req_builder =
2192            local_var_req_builder.query(&[("preshared_key__ic", &local_var_str.to_string())]);
2193    }
2194    if let Some(ref local_var_str) = preshared_key__ie {
2195        local_var_req_builder =
2196            local_var_req_builder.query(&[("preshared_key__ie", &local_var_str.to_string())]);
2197    }
2198    if let Some(ref local_var_str) = preshared_key__iew {
2199        local_var_req_builder =
2200            local_var_req_builder.query(&[("preshared_key__iew", &local_var_str.to_string())]);
2201    }
2202    if let Some(ref local_var_str) = preshared_key__iregex {
2203        local_var_req_builder =
2204            local_var_req_builder.query(&[("preshared_key__iregex", &local_var_str.to_string())]);
2205    }
2206    if let Some(ref local_var_str) = preshared_key__isw {
2207        local_var_req_builder =
2208            local_var_req_builder.query(&[("preshared_key__isw", &local_var_str.to_string())]);
2209    }
2210    if let Some(ref local_var_str) = preshared_key__n {
2211        local_var_req_builder =
2212            local_var_req_builder.query(&[("preshared_key__n", &local_var_str.to_string())]);
2213    }
2214    if let Some(ref local_var_str) = preshared_key__nic {
2215        local_var_req_builder =
2216            local_var_req_builder.query(&[("preshared_key__nic", &local_var_str.to_string())]);
2217    }
2218    if let Some(ref local_var_str) = preshared_key__nie {
2219        local_var_req_builder =
2220            local_var_req_builder.query(&[("preshared_key__nie", &local_var_str.to_string())]);
2221    }
2222    if let Some(ref local_var_str) = preshared_key__niew {
2223        local_var_req_builder =
2224            local_var_req_builder.query(&[("preshared_key__niew", &local_var_str.to_string())]);
2225    }
2226    if let Some(ref local_var_str) = preshared_key__nisw {
2227        local_var_req_builder =
2228            local_var_req_builder.query(&[("preshared_key__nisw", &local_var_str.to_string())]);
2229    }
2230    if let Some(ref local_var_str) = preshared_key__regex {
2231        local_var_req_builder =
2232            local_var_req_builder.query(&[("preshared_key__regex", &local_var_str.to_string())]);
2233    }
2234    if let Some(ref local_var_str) = q {
2235        local_var_req_builder = local_var_req_builder.query(&[("q", &local_var_str.to_string())]);
2236    }
2237    if let Some(ref local_var_str) = tag {
2238        local_var_req_builder = match "multi" {
2239            "multi" => local_var_req_builder.query(
2240                &local_var_str
2241                    .into_iter()
2242                    .map(|p| ("tag".to_owned(), p.to_string()))
2243                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2244            ),
2245            _ => local_var_req_builder.query(&[(
2246                "tag",
2247                &local_var_str
2248                    .into_iter()
2249                    .map(|p| p.to_string())
2250                    .collect::<Vec<String>>()
2251                    .join(",")
2252                    .to_string(),
2253            )]),
2254        };
2255    }
2256    if let Some(ref local_var_str) = tag__n {
2257        local_var_req_builder = match "multi" {
2258            "multi" => local_var_req_builder.query(
2259                &local_var_str
2260                    .into_iter()
2261                    .map(|p| ("tag__n".to_owned(), p.to_string()))
2262                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2263            ),
2264            _ => local_var_req_builder.query(&[(
2265                "tag__n",
2266                &local_var_str
2267                    .into_iter()
2268                    .map(|p| p.to_string())
2269                    .collect::<Vec<String>>()
2270                    .join(",")
2271                    .to_string(),
2272            )]),
2273        };
2274    }
2275    if let Some(ref local_var_str) = tag_id {
2276        local_var_req_builder = match "multi" {
2277            "multi" => local_var_req_builder.query(
2278                &local_var_str
2279                    .into_iter()
2280                    .map(|p| ("tag_id".to_owned(), p.to_string()))
2281                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2282            ),
2283            _ => local_var_req_builder.query(&[(
2284                "tag_id",
2285                &local_var_str
2286                    .into_iter()
2287                    .map(|p| p.to_string())
2288                    .collect::<Vec<String>>()
2289                    .join(",")
2290                    .to_string(),
2291            )]),
2292        };
2293    }
2294    if let Some(ref local_var_str) = tag_id__n {
2295        local_var_req_builder = match "multi" {
2296            "multi" => local_var_req_builder.query(
2297                &local_var_str
2298                    .into_iter()
2299                    .map(|p| ("tag_id__n".to_owned(), p.to_string()))
2300                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2301            ),
2302            _ => local_var_req_builder.query(&[(
2303                "tag_id__n",
2304                &local_var_str
2305                    .into_iter()
2306                    .map(|p| p.to_string())
2307                    .collect::<Vec<String>>()
2308                    .join(",")
2309                    .to_string(),
2310            )]),
2311        };
2312    }
2313    if let Some(ref local_var_str) = updated_by_request {
2314        local_var_req_builder =
2315            local_var_req_builder.query(&[("updated_by_request", &local_var_str.to_string())]);
2316    }
2317    if let Some(ref local_var_str) = version {
2318        local_var_req_builder = match "multi" {
2319            "multi" => local_var_req_builder.query(
2320                &local_var_str
2321                    .into_iter()
2322                    .map(|p| ("version".to_owned(), p.to_string()))
2323                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2324            ),
2325            _ => local_var_req_builder.query(&[(
2326                "version",
2327                &local_var_str
2328                    .into_iter()
2329                    .map(|p| p.to_string())
2330                    .collect::<Vec<String>>()
2331                    .join(",")
2332                    .to_string(),
2333            )]),
2334        };
2335    }
2336    if let Some(ref local_var_str) = version__ic {
2337        local_var_req_builder = match "multi" {
2338            "multi" => local_var_req_builder.query(
2339                &local_var_str
2340                    .into_iter()
2341                    .map(|p| ("version__ic".to_owned(), p.to_string()))
2342                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2343            ),
2344            _ => local_var_req_builder.query(&[(
2345                "version__ic",
2346                &local_var_str
2347                    .into_iter()
2348                    .map(|p| p.to_string())
2349                    .collect::<Vec<String>>()
2350                    .join(",")
2351                    .to_string(),
2352            )]),
2353        };
2354    }
2355    if let Some(ref local_var_str) = version__ie {
2356        local_var_req_builder = match "multi" {
2357            "multi" => local_var_req_builder.query(
2358                &local_var_str
2359                    .into_iter()
2360                    .map(|p| ("version__ie".to_owned(), p.to_string()))
2361                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2362            ),
2363            _ => local_var_req_builder.query(&[(
2364                "version__ie",
2365                &local_var_str
2366                    .into_iter()
2367                    .map(|p| p.to_string())
2368                    .collect::<Vec<String>>()
2369                    .join(",")
2370                    .to_string(),
2371            )]),
2372        };
2373    }
2374    if let Some(ref local_var_str) = version__iew {
2375        local_var_req_builder = match "multi" {
2376            "multi" => local_var_req_builder.query(
2377                &local_var_str
2378                    .into_iter()
2379                    .map(|p| ("version__iew".to_owned(), p.to_string()))
2380                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2381            ),
2382            _ => local_var_req_builder.query(&[(
2383                "version__iew",
2384                &local_var_str
2385                    .into_iter()
2386                    .map(|p| p.to_string())
2387                    .collect::<Vec<String>>()
2388                    .join(",")
2389                    .to_string(),
2390            )]),
2391        };
2392    }
2393    if let Some(ref local_var_str) = version__iregex {
2394        local_var_req_builder = match "multi" {
2395            "multi" => local_var_req_builder.query(
2396                &local_var_str
2397                    .into_iter()
2398                    .map(|p| ("version__iregex".to_owned(), p.to_string()))
2399                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2400            ),
2401            _ => local_var_req_builder.query(&[(
2402                "version__iregex",
2403                &local_var_str
2404                    .into_iter()
2405                    .map(|p| p.to_string())
2406                    .collect::<Vec<String>>()
2407                    .join(",")
2408                    .to_string(),
2409            )]),
2410        };
2411    }
2412    if let Some(ref local_var_str) = version__isw {
2413        local_var_req_builder = match "multi" {
2414            "multi" => local_var_req_builder.query(
2415                &local_var_str
2416                    .into_iter()
2417                    .map(|p| ("version__isw".to_owned(), p.to_string()))
2418                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2419            ),
2420            _ => local_var_req_builder.query(&[(
2421                "version__isw",
2422                &local_var_str
2423                    .into_iter()
2424                    .map(|p| p.to_string())
2425                    .collect::<Vec<String>>()
2426                    .join(",")
2427                    .to_string(),
2428            )]),
2429        };
2430    }
2431    if let Some(ref local_var_str) = version__n {
2432        local_var_req_builder = match "multi" {
2433            "multi" => local_var_req_builder.query(
2434                &local_var_str
2435                    .into_iter()
2436                    .map(|p| ("version__n".to_owned(), p.to_string()))
2437                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2438            ),
2439            _ => local_var_req_builder.query(&[(
2440                "version__n",
2441                &local_var_str
2442                    .into_iter()
2443                    .map(|p| p.to_string())
2444                    .collect::<Vec<String>>()
2445                    .join(",")
2446                    .to_string(),
2447            )]),
2448        };
2449    }
2450    if let Some(ref local_var_str) = version__nic {
2451        local_var_req_builder = match "multi" {
2452            "multi" => local_var_req_builder.query(
2453                &local_var_str
2454                    .into_iter()
2455                    .map(|p| ("version__nic".to_owned(), p.to_string()))
2456                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2457            ),
2458            _ => local_var_req_builder.query(&[(
2459                "version__nic",
2460                &local_var_str
2461                    .into_iter()
2462                    .map(|p| p.to_string())
2463                    .collect::<Vec<String>>()
2464                    .join(",")
2465                    .to_string(),
2466            )]),
2467        };
2468    }
2469    if let Some(ref local_var_str) = version__nie {
2470        local_var_req_builder = match "multi" {
2471            "multi" => local_var_req_builder.query(
2472                &local_var_str
2473                    .into_iter()
2474                    .map(|p| ("version__nie".to_owned(), p.to_string()))
2475                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2476            ),
2477            _ => local_var_req_builder.query(&[(
2478                "version__nie",
2479                &local_var_str
2480                    .into_iter()
2481                    .map(|p| p.to_string())
2482                    .collect::<Vec<String>>()
2483                    .join(",")
2484                    .to_string(),
2485            )]),
2486        };
2487    }
2488    if let Some(ref local_var_str) = version__niew {
2489        local_var_req_builder = match "multi" {
2490            "multi" => local_var_req_builder.query(
2491                &local_var_str
2492                    .into_iter()
2493                    .map(|p| ("version__niew".to_owned(), p.to_string()))
2494                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2495            ),
2496            _ => local_var_req_builder.query(&[(
2497                "version__niew",
2498                &local_var_str
2499                    .into_iter()
2500                    .map(|p| p.to_string())
2501                    .collect::<Vec<String>>()
2502                    .join(",")
2503                    .to_string(),
2504            )]),
2505        };
2506    }
2507    if let Some(ref local_var_str) = version__nisw {
2508        local_var_req_builder = match "multi" {
2509            "multi" => local_var_req_builder.query(
2510                &local_var_str
2511                    .into_iter()
2512                    .map(|p| ("version__nisw".to_owned(), p.to_string()))
2513                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2514            ),
2515            _ => local_var_req_builder.query(&[(
2516                "version__nisw",
2517                &local_var_str
2518                    .into_iter()
2519                    .map(|p| p.to_string())
2520                    .collect::<Vec<String>>()
2521                    .join(",")
2522                    .to_string(),
2523            )]),
2524        };
2525    }
2526    if let Some(ref local_var_str) = version__regex {
2527        local_var_req_builder = match "multi" {
2528            "multi" => local_var_req_builder.query(
2529                &local_var_str
2530                    .into_iter()
2531                    .map(|p| ("version__regex".to_owned(), p.to_string()))
2532                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2533            ),
2534            _ => local_var_req_builder.query(&[(
2535                "version__regex",
2536                &local_var_str
2537                    .into_iter()
2538                    .map(|p| p.to_string())
2539                    .collect::<Vec<String>>()
2540                    .join(",")
2541                    .to_string(),
2542            )]),
2543        };
2544    }
2545    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
2546        local_var_req_builder =
2547            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
2548    }
2549    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
2550        let local_var_key = local_var_apikey.key.clone();
2551        let local_var_value = match local_var_apikey.prefix {
2552            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
2553            None => local_var_key,
2554        };
2555        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
2556    };
2557
2558    let local_var_req = local_var_req_builder.build()?;
2559    let local_var_resp = local_var_client.execute(local_var_req).await?;
2560
2561    let local_var_status = local_var_resp.status();
2562    let local_var_content = local_var_resp.text().await?;
2563
2564    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
2565        serde_json::from_str(&local_var_content).map_err(Error::from)
2566    } else {
2567        let local_var_entity: Option<VpnIkePoliciesListError> =
2568            serde_json::from_str(&local_var_content).ok();
2569        let local_var_error = ResponseContent {
2570            status: local_var_status,
2571            content: local_var_content,
2572            entity: local_var_entity,
2573        };
2574        Err(Error::ResponseError(local_var_error))
2575    }
2576}
2577
2578/// Patch a IKE policy object.
2579pub async fn vpn_ike_policies_partial_update(
2580    configuration: &configuration::Configuration,
2581    id: i32,
2582    patched_writable_ike_policy_request: Option<crate::models::PatchedWritableIkePolicyRequest>,
2583) -> Result<crate::models::IkePolicy, Error<VpnIkePoliciesPartialUpdateError>> {
2584    let local_var_configuration = configuration;
2585
2586    let local_var_client = &local_var_configuration.client;
2587
2588    let local_var_uri_str = format!(
2589        "{}/api/vpn/ike-policies/{id}/",
2590        local_var_configuration.base_path,
2591        id = id
2592    );
2593    let mut local_var_req_builder =
2594        local_var_client.request(reqwest::Method::PATCH, local_var_uri_str.as_str());
2595
2596    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
2597        local_var_req_builder =
2598            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
2599    }
2600    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
2601        let local_var_key = local_var_apikey.key.clone();
2602        let local_var_value = match local_var_apikey.prefix {
2603            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
2604            None => local_var_key,
2605        };
2606        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
2607    };
2608    local_var_req_builder = local_var_req_builder.json(&patched_writable_ike_policy_request);
2609
2610    let local_var_req = local_var_req_builder.build()?;
2611    let local_var_resp = local_var_client.execute(local_var_req).await?;
2612
2613    let local_var_status = local_var_resp.status();
2614    let local_var_content = local_var_resp.text().await?;
2615
2616    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
2617        serde_json::from_str(&local_var_content).map_err(Error::from)
2618    } else {
2619        let local_var_entity: Option<VpnIkePoliciesPartialUpdateError> =
2620            serde_json::from_str(&local_var_content).ok();
2621        let local_var_error = ResponseContent {
2622            status: local_var_status,
2623            content: local_var_content,
2624            entity: local_var_entity,
2625        };
2626        Err(Error::ResponseError(local_var_error))
2627    }
2628}
2629
2630/// Get a IKE policy object.
2631pub async fn vpn_ike_policies_retrieve(
2632    configuration: &configuration::Configuration,
2633    id: i32,
2634) -> Result<crate::models::IkePolicy, Error<VpnIkePoliciesRetrieveError>> {
2635    let local_var_configuration = configuration;
2636
2637    let local_var_client = &local_var_configuration.client;
2638
2639    let local_var_uri_str = format!(
2640        "{}/api/vpn/ike-policies/{id}/",
2641        local_var_configuration.base_path,
2642        id = id
2643    );
2644    let mut local_var_req_builder =
2645        local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
2646
2647    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
2648        local_var_req_builder =
2649            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
2650    }
2651    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
2652        let local_var_key = local_var_apikey.key.clone();
2653        let local_var_value = match local_var_apikey.prefix {
2654            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
2655            None => local_var_key,
2656        };
2657        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
2658    };
2659
2660    let local_var_req = local_var_req_builder.build()?;
2661    let local_var_resp = local_var_client.execute(local_var_req).await?;
2662
2663    let local_var_status = local_var_resp.status();
2664    let local_var_content = local_var_resp.text().await?;
2665
2666    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
2667        serde_json::from_str(&local_var_content).map_err(Error::from)
2668    } else {
2669        let local_var_entity: Option<VpnIkePoliciesRetrieveError> =
2670            serde_json::from_str(&local_var_content).ok();
2671        let local_var_error = ResponseContent {
2672            status: local_var_status,
2673            content: local_var_content,
2674            entity: local_var_entity,
2675        };
2676        Err(Error::ResponseError(local_var_error))
2677    }
2678}
2679
2680/// Put a IKE policy object.
2681pub async fn vpn_ike_policies_update(
2682    configuration: &configuration::Configuration,
2683    id: i32,
2684    writable_ike_policy_request: crate::models::WritableIkePolicyRequest,
2685) -> Result<crate::models::IkePolicy, Error<VpnIkePoliciesUpdateError>> {
2686    let local_var_configuration = configuration;
2687
2688    let local_var_client = &local_var_configuration.client;
2689
2690    let local_var_uri_str = format!(
2691        "{}/api/vpn/ike-policies/{id}/",
2692        local_var_configuration.base_path,
2693        id = id
2694    );
2695    let mut local_var_req_builder =
2696        local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());
2697
2698    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
2699        local_var_req_builder =
2700            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
2701    }
2702    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
2703        let local_var_key = local_var_apikey.key.clone();
2704        let local_var_value = match local_var_apikey.prefix {
2705            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
2706            None => local_var_key,
2707        };
2708        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
2709    };
2710    local_var_req_builder = local_var_req_builder.json(&writable_ike_policy_request);
2711
2712    let local_var_req = local_var_req_builder.build()?;
2713    let local_var_resp = local_var_client.execute(local_var_req).await?;
2714
2715    let local_var_status = local_var_resp.status();
2716    let local_var_content = local_var_resp.text().await?;
2717
2718    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
2719        serde_json::from_str(&local_var_content).map_err(Error::from)
2720    } else {
2721        let local_var_entity: Option<VpnIkePoliciesUpdateError> =
2722            serde_json::from_str(&local_var_content).ok();
2723        let local_var_error = ResponseContent {
2724            status: local_var_status,
2725            content: local_var_content,
2726            entity: local_var_entity,
2727        };
2728        Err(Error::ResponseError(local_var_error))
2729    }
2730}
2731
2732/// Delete a list of IKE proposal objects.
2733pub async fn vpn_ike_proposals_bulk_destroy(
2734    configuration: &configuration::Configuration,
2735    ike_proposal_request: Vec<crate::models::IkeProposalRequest>,
2736) -> Result<(), Error<VpnIkeProposalsBulkDestroyError>> {
2737    let local_var_configuration = configuration;
2738
2739    let local_var_client = &local_var_configuration.client;
2740
2741    let local_var_uri_str = format!(
2742        "{}/api/vpn/ike-proposals/",
2743        local_var_configuration.base_path
2744    );
2745    let mut local_var_req_builder =
2746        local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());
2747
2748    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
2749        local_var_req_builder =
2750            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
2751    }
2752    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
2753        let local_var_key = local_var_apikey.key.clone();
2754        let local_var_value = match local_var_apikey.prefix {
2755            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
2756            None => local_var_key,
2757        };
2758        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
2759    };
2760    local_var_req_builder = local_var_req_builder.json(&ike_proposal_request);
2761
2762    let local_var_req = local_var_req_builder.build()?;
2763    let local_var_resp = local_var_client.execute(local_var_req).await?;
2764
2765    let local_var_status = local_var_resp.status();
2766    let local_var_content = local_var_resp.text().await?;
2767
2768    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
2769        Ok(())
2770    } else {
2771        let local_var_entity: Option<VpnIkeProposalsBulkDestroyError> =
2772            serde_json::from_str(&local_var_content).ok();
2773        let local_var_error = ResponseContent {
2774            status: local_var_status,
2775            content: local_var_content,
2776            entity: local_var_entity,
2777        };
2778        Err(Error::ResponseError(local_var_error))
2779    }
2780}
2781
2782/// Patch a list of IKE proposal objects.
2783pub async fn vpn_ike_proposals_bulk_partial_update(
2784    configuration: &configuration::Configuration,
2785    ike_proposal_request: Vec<crate::models::IkeProposalRequest>,
2786) -> Result<Vec<crate::models::IkeProposal>, Error<VpnIkeProposalsBulkPartialUpdateError>> {
2787    let local_var_configuration = configuration;
2788
2789    let local_var_client = &local_var_configuration.client;
2790
2791    let local_var_uri_str = format!(
2792        "{}/api/vpn/ike-proposals/",
2793        local_var_configuration.base_path
2794    );
2795    let mut local_var_req_builder =
2796        local_var_client.request(reqwest::Method::PATCH, local_var_uri_str.as_str());
2797
2798    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
2799        local_var_req_builder =
2800            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
2801    }
2802    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
2803        let local_var_key = local_var_apikey.key.clone();
2804        let local_var_value = match local_var_apikey.prefix {
2805            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
2806            None => local_var_key,
2807        };
2808        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
2809    };
2810    local_var_req_builder = local_var_req_builder.json(&ike_proposal_request);
2811
2812    let local_var_req = local_var_req_builder.build()?;
2813    let local_var_resp = local_var_client.execute(local_var_req).await?;
2814
2815    let local_var_status = local_var_resp.status();
2816    let local_var_content = local_var_resp.text().await?;
2817
2818    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
2819        serde_json::from_str(&local_var_content).map_err(Error::from)
2820    } else {
2821        let local_var_entity: Option<VpnIkeProposalsBulkPartialUpdateError> =
2822            serde_json::from_str(&local_var_content).ok();
2823        let local_var_error = ResponseContent {
2824            status: local_var_status,
2825            content: local_var_content,
2826            entity: local_var_entity,
2827        };
2828        Err(Error::ResponseError(local_var_error))
2829    }
2830}
2831
2832/// Put a list of IKE proposal objects.
2833pub async fn vpn_ike_proposals_bulk_update(
2834    configuration: &configuration::Configuration,
2835    ike_proposal_request: Vec<crate::models::IkeProposalRequest>,
2836) -> Result<Vec<crate::models::IkeProposal>, Error<VpnIkeProposalsBulkUpdateError>> {
2837    let local_var_configuration = configuration;
2838
2839    let local_var_client = &local_var_configuration.client;
2840
2841    let local_var_uri_str = format!(
2842        "{}/api/vpn/ike-proposals/",
2843        local_var_configuration.base_path
2844    );
2845    let mut local_var_req_builder =
2846        local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());
2847
2848    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
2849        local_var_req_builder =
2850            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
2851    }
2852    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
2853        let local_var_key = local_var_apikey.key.clone();
2854        let local_var_value = match local_var_apikey.prefix {
2855            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
2856            None => local_var_key,
2857        };
2858        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
2859    };
2860    local_var_req_builder = local_var_req_builder.json(&ike_proposal_request);
2861
2862    let local_var_req = local_var_req_builder.build()?;
2863    let local_var_resp = local_var_client.execute(local_var_req).await?;
2864
2865    let local_var_status = local_var_resp.status();
2866    let local_var_content = local_var_resp.text().await?;
2867
2868    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
2869        serde_json::from_str(&local_var_content).map_err(Error::from)
2870    } else {
2871        let local_var_entity: Option<VpnIkeProposalsBulkUpdateError> =
2872            serde_json::from_str(&local_var_content).ok();
2873        let local_var_error = ResponseContent {
2874            status: local_var_status,
2875            content: local_var_content,
2876            entity: local_var_entity,
2877        };
2878        Err(Error::ResponseError(local_var_error))
2879    }
2880}
2881
2882/// Post a list of IKE proposal objects.
2883pub async fn vpn_ike_proposals_create(
2884    configuration: &configuration::Configuration,
2885    writable_ike_proposal_request: crate::models::WritableIkeProposalRequest,
2886) -> Result<crate::models::IkeProposal, Error<VpnIkeProposalsCreateError>> {
2887    let local_var_configuration = configuration;
2888
2889    let local_var_client = &local_var_configuration.client;
2890
2891    let local_var_uri_str = format!(
2892        "{}/api/vpn/ike-proposals/",
2893        local_var_configuration.base_path
2894    );
2895    let mut local_var_req_builder =
2896        local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
2897
2898    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
2899        local_var_req_builder =
2900            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
2901    }
2902    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
2903        let local_var_key = local_var_apikey.key.clone();
2904        let local_var_value = match local_var_apikey.prefix {
2905            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
2906            None => local_var_key,
2907        };
2908        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
2909    };
2910    local_var_req_builder = local_var_req_builder.json(&writable_ike_proposal_request);
2911
2912    let local_var_req = local_var_req_builder.build()?;
2913    let local_var_resp = local_var_client.execute(local_var_req).await?;
2914
2915    let local_var_status = local_var_resp.status();
2916    let local_var_content = local_var_resp.text().await?;
2917
2918    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
2919        serde_json::from_str(&local_var_content).map_err(Error::from)
2920    } else {
2921        let local_var_entity: Option<VpnIkeProposalsCreateError> =
2922            serde_json::from_str(&local_var_content).ok();
2923        let local_var_error = ResponseContent {
2924            status: local_var_status,
2925            content: local_var_content,
2926            entity: local_var_entity,
2927        };
2928        Err(Error::ResponseError(local_var_error))
2929    }
2930}
2931
2932/// Delete a IKE proposal object.
2933pub async fn vpn_ike_proposals_destroy(
2934    configuration: &configuration::Configuration,
2935    id: i32,
2936) -> Result<(), Error<VpnIkeProposalsDestroyError>> {
2937    let local_var_configuration = configuration;
2938
2939    let local_var_client = &local_var_configuration.client;
2940
2941    let local_var_uri_str = format!(
2942        "{}/api/vpn/ike-proposals/{id}/",
2943        local_var_configuration.base_path,
2944        id = id
2945    );
2946    let mut local_var_req_builder =
2947        local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());
2948
2949    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
2950        local_var_req_builder =
2951            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
2952    }
2953    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
2954        let local_var_key = local_var_apikey.key.clone();
2955        let local_var_value = match local_var_apikey.prefix {
2956            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
2957            None => local_var_key,
2958        };
2959        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
2960    };
2961
2962    let local_var_req = local_var_req_builder.build()?;
2963    let local_var_resp = local_var_client.execute(local_var_req).await?;
2964
2965    let local_var_status = local_var_resp.status();
2966    let local_var_content = local_var_resp.text().await?;
2967
2968    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
2969        Ok(())
2970    } else {
2971        let local_var_entity: Option<VpnIkeProposalsDestroyError> =
2972            serde_json::from_str(&local_var_content).ok();
2973        let local_var_error = ResponseContent {
2974            status: local_var_status,
2975            content: local_var_content,
2976            entity: local_var_entity,
2977        };
2978        Err(Error::ResponseError(local_var_error))
2979    }
2980}
2981
2982/// Get a list of IKE proposal objects.
2983pub async fn vpn_ike_proposals_list(
2984    configuration: &configuration::Configuration,
2985    authentication_algorithm: Option<Vec<String>>,
2986    authentication_algorithm__empty: Option<bool>,
2987    authentication_algorithm__ic: Option<Vec<String>>,
2988    authentication_algorithm__ie: Option<Vec<String>>,
2989    authentication_algorithm__iew: Option<Vec<String>>,
2990    authentication_algorithm__iregex: Option<Vec<String>>,
2991    authentication_algorithm__isw: Option<Vec<String>>,
2992    authentication_algorithm__n: Option<Vec<String>>,
2993    authentication_algorithm__nic: Option<Vec<String>>,
2994    authentication_algorithm__nie: Option<Vec<String>>,
2995    authentication_algorithm__niew: Option<Vec<String>>,
2996    authentication_algorithm__nisw: Option<Vec<String>>,
2997    authentication_algorithm__regex: Option<Vec<String>>,
2998    authentication_method: Option<Vec<String>>,
2999    authentication_method__empty: Option<bool>,
3000    authentication_method__ic: Option<Vec<String>>,
3001    authentication_method__ie: Option<Vec<String>>,
3002    authentication_method__iew: Option<Vec<String>>,
3003    authentication_method__iregex: Option<Vec<String>>,
3004    authentication_method__isw: Option<Vec<String>>,
3005    authentication_method__n: Option<Vec<String>>,
3006    authentication_method__nic: Option<Vec<String>>,
3007    authentication_method__nie: Option<Vec<String>>,
3008    authentication_method__niew: Option<Vec<String>>,
3009    authentication_method__nisw: Option<Vec<String>>,
3010    authentication_method__regex: Option<Vec<String>>,
3011    created: Option<Vec<String>>,
3012    created__empty: Option<Vec<String>>,
3013    created__gt: Option<Vec<String>>,
3014    created__gte: Option<Vec<String>>,
3015    created__lt: Option<Vec<String>>,
3016    created__lte: Option<Vec<String>>,
3017    created__n: Option<Vec<String>>,
3018    created_by_request: Option<&str>,
3019    description: Option<Vec<String>>,
3020    description__empty: Option<bool>,
3021    description__ic: Option<Vec<String>>,
3022    description__ie: Option<Vec<String>>,
3023    description__iew: Option<Vec<String>>,
3024    description__iregex: Option<Vec<String>>,
3025    description__isw: Option<Vec<String>>,
3026    description__n: Option<Vec<String>>,
3027    description__nic: Option<Vec<String>>,
3028    description__nie: Option<Vec<String>>,
3029    description__niew: Option<Vec<String>>,
3030    description__nisw: Option<Vec<String>>,
3031    description__regex: Option<Vec<String>>,
3032    encryption_algorithm: Option<Vec<String>>,
3033    encryption_algorithm__empty: Option<bool>,
3034    encryption_algorithm__ic: Option<Vec<String>>,
3035    encryption_algorithm__ie: Option<Vec<String>>,
3036    encryption_algorithm__iew: Option<Vec<String>>,
3037    encryption_algorithm__iregex: Option<Vec<String>>,
3038    encryption_algorithm__isw: Option<Vec<String>>,
3039    encryption_algorithm__n: Option<Vec<String>>,
3040    encryption_algorithm__nic: Option<Vec<String>>,
3041    encryption_algorithm__nie: Option<Vec<String>>,
3042    encryption_algorithm__niew: Option<Vec<String>>,
3043    encryption_algorithm__nisw: Option<Vec<String>>,
3044    encryption_algorithm__regex: Option<Vec<String>>,
3045    group: Option<Vec<i32>>,
3046    group__ic: Option<Vec<i32>>,
3047    group__ie: Option<Vec<i32>>,
3048    group__iew: Option<Vec<i32>>,
3049    group__iregex: Option<Vec<i32>>,
3050    group__isw: Option<Vec<i32>>,
3051    group__n: Option<Vec<i32>>,
3052    group__nic: Option<Vec<i32>>,
3053    group__nie: Option<Vec<i32>>,
3054    group__niew: Option<Vec<i32>>,
3055    group__nisw: Option<Vec<i32>>,
3056    group__regex: Option<Vec<i32>>,
3057    id: Option<Vec<i32>>,
3058    id__empty: Option<bool>,
3059    id__gt: Option<Vec<i32>>,
3060    id__gte: Option<Vec<i32>>,
3061    id__lt: Option<Vec<i32>>,
3062    id__lte: Option<Vec<i32>>,
3063    id__n: Option<Vec<i32>>,
3064    ike_policy: Option<Vec<String>>,
3065    ike_policy__n: Option<Vec<String>>,
3066    ike_policy_id: Option<Vec<i32>>,
3067    ike_policy_id__n: Option<Vec<i32>>,
3068    last_updated: Option<Vec<String>>,
3069    last_updated__empty: Option<Vec<String>>,
3070    last_updated__gt: Option<Vec<String>>,
3071    last_updated__gte: Option<Vec<String>>,
3072    last_updated__lt: Option<Vec<String>>,
3073    last_updated__lte: Option<Vec<String>>,
3074    last_updated__n: Option<Vec<String>>,
3075    limit: Option<i32>,
3076    modified_by_request: Option<&str>,
3077    name: Option<Vec<String>>,
3078    name__empty: Option<bool>,
3079    name__ic: Option<Vec<String>>,
3080    name__ie: Option<Vec<String>>,
3081    name__iew: Option<Vec<String>>,
3082    name__iregex: Option<Vec<String>>,
3083    name__isw: Option<Vec<String>>,
3084    name__n: Option<Vec<String>>,
3085    name__nic: Option<Vec<String>>,
3086    name__nie: Option<Vec<String>>,
3087    name__niew: Option<Vec<String>>,
3088    name__nisw: Option<Vec<String>>,
3089    name__regex: Option<Vec<String>>,
3090    offset: Option<i32>,
3091    ordering: Option<&str>,
3092    q: Option<&str>,
3093    sa_lifetime: Option<Vec<i32>>,
3094    sa_lifetime__empty: Option<bool>,
3095    sa_lifetime__gt: Option<Vec<i32>>,
3096    sa_lifetime__gte: Option<Vec<i32>>,
3097    sa_lifetime__lt: Option<Vec<i32>>,
3098    sa_lifetime__lte: Option<Vec<i32>>,
3099    sa_lifetime__n: Option<Vec<i32>>,
3100    tag: Option<Vec<String>>,
3101    tag__n: Option<Vec<String>>,
3102    tag_id: Option<Vec<i32>>,
3103    tag_id__n: Option<Vec<i32>>,
3104    updated_by_request: Option<&str>,
3105) -> Result<crate::models::PaginatedIkeProposalList, Error<VpnIkeProposalsListError>> {
3106    let local_var_configuration = configuration;
3107
3108    let local_var_client = &local_var_configuration.client;
3109
3110    let local_var_uri_str = format!(
3111        "{}/api/vpn/ike-proposals/",
3112        local_var_configuration.base_path
3113    );
3114    let mut local_var_req_builder =
3115        local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
3116
3117    if let Some(ref local_var_str) = authentication_algorithm {
3118        local_var_req_builder = match "multi" {
3119            "multi" => local_var_req_builder.query(
3120                &local_var_str
3121                    .into_iter()
3122                    .map(|p| ("authentication_algorithm".to_owned(), p.to_string()))
3123                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3124            ),
3125            _ => local_var_req_builder.query(&[(
3126                "authentication_algorithm",
3127                &local_var_str
3128                    .into_iter()
3129                    .map(|p| p.to_string())
3130                    .collect::<Vec<String>>()
3131                    .join(",")
3132                    .to_string(),
3133            )]),
3134        };
3135    }
3136    if let Some(ref local_var_str) = authentication_algorithm__empty {
3137        local_var_req_builder = local_var_req_builder.query(&[(
3138            "authentication_algorithm__empty",
3139            &local_var_str.to_string(),
3140        )]);
3141    }
3142    if let Some(ref local_var_str) = authentication_algorithm__ic {
3143        local_var_req_builder = match "multi" {
3144            "multi" => local_var_req_builder.query(
3145                &local_var_str
3146                    .into_iter()
3147                    .map(|p| ("authentication_algorithm__ic".to_owned(), p.to_string()))
3148                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3149            ),
3150            _ => local_var_req_builder.query(&[(
3151                "authentication_algorithm__ic",
3152                &local_var_str
3153                    .into_iter()
3154                    .map(|p| p.to_string())
3155                    .collect::<Vec<String>>()
3156                    .join(",")
3157                    .to_string(),
3158            )]),
3159        };
3160    }
3161    if let Some(ref local_var_str) = authentication_algorithm__ie {
3162        local_var_req_builder = match "multi" {
3163            "multi" => local_var_req_builder.query(
3164                &local_var_str
3165                    .into_iter()
3166                    .map(|p| ("authentication_algorithm__ie".to_owned(), p.to_string()))
3167                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3168            ),
3169            _ => local_var_req_builder.query(&[(
3170                "authentication_algorithm__ie",
3171                &local_var_str
3172                    .into_iter()
3173                    .map(|p| p.to_string())
3174                    .collect::<Vec<String>>()
3175                    .join(",")
3176                    .to_string(),
3177            )]),
3178        };
3179    }
3180    if let Some(ref local_var_str) = authentication_algorithm__iew {
3181        local_var_req_builder = match "multi" {
3182            "multi" => local_var_req_builder.query(
3183                &local_var_str
3184                    .into_iter()
3185                    .map(|p| ("authentication_algorithm__iew".to_owned(), p.to_string()))
3186                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3187            ),
3188            _ => local_var_req_builder.query(&[(
3189                "authentication_algorithm__iew",
3190                &local_var_str
3191                    .into_iter()
3192                    .map(|p| p.to_string())
3193                    .collect::<Vec<String>>()
3194                    .join(",")
3195                    .to_string(),
3196            )]),
3197        };
3198    }
3199    if let Some(ref local_var_str) = authentication_algorithm__iregex {
3200        local_var_req_builder = match "multi" {
3201            "multi" => local_var_req_builder.query(
3202                &local_var_str
3203                    .into_iter()
3204                    .map(|p| ("authentication_algorithm__iregex".to_owned(), p.to_string()))
3205                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3206            ),
3207            _ => local_var_req_builder.query(&[(
3208                "authentication_algorithm__iregex",
3209                &local_var_str
3210                    .into_iter()
3211                    .map(|p| p.to_string())
3212                    .collect::<Vec<String>>()
3213                    .join(",")
3214                    .to_string(),
3215            )]),
3216        };
3217    }
3218    if let Some(ref local_var_str) = authentication_algorithm__isw {
3219        local_var_req_builder = match "multi" {
3220            "multi" => local_var_req_builder.query(
3221                &local_var_str
3222                    .into_iter()
3223                    .map(|p| ("authentication_algorithm__isw".to_owned(), p.to_string()))
3224                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3225            ),
3226            _ => local_var_req_builder.query(&[(
3227                "authentication_algorithm__isw",
3228                &local_var_str
3229                    .into_iter()
3230                    .map(|p| p.to_string())
3231                    .collect::<Vec<String>>()
3232                    .join(",")
3233                    .to_string(),
3234            )]),
3235        };
3236    }
3237    if let Some(ref local_var_str) = authentication_algorithm__n {
3238        local_var_req_builder = match "multi" {
3239            "multi" => local_var_req_builder.query(
3240                &local_var_str
3241                    .into_iter()
3242                    .map(|p| ("authentication_algorithm__n".to_owned(), p.to_string()))
3243                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3244            ),
3245            _ => local_var_req_builder.query(&[(
3246                "authentication_algorithm__n",
3247                &local_var_str
3248                    .into_iter()
3249                    .map(|p| p.to_string())
3250                    .collect::<Vec<String>>()
3251                    .join(",")
3252                    .to_string(),
3253            )]),
3254        };
3255    }
3256    if let Some(ref local_var_str) = authentication_algorithm__nic {
3257        local_var_req_builder = match "multi" {
3258            "multi" => local_var_req_builder.query(
3259                &local_var_str
3260                    .into_iter()
3261                    .map(|p| ("authentication_algorithm__nic".to_owned(), p.to_string()))
3262                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3263            ),
3264            _ => local_var_req_builder.query(&[(
3265                "authentication_algorithm__nic",
3266                &local_var_str
3267                    .into_iter()
3268                    .map(|p| p.to_string())
3269                    .collect::<Vec<String>>()
3270                    .join(",")
3271                    .to_string(),
3272            )]),
3273        };
3274    }
3275    if let Some(ref local_var_str) = authentication_algorithm__nie {
3276        local_var_req_builder = match "multi" {
3277            "multi" => local_var_req_builder.query(
3278                &local_var_str
3279                    .into_iter()
3280                    .map(|p| ("authentication_algorithm__nie".to_owned(), p.to_string()))
3281                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3282            ),
3283            _ => local_var_req_builder.query(&[(
3284                "authentication_algorithm__nie",
3285                &local_var_str
3286                    .into_iter()
3287                    .map(|p| p.to_string())
3288                    .collect::<Vec<String>>()
3289                    .join(",")
3290                    .to_string(),
3291            )]),
3292        };
3293    }
3294    if let Some(ref local_var_str) = authentication_algorithm__niew {
3295        local_var_req_builder = match "multi" {
3296            "multi" => local_var_req_builder.query(
3297                &local_var_str
3298                    .into_iter()
3299                    .map(|p| ("authentication_algorithm__niew".to_owned(), p.to_string()))
3300                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3301            ),
3302            _ => local_var_req_builder.query(&[(
3303                "authentication_algorithm__niew",
3304                &local_var_str
3305                    .into_iter()
3306                    .map(|p| p.to_string())
3307                    .collect::<Vec<String>>()
3308                    .join(",")
3309                    .to_string(),
3310            )]),
3311        };
3312    }
3313    if let Some(ref local_var_str) = authentication_algorithm__nisw {
3314        local_var_req_builder = match "multi" {
3315            "multi" => local_var_req_builder.query(
3316                &local_var_str
3317                    .into_iter()
3318                    .map(|p| ("authentication_algorithm__nisw".to_owned(), p.to_string()))
3319                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3320            ),
3321            _ => local_var_req_builder.query(&[(
3322                "authentication_algorithm__nisw",
3323                &local_var_str
3324                    .into_iter()
3325                    .map(|p| p.to_string())
3326                    .collect::<Vec<String>>()
3327                    .join(",")
3328                    .to_string(),
3329            )]),
3330        };
3331    }
3332    if let Some(ref local_var_str) = authentication_algorithm__regex {
3333        local_var_req_builder = match "multi" {
3334            "multi" => local_var_req_builder.query(
3335                &local_var_str
3336                    .into_iter()
3337                    .map(|p| ("authentication_algorithm__regex".to_owned(), p.to_string()))
3338                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3339            ),
3340            _ => local_var_req_builder.query(&[(
3341                "authentication_algorithm__regex",
3342                &local_var_str
3343                    .into_iter()
3344                    .map(|p| p.to_string())
3345                    .collect::<Vec<String>>()
3346                    .join(",")
3347                    .to_string(),
3348            )]),
3349        };
3350    }
3351    if let Some(ref local_var_str) = authentication_method {
3352        local_var_req_builder = match "multi" {
3353            "multi" => local_var_req_builder.query(
3354                &local_var_str
3355                    .into_iter()
3356                    .map(|p| ("authentication_method".to_owned(), p.to_string()))
3357                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3358            ),
3359            _ => local_var_req_builder.query(&[(
3360                "authentication_method",
3361                &local_var_str
3362                    .into_iter()
3363                    .map(|p| p.to_string())
3364                    .collect::<Vec<String>>()
3365                    .join(",")
3366                    .to_string(),
3367            )]),
3368        };
3369    }
3370    if let Some(ref local_var_str) = authentication_method__empty {
3371        local_var_req_builder = local_var_req_builder
3372            .query(&[("authentication_method__empty", &local_var_str.to_string())]);
3373    }
3374    if let Some(ref local_var_str) = authentication_method__ic {
3375        local_var_req_builder = match "multi" {
3376            "multi" => local_var_req_builder.query(
3377                &local_var_str
3378                    .into_iter()
3379                    .map(|p| ("authentication_method__ic".to_owned(), p.to_string()))
3380                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3381            ),
3382            _ => local_var_req_builder.query(&[(
3383                "authentication_method__ic",
3384                &local_var_str
3385                    .into_iter()
3386                    .map(|p| p.to_string())
3387                    .collect::<Vec<String>>()
3388                    .join(",")
3389                    .to_string(),
3390            )]),
3391        };
3392    }
3393    if let Some(ref local_var_str) = authentication_method__ie {
3394        local_var_req_builder = match "multi" {
3395            "multi" => local_var_req_builder.query(
3396                &local_var_str
3397                    .into_iter()
3398                    .map(|p| ("authentication_method__ie".to_owned(), p.to_string()))
3399                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3400            ),
3401            _ => local_var_req_builder.query(&[(
3402                "authentication_method__ie",
3403                &local_var_str
3404                    .into_iter()
3405                    .map(|p| p.to_string())
3406                    .collect::<Vec<String>>()
3407                    .join(",")
3408                    .to_string(),
3409            )]),
3410        };
3411    }
3412    if let Some(ref local_var_str) = authentication_method__iew {
3413        local_var_req_builder = match "multi" {
3414            "multi" => local_var_req_builder.query(
3415                &local_var_str
3416                    .into_iter()
3417                    .map(|p| ("authentication_method__iew".to_owned(), p.to_string()))
3418                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3419            ),
3420            _ => local_var_req_builder.query(&[(
3421                "authentication_method__iew",
3422                &local_var_str
3423                    .into_iter()
3424                    .map(|p| p.to_string())
3425                    .collect::<Vec<String>>()
3426                    .join(",")
3427                    .to_string(),
3428            )]),
3429        };
3430    }
3431    if let Some(ref local_var_str) = authentication_method__iregex {
3432        local_var_req_builder = match "multi" {
3433            "multi" => local_var_req_builder.query(
3434                &local_var_str
3435                    .into_iter()
3436                    .map(|p| ("authentication_method__iregex".to_owned(), p.to_string()))
3437                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3438            ),
3439            _ => local_var_req_builder.query(&[(
3440                "authentication_method__iregex",
3441                &local_var_str
3442                    .into_iter()
3443                    .map(|p| p.to_string())
3444                    .collect::<Vec<String>>()
3445                    .join(",")
3446                    .to_string(),
3447            )]),
3448        };
3449    }
3450    if let Some(ref local_var_str) = authentication_method__isw {
3451        local_var_req_builder = match "multi" {
3452            "multi" => local_var_req_builder.query(
3453                &local_var_str
3454                    .into_iter()
3455                    .map(|p| ("authentication_method__isw".to_owned(), p.to_string()))
3456                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3457            ),
3458            _ => local_var_req_builder.query(&[(
3459                "authentication_method__isw",
3460                &local_var_str
3461                    .into_iter()
3462                    .map(|p| p.to_string())
3463                    .collect::<Vec<String>>()
3464                    .join(",")
3465                    .to_string(),
3466            )]),
3467        };
3468    }
3469    if let Some(ref local_var_str) = authentication_method__n {
3470        local_var_req_builder = match "multi" {
3471            "multi" => local_var_req_builder.query(
3472                &local_var_str
3473                    .into_iter()
3474                    .map(|p| ("authentication_method__n".to_owned(), p.to_string()))
3475                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3476            ),
3477            _ => local_var_req_builder.query(&[(
3478                "authentication_method__n",
3479                &local_var_str
3480                    .into_iter()
3481                    .map(|p| p.to_string())
3482                    .collect::<Vec<String>>()
3483                    .join(",")
3484                    .to_string(),
3485            )]),
3486        };
3487    }
3488    if let Some(ref local_var_str) = authentication_method__nic {
3489        local_var_req_builder = match "multi" {
3490            "multi" => local_var_req_builder.query(
3491                &local_var_str
3492                    .into_iter()
3493                    .map(|p| ("authentication_method__nic".to_owned(), p.to_string()))
3494                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3495            ),
3496            _ => local_var_req_builder.query(&[(
3497                "authentication_method__nic",
3498                &local_var_str
3499                    .into_iter()
3500                    .map(|p| p.to_string())
3501                    .collect::<Vec<String>>()
3502                    .join(",")
3503                    .to_string(),
3504            )]),
3505        };
3506    }
3507    if let Some(ref local_var_str) = authentication_method__nie {
3508        local_var_req_builder = match "multi" {
3509            "multi" => local_var_req_builder.query(
3510                &local_var_str
3511                    .into_iter()
3512                    .map(|p| ("authentication_method__nie".to_owned(), p.to_string()))
3513                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3514            ),
3515            _ => local_var_req_builder.query(&[(
3516                "authentication_method__nie",
3517                &local_var_str
3518                    .into_iter()
3519                    .map(|p| p.to_string())
3520                    .collect::<Vec<String>>()
3521                    .join(",")
3522                    .to_string(),
3523            )]),
3524        };
3525    }
3526    if let Some(ref local_var_str) = authentication_method__niew {
3527        local_var_req_builder = match "multi" {
3528            "multi" => local_var_req_builder.query(
3529                &local_var_str
3530                    .into_iter()
3531                    .map(|p| ("authentication_method__niew".to_owned(), p.to_string()))
3532                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3533            ),
3534            _ => local_var_req_builder.query(&[(
3535                "authentication_method__niew",
3536                &local_var_str
3537                    .into_iter()
3538                    .map(|p| p.to_string())
3539                    .collect::<Vec<String>>()
3540                    .join(",")
3541                    .to_string(),
3542            )]),
3543        };
3544    }
3545    if let Some(ref local_var_str) = authentication_method__nisw {
3546        local_var_req_builder = match "multi" {
3547            "multi" => local_var_req_builder.query(
3548                &local_var_str
3549                    .into_iter()
3550                    .map(|p| ("authentication_method__nisw".to_owned(), p.to_string()))
3551                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3552            ),
3553            _ => local_var_req_builder.query(&[(
3554                "authentication_method__nisw",
3555                &local_var_str
3556                    .into_iter()
3557                    .map(|p| p.to_string())
3558                    .collect::<Vec<String>>()
3559                    .join(",")
3560                    .to_string(),
3561            )]),
3562        };
3563    }
3564    if let Some(ref local_var_str) = authentication_method__regex {
3565        local_var_req_builder = match "multi" {
3566            "multi" => local_var_req_builder.query(
3567                &local_var_str
3568                    .into_iter()
3569                    .map(|p| ("authentication_method__regex".to_owned(), p.to_string()))
3570                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3571            ),
3572            _ => local_var_req_builder.query(&[(
3573                "authentication_method__regex",
3574                &local_var_str
3575                    .into_iter()
3576                    .map(|p| p.to_string())
3577                    .collect::<Vec<String>>()
3578                    .join(",")
3579                    .to_string(),
3580            )]),
3581        };
3582    }
3583    if let Some(ref local_var_str) = created {
3584        local_var_req_builder = match "multi" {
3585            "multi" => local_var_req_builder.query(
3586                &local_var_str
3587                    .into_iter()
3588                    .map(|p| ("created".to_owned(), p.to_string()))
3589                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3590            ),
3591            _ => local_var_req_builder.query(&[(
3592                "created",
3593                &local_var_str
3594                    .into_iter()
3595                    .map(|p| p.to_string())
3596                    .collect::<Vec<String>>()
3597                    .join(",")
3598                    .to_string(),
3599            )]),
3600        };
3601    }
3602    if let Some(ref local_var_str) = created__empty {
3603        local_var_req_builder = match "multi" {
3604            "multi" => local_var_req_builder.query(
3605                &local_var_str
3606                    .into_iter()
3607                    .map(|p| ("created__empty".to_owned(), p.to_string()))
3608                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3609            ),
3610            _ => local_var_req_builder.query(&[(
3611                "created__empty",
3612                &local_var_str
3613                    .into_iter()
3614                    .map(|p| p.to_string())
3615                    .collect::<Vec<String>>()
3616                    .join(",")
3617                    .to_string(),
3618            )]),
3619        };
3620    }
3621    if let Some(ref local_var_str) = created__gt {
3622        local_var_req_builder = match "multi" {
3623            "multi" => local_var_req_builder.query(
3624                &local_var_str
3625                    .into_iter()
3626                    .map(|p| ("created__gt".to_owned(), p.to_string()))
3627                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3628            ),
3629            _ => local_var_req_builder.query(&[(
3630                "created__gt",
3631                &local_var_str
3632                    .into_iter()
3633                    .map(|p| p.to_string())
3634                    .collect::<Vec<String>>()
3635                    .join(",")
3636                    .to_string(),
3637            )]),
3638        };
3639    }
3640    if let Some(ref local_var_str) = created__gte {
3641        local_var_req_builder = match "multi" {
3642            "multi" => local_var_req_builder.query(
3643                &local_var_str
3644                    .into_iter()
3645                    .map(|p| ("created__gte".to_owned(), p.to_string()))
3646                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3647            ),
3648            _ => local_var_req_builder.query(&[(
3649                "created__gte",
3650                &local_var_str
3651                    .into_iter()
3652                    .map(|p| p.to_string())
3653                    .collect::<Vec<String>>()
3654                    .join(",")
3655                    .to_string(),
3656            )]),
3657        };
3658    }
3659    if let Some(ref local_var_str) = created__lt {
3660        local_var_req_builder = match "multi" {
3661            "multi" => local_var_req_builder.query(
3662                &local_var_str
3663                    .into_iter()
3664                    .map(|p| ("created__lt".to_owned(), p.to_string()))
3665                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3666            ),
3667            _ => local_var_req_builder.query(&[(
3668                "created__lt",
3669                &local_var_str
3670                    .into_iter()
3671                    .map(|p| p.to_string())
3672                    .collect::<Vec<String>>()
3673                    .join(",")
3674                    .to_string(),
3675            )]),
3676        };
3677    }
3678    if let Some(ref local_var_str) = created__lte {
3679        local_var_req_builder = match "multi" {
3680            "multi" => local_var_req_builder.query(
3681                &local_var_str
3682                    .into_iter()
3683                    .map(|p| ("created__lte".to_owned(), p.to_string()))
3684                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3685            ),
3686            _ => local_var_req_builder.query(&[(
3687                "created__lte",
3688                &local_var_str
3689                    .into_iter()
3690                    .map(|p| p.to_string())
3691                    .collect::<Vec<String>>()
3692                    .join(",")
3693                    .to_string(),
3694            )]),
3695        };
3696    }
3697    if let Some(ref local_var_str) = created__n {
3698        local_var_req_builder = match "multi" {
3699            "multi" => local_var_req_builder.query(
3700                &local_var_str
3701                    .into_iter()
3702                    .map(|p| ("created__n".to_owned(), p.to_string()))
3703                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3704            ),
3705            _ => local_var_req_builder.query(&[(
3706                "created__n",
3707                &local_var_str
3708                    .into_iter()
3709                    .map(|p| p.to_string())
3710                    .collect::<Vec<String>>()
3711                    .join(",")
3712                    .to_string(),
3713            )]),
3714        };
3715    }
3716    if let Some(ref local_var_str) = created_by_request {
3717        local_var_req_builder =
3718            local_var_req_builder.query(&[("created_by_request", &local_var_str.to_string())]);
3719    }
3720    if let Some(ref local_var_str) = description {
3721        local_var_req_builder = match "multi" {
3722            "multi" => local_var_req_builder.query(
3723                &local_var_str
3724                    .into_iter()
3725                    .map(|p| ("description".to_owned(), p.to_string()))
3726                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3727            ),
3728            _ => local_var_req_builder.query(&[(
3729                "description",
3730                &local_var_str
3731                    .into_iter()
3732                    .map(|p| p.to_string())
3733                    .collect::<Vec<String>>()
3734                    .join(",")
3735                    .to_string(),
3736            )]),
3737        };
3738    }
3739    if let Some(ref local_var_str) = description__empty {
3740        local_var_req_builder =
3741            local_var_req_builder.query(&[("description__empty", &local_var_str.to_string())]);
3742    }
3743    if let Some(ref local_var_str) = description__ic {
3744        local_var_req_builder = match "multi" {
3745            "multi" => local_var_req_builder.query(
3746                &local_var_str
3747                    .into_iter()
3748                    .map(|p| ("description__ic".to_owned(), p.to_string()))
3749                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3750            ),
3751            _ => local_var_req_builder.query(&[(
3752                "description__ic",
3753                &local_var_str
3754                    .into_iter()
3755                    .map(|p| p.to_string())
3756                    .collect::<Vec<String>>()
3757                    .join(",")
3758                    .to_string(),
3759            )]),
3760        };
3761    }
3762    if let Some(ref local_var_str) = description__ie {
3763        local_var_req_builder = match "multi" {
3764            "multi" => local_var_req_builder.query(
3765                &local_var_str
3766                    .into_iter()
3767                    .map(|p| ("description__ie".to_owned(), p.to_string()))
3768                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3769            ),
3770            _ => local_var_req_builder.query(&[(
3771                "description__ie",
3772                &local_var_str
3773                    .into_iter()
3774                    .map(|p| p.to_string())
3775                    .collect::<Vec<String>>()
3776                    .join(",")
3777                    .to_string(),
3778            )]),
3779        };
3780    }
3781    if let Some(ref local_var_str) = description__iew {
3782        local_var_req_builder = match "multi" {
3783            "multi" => local_var_req_builder.query(
3784                &local_var_str
3785                    .into_iter()
3786                    .map(|p| ("description__iew".to_owned(), p.to_string()))
3787                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3788            ),
3789            _ => local_var_req_builder.query(&[(
3790                "description__iew",
3791                &local_var_str
3792                    .into_iter()
3793                    .map(|p| p.to_string())
3794                    .collect::<Vec<String>>()
3795                    .join(",")
3796                    .to_string(),
3797            )]),
3798        };
3799    }
3800    if let Some(ref local_var_str) = description__iregex {
3801        local_var_req_builder = match "multi" {
3802            "multi" => local_var_req_builder.query(
3803                &local_var_str
3804                    .into_iter()
3805                    .map(|p| ("description__iregex".to_owned(), p.to_string()))
3806                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3807            ),
3808            _ => local_var_req_builder.query(&[(
3809                "description__iregex",
3810                &local_var_str
3811                    .into_iter()
3812                    .map(|p| p.to_string())
3813                    .collect::<Vec<String>>()
3814                    .join(",")
3815                    .to_string(),
3816            )]),
3817        };
3818    }
3819    if let Some(ref local_var_str) = description__isw {
3820        local_var_req_builder = match "multi" {
3821            "multi" => local_var_req_builder.query(
3822                &local_var_str
3823                    .into_iter()
3824                    .map(|p| ("description__isw".to_owned(), p.to_string()))
3825                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3826            ),
3827            _ => local_var_req_builder.query(&[(
3828                "description__isw",
3829                &local_var_str
3830                    .into_iter()
3831                    .map(|p| p.to_string())
3832                    .collect::<Vec<String>>()
3833                    .join(",")
3834                    .to_string(),
3835            )]),
3836        };
3837    }
3838    if let Some(ref local_var_str) = description__n {
3839        local_var_req_builder = match "multi" {
3840            "multi" => local_var_req_builder.query(
3841                &local_var_str
3842                    .into_iter()
3843                    .map(|p| ("description__n".to_owned(), p.to_string()))
3844                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3845            ),
3846            _ => local_var_req_builder.query(&[(
3847                "description__n",
3848                &local_var_str
3849                    .into_iter()
3850                    .map(|p| p.to_string())
3851                    .collect::<Vec<String>>()
3852                    .join(",")
3853                    .to_string(),
3854            )]),
3855        };
3856    }
3857    if let Some(ref local_var_str) = description__nic {
3858        local_var_req_builder = match "multi" {
3859            "multi" => local_var_req_builder.query(
3860                &local_var_str
3861                    .into_iter()
3862                    .map(|p| ("description__nic".to_owned(), p.to_string()))
3863                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3864            ),
3865            _ => local_var_req_builder.query(&[(
3866                "description__nic",
3867                &local_var_str
3868                    .into_iter()
3869                    .map(|p| p.to_string())
3870                    .collect::<Vec<String>>()
3871                    .join(",")
3872                    .to_string(),
3873            )]),
3874        };
3875    }
3876    if let Some(ref local_var_str) = description__nie {
3877        local_var_req_builder = match "multi" {
3878            "multi" => local_var_req_builder.query(
3879                &local_var_str
3880                    .into_iter()
3881                    .map(|p| ("description__nie".to_owned(), p.to_string()))
3882                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3883            ),
3884            _ => local_var_req_builder.query(&[(
3885                "description__nie",
3886                &local_var_str
3887                    .into_iter()
3888                    .map(|p| p.to_string())
3889                    .collect::<Vec<String>>()
3890                    .join(",")
3891                    .to_string(),
3892            )]),
3893        };
3894    }
3895    if let Some(ref local_var_str) = description__niew {
3896        local_var_req_builder = match "multi" {
3897            "multi" => local_var_req_builder.query(
3898                &local_var_str
3899                    .into_iter()
3900                    .map(|p| ("description__niew".to_owned(), p.to_string()))
3901                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3902            ),
3903            _ => local_var_req_builder.query(&[(
3904                "description__niew",
3905                &local_var_str
3906                    .into_iter()
3907                    .map(|p| p.to_string())
3908                    .collect::<Vec<String>>()
3909                    .join(",")
3910                    .to_string(),
3911            )]),
3912        };
3913    }
3914    if let Some(ref local_var_str) = description__nisw {
3915        local_var_req_builder = match "multi" {
3916            "multi" => local_var_req_builder.query(
3917                &local_var_str
3918                    .into_iter()
3919                    .map(|p| ("description__nisw".to_owned(), p.to_string()))
3920                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3921            ),
3922            _ => local_var_req_builder.query(&[(
3923                "description__nisw",
3924                &local_var_str
3925                    .into_iter()
3926                    .map(|p| p.to_string())
3927                    .collect::<Vec<String>>()
3928                    .join(",")
3929                    .to_string(),
3930            )]),
3931        };
3932    }
3933    if let Some(ref local_var_str) = description__regex {
3934        local_var_req_builder = match "multi" {
3935            "multi" => local_var_req_builder.query(
3936                &local_var_str
3937                    .into_iter()
3938                    .map(|p| ("description__regex".to_owned(), p.to_string()))
3939                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3940            ),
3941            _ => local_var_req_builder.query(&[(
3942                "description__regex",
3943                &local_var_str
3944                    .into_iter()
3945                    .map(|p| p.to_string())
3946                    .collect::<Vec<String>>()
3947                    .join(",")
3948                    .to_string(),
3949            )]),
3950        };
3951    }
3952    if let Some(ref local_var_str) = encryption_algorithm {
3953        local_var_req_builder = match "multi" {
3954            "multi" => local_var_req_builder.query(
3955                &local_var_str
3956                    .into_iter()
3957                    .map(|p| ("encryption_algorithm".to_owned(), p.to_string()))
3958                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3959            ),
3960            _ => local_var_req_builder.query(&[(
3961                "encryption_algorithm",
3962                &local_var_str
3963                    .into_iter()
3964                    .map(|p| p.to_string())
3965                    .collect::<Vec<String>>()
3966                    .join(",")
3967                    .to_string(),
3968            )]),
3969        };
3970    }
3971    if let Some(ref local_var_str) = encryption_algorithm__empty {
3972        local_var_req_builder = local_var_req_builder
3973            .query(&[("encryption_algorithm__empty", &local_var_str.to_string())]);
3974    }
3975    if let Some(ref local_var_str) = encryption_algorithm__ic {
3976        local_var_req_builder = match "multi" {
3977            "multi" => local_var_req_builder.query(
3978                &local_var_str
3979                    .into_iter()
3980                    .map(|p| ("encryption_algorithm__ic".to_owned(), p.to_string()))
3981                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3982            ),
3983            _ => local_var_req_builder.query(&[(
3984                "encryption_algorithm__ic",
3985                &local_var_str
3986                    .into_iter()
3987                    .map(|p| p.to_string())
3988                    .collect::<Vec<String>>()
3989                    .join(",")
3990                    .to_string(),
3991            )]),
3992        };
3993    }
3994    if let Some(ref local_var_str) = encryption_algorithm__ie {
3995        local_var_req_builder = match "multi" {
3996            "multi" => local_var_req_builder.query(
3997                &local_var_str
3998                    .into_iter()
3999                    .map(|p| ("encryption_algorithm__ie".to_owned(), p.to_string()))
4000                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4001            ),
4002            _ => local_var_req_builder.query(&[(
4003                "encryption_algorithm__ie",
4004                &local_var_str
4005                    .into_iter()
4006                    .map(|p| p.to_string())
4007                    .collect::<Vec<String>>()
4008                    .join(",")
4009                    .to_string(),
4010            )]),
4011        };
4012    }
4013    if let Some(ref local_var_str) = encryption_algorithm__iew {
4014        local_var_req_builder = match "multi" {
4015            "multi" => local_var_req_builder.query(
4016                &local_var_str
4017                    .into_iter()
4018                    .map(|p| ("encryption_algorithm__iew".to_owned(), p.to_string()))
4019                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4020            ),
4021            _ => local_var_req_builder.query(&[(
4022                "encryption_algorithm__iew",
4023                &local_var_str
4024                    .into_iter()
4025                    .map(|p| p.to_string())
4026                    .collect::<Vec<String>>()
4027                    .join(",")
4028                    .to_string(),
4029            )]),
4030        };
4031    }
4032    if let Some(ref local_var_str) = encryption_algorithm__iregex {
4033        local_var_req_builder = match "multi" {
4034            "multi" => local_var_req_builder.query(
4035                &local_var_str
4036                    .into_iter()
4037                    .map(|p| ("encryption_algorithm__iregex".to_owned(), p.to_string()))
4038                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4039            ),
4040            _ => local_var_req_builder.query(&[(
4041                "encryption_algorithm__iregex",
4042                &local_var_str
4043                    .into_iter()
4044                    .map(|p| p.to_string())
4045                    .collect::<Vec<String>>()
4046                    .join(",")
4047                    .to_string(),
4048            )]),
4049        };
4050    }
4051    if let Some(ref local_var_str) = encryption_algorithm__isw {
4052        local_var_req_builder = match "multi" {
4053            "multi" => local_var_req_builder.query(
4054                &local_var_str
4055                    .into_iter()
4056                    .map(|p| ("encryption_algorithm__isw".to_owned(), p.to_string()))
4057                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4058            ),
4059            _ => local_var_req_builder.query(&[(
4060                "encryption_algorithm__isw",
4061                &local_var_str
4062                    .into_iter()
4063                    .map(|p| p.to_string())
4064                    .collect::<Vec<String>>()
4065                    .join(",")
4066                    .to_string(),
4067            )]),
4068        };
4069    }
4070    if let Some(ref local_var_str) = encryption_algorithm__n {
4071        local_var_req_builder = match "multi" {
4072            "multi" => local_var_req_builder.query(
4073                &local_var_str
4074                    .into_iter()
4075                    .map(|p| ("encryption_algorithm__n".to_owned(), p.to_string()))
4076                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4077            ),
4078            _ => local_var_req_builder.query(&[(
4079                "encryption_algorithm__n",
4080                &local_var_str
4081                    .into_iter()
4082                    .map(|p| p.to_string())
4083                    .collect::<Vec<String>>()
4084                    .join(",")
4085                    .to_string(),
4086            )]),
4087        };
4088    }
4089    if let Some(ref local_var_str) = encryption_algorithm__nic {
4090        local_var_req_builder = match "multi" {
4091            "multi" => local_var_req_builder.query(
4092                &local_var_str
4093                    .into_iter()
4094                    .map(|p| ("encryption_algorithm__nic".to_owned(), p.to_string()))
4095                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4096            ),
4097            _ => local_var_req_builder.query(&[(
4098                "encryption_algorithm__nic",
4099                &local_var_str
4100                    .into_iter()
4101                    .map(|p| p.to_string())
4102                    .collect::<Vec<String>>()
4103                    .join(",")
4104                    .to_string(),
4105            )]),
4106        };
4107    }
4108    if let Some(ref local_var_str) = encryption_algorithm__nie {
4109        local_var_req_builder = match "multi" {
4110            "multi" => local_var_req_builder.query(
4111                &local_var_str
4112                    .into_iter()
4113                    .map(|p| ("encryption_algorithm__nie".to_owned(), p.to_string()))
4114                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4115            ),
4116            _ => local_var_req_builder.query(&[(
4117                "encryption_algorithm__nie",
4118                &local_var_str
4119                    .into_iter()
4120                    .map(|p| p.to_string())
4121                    .collect::<Vec<String>>()
4122                    .join(",")
4123                    .to_string(),
4124            )]),
4125        };
4126    }
4127    if let Some(ref local_var_str) = encryption_algorithm__niew {
4128        local_var_req_builder = match "multi" {
4129            "multi" => local_var_req_builder.query(
4130                &local_var_str
4131                    .into_iter()
4132                    .map(|p| ("encryption_algorithm__niew".to_owned(), p.to_string()))
4133                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4134            ),
4135            _ => local_var_req_builder.query(&[(
4136                "encryption_algorithm__niew",
4137                &local_var_str
4138                    .into_iter()
4139                    .map(|p| p.to_string())
4140                    .collect::<Vec<String>>()
4141                    .join(",")
4142                    .to_string(),
4143            )]),
4144        };
4145    }
4146    if let Some(ref local_var_str) = encryption_algorithm__nisw {
4147        local_var_req_builder = match "multi" {
4148            "multi" => local_var_req_builder.query(
4149                &local_var_str
4150                    .into_iter()
4151                    .map(|p| ("encryption_algorithm__nisw".to_owned(), p.to_string()))
4152                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4153            ),
4154            _ => local_var_req_builder.query(&[(
4155                "encryption_algorithm__nisw",
4156                &local_var_str
4157                    .into_iter()
4158                    .map(|p| p.to_string())
4159                    .collect::<Vec<String>>()
4160                    .join(",")
4161                    .to_string(),
4162            )]),
4163        };
4164    }
4165    if let Some(ref local_var_str) = encryption_algorithm__regex {
4166        local_var_req_builder = match "multi" {
4167            "multi" => local_var_req_builder.query(
4168                &local_var_str
4169                    .into_iter()
4170                    .map(|p| ("encryption_algorithm__regex".to_owned(), p.to_string()))
4171                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4172            ),
4173            _ => local_var_req_builder.query(&[(
4174                "encryption_algorithm__regex",
4175                &local_var_str
4176                    .into_iter()
4177                    .map(|p| p.to_string())
4178                    .collect::<Vec<String>>()
4179                    .join(",")
4180                    .to_string(),
4181            )]),
4182        };
4183    }
4184    if let Some(ref local_var_str) = group {
4185        local_var_req_builder = match "multi" {
4186            "multi" => local_var_req_builder.query(
4187                &local_var_str
4188                    .into_iter()
4189                    .map(|p| ("group".to_owned(), p.to_string()))
4190                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4191            ),
4192            _ => local_var_req_builder.query(&[(
4193                "group",
4194                &local_var_str
4195                    .into_iter()
4196                    .map(|p| p.to_string())
4197                    .collect::<Vec<String>>()
4198                    .join(",")
4199                    .to_string(),
4200            )]),
4201        };
4202    }
4203    if let Some(ref local_var_str) = group__ic {
4204        local_var_req_builder = match "multi" {
4205            "multi" => local_var_req_builder.query(
4206                &local_var_str
4207                    .into_iter()
4208                    .map(|p| ("group__ic".to_owned(), p.to_string()))
4209                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4210            ),
4211            _ => local_var_req_builder.query(&[(
4212                "group__ic",
4213                &local_var_str
4214                    .into_iter()
4215                    .map(|p| p.to_string())
4216                    .collect::<Vec<String>>()
4217                    .join(",")
4218                    .to_string(),
4219            )]),
4220        };
4221    }
4222    if let Some(ref local_var_str) = group__ie {
4223        local_var_req_builder = match "multi" {
4224            "multi" => local_var_req_builder.query(
4225                &local_var_str
4226                    .into_iter()
4227                    .map(|p| ("group__ie".to_owned(), p.to_string()))
4228                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4229            ),
4230            _ => local_var_req_builder.query(&[(
4231                "group__ie",
4232                &local_var_str
4233                    .into_iter()
4234                    .map(|p| p.to_string())
4235                    .collect::<Vec<String>>()
4236                    .join(",")
4237                    .to_string(),
4238            )]),
4239        };
4240    }
4241    if let Some(ref local_var_str) = group__iew {
4242        local_var_req_builder = match "multi" {
4243            "multi" => local_var_req_builder.query(
4244                &local_var_str
4245                    .into_iter()
4246                    .map(|p| ("group__iew".to_owned(), p.to_string()))
4247                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4248            ),
4249            _ => local_var_req_builder.query(&[(
4250                "group__iew",
4251                &local_var_str
4252                    .into_iter()
4253                    .map(|p| p.to_string())
4254                    .collect::<Vec<String>>()
4255                    .join(",")
4256                    .to_string(),
4257            )]),
4258        };
4259    }
4260    if let Some(ref local_var_str) = group__iregex {
4261        local_var_req_builder = match "multi" {
4262            "multi" => local_var_req_builder.query(
4263                &local_var_str
4264                    .into_iter()
4265                    .map(|p| ("group__iregex".to_owned(), p.to_string()))
4266                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4267            ),
4268            _ => local_var_req_builder.query(&[(
4269                "group__iregex",
4270                &local_var_str
4271                    .into_iter()
4272                    .map(|p| p.to_string())
4273                    .collect::<Vec<String>>()
4274                    .join(",")
4275                    .to_string(),
4276            )]),
4277        };
4278    }
4279    if let Some(ref local_var_str) = group__isw {
4280        local_var_req_builder = match "multi" {
4281            "multi" => local_var_req_builder.query(
4282                &local_var_str
4283                    .into_iter()
4284                    .map(|p| ("group__isw".to_owned(), p.to_string()))
4285                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4286            ),
4287            _ => local_var_req_builder.query(&[(
4288                "group__isw",
4289                &local_var_str
4290                    .into_iter()
4291                    .map(|p| p.to_string())
4292                    .collect::<Vec<String>>()
4293                    .join(",")
4294                    .to_string(),
4295            )]),
4296        };
4297    }
4298    if let Some(ref local_var_str) = group__n {
4299        local_var_req_builder = match "multi" {
4300            "multi" => local_var_req_builder.query(
4301                &local_var_str
4302                    .into_iter()
4303                    .map(|p| ("group__n".to_owned(), p.to_string()))
4304                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4305            ),
4306            _ => local_var_req_builder.query(&[(
4307                "group__n",
4308                &local_var_str
4309                    .into_iter()
4310                    .map(|p| p.to_string())
4311                    .collect::<Vec<String>>()
4312                    .join(",")
4313                    .to_string(),
4314            )]),
4315        };
4316    }
4317    if let Some(ref local_var_str) = group__nic {
4318        local_var_req_builder = match "multi" {
4319            "multi" => local_var_req_builder.query(
4320                &local_var_str
4321                    .into_iter()
4322                    .map(|p| ("group__nic".to_owned(), p.to_string()))
4323                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4324            ),
4325            _ => local_var_req_builder.query(&[(
4326                "group__nic",
4327                &local_var_str
4328                    .into_iter()
4329                    .map(|p| p.to_string())
4330                    .collect::<Vec<String>>()
4331                    .join(",")
4332                    .to_string(),
4333            )]),
4334        };
4335    }
4336    if let Some(ref local_var_str) = group__nie {
4337        local_var_req_builder = match "multi" {
4338            "multi" => local_var_req_builder.query(
4339                &local_var_str
4340                    .into_iter()
4341                    .map(|p| ("group__nie".to_owned(), p.to_string()))
4342                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4343            ),
4344            _ => local_var_req_builder.query(&[(
4345                "group__nie",
4346                &local_var_str
4347                    .into_iter()
4348                    .map(|p| p.to_string())
4349                    .collect::<Vec<String>>()
4350                    .join(",")
4351                    .to_string(),
4352            )]),
4353        };
4354    }
4355    if let Some(ref local_var_str) = group__niew {
4356        local_var_req_builder = match "multi" {
4357            "multi" => local_var_req_builder.query(
4358                &local_var_str
4359                    .into_iter()
4360                    .map(|p| ("group__niew".to_owned(), p.to_string()))
4361                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4362            ),
4363            _ => local_var_req_builder.query(&[(
4364                "group__niew",
4365                &local_var_str
4366                    .into_iter()
4367                    .map(|p| p.to_string())
4368                    .collect::<Vec<String>>()
4369                    .join(",")
4370                    .to_string(),
4371            )]),
4372        };
4373    }
4374    if let Some(ref local_var_str) = group__nisw {
4375        local_var_req_builder = match "multi" {
4376            "multi" => local_var_req_builder.query(
4377                &local_var_str
4378                    .into_iter()
4379                    .map(|p| ("group__nisw".to_owned(), p.to_string()))
4380                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4381            ),
4382            _ => local_var_req_builder.query(&[(
4383                "group__nisw",
4384                &local_var_str
4385                    .into_iter()
4386                    .map(|p| p.to_string())
4387                    .collect::<Vec<String>>()
4388                    .join(",")
4389                    .to_string(),
4390            )]),
4391        };
4392    }
4393    if let Some(ref local_var_str) = group__regex {
4394        local_var_req_builder = match "multi" {
4395            "multi" => local_var_req_builder.query(
4396                &local_var_str
4397                    .into_iter()
4398                    .map(|p| ("group__regex".to_owned(), p.to_string()))
4399                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4400            ),
4401            _ => local_var_req_builder.query(&[(
4402                "group__regex",
4403                &local_var_str
4404                    .into_iter()
4405                    .map(|p| p.to_string())
4406                    .collect::<Vec<String>>()
4407                    .join(",")
4408                    .to_string(),
4409            )]),
4410        };
4411    }
4412    if let Some(ref local_var_str) = id {
4413        local_var_req_builder = match "multi" {
4414            "multi" => local_var_req_builder.query(
4415                &local_var_str
4416                    .into_iter()
4417                    .map(|p| ("id".to_owned(), p.to_string()))
4418                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4419            ),
4420            _ => local_var_req_builder.query(&[(
4421                "id",
4422                &local_var_str
4423                    .into_iter()
4424                    .map(|p| p.to_string())
4425                    .collect::<Vec<String>>()
4426                    .join(",")
4427                    .to_string(),
4428            )]),
4429        };
4430    }
4431    if let Some(ref local_var_str) = id__empty {
4432        local_var_req_builder =
4433            local_var_req_builder.query(&[("id__empty", &local_var_str.to_string())]);
4434    }
4435    if let Some(ref local_var_str) = id__gt {
4436        local_var_req_builder = match "multi" {
4437            "multi" => local_var_req_builder.query(
4438                &local_var_str
4439                    .into_iter()
4440                    .map(|p| ("id__gt".to_owned(), p.to_string()))
4441                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4442            ),
4443            _ => local_var_req_builder.query(&[(
4444                "id__gt",
4445                &local_var_str
4446                    .into_iter()
4447                    .map(|p| p.to_string())
4448                    .collect::<Vec<String>>()
4449                    .join(",")
4450                    .to_string(),
4451            )]),
4452        };
4453    }
4454    if let Some(ref local_var_str) = id__gte {
4455        local_var_req_builder = match "multi" {
4456            "multi" => local_var_req_builder.query(
4457                &local_var_str
4458                    .into_iter()
4459                    .map(|p| ("id__gte".to_owned(), p.to_string()))
4460                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4461            ),
4462            _ => local_var_req_builder.query(&[(
4463                "id__gte",
4464                &local_var_str
4465                    .into_iter()
4466                    .map(|p| p.to_string())
4467                    .collect::<Vec<String>>()
4468                    .join(",")
4469                    .to_string(),
4470            )]),
4471        };
4472    }
4473    if let Some(ref local_var_str) = id__lt {
4474        local_var_req_builder = match "multi" {
4475            "multi" => local_var_req_builder.query(
4476                &local_var_str
4477                    .into_iter()
4478                    .map(|p| ("id__lt".to_owned(), p.to_string()))
4479                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4480            ),
4481            _ => local_var_req_builder.query(&[(
4482                "id__lt",
4483                &local_var_str
4484                    .into_iter()
4485                    .map(|p| p.to_string())
4486                    .collect::<Vec<String>>()
4487                    .join(",")
4488                    .to_string(),
4489            )]),
4490        };
4491    }
4492    if let Some(ref local_var_str) = id__lte {
4493        local_var_req_builder = match "multi" {
4494            "multi" => local_var_req_builder.query(
4495                &local_var_str
4496                    .into_iter()
4497                    .map(|p| ("id__lte".to_owned(), p.to_string()))
4498                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4499            ),
4500            _ => local_var_req_builder.query(&[(
4501                "id__lte",
4502                &local_var_str
4503                    .into_iter()
4504                    .map(|p| p.to_string())
4505                    .collect::<Vec<String>>()
4506                    .join(",")
4507                    .to_string(),
4508            )]),
4509        };
4510    }
4511    if let Some(ref local_var_str) = id__n {
4512        local_var_req_builder = match "multi" {
4513            "multi" => local_var_req_builder.query(
4514                &local_var_str
4515                    .into_iter()
4516                    .map(|p| ("id__n".to_owned(), p.to_string()))
4517                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4518            ),
4519            _ => local_var_req_builder.query(&[(
4520                "id__n",
4521                &local_var_str
4522                    .into_iter()
4523                    .map(|p| p.to_string())
4524                    .collect::<Vec<String>>()
4525                    .join(",")
4526                    .to_string(),
4527            )]),
4528        };
4529    }
4530    if let Some(ref local_var_str) = ike_policy {
4531        local_var_req_builder = match "multi" {
4532            "multi" => local_var_req_builder.query(
4533                &local_var_str
4534                    .into_iter()
4535                    .map(|p| ("ike_policy".to_owned(), p.to_string()))
4536                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4537            ),
4538            _ => local_var_req_builder.query(&[(
4539                "ike_policy",
4540                &local_var_str
4541                    .into_iter()
4542                    .map(|p| p.to_string())
4543                    .collect::<Vec<String>>()
4544                    .join(",")
4545                    .to_string(),
4546            )]),
4547        };
4548    }
4549    if let Some(ref local_var_str) = ike_policy__n {
4550        local_var_req_builder = match "multi" {
4551            "multi" => local_var_req_builder.query(
4552                &local_var_str
4553                    .into_iter()
4554                    .map(|p| ("ike_policy__n".to_owned(), p.to_string()))
4555                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4556            ),
4557            _ => local_var_req_builder.query(&[(
4558                "ike_policy__n",
4559                &local_var_str
4560                    .into_iter()
4561                    .map(|p| p.to_string())
4562                    .collect::<Vec<String>>()
4563                    .join(",")
4564                    .to_string(),
4565            )]),
4566        };
4567    }
4568    if let Some(ref local_var_str) = ike_policy_id {
4569        local_var_req_builder = match "multi" {
4570            "multi" => local_var_req_builder.query(
4571                &local_var_str
4572                    .into_iter()
4573                    .map(|p| ("ike_policy_id".to_owned(), p.to_string()))
4574                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4575            ),
4576            _ => local_var_req_builder.query(&[(
4577                "ike_policy_id",
4578                &local_var_str
4579                    .into_iter()
4580                    .map(|p| p.to_string())
4581                    .collect::<Vec<String>>()
4582                    .join(",")
4583                    .to_string(),
4584            )]),
4585        };
4586    }
4587    if let Some(ref local_var_str) = ike_policy_id__n {
4588        local_var_req_builder = match "multi" {
4589            "multi" => local_var_req_builder.query(
4590                &local_var_str
4591                    .into_iter()
4592                    .map(|p| ("ike_policy_id__n".to_owned(), p.to_string()))
4593                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4594            ),
4595            _ => local_var_req_builder.query(&[(
4596                "ike_policy_id__n",
4597                &local_var_str
4598                    .into_iter()
4599                    .map(|p| p.to_string())
4600                    .collect::<Vec<String>>()
4601                    .join(",")
4602                    .to_string(),
4603            )]),
4604        };
4605    }
4606    if let Some(ref local_var_str) = last_updated {
4607        local_var_req_builder = match "multi" {
4608            "multi" => local_var_req_builder.query(
4609                &local_var_str
4610                    .into_iter()
4611                    .map(|p| ("last_updated".to_owned(), p.to_string()))
4612                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4613            ),
4614            _ => local_var_req_builder.query(&[(
4615                "last_updated",
4616                &local_var_str
4617                    .into_iter()
4618                    .map(|p| p.to_string())
4619                    .collect::<Vec<String>>()
4620                    .join(",")
4621                    .to_string(),
4622            )]),
4623        };
4624    }
4625    if let Some(ref local_var_str) = last_updated__empty {
4626        local_var_req_builder = match "multi" {
4627            "multi" => local_var_req_builder.query(
4628                &local_var_str
4629                    .into_iter()
4630                    .map(|p| ("last_updated__empty".to_owned(), p.to_string()))
4631                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4632            ),
4633            _ => local_var_req_builder.query(&[(
4634                "last_updated__empty",
4635                &local_var_str
4636                    .into_iter()
4637                    .map(|p| p.to_string())
4638                    .collect::<Vec<String>>()
4639                    .join(",")
4640                    .to_string(),
4641            )]),
4642        };
4643    }
4644    if let Some(ref local_var_str) = last_updated__gt {
4645        local_var_req_builder = match "multi" {
4646            "multi" => local_var_req_builder.query(
4647                &local_var_str
4648                    .into_iter()
4649                    .map(|p| ("last_updated__gt".to_owned(), p.to_string()))
4650                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4651            ),
4652            _ => local_var_req_builder.query(&[(
4653                "last_updated__gt",
4654                &local_var_str
4655                    .into_iter()
4656                    .map(|p| p.to_string())
4657                    .collect::<Vec<String>>()
4658                    .join(",")
4659                    .to_string(),
4660            )]),
4661        };
4662    }
4663    if let Some(ref local_var_str) = last_updated__gte {
4664        local_var_req_builder = match "multi" {
4665            "multi" => local_var_req_builder.query(
4666                &local_var_str
4667                    .into_iter()
4668                    .map(|p| ("last_updated__gte".to_owned(), p.to_string()))
4669                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4670            ),
4671            _ => local_var_req_builder.query(&[(
4672                "last_updated__gte",
4673                &local_var_str
4674                    .into_iter()
4675                    .map(|p| p.to_string())
4676                    .collect::<Vec<String>>()
4677                    .join(",")
4678                    .to_string(),
4679            )]),
4680        };
4681    }
4682    if let Some(ref local_var_str) = last_updated__lt {
4683        local_var_req_builder = match "multi" {
4684            "multi" => local_var_req_builder.query(
4685                &local_var_str
4686                    .into_iter()
4687                    .map(|p| ("last_updated__lt".to_owned(), p.to_string()))
4688                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4689            ),
4690            _ => local_var_req_builder.query(&[(
4691                "last_updated__lt",
4692                &local_var_str
4693                    .into_iter()
4694                    .map(|p| p.to_string())
4695                    .collect::<Vec<String>>()
4696                    .join(",")
4697                    .to_string(),
4698            )]),
4699        };
4700    }
4701    if let Some(ref local_var_str) = last_updated__lte {
4702        local_var_req_builder = match "multi" {
4703            "multi" => local_var_req_builder.query(
4704                &local_var_str
4705                    .into_iter()
4706                    .map(|p| ("last_updated__lte".to_owned(), p.to_string()))
4707                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4708            ),
4709            _ => local_var_req_builder.query(&[(
4710                "last_updated__lte",
4711                &local_var_str
4712                    .into_iter()
4713                    .map(|p| p.to_string())
4714                    .collect::<Vec<String>>()
4715                    .join(",")
4716                    .to_string(),
4717            )]),
4718        };
4719    }
4720    if let Some(ref local_var_str) = last_updated__n {
4721        local_var_req_builder = match "multi" {
4722            "multi" => local_var_req_builder.query(
4723                &local_var_str
4724                    .into_iter()
4725                    .map(|p| ("last_updated__n".to_owned(), p.to_string()))
4726                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4727            ),
4728            _ => local_var_req_builder.query(&[(
4729                "last_updated__n",
4730                &local_var_str
4731                    .into_iter()
4732                    .map(|p| p.to_string())
4733                    .collect::<Vec<String>>()
4734                    .join(",")
4735                    .to_string(),
4736            )]),
4737        };
4738    }
4739    if let Some(ref local_var_str) = limit {
4740        local_var_req_builder =
4741            local_var_req_builder.query(&[("limit", &local_var_str.to_string())]);
4742    }
4743    if let Some(ref local_var_str) = modified_by_request {
4744        local_var_req_builder =
4745            local_var_req_builder.query(&[("modified_by_request", &local_var_str.to_string())]);
4746    }
4747    if let Some(ref local_var_str) = name {
4748        local_var_req_builder = match "multi" {
4749            "multi" => local_var_req_builder.query(
4750                &local_var_str
4751                    .into_iter()
4752                    .map(|p| ("name".to_owned(), p.to_string()))
4753                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4754            ),
4755            _ => local_var_req_builder.query(&[(
4756                "name",
4757                &local_var_str
4758                    .into_iter()
4759                    .map(|p| p.to_string())
4760                    .collect::<Vec<String>>()
4761                    .join(",")
4762                    .to_string(),
4763            )]),
4764        };
4765    }
4766    if let Some(ref local_var_str) = name__empty {
4767        local_var_req_builder =
4768            local_var_req_builder.query(&[("name__empty", &local_var_str.to_string())]);
4769    }
4770    if let Some(ref local_var_str) = name__ic {
4771        local_var_req_builder = match "multi" {
4772            "multi" => local_var_req_builder.query(
4773                &local_var_str
4774                    .into_iter()
4775                    .map(|p| ("name__ic".to_owned(), p.to_string()))
4776                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4777            ),
4778            _ => local_var_req_builder.query(&[(
4779                "name__ic",
4780                &local_var_str
4781                    .into_iter()
4782                    .map(|p| p.to_string())
4783                    .collect::<Vec<String>>()
4784                    .join(",")
4785                    .to_string(),
4786            )]),
4787        };
4788    }
4789    if let Some(ref local_var_str) = name__ie {
4790        local_var_req_builder = match "multi" {
4791            "multi" => local_var_req_builder.query(
4792                &local_var_str
4793                    .into_iter()
4794                    .map(|p| ("name__ie".to_owned(), p.to_string()))
4795                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4796            ),
4797            _ => local_var_req_builder.query(&[(
4798                "name__ie",
4799                &local_var_str
4800                    .into_iter()
4801                    .map(|p| p.to_string())
4802                    .collect::<Vec<String>>()
4803                    .join(",")
4804                    .to_string(),
4805            )]),
4806        };
4807    }
4808    if let Some(ref local_var_str) = name__iew {
4809        local_var_req_builder = match "multi" {
4810            "multi" => local_var_req_builder.query(
4811                &local_var_str
4812                    .into_iter()
4813                    .map(|p| ("name__iew".to_owned(), p.to_string()))
4814                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4815            ),
4816            _ => local_var_req_builder.query(&[(
4817                "name__iew",
4818                &local_var_str
4819                    .into_iter()
4820                    .map(|p| p.to_string())
4821                    .collect::<Vec<String>>()
4822                    .join(",")
4823                    .to_string(),
4824            )]),
4825        };
4826    }
4827    if let Some(ref local_var_str) = name__iregex {
4828        local_var_req_builder = match "multi" {
4829            "multi" => local_var_req_builder.query(
4830                &local_var_str
4831                    .into_iter()
4832                    .map(|p| ("name__iregex".to_owned(), p.to_string()))
4833                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4834            ),
4835            _ => local_var_req_builder.query(&[(
4836                "name__iregex",
4837                &local_var_str
4838                    .into_iter()
4839                    .map(|p| p.to_string())
4840                    .collect::<Vec<String>>()
4841                    .join(",")
4842                    .to_string(),
4843            )]),
4844        };
4845    }
4846    if let Some(ref local_var_str) = name__isw {
4847        local_var_req_builder = match "multi" {
4848            "multi" => local_var_req_builder.query(
4849                &local_var_str
4850                    .into_iter()
4851                    .map(|p| ("name__isw".to_owned(), p.to_string()))
4852                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4853            ),
4854            _ => local_var_req_builder.query(&[(
4855                "name__isw",
4856                &local_var_str
4857                    .into_iter()
4858                    .map(|p| p.to_string())
4859                    .collect::<Vec<String>>()
4860                    .join(",")
4861                    .to_string(),
4862            )]),
4863        };
4864    }
4865    if let Some(ref local_var_str) = name__n {
4866        local_var_req_builder = match "multi" {
4867            "multi" => local_var_req_builder.query(
4868                &local_var_str
4869                    .into_iter()
4870                    .map(|p| ("name__n".to_owned(), p.to_string()))
4871                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4872            ),
4873            _ => local_var_req_builder.query(&[(
4874                "name__n",
4875                &local_var_str
4876                    .into_iter()
4877                    .map(|p| p.to_string())
4878                    .collect::<Vec<String>>()
4879                    .join(",")
4880                    .to_string(),
4881            )]),
4882        };
4883    }
4884    if let Some(ref local_var_str) = name__nic {
4885        local_var_req_builder = match "multi" {
4886            "multi" => local_var_req_builder.query(
4887                &local_var_str
4888                    .into_iter()
4889                    .map(|p| ("name__nic".to_owned(), p.to_string()))
4890                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4891            ),
4892            _ => local_var_req_builder.query(&[(
4893                "name__nic",
4894                &local_var_str
4895                    .into_iter()
4896                    .map(|p| p.to_string())
4897                    .collect::<Vec<String>>()
4898                    .join(",")
4899                    .to_string(),
4900            )]),
4901        };
4902    }
4903    if let Some(ref local_var_str) = name__nie {
4904        local_var_req_builder = match "multi" {
4905            "multi" => local_var_req_builder.query(
4906                &local_var_str
4907                    .into_iter()
4908                    .map(|p| ("name__nie".to_owned(), p.to_string()))
4909                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4910            ),
4911            _ => local_var_req_builder.query(&[(
4912                "name__nie",
4913                &local_var_str
4914                    .into_iter()
4915                    .map(|p| p.to_string())
4916                    .collect::<Vec<String>>()
4917                    .join(",")
4918                    .to_string(),
4919            )]),
4920        };
4921    }
4922    if let Some(ref local_var_str) = name__niew {
4923        local_var_req_builder = match "multi" {
4924            "multi" => local_var_req_builder.query(
4925                &local_var_str
4926                    .into_iter()
4927                    .map(|p| ("name__niew".to_owned(), p.to_string()))
4928                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4929            ),
4930            _ => local_var_req_builder.query(&[(
4931                "name__niew",
4932                &local_var_str
4933                    .into_iter()
4934                    .map(|p| p.to_string())
4935                    .collect::<Vec<String>>()
4936                    .join(",")
4937                    .to_string(),
4938            )]),
4939        };
4940    }
4941    if let Some(ref local_var_str) = name__nisw {
4942        local_var_req_builder = match "multi" {
4943            "multi" => local_var_req_builder.query(
4944                &local_var_str
4945                    .into_iter()
4946                    .map(|p| ("name__nisw".to_owned(), p.to_string()))
4947                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4948            ),
4949            _ => local_var_req_builder.query(&[(
4950                "name__nisw",
4951                &local_var_str
4952                    .into_iter()
4953                    .map(|p| p.to_string())
4954                    .collect::<Vec<String>>()
4955                    .join(",")
4956                    .to_string(),
4957            )]),
4958        };
4959    }
4960    if let Some(ref local_var_str) = name__regex {
4961        local_var_req_builder = match "multi" {
4962            "multi" => local_var_req_builder.query(
4963                &local_var_str
4964                    .into_iter()
4965                    .map(|p| ("name__regex".to_owned(), p.to_string()))
4966                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4967            ),
4968            _ => local_var_req_builder.query(&[(
4969                "name__regex",
4970                &local_var_str
4971                    .into_iter()
4972                    .map(|p| p.to_string())
4973                    .collect::<Vec<String>>()
4974                    .join(",")
4975                    .to_string(),
4976            )]),
4977        };
4978    }
4979    if let Some(ref local_var_str) = offset {
4980        local_var_req_builder =
4981            local_var_req_builder.query(&[("offset", &local_var_str.to_string())]);
4982    }
4983    if let Some(ref local_var_str) = ordering {
4984        local_var_req_builder =
4985            local_var_req_builder.query(&[("ordering", &local_var_str.to_string())]);
4986    }
4987    if let Some(ref local_var_str) = q {
4988        local_var_req_builder = local_var_req_builder.query(&[("q", &local_var_str.to_string())]);
4989    }
4990    if let Some(ref local_var_str) = sa_lifetime {
4991        local_var_req_builder = match "multi" {
4992            "multi" => local_var_req_builder.query(
4993                &local_var_str
4994                    .into_iter()
4995                    .map(|p| ("sa_lifetime".to_owned(), p.to_string()))
4996                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4997            ),
4998            _ => local_var_req_builder.query(&[(
4999                "sa_lifetime",
5000                &local_var_str
5001                    .into_iter()
5002                    .map(|p| p.to_string())
5003                    .collect::<Vec<String>>()
5004                    .join(",")
5005                    .to_string(),
5006            )]),
5007        };
5008    }
5009    if let Some(ref local_var_str) = sa_lifetime__empty {
5010        local_var_req_builder =
5011            local_var_req_builder.query(&[("sa_lifetime__empty", &local_var_str.to_string())]);
5012    }
5013    if let Some(ref local_var_str) = sa_lifetime__gt {
5014        local_var_req_builder = match "multi" {
5015            "multi" => local_var_req_builder.query(
5016                &local_var_str
5017                    .into_iter()
5018                    .map(|p| ("sa_lifetime__gt".to_owned(), p.to_string()))
5019                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5020            ),
5021            _ => local_var_req_builder.query(&[(
5022                "sa_lifetime__gt",
5023                &local_var_str
5024                    .into_iter()
5025                    .map(|p| p.to_string())
5026                    .collect::<Vec<String>>()
5027                    .join(",")
5028                    .to_string(),
5029            )]),
5030        };
5031    }
5032    if let Some(ref local_var_str) = sa_lifetime__gte {
5033        local_var_req_builder = match "multi" {
5034            "multi" => local_var_req_builder.query(
5035                &local_var_str
5036                    .into_iter()
5037                    .map(|p| ("sa_lifetime__gte".to_owned(), p.to_string()))
5038                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5039            ),
5040            _ => local_var_req_builder.query(&[(
5041                "sa_lifetime__gte",
5042                &local_var_str
5043                    .into_iter()
5044                    .map(|p| p.to_string())
5045                    .collect::<Vec<String>>()
5046                    .join(",")
5047                    .to_string(),
5048            )]),
5049        };
5050    }
5051    if let Some(ref local_var_str) = sa_lifetime__lt {
5052        local_var_req_builder = match "multi" {
5053            "multi" => local_var_req_builder.query(
5054                &local_var_str
5055                    .into_iter()
5056                    .map(|p| ("sa_lifetime__lt".to_owned(), p.to_string()))
5057                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5058            ),
5059            _ => local_var_req_builder.query(&[(
5060                "sa_lifetime__lt",
5061                &local_var_str
5062                    .into_iter()
5063                    .map(|p| p.to_string())
5064                    .collect::<Vec<String>>()
5065                    .join(",")
5066                    .to_string(),
5067            )]),
5068        };
5069    }
5070    if let Some(ref local_var_str) = sa_lifetime__lte {
5071        local_var_req_builder = match "multi" {
5072            "multi" => local_var_req_builder.query(
5073                &local_var_str
5074                    .into_iter()
5075                    .map(|p| ("sa_lifetime__lte".to_owned(), p.to_string()))
5076                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5077            ),
5078            _ => local_var_req_builder.query(&[(
5079                "sa_lifetime__lte",
5080                &local_var_str
5081                    .into_iter()
5082                    .map(|p| p.to_string())
5083                    .collect::<Vec<String>>()
5084                    .join(",")
5085                    .to_string(),
5086            )]),
5087        };
5088    }
5089    if let Some(ref local_var_str) = sa_lifetime__n {
5090        local_var_req_builder = match "multi" {
5091            "multi" => local_var_req_builder.query(
5092                &local_var_str
5093                    .into_iter()
5094                    .map(|p| ("sa_lifetime__n".to_owned(), p.to_string()))
5095                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5096            ),
5097            _ => local_var_req_builder.query(&[(
5098                "sa_lifetime__n",
5099                &local_var_str
5100                    .into_iter()
5101                    .map(|p| p.to_string())
5102                    .collect::<Vec<String>>()
5103                    .join(",")
5104                    .to_string(),
5105            )]),
5106        };
5107    }
5108    if let Some(ref local_var_str) = tag {
5109        local_var_req_builder = match "multi" {
5110            "multi" => local_var_req_builder.query(
5111                &local_var_str
5112                    .into_iter()
5113                    .map(|p| ("tag".to_owned(), p.to_string()))
5114                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5115            ),
5116            _ => local_var_req_builder.query(&[(
5117                "tag",
5118                &local_var_str
5119                    .into_iter()
5120                    .map(|p| p.to_string())
5121                    .collect::<Vec<String>>()
5122                    .join(",")
5123                    .to_string(),
5124            )]),
5125        };
5126    }
5127    if let Some(ref local_var_str) = tag__n {
5128        local_var_req_builder = match "multi" {
5129            "multi" => local_var_req_builder.query(
5130                &local_var_str
5131                    .into_iter()
5132                    .map(|p| ("tag__n".to_owned(), p.to_string()))
5133                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5134            ),
5135            _ => local_var_req_builder.query(&[(
5136                "tag__n",
5137                &local_var_str
5138                    .into_iter()
5139                    .map(|p| p.to_string())
5140                    .collect::<Vec<String>>()
5141                    .join(",")
5142                    .to_string(),
5143            )]),
5144        };
5145    }
5146    if let Some(ref local_var_str) = tag_id {
5147        local_var_req_builder = match "multi" {
5148            "multi" => local_var_req_builder.query(
5149                &local_var_str
5150                    .into_iter()
5151                    .map(|p| ("tag_id".to_owned(), p.to_string()))
5152                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5153            ),
5154            _ => local_var_req_builder.query(&[(
5155                "tag_id",
5156                &local_var_str
5157                    .into_iter()
5158                    .map(|p| p.to_string())
5159                    .collect::<Vec<String>>()
5160                    .join(",")
5161                    .to_string(),
5162            )]),
5163        };
5164    }
5165    if let Some(ref local_var_str) = tag_id__n {
5166        local_var_req_builder = match "multi" {
5167            "multi" => local_var_req_builder.query(
5168                &local_var_str
5169                    .into_iter()
5170                    .map(|p| ("tag_id__n".to_owned(), p.to_string()))
5171                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5172            ),
5173            _ => local_var_req_builder.query(&[(
5174                "tag_id__n",
5175                &local_var_str
5176                    .into_iter()
5177                    .map(|p| p.to_string())
5178                    .collect::<Vec<String>>()
5179                    .join(",")
5180                    .to_string(),
5181            )]),
5182        };
5183    }
5184    if let Some(ref local_var_str) = updated_by_request {
5185        local_var_req_builder =
5186            local_var_req_builder.query(&[("updated_by_request", &local_var_str.to_string())]);
5187    }
5188    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
5189        local_var_req_builder =
5190            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
5191    }
5192    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
5193        let local_var_key = local_var_apikey.key.clone();
5194        let local_var_value = match local_var_apikey.prefix {
5195            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
5196            None => local_var_key,
5197        };
5198        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
5199    };
5200
5201    let local_var_req = local_var_req_builder.build()?;
5202    let local_var_resp = local_var_client.execute(local_var_req).await?;
5203
5204    let local_var_status = local_var_resp.status();
5205    let local_var_content = local_var_resp.text().await?;
5206
5207    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
5208        serde_json::from_str(&local_var_content).map_err(Error::from)
5209    } else {
5210        let local_var_entity: Option<VpnIkeProposalsListError> =
5211            serde_json::from_str(&local_var_content).ok();
5212        let local_var_error = ResponseContent {
5213            status: local_var_status,
5214            content: local_var_content,
5215            entity: local_var_entity,
5216        };
5217        Err(Error::ResponseError(local_var_error))
5218    }
5219}
5220
5221/// Patch a IKE proposal object.
5222pub async fn vpn_ike_proposals_partial_update(
5223    configuration: &configuration::Configuration,
5224    id: i32,
5225    patched_writable_ike_proposal_request: Option<crate::models::PatchedWritableIkeProposalRequest>,
5226) -> Result<crate::models::IkeProposal, Error<VpnIkeProposalsPartialUpdateError>> {
5227    let local_var_configuration = configuration;
5228
5229    let local_var_client = &local_var_configuration.client;
5230
5231    let local_var_uri_str = format!(
5232        "{}/api/vpn/ike-proposals/{id}/",
5233        local_var_configuration.base_path,
5234        id = id
5235    );
5236    let mut local_var_req_builder =
5237        local_var_client.request(reqwest::Method::PATCH, local_var_uri_str.as_str());
5238
5239    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
5240        local_var_req_builder =
5241            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
5242    }
5243    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
5244        let local_var_key = local_var_apikey.key.clone();
5245        let local_var_value = match local_var_apikey.prefix {
5246            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
5247            None => local_var_key,
5248        };
5249        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
5250    };
5251    local_var_req_builder = local_var_req_builder.json(&patched_writable_ike_proposal_request);
5252
5253    let local_var_req = local_var_req_builder.build()?;
5254    let local_var_resp = local_var_client.execute(local_var_req).await?;
5255
5256    let local_var_status = local_var_resp.status();
5257    let local_var_content = local_var_resp.text().await?;
5258
5259    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
5260        serde_json::from_str(&local_var_content).map_err(Error::from)
5261    } else {
5262        let local_var_entity: Option<VpnIkeProposalsPartialUpdateError> =
5263            serde_json::from_str(&local_var_content).ok();
5264        let local_var_error = ResponseContent {
5265            status: local_var_status,
5266            content: local_var_content,
5267            entity: local_var_entity,
5268        };
5269        Err(Error::ResponseError(local_var_error))
5270    }
5271}
5272
5273/// Get a IKE proposal object.
5274pub async fn vpn_ike_proposals_retrieve(
5275    configuration: &configuration::Configuration,
5276    id: i32,
5277) -> Result<crate::models::IkeProposal, Error<VpnIkeProposalsRetrieveError>> {
5278    let local_var_configuration = configuration;
5279
5280    let local_var_client = &local_var_configuration.client;
5281
5282    let local_var_uri_str = format!(
5283        "{}/api/vpn/ike-proposals/{id}/",
5284        local_var_configuration.base_path,
5285        id = id
5286    );
5287    let mut local_var_req_builder =
5288        local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
5289
5290    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
5291        local_var_req_builder =
5292            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
5293    }
5294    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
5295        let local_var_key = local_var_apikey.key.clone();
5296        let local_var_value = match local_var_apikey.prefix {
5297            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
5298            None => local_var_key,
5299        };
5300        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
5301    };
5302
5303    let local_var_req = local_var_req_builder.build()?;
5304    let local_var_resp = local_var_client.execute(local_var_req).await?;
5305
5306    let local_var_status = local_var_resp.status();
5307    let local_var_content = local_var_resp.text().await?;
5308
5309    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
5310        serde_json::from_str(&local_var_content).map_err(Error::from)
5311    } else {
5312        let local_var_entity: Option<VpnIkeProposalsRetrieveError> =
5313            serde_json::from_str(&local_var_content).ok();
5314        let local_var_error = ResponseContent {
5315            status: local_var_status,
5316            content: local_var_content,
5317            entity: local_var_entity,
5318        };
5319        Err(Error::ResponseError(local_var_error))
5320    }
5321}
5322
5323/// Put a IKE proposal object.
5324pub async fn vpn_ike_proposals_update(
5325    configuration: &configuration::Configuration,
5326    id: i32,
5327    writable_ike_proposal_request: crate::models::WritableIkeProposalRequest,
5328) -> Result<crate::models::IkeProposal, Error<VpnIkeProposalsUpdateError>> {
5329    let local_var_configuration = configuration;
5330
5331    let local_var_client = &local_var_configuration.client;
5332
5333    let local_var_uri_str = format!(
5334        "{}/api/vpn/ike-proposals/{id}/",
5335        local_var_configuration.base_path,
5336        id = id
5337    );
5338    let mut local_var_req_builder =
5339        local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());
5340
5341    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
5342        local_var_req_builder =
5343            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
5344    }
5345    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
5346        let local_var_key = local_var_apikey.key.clone();
5347        let local_var_value = match local_var_apikey.prefix {
5348            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
5349            None => local_var_key,
5350        };
5351        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
5352    };
5353    local_var_req_builder = local_var_req_builder.json(&writable_ike_proposal_request);
5354
5355    let local_var_req = local_var_req_builder.build()?;
5356    let local_var_resp = local_var_client.execute(local_var_req).await?;
5357
5358    let local_var_status = local_var_resp.status();
5359    let local_var_content = local_var_resp.text().await?;
5360
5361    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
5362        serde_json::from_str(&local_var_content).map_err(Error::from)
5363    } else {
5364        let local_var_entity: Option<VpnIkeProposalsUpdateError> =
5365            serde_json::from_str(&local_var_content).ok();
5366        let local_var_error = ResponseContent {
5367            status: local_var_status,
5368            content: local_var_content,
5369            entity: local_var_entity,
5370        };
5371        Err(Error::ResponseError(local_var_error))
5372    }
5373}
5374
5375/// Delete a list of IPSec policy objects.
5376pub async fn vpn_ipsec_policies_bulk_destroy(
5377    configuration: &configuration::Configuration,
5378    ip_sec_policy_request: Vec<crate::models::IpSecPolicyRequest>,
5379) -> Result<(), Error<VpnIpsecPoliciesBulkDestroyError>> {
5380    let local_var_configuration = configuration;
5381
5382    let local_var_client = &local_var_configuration.client;
5383
5384    let local_var_uri_str = format!(
5385        "{}/api/vpn/ipsec-policies/",
5386        local_var_configuration.base_path
5387    );
5388    let mut local_var_req_builder =
5389        local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());
5390
5391    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
5392        local_var_req_builder =
5393            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
5394    }
5395    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
5396        let local_var_key = local_var_apikey.key.clone();
5397        let local_var_value = match local_var_apikey.prefix {
5398            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
5399            None => local_var_key,
5400        };
5401        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
5402    };
5403    local_var_req_builder = local_var_req_builder.json(&ip_sec_policy_request);
5404
5405    let local_var_req = local_var_req_builder.build()?;
5406    let local_var_resp = local_var_client.execute(local_var_req).await?;
5407
5408    let local_var_status = local_var_resp.status();
5409    let local_var_content = local_var_resp.text().await?;
5410
5411    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
5412        Ok(())
5413    } else {
5414        let local_var_entity: Option<VpnIpsecPoliciesBulkDestroyError> =
5415            serde_json::from_str(&local_var_content).ok();
5416        let local_var_error = ResponseContent {
5417            status: local_var_status,
5418            content: local_var_content,
5419            entity: local_var_entity,
5420        };
5421        Err(Error::ResponseError(local_var_error))
5422    }
5423}
5424
5425/// Patch a list of IPSec policy objects.
5426pub async fn vpn_ipsec_policies_bulk_partial_update(
5427    configuration: &configuration::Configuration,
5428    ip_sec_policy_request: Vec<crate::models::IpSecPolicyRequest>,
5429) -> Result<Vec<crate::models::IpSecPolicy>, Error<VpnIpsecPoliciesBulkPartialUpdateError>> {
5430    let local_var_configuration = configuration;
5431
5432    let local_var_client = &local_var_configuration.client;
5433
5434    let local_var_uri_str = format!(
5435        "{}/api/vpn/ipsec-policies/",
5436        local_var_configuration.base_path
5437    );
5438    let mut local_var_req_builder =
5439        local_var_client.request(reqwest::Method::PATCH, local_var_uri_str.as_str());
5440
5441    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
5442        local_var_req_builder =
5443            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
5444    }
5445    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
5446        let local_var_key = local_var_apikey.key.clone();
5447        let local_var_value = match local_var_apikey.prefix {
5448            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
5449            None => local_var_key,
5450        };
5451        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
5452    };
5453    local_var_req_builder = local_var_req_builder.json(&ip_sec_policy_request);
5454
5455    let local_var_req = local_var_req_builder.build()?;
5456    let local_var_resp = local_var_client.execute(local_var_req).await?;
5457
5458    let local_var_status = local_var_resp.status();
5459    let local_var_content = local_var_resp.text().await?;
5460
5461    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
5462        serde_json::from_str(&local_var_content).map_err(Error::from)
5463    } else {
5464        let local_var_entity: Option<VpnIpsecPoliciesBulkPartialUpdateError> =
5465            serde_json::from_str(&local_var_content).ok();
5466        let local_var_error = ResponseContent {
5467            status: local_var_status,
5468            content: local_var_content,
5469            entity: local_var_entity,
5470        };
5471        Err(Error::ResponseError(local_var_error))
5472    }
5473}
5474
5475/// Put a list of IPSec policy objects.
5476pub async fn vpn_ipsec_policies_bulk_update(
5477    configuration: &configuration::Configuration,
5478    ip_sec_policy_request: Vec<crate::models::IpSecPolicyRequest>,
5479) -> Result<Vec<crate::models::IpSecPolicy>, Error<VpnIpsecPoliciesBulkUpdateError>> {
5480    let local_var_configuration = configuration;
5481
5482    let local_var_client = &local_var_configuration.client;
5483
5484    let local_var_uri_str = format!(
5485        "{}/api/vpn/ipsec-policies/",
5486        local_var_configuration.base_path
5487    );
5488    let mut local_var_req_builder =
5489        local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());
5490
5491    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
5492        local_var_req_builder =
5493            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
5494    }
5495    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
5496        let local_var_key = local_var_apikey.key.clone();
5497        let local_var_value = match local_var_apikey.prefix {
5498            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
5499            None => local_var_key,
5500        };
5501        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
5502    };
5503    local_var_req_builder = local_var_req_builder.json(&ip_sec_policy_request);
5504
5505    let local_var_req = local_var_req_builder.build()?;
5506    let local_var_resp = local_var_client.execute(local_var_req).await?;
5507
5508    let local_var_status = local_var_resp.status();
5509    let local_var_content = local_var_resp.text().await?;
5510
5511    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
5512        serde_json::from_str(&local_var_content).map_err(Error::from)
5513    } else {
5514        let local_var_entity: Option<VpnIpsecPoliciesBulkUpdateError> =
5515            serde_json::from_str(&local_var_content).ok();
5516        let local_var_error = ResponseContent {
5517            status: local_var_status,
5518            content: local_var_content,
5519            entity: local_var_entity,
5520        };
5521        Err(Error::ResponseError(local_var_error))
5522    }
5523}
5524
5525/// Post a list of IPSec policy objects.
5526pub async fn vpn_ipsec_policies_create(
5527    configuration: &configuration::Configuration,
5528    writable_ip_sec_policy_request: crate::models::WritableIpSecPolicyRequest,
5529) -> Result<crate::models::IpSecPolicy, Error<VpnIpsecPoliciesCreateError>> {
5530    let local_var_configuration = configuration;
5531
5532    let local_var_client = &local_var_configuration.client;
5533
5534    let local_var_uri_str = format!(
5535        "{}/api/vpn/ipsec-policies/",
5536        local_var_configuration.base_path
5537    );
5538    let mut local_var_req_builder =
5539        local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
5540
5541    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
5542        local_var_req_builder =
5543            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
5544    }
5545    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
5546        let local_var_key = local_var_apikey.key.clone();
5547        let local_var_value = match local_var_apikey.prefix {
5548            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
5549            None => local_var_key,
5550        };
5551        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
5552    };
5553    local_var_req_builder = local_var_req_builder.json(&writable_ip_sec_policy_request);
5554
5555    let local_var_req = local_var_req_builder.build()?;
5556    let local_var_resp = local_var_client.execute(local_var_req).await?;
5557
5558    let local_var_status = local_var_resp.status();
5559    let local_var_content = local_var_resp.text().await?;
5560
5561    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
5562        serde_json::from_str(&local_var_content).map_err(Error::from)
5563    } else {
5564        let local_var_entity: Option<VpnIpsecPoliciesCreateError> =
5565            serde_json::from_str(&local_var_content).ok();
5566        let local_var_error = ResponseContent {
5567            status: local_var_status,
5568            content: local_var_content,
5569            entity: local_var_entity,
5570        };
5571        Err(Error::ResponseError(local_var_error))
5572    }
5573}
5574
5575/// Delete a IPSec policy object.
5576pub async fn vpn_ipsec_policies_destroy(
5577    configuration: &configuration::Configuration,
5578    id: i32,
5579) -> Result<(), Error<VpnIpsecPoliciesDestroyError>> {
5580    let local_var_configuration = configuration;
5581
5582    let local_var_client = &local_var_configuration.client;
5583
5584    let local_var_uri_str = format!(
5585        "{}/api/vpn/ipsec-policies/{id}/",
5586        local_var_configuration.base_path,
5587        id = id
5588    );
5589    let mut local_var_req_builder =
5590        local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());
5591
5592    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
5593        local_var_req_builder =
5594            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
5595    }
5596    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
5597        let local_var_key = local_var_apikey.key.clone();
5598        let local_var_value = match local_var_apikey.prefix {
5599            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
5600            None => local_var_key,
5601        };
5602        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
5603    };
5604
5605    let local_var_req = local_var_req_builder.build()?;
5606    let local_var_resp = local_var_client.execute(local_var_req).await?;
5607
5608    let local_var_status = local_var_resp.status();
5609    let local_var_content = local_var_resp.text().await?;
5610
5611    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
5612        Ok(())
5613    } else {
5614        let local_var_entity: Option<VpnIpsecPoliciesDestroyError> =
5615            serde_json::from_str(&local_var_content).ok();
5616        let local_var_error = ResponseContent {
5617            status: local_var_status,
5618            content: local_var_content,
5619            entity: local_var_entity,
5620        };
5621        Err(Error::ResponseError(local_var_error))
5622    }
5623}
5624
5625/// Get a list of IPSec policy objects.
5626pub async fn vpn_ipsec_policies_list(
5627    configuration: &configuration::Configuration,
5628    created: Option<Vec<String>>,
5629    created__empty: Option<Vec<String>>,
5630    created__gt: Option<Vec<String>>,
5631    created__gte: Option<Vec<String>>,
5632    created__lt: Option<Vec<String>>,
5633    created__lte: Option<Vec<String>>,
5634    created__n: Option<Vec<String>>,
5635    created_by_request: Option<&str>,
5636    description: Option<Vec<String>>,
5637    description__empty: Option<bool>,
5638    description__ic: Option<Vec<String>>,
5639    description__ie: Option<Vec<String>>,
5640    description__iew: Option<Vec<String>>,
5641    description__iregex: Option<Vec<String>>,
5642    description__isw: Option<Vec<String>>,
5643    description__n: Option<Vec<String>>,
5644    description__nic: Option<Vec<String>>,
5645    description__nie: Option<Vec<String>>,
5646    description__niew: Option<Vec<String>>,
5647    description__nisw: Option<Vec<String>>,
5648    description__regex: Option<Vec<String>>,
5649    id: Option<Vec<i32>>,
5650    id__empty: Option<bool>,
5651    id__gt: Option<Vec<i32>>,
5652    id__gte: Option<Vec<i32>>,
5653    id__lt: Option<Vec<i32>>,
5654    id__lte: Option<Vec<i32>>,
5655    id__n: Option<Vec<i32>>,
5656    ipsec_proposal: Option<Vec<String>>,
5657    ipsec_proposal__n: Option<Vec<String>>,
5658    ipsec_proposal_id: Option<Vec<i32>>,
5659    ipsec_proposal_id__n: Option<Vec<i32>>,
5660    last_updated: Option<Vec<String>>,
5661    last_updated__empty: Option<Vec<String>>,
5662    last_updated__gt: Option<Vec<String>>,
5663    last_updated__gte: Option<Vec<String>>,
5664    last_updated__lt: Option<Vec<String>>,
5665    last_updated__lte: Option<Vec<String>>,
5666    last_updated__n: Option<Vec<String>>,
5667    limit: Option<i32>,
5668    modified_by_request: Option<&str>,
5669    name: Option<Vec<String>>,
5670    name__empty: Option<bool>,
5671    name__ic: Option<Vec<String>>,
5672    name__ie: Option<Vec<String>>,
5673    name__iew: Option<Vec<String>>,
5674    name__iregex: Option<Vec<String>>,
5675    name__isw: Option<Vec<String>>,
5676    name__n: Option<Vec<String>>,
5677    name__nic: Option<Vec<String>>,
5678    name__nie: Option<Vec<String>>,
5679    name__niew: Option<Vec<String>>,
5680    name__nisw: Option<Vec<String>>,
5681    name__regex: Option<Vec<String>>,
5682    offset: Option<i32>,
5683    ordering: Option<&str>,
5684    pfs_group: Option<Vec<i32>>,
5685    pfs_group__ic: Option<Vec<i32>>,
5686    pfs_group__ie: Option<Vec<i32>>,
5687    pfs_group__iew: Option<Vec<i32>>,
5688    pfs_group__iregex: Option<Vec<i32>>,
5689    pfs_group__isw: Option<Vec<i32>>,
5690    pfs_group__n: Option<Vec<i32>>,
5691    pfs_group__nic: Option<Vec<i32>>,
5692    pfs_group__nie: Option<Vec<i32>>,
5693    pfs_group__niew: Option<Vec<i32>>,
5694    pfs_group__nisw: Option<Vec<i32>>,
5695    pfs_group__regex: Option<Vec<i32>>,
5696    q: Option<&str>,
5697    tag: Option<Vec<String>>,
5698    tag__n: Option<Vec<String>>,
5699    tag_id: Option<Vec<i32>>,
5700    tag_id__n: Option<Vec<i32>>,
5701    updated_by_request: Option<&str>,
5702) -> Result<crate::models::PaginatedIpSecPolicyList, Error<VpnIpsecPoliciesListError>> {
5703    let local_var_configuration = configuration;
5704
5705    let local_var_client = &local_var_configuration.client;
5706
5707    let local_var_uri_str = format!(
5708        "{}/api/vpn/ipsec-policies/",
5709        local_var_configuration.base_path
5710    );
5711    let mut local_var_req_builder =
5712        local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
5713
5714    if let Some(ref local_var_str) = created {
5715        local_var_req_builder = match "multi" {
5716            "multi" => local_var_req_builder.query(
5717                &local_var_str
5718                    .into_iter()
5719                    .map(|p| ("created".to_owned(), p.to_string()))
5720                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5721            ),
5722            _ => local_var_req_builder.query(&[(
5723                "created",
5724                &local_var_str
5725                    .into_iter()
5726                    .map(|p| p.to_string())
5727                    .collect::<Vec<String>>()
5728                    .join(",")
5729                    .to_string(),
5730            )]),
5731        };
5732    }
5733    if let Some(ref local_var_str) = created__empty {
5734        local_var_req_builder = match "multi" {
5735            "multi" => local_var_req_builder.query(
5736                &local_var_str
5737                    .into_iter()
5738                    .map(|p| ("created__empty".to_owned(), p.to_string()))
5739                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5740            ),
5741            _ => local_var_req_builder.query(&[(
5742                "created__empty",
5743                &local_var_str
5744                    .into_iter()
5745                    .map(|p| p.to_string())
5746                    .collect::<Vec<String>>()
5747                    .join(",")
5748                    .to_string(),
5749            )]),
5750        };
5751    }
5752    if let Some(ref local_var_str) = created__gt {
5753        local_var_req_builder = match "multi" {
5754            "multi" => local_var_req_builder.query(
5755                &local_var_str
5756                    .into_iter()
5757                    .map(|p| ("created__gt".to_owned(), p.to_string()))
5758                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5759            ),
5760            _ => local_var_req_builder.query(&[(
5761                "created__gt",
5762                &local_var_str
5763                    .into_iter()
5764                    .map(|p| p.to_string())
5765                    .collect::<Vec<String>>()
5766                    .join(",")
5767                    .to_string(),
5768            )]),
5769        };
5770    }
5771    if let Some(ref local_var_str) = created__gte {
5772        local_var_req_builder = match "multi" {
5773            "multi" => local_var_req_builder.query(
5774                &local_var_str
5775                    .into_iter()
5776                    .map(|p| ("created__gte".to_owned(), p.to_string()))
5777                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5778            ),
5779            _ => local_var_req_builder.query(&[(
5780                "created__gte",
5781                &local_var_str
5782                    .into_iter()
5783                    .map(|p| p.to_string())
5784                    .collect::<Vec<String>>()
5785                    .join(",")
5786                    .to_string(),
5787            )]),
5788        };
5789    }
5790    if let Some(ref local_var_str) = created__lt {
5791        local_var_req_builder = match "multi" {
5792            "multi" => local_var_req_builder.query(
5793                &local_var_str
5794                    .into_iter()
5795                    .map(|p| ("created__lt".to_owned(), p.to_string()))
5796                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5797            ),
5798            _ => local_var_req_builder.query(&[(
5799                "created__lt",
5800                &local_var_str
5801                    .into_iter()
5802                    .map(|p| p.to_string())
5803                    .collect::<Vec<String>>()
5804                    .join(",")
5805                    .to_string(),
5806            )]),
5807        };
5808    }
5809    if let Some(ref local_var_str) = created__lte {
5810        local_var_req_builder = match "multi" {
5811            "multi" => local_var_req_builder.query(
5812                &local_var_str
5813                    .into_iter()
5814                    .map(|p| ("created__lte".to_owned(), p.to_string()))
5815                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5816            ),
5817            _ => local_var_req_builder.query(&[(
5818                "created__lte",
5819                &local_var_str
5820                    .into_iter()
5821                    .map(|p| p.to_string())
5822                    .collect::<Vec<String>>()
5823                    .join(",")
5824                    .to_string(),
5825            )]),
5826        };
5827    }
5828    if let Some(ref local_var_str) = created__n {
5829        local_var_req_builder = match "multi" {
5830            "multi" => local_var_req_builder.query(
5831                &local_var_str
5832                    .into_iter()
5833                    .map(|p| ("created__n".to_owned(), p.to_string()))
5834                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5835            ),
5836            _ => local_var_req_builder.query(&[(
5837                "created__n",
5838                &local_var_str
5839                    .into_iter()
5840                    .map(|p| p.to_string())
5841                    .collect::<Vec<String>>()
5842                    .join(",")
5843                    .to_string(),
5844            )]),
5845        };
5846    }
5847    if let Some(ref local_var_str) = created_by_request {
5848        local_var_req_builder =
5849            local_var_req_builder.query(&[("created_by_request", &local_var_str.to_string())]);
5850    }
5851    if let Some(ref local_var_str) = description {
5852        local_var_req_builder = match "multi" {
5853            "multi" => local_var_req_builder.query(
5854                &local_var_str
5855                    .into_iter()
5856                    .map(|p| ("description".to_owned(), p.to_string()))
5857                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5858            ),
5859            _ => local_var_req_builder.query(&[(
5860                "description",
5861                &local_var_str
5862                    .into_iter()
5863                    .map(|p| p.to_string())
5864                    .collect::<Vec<String>>()
5865                    .join(",")
5866                    .to_string(),
5867            )]),
5868        };
5869    }
5870    if let Some(ref local_var_str) = description__empty {
5871        local_var_req_builder =
5872            local_var_req_builder.query(&[("description__empty", &local_var_str.to_string())]);
5873    }
5874    if let Some(ref local_var_str) = description__ic {
5875        local_var_req_builder = match "multi" {
5876            "multi" => local_var_req_builder.query(
5877                &local_var_str
5878                    .into_iter()
5879                    .map(|p| ("description__ic".to_owned(), p.to_string()))
5880                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5881            ),
5882            _ => local_var_req_builder.query(&[(
5883                "description__ic",
5884                &local_var_str
5885                    .into_iter()
5886                    .map(|p| p.to_string())
5887                    .collect::<Vec<String>>()
5888                    .join(",")
5889                    .to_string(),
5890            )]),
5891        };
5892    }
5893    if let Some(ref local_var_str) = description__ie {
5894        local_var_req_builder = match "multi" {
5895            "multi" => local_var_req_builder.query(
5896                &local_var_str
5897                    .into_iter()
5898                    .map(|p| ("description__ie".to_owned(), p.to_string()))
5899                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5900            ),
5901            _ => local_var_req_builder.query(&[(
5902                "description__ie",
5903                &local_var_str
5904                    .into_iter()
5905                    .map(|p| p.to_string())
5906                    .collect::<Vec<String>>()
5907                    .join(",")
5908                    .to_string(),
5909            )]),
5910        };
5911    }
5912    if let Some(ref local_var_str) = description__iew {
5913        local_var_req_builder = match "multi" {
5914            "multi" => local_var_req_builder.query(
5915                &local_var_str
5916                    .into_iter()
5917                    .map(|p| ("description__iew".to_owned(), p.to_string()))
5918                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5919            ),
5920            _ => local_var_req_builder.query(&[(
5921                "description__iew",
5922                &local_var_str
5923                    .into_iter()
5924                    .map(|p| p.to_string())
5925                    .collect::<Vec<String>>()
5926                    .join(",")
5927                    .to_string(),
5928            )]),
5929        };
5930    }
5931    if let Some(ref local_var_str) = description__iregex {
5932        local_var_req_builder = match "multi" {
5933            "multi" => local_var_req_builder.query(
5934                &local_var_str
5935                    .into_iter()
5936                    .map(|p| ("description__iregex".to_owned(), p.to_string()))
5937                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5938            ),
5939            _ => local_var_req_builder.query(&[(
5940                "description__iregex",
5941                &local_var_str
5942                    .into_iter()
5943                    .map(|p| p.to_string())
5944                    .collect::<Vec<String>>()
5945                    .join(",")
5946                    .to_string(),
5947            )]),
5948        };
5949    }
5950    if let Some(ref local_var_str) = description__isw {
5951        local_var_req_builder = match "multi" {
5952            "multi" => local_var_req_builder.query(
5953                &local_var_str
5954                    .into_iter()
5955                    .map(|p| ("description__isw".to_owned(), p.to_string()))
5956                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5957            ),
5958            _ => local_var_req_builder.query(&[(
5959                "description__isw",
5960                &local_var_str
5961                    .into_iter()
5962                    .map(|p| p.to_string())
5963                    .collect::<Vec<String>>()
5964                    .join(",")
5965                    .to_string(),
5966            )]),
5967        };
5968    }
5969    if let Some(ref local_var_str) = description__n {
5970        local_var_req_builder = match "multi" {
5971            "multi" => local_var_req_builder.query(
5972                &local_var_str
5973                    .into_iter()
5974                    .map(|p| ("description__n".to_owned(), p.to_string()))
5975                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5976            ),
5977            _ => local_var_req_builder.query(&[(
5978                "description__n",
5979                &local_var_str
5980                    .into_iter()
5981                    .map(|p| p.to_string())
5982                    .collect::<Vec<String>>()
5983                    .join(",")
5984                    .to_string(),
5985            )]),
5986        };
5987    }
5988    if let Some(ref local_var_str) = description__nic {
5989        local_var_req_builder = match "multi" {
5990            "multi" => local_var_req_builder.query(
5991                &local_var_str
5992                    .into_iter()
5993                    .map(|p| ("description__nic".to_owned(), p.to_string()))
5994                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5995            ),
5996            _ => local_var_req_builder.query(&[(
5997                "description__nic",
5998                &local_var_str
5999                    .into_iter()
6000                    .map(|p| p.to_string())
6001                    .collect::<Vec<String>>()
6002                    .join(",")
6003                    .to_string(),
6004            )]),
6005        };
6006    }
6007    if let Some(ref local_var_str) = description__nie {
6008        local_var_req_builder = match "multi" {
6009            "multi" => local_var_req_builder.query(
6010                &local_var_str
6011                    .into_iter()
6012                    .map(|p| ("description__nie".to_owned(), p.to_string()))
6013                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6014            ),
6015            _ => local_var_req_builder.query(&[(
6016                "description__nie",
6017                &local_var_str
6018                    .into_iter()
6019                    .map(|p| p.to_string())
6020                    .collect::<Vec<String>>()
6021                    .join(",")
6022                    .to_string(),
6023            )]),
6024        };
6025    }
6026    if let Some(ref local_var_str) = description__niew {
6027        local_var_req_builder = match "multi" {
6028            "multi" => local_var_req_builder.query(
6029                &local_var_str
6030                    .into_iter()
6031                    .map(|p| ("description__niew".to_owned(), p.to_string()))
6032                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6033            ),
6034            _ => local_var_req_builder.query(&[(
6035                "description__niew",
6036                &local_var_str
6037                    .into_iter()
6038                    .map(|p| p.to_string())
6039                    .collect::<Vec<String>>()
6040                    .join(",")
6041                    .to_string(),
6042            )]),
6043        };
6044    }
6045    if let Some(ref local_var_str) = description__nisw {
6046        local_var_req_builder = match "multi" {
6047            "multi" => local_var_req_builder.query(
6048                &local_var_str
6049                    .into_iter()
6050                    .map(|p| ("description__nisw".to_owned(), p.to_string()))
6051                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6052            ),
6053            _ => local_var_req_builder.query(&[(
6054                "description__nisw",
6055                &local_var_str
6056                    .into_iter()
6057                    .map(|p| p.to_string())
6058                    .collect::<Vec<String>>()
6059                    .join(",")
6060                    .to_string(),
6061            )]),
6062        };
6063    }
6064    if let Some(ref local_var_str) = description__regex {
6065        local_var_req_builder = match "multi" {
6066            "multi" => local_var_req_builder.query(
6067                &local_var_str
6068                    .into_iter()
6069                    .map(|p| ("description__regex".to_owned(), p.to_string()))
6070                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6071            ),
6072            _ => local_var_req_builder.query(&[(
6073                "description__regex",
6074                &local_var_str
6075                    .into_iter()
6076                    .map(|p| p.to_string())
6077                    .collect::<Vec<String>>()
6078                    .join(",")
6079                    .to_string(),
6080            )]),
6081        };
6082    }
6083    if let Some(ref local_var_str) = id {
6084        local_var_req_builder = match "multi" {
6085            "multi" => local_var_req_builder.query(
6086                &local_var_str
6087                    .into_iter()
6088                    .map(|p| ("id".to_owned(), p.to_string()))
6089                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6090            ),
6091            _ => local_var_req_builder.query(&[(
6092                "id",
6093                &local_var_str
6094                    .into_iter()
6095                    .map(|p| p.to_string())
6096                    .collect::<Vec<String>>()
6097                    .join(",")
6098                    .to_string(),
6099            )]),
6100        };
6101    }
6102    if let Some(ref local_var_str) = id__empty {
6103        local_var_req_builder =
6104            local_var_req_builder.query(&[("id__empty", &local_var_str.to_string())]);
6105    }
6106    if let Some(ref local_var_str) = id__gt {
6107        local_var_req_builder = match "multi" {
6108            "multi" => local_var_req_builder.query(
6109                &local_var_str
6110                    .into_iter()
6111                    .map(|p| ("id__gt".to_owned(), p.to_string()))
6112                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6113            ),
6114            _ => local_var_req_builder.query(&[(
6115                "id__gt",
6116                &local_var_str
6117                    .into_iter()
6118                    .map(|p| p.to_string())
6119                    .collect::<Vec<String>>()
6120                    .join(",")
6121                    .to_string(),
6122            )]),
6123        };
6124    }
6125    if let Some(ref local_var_str) = id__gte {
6126        local_var_req_builder = match "multi" {
6127            "multi" => local_var_req_builder.query(
6128                &local_var_str
6129                    .into_iter()
6130                    .map(|p| ("id__gte".to_owned(), p.to_string()))
6131                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6132            ),
6133            _ => local_var_req_builder.query(&[(
6134                "id__gte",
6135                &local_var_str
6136                    .into_iter()
6137                    .map(|p| p.to_string())
6138                    .collect::<Vec<String>>()
6139                    .join(",")
6140                    .to_string(),
6141            )]),
6142        };
6143    }
6144    if let Some(ref local_var_str) = id__lt {
6145        local_var_req_builder = match "multi" {
6146            "multi" => local_var_req_builder.query(
6147                &local_var_str
6148                    .into_iter()
6149                    .map(|p| ("id__lt".to_owned(), p.to_string()))
6150                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6151            ),
6152            _ => local_var_req_builder.query(&[(
6153                "id__lt",
6154                &local_var_str
6155                    .into_iter()
6156                    .map(|p| p.to_string())
6157                    .collect::<Vec<String>>()
6158                    .join(",")
6159                    .to_string(),
6160            )]),
6161        };
6162    }
6163    if let Some(ref local_var_str) = id__lte {
6164        local_var_req_builder = match "multi" {
6165            "multi" => local_var_req_builder.query(
6166                &local_var_str
6167                    .into_iter()
6168                    .map(|p| ("id__lte".to_owned(), p.to_string()))
6169                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6170            ),
6171            _ => local_var_req_builder.query(&[(
6172                "id__lte",
6173                &local_var_str
6174                    .into_iter()
6175                    .map(|p| p.to_string())
6176                    .collect::<Vec<String>>()
6177                    .join(",")
6178                    .to_string(),
6179            )]),
6180        };
6181    }
6182    if let Some(ref local_var_str) = id__n {
6183        local_var_req_builder = match "multi" {
6184            "multi" => local_var_req_builder.query(
6185                &local_var_str
6186                    .into_iter()
6187                    .map(|p| ("id__n".to_owned(), p.to_string()))
6188                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6189            ),
6190            _ => local_var_req_builder.query(&[(
6191                "id__n",
6192                &local_var_str
6193                    .into_iter()
6194                    .map(|p| p.to_string())
6195                    .collect::<Vec<String>>()
6196                    .join(",")
6197                    .to_string(),
6198            )]),
6199        };
6200    }
6201    if let Some(ref local_var_str) = ipsec_proposal {
6202        local_var_req_builder = match "multi" {
6203            "multi" => local_var_req_builder.query(
6204                &local_var_str
6205                    .into_iter()
6206                    .map(|p| ("ipsec_proposal".to_owned(), p.to_string()))
6207                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6208            ),
6209            _ => local_var_req_builder.query(&[(
6210                "ipsec_proposal",
6211                &local_var_str
6212                    .into_iter()
6213                    .map(|p| p.to_string())
6214                    .collect::<Vec<String>>()
6215                    .join(",")
6216                    .to_string(),
6217            )]),
6218        };
6219    }
6220    if let Some(ref local_var_str) = ipsec_proposal__n {
6221        local_var_req_builder = match "multi" {
6222            "multi" => local_var_req_builder.query(
6223                &local_var_str
6224                    .into_iter()
6225                    .map(|p| ("ipsec_proposal__n".to_owned(), p.to_string()))
6226                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6227            ),
6228            _ => local_var_req_builder.query(&[(
6229                "ipsec_proposal__n",
6230                &local_var_str
6231                    .into_iter()
6232                    .map(|p| p.to_string())
6233                    .collect::<Vec<String>>()
6234                    .join(",")
6235                    .to_string(),
6236            )]),
6237        };
6238    }
6239    if let Some(ref local_var_str) = ipsec_proposal_id {
6240        local_var_req_builder = match "multi" {
6241            "multi" => local_var_req_builder.query(
6242                &local_var_str
6243                    .into_iter()
6244                    .map(|p| ("ipsec_proposal_id".to_owned(), p.to_string()))
6245                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6246            ),
6247            _ => local_var_req_builder.query(&[(
6248                "ipsec_proposal_id",
6249                &local_var_str
6250                    .into_iter()
6251                    .map(|p| p.to_string())
6252                    .collect::<Vec<String>>()
6253                    .join(",")
6254                    .to_string(),
6255            )]),
6256        };
6257    }
6258    if let Some(ref local_var_str) = ipsec_proposal_id__n {
6259        local_var_req_builder = match "multi" {
6260            "multi" => local_var_req_builder.query(
6261                &local_var_str
6262                    .into_iter()
6263                    .map(|p| ("ipsec_proposal_id__n".to_owned(), p.to_string()))
6264                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6265            ),
6266            _ => local_var_req_builder.query(&[(
6267                "ipsec_proposal_id__n",
6268                &local_var_str
6269                    .into_iter()
6270                    .map(|p| p.to_string())
6271                    .collect::<Vec<String>>()
6272                    .join(",")
6273                    .to_string(),
6274            )]),
6275        };
6276    }
6277    if let Some(ref local_var_str) = last_updated {
6278        local_var_req_builder = match "multi" {
6279            "multi" => local_var_req_builder.query(
6280                &local_var_str
6281                    .into_iter()
6282                    .map(|p| ("last_updated".to_owned(), p.to_string()))
6283                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6284            ),
6285            _ => local_var_req_builder.query(&[(
6286                "last_updated",
6287                &local_var_str
6288                    .into_iter()
6289                    .map(|p| p.to_string())
6290                    .collect::<Vec<String>>()
6291                    .join(",")
6292                    .to_string(),
6293            )]),
6294        };
6295    }
6296    if let Some(ref local_var_str) = last_updated__empty {
6297        local_var_req_builder = match "multi" {
6298            "multi" => local_var_req_builder.query(
6299                &local_var_str
6300                    .into_iter()
6301                    .map(|p| ("last_updated__empty".to_owned(), p.to_string()))
6302                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6303            ),
6304            _ => local_var_req_builder.query(&[(
6305                "last_updated__empty",
6306                &local_var_str
6307                    .into_iter()
6308                    .map(|p| p.to_string())
6309                    .collect::<Vec<String>>()
6310                    .join(",")
6311                    .to_string(),
6312            )]),
6313        };
6314    }
6315    if let Some(ref local_var_str) = last_updated__gt {
6316        local_var_req_builder = match "multi" {
6317            "multi" => local_var_req_builder.query(
6318                &local_var_str
6319                    .into_iter()
6320                    .map(|p| ("last_updated__gt".to_owned(), p.to_string()))
6321                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6322            ),
6323            _ => local_var_req_builder.query(&[(
6324                "last_updated__gt",
6325                &local_var_str
6326                    .into_iter()
6327                    .map(|p| p.to_string())
6328                    .collect::<Vec<String>>()
6329                    .join(",")
6330                    .to_string(),
6331            )]),
6332        };
6333    }
6334    if let Some(ref local_var_str) = last_updated__gte {
6335        local_var_req_builder = match "multi" {
6336            "multi" => local_var_req_builder.query(
6337                &local_var_str
6338                    .into_iter()
6339                    .map(|p| ("last_updated__gte".to_owned(), p.to_string()))
6340                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6341            ),
6342            _ => local_var_req_builder.query(&[(
6343                "last_updated__gte",
6344                &local_var_str
6345                    .into_iter()
6346                    .map(|p| p.to_string())
6347                    .collect::<Vec<String>>()
6348                    .join(",")
6349                    .to_string(),
6350            )]),
6351        };
6352    }
6353    if let Some(ref local_var_str) = last_updated__lt {
6354        local_var_req_builder = match "multi" {
6355            "multi" => local_var_req_builder.query(
6356                &local_var_str
6357                    .into_iter()
6358                    .map(|p| ("last_updated__lt".to_owned(), p.to_string()))
6359                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6360            ),
6361            _ => local_var_req_builder.query(&[(
6362                "last_updated__lt",
6363                &local_var_str
6364                    .into_iter()
6365                    .map(|p| p.to_string())
6366                    .collect::<Vec<String>>()
6367                    .join(",")
6368                    .to_string(),
6369            )]),
6370        };
6371    }
6372    if let Some(ref local_var_str) = last_updated__lte {
6373        local_var_req_builder = match "multi" {
6374            "multi" => local_var_req_builder.query(
6375                &local_var_str
6376                    .into_iter()
6377                    .map(|p| ("last_updated__lte".to_owned(), p.to_string()))
6378                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6379            ),
6380            _ => local_var_req_builder.query(&[(
6381                "last_updated__lte",
6382                &local_var_str
6383                    .into_iter()
6384                    .map(|p| p.to_string())
6385                    .collect::<Vec<String>>()
6386                    .join(",")
6387                    .to_string(),
6388            )]),
6389        };
6390    }
6391    if let Some(ref local_var_str) = last_updated__n {
6392        local_var_req_builder = match "multi" {
6393            "multi" => local_var_req_builder.query(
6394                &local_var_str
6395                    .into_iter()
6396                    .map(|p| ("last_updated__n".to_owned(), p.to_string()))
6397                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6398            ),
6399            _ => local_var_req_builder.query(&[(
6400                "last_updated__n",
6401                &local_var_str
6402                    .into_iter()
6403                    .map(|p| p.to_string())
6404                    .collect::<Vec<String>>()
6405                    .join(",")
6406                    .to_string(),
6407            )]),
6408        };
6409    }
6410    if let Some(ref local_var_str) = limit {
6411        local_var_req_builder =
6412            local_var_req_builder.query(&[("limit", &local_var_str.to_string())]);
6413    }
6414    if let Some(ref local_var_str) = modified_by_request {
6415        local_var_req_builder =
6416            local_var_req_builder.query(&[("modified_by_request", &local_var_str.to_string())]);
6417    }
6418    if let Some(ref local_var_str) = name {
6419        local_var_req_builder = match "multi" {
6420            "multi" => local_var_req_builder.query(
6421                &local_var_str
6422                    .into_iter()
6423                    .map(|p| ("name".to_owned(), p.to_string()))
6424                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6425            ),
6426            _ => local_var_req_builder.query(&[(
6427                "name",
6428                &local_var_str
6429                    .into_iter()
6430                    .map(|p| p.to_string())
6431                    .collect::<Vec<String>>()
6432                    .join(",")
6433                    .to_string(),
6434            )]),
6435        };
6436    }
6437    if let Some(ref local_var_str) = name__empty {
6438        local_var_req_builder =
6439            local_var_req_builder.query(&[("name__empty", &local_var_str.to_string())]);
6440    }
6441    if let Some(ref local_var_str) = name__ic {
6442        local_var_req_builder = match "multi" {
6443            "multi" => local_var_req_builder.query(
6444                &local_var_str
6445                    .into_iter()
6446                    .map(|p| ("name__ic".to_owned(), p.to_string()))
6447                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6448            ),
6449            _ => local_var_req_builder.query(&[(
6450                "name__ic",
6451                &local_var_str
6452                    .into_iter()
6453                    .map(|p| p.to_string())
6454                    .collect::<Vec<String>>()
6455                    .join(",")
6456                    .to_string(),
6457            )]),
6458        };
6459    }
6460    if let Some(ref local_var_str) = name__ie {
6461        local_var_req_builder = match "multi" {
6462            "multi" => local_var_req_builder.query(
6463                &local_var_str
6464                    .into_iter()
6465                    .map(|p| ("name__ie".to_owned(), p.to_string()))
6466                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6467            ),
6468            _ => local_var_req_builder.query(&[(
6469                "name__ie",
6470                &local_var_str
6471                    .into_iter()
6472                    .map(|p| p.to_string())
6473                    .collect::<Vec<String>>()
6474                    .join(",")
6475                    .to_string(),
6476            )]),
6477        };
6478    }
6479    if let Some(ref local_var_str) = name__iew {
6480        local_var_req_builder = match "multi" {
6481            "multi" => local_var_req_builder.query(
6482                &local_var_str
6483                    .into_iter()
6484                    .map(|p| ("name__iew".to_owned(), p.to_string()))
6485                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6486            ),
6487            _ => local_var_req_builder.query(&[(
6488                "name__iew",
6489                &local_var_str
6490                    .into_iter()
6491                    .map(|p| p.to_string())
6492                    .collect::<Vec<String>>()
6493                    .join(",")
6494                    .to_string(),
6495            )]),
6496        };
6497    }
6498    if let Some(ref local_var_str) = name__iregex {
6499        local_var_req_builder = match "multi" {
6500            "multi" => local_var_req_builder.query(
6501                &local_var_str
6502                    .into_iter()
6503                    .map(|p| ("name__iregex".to_owned(), p.to_string()))
6504                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6505            ),
6506            _ => local_var_req_builder.query(&[(
6507                "name__iregex",
6508                &local_var_str
6509                    .into_iter()
6510                    .map(|p| p.to_string())
6511                    .collect::<Vec<String>>()
6512                    .join(",")
6513                    .to_string(),
6514            )]),
6515        };
6516    }
6517    if let Some(ref local_var_str) = name__isw {
6518        local_var_req_builder = match "multi" {
6519            "multi" => local_var_req_builder.query(
6520                &local_var_str
6521                    .into_iter()
6522                    .map(|p| ("name__isw".to_owned(), p.to_string()))
6523                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6524            ),
6525            _ => local_var_req_builder.query(&[(
6526                "name__isw",
6527                &local_var_str
6528                    .into_iter()
6529                    .map(|p| p.to_string())
6530                    .collect::<Vec<String>>()
6531                    .join(",")
6532                    .to_string(),
6533            )]),
6534        };
6535    }
6536    if let Some(ref local_var_str) = name__n {
6537        local_var_req_builder = match "multi" {
6538            "multi" => local_var_req_builder.query(
6539                &local_var_str
6540                    .into_iter()
6541                    .map(|p| ("name__n".to_owned(), p.to_string()))
6542                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6543            ),
6544            _ => local_var_req_builder.query(&[(
6545                "name__n",
6546                &local_var_str
6547                    .into_iter()
6548                    .map(|p| p.to_string())
6549                    .collect::<Vec<String>>()
6550                    .join(",")
6551                    .to_string(),
6552            )]),
6553        };
6554    }
6555    if let Some(ref local_var_str) = name__nic {
6556        local_var_req_builder = match "multi" {
6557            "multi" => local_var_req_builder.query(
6558                &local_var_str
6559                    .into_iter()
6560                    .map(|p| ("name__nic".to_owned(), p.to_string()))
6561                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6562            ),
6563            _ => local_var_req_builder.query(&[(
6564                "name__nic",
6565                &local_var_str
6566                    .into_iter()
6567                    .map(|p| p.to_string())
6568                    .collect::<Vec<String>>()
6569                    .join(",")
6570                    .to_string(),
6571            )]),
6572        };
6573    }
6574    if let Some(ref local_var_str) = name__nie {
6575        local_var_req_builder = match "multi" {
6576            "multi" => local_var_req_builder.query(
6577                &local_var_str
6578                    .into_iter()
6579                    .map(|p| ("name__nie".to_owned(), p.to_string()))
6580                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6581            ),
6582            _ => local_var_req_builder.query(&[(
6583                "name__nie",
6584                &local_var_str
6585                    .into_iter()
6586                    .map(|p| p.to_string())
6587                    .collect::<Vec<String>>()
6588                    .join(",")
6589                    .to_string(),
6590            )]),
6591        };
6592    }
6593    if let Some(ref local_var_str) = name__niew {
6594        local_var_req_builder = match "multi" {
6595            "multi" => local_var_req_builder.query(
6596                &local_var_str
6597                    .into_iter()
6598                    .map(|p| ("name__niew".to_owned(), p.to_string()))
6599                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6600            ),
6601            _ => local_var_req_builder.query(&[(
6602                "name__niew",
6603                &local_var_str
6604                    .into_iter()
6605                    .map(|p| p.to_string())
6606                    .collect::<Vec<String>>()
6607                    .join(",")
6608                    .to_string(),
6609            )]),
6610        };
6611    }
6612    if let Some(ref local_var_str) = name__nisw {
6613        local_var_req_builder = match "multi" {
6614            "multi" => local_var_req_builder.query(
6615                &local_var_str
6616                    .into_iter()
6617                    .map(|p| ("name__nisw".to_owned(), p.to_string()))
6618                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6619            ),
6620            _ => local_var_req_builder.query(&[(
6621                "name__nisw",
6622                &local_var_str
6623                    .into_iter()
6624                    .map(|p| p.to_string())
6625                    .collect::<Vec<String>>()
6626                    .join(",")
6627                    .to_string(),
6628            )]),
6629        };
6630    }
6631    if let Some(ref local_var_str) = name__regex {
6632        local_var_req_builder = match "multi" {
6633            "multi" => local_var_req_builder.query(
6634                &local_var_str
6635                    .into_iter()
6636                    .map(|p| ("name__regex".to_owned(), p.to_string()))
6637                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6638            ),
6639            _ => local_var_req_builder.query(&[(
6640                "name__regex",
6641                &local_var_str
6642                    .into_iter()
6643                    .map(|p| p.to_string())
6644                    .collect::<Vec<String>>()
6645                    .join(",")
6646                    .to_string(),
6647            )]),
6648        };
6649    }
6650    if let Some(ref local_var_str) = offset {
6651        local_var_req_builder =
6652            local_var_req_builder.query(&[("offset", &local_var_str.to_string())]);
6653    }
6654    if let Some(ref local_var_str) = ordering {
6655        local_var_req_builder =
6656            local_var_req_builder.query(&[("ordering", &local_var_str.to_string())]);
6657    }
6658    if let Some(ref local_var_str) = pfs_group {
6659        local_var_req_builder = match "multi" {
6660            "multi" => local_var_req_builder.query(
6661                &local_var_str
6662                    .into_iter()
6663                    .map(|p| ("pfs_group".to_owned(), p.to_string()))
6664                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6665            ),
6666            _ => local_var_req_builder.query(&[(
6667                "pfs_group",
6668                &local_var_str
6669                    .into_iter()
6670                    .map(|p| p.to_string())
6671                    .collect::<Vec<String>>()
6672                    .join(",")
6673                    .to_string(),
6674            )]),
6675        };
6676    }
6677    if let Some(ref local_var_str) = pfs_group__ic {
6678        local_var_req_builder = match "multi" {
6679            "multi" => local_var_req_builder.query(
6680                &local_var_str
6681                    .into_iter()
6682                    .map(|p| ("pfs_group__ic".to_owned(), p.to_string()))
6683                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6684            ),
6685            _ => local_var_req_builder.query(&[(
6686                "pfs_group__ic",
6687                &local_var_str
6688                    .into_iter()
6689                    .map(|p| p.to_string())
6690                    .collect::<Vec<String>>()
6691                    .join(",")
6692                    .to_string(),
6693            )]),
6694        };
6695    }
6696    if let Some(ref local_var_str) = pfs_group__ie {
6697        local_var_req_builder = match "multi" {
6698            "multi" => local_var_req_builder.query(
6699                &local_var_str
6700                    .into_iter()
6701                    .map(|p| ("pfs_group__ie".to_owned(), p.to_string()))
6702                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6703            ),
6704            _ => local_var_req_builder.query(&[(
6705                "pfs_group__ie",
6706                &local_var_str
6707                    .into_iter()
6708                    .map(|p| p.to_string())
6709                    .collect::<Vec<String>>()
6710                    .join(",")
6711                    .to_string(),
6712            )]),
6713        };
6714    }
6715    if let Some(ref local_var_str) = pfs_group__iew {
6716        local_var_req_builder = match "multi" {
6717            "multi" => local_var_req_builder.query(
6718                &local_var_str
6719                    .into_iter()
6720                    .map(|p| ("pfs_group__iew".to_owned(), p.to_string()))
6721                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6722            ),
6723            _ => local_var_req_builder.query(&[(
6724                "pfs_group__iew",
6725                &local_var_str
6726                    .into_iter()
6727                    .map(|p| p.to_string())
6728                    .collect::<Vec<String>>()
6729                    .join(",")
6730                    .to_string(),
6731            )]),
6732        };
6733    }
6734    if let Some(ref local_var_str) = pfs_group__iregex {
6735        local_var_req_builder = match "multi" {
6736            "multi" => local_var_req_builder.query(
6737                &local_var_str
6738                    .into_iter()
6739                    .map(|p| ("pfs_group__iregex".to_owned(), p.to_string()))
6740                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6741            ),
6742            _ => local_var_req_builder.query(&[(
6743                "pfs_group__iregex",
6744                &local_var_str
6745                    .into_iter()
6746                    .map(|p| p.to_string())
6747                    .collect::<Vec<String>>()
6748                    .join(",")
6749                    .to_string(),
6750            )]),
6751        };
6752    }
6753    if let Some(ref local_var_str) = pfs_group__isw {
6754        local_var_req_builder = match "multi" {
6755            "multi" => local_var_req_builder.query(
6756                &local_var_str
6757                    .into_iter()
6758                    .map(|p| ("pfs_group__isw".to_owned(), p.to_string()))
6759                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6760            ),
6761            _ => local_var_req_builder.query(&[(
6762                "pfs_group__isw",
6763                &local_var_str
6764                    .into_iter()
6765                    .map(|p| p.to_string())
6766                    .collect::<Vec<String>>()
6767                    .join(",")
6768                    .to_string(),
6769            )]),
6770        };
6771    }
6772    if let Some(ref local_var_str) = pfs_group__n {
6773        local_var_req_builder = match "multi" {
6774            "multi" => local_var_req_builder.query(
6775                &local_var_str
6776                    .into_iter()
6777                    .map(|p| ("pfs_group__n".to_owned(), p.to_string()))
6778                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6779            ),
6780            _ => local_var_req_builder.query(&[(
6781                "pfs_group__n",
6782                &local_var_str
6783                    .into_iter()
6784                    .map(|p| p.to_string())
6785                    .collect::<Vec<String>>()
6786                    .join(",")
6787                    .to_string(),
6788            )]),
6789        };
6790    }
6791    if let Some(ref local_var_str) = pfs_group__nic {
6792        local_var_req_builder = match "multi" {
6793            "multi" => local_var_req_builder.query(
6794                &local_var_str
6795                    .into_iter()
6796                    .map(|p| ("pfs_group__nic".to_owned(), p.to_string()))
6797                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6798            ),
6799            _ => local_var_req_builder.query(&[(
6800                "pfs_group__nic",
6801                &local_var_str
6802                    .into_iter()
6803                    .map(|p| p.to_string())
6804                    .collect::<Vec<String>>()
6805                    .join(",")
6806                    .to_string(),
6807            )]),
6808        };
6809    }
6810    if let Some(ref local_var_str) = pfs_group__nie {
6811        local_var_req_builder = match "multi" {
6812            "multi" => local_var_req_builder.query(
6813                &local_var_str
6814                    .into_iter()
6815                    .map(|p| ("pfs_group__nie".to_owned(), p.to_string()))
6816                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6817            ),
6818            _ => local_var_req_builder.query(&[(
6819                "pfs_group__nie",
6820                &local_var_str
6821                    .into_iter()
6822                    .map(|p| p.to_string())
6823                    .collect::<Vec<String>>()
6824                    .join(",")
6825                    .to_string(),
6826            )]),
6827        };
6828    }
6829    if let Some(ref local_var_str) = pfs_group__niew {
6830        local_var_req_builder = match "multi" {
6831            "multi" => local_var_req_builder.query(
6832                &local_var_str
6833                    .into_iter()
6834                    .map(|p| ("pfs_group__niew".to_owned(), p.to_string()))
6835                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6836            ),
6837            _ => local_var_req_builder.query(&[(
6838                "pfs_group__niew",
6839                &local_var_str
6840                    .into_iter()
6841                    .map(|p| p.to_string())
6842                    .collect::<Vec<String>>()
6843                    .join(",")
6844                    .to_string(),
6845            )]),
6846        };
6847    }
6848    if let Some(ref local_var_str) = pfs_group__nisw {
6849        local_var_req_builder = match "multi" {
6850            "multi" => local_var_req_builder.query(
6851                &local_var_str
6852                    .into_iter()
6853                    .map(|p| ("pfs_group__nisw".to_owned(), p.to_string()))
6854                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6855            ),
6856            _ => local_var_req_builder.query(&[(
6857                "pfs_group__nisw",
6858                &local_var_str
6859                    .into_iter()
6860                    .map(|p| p.to_string())
6861                    .collect::<Vec<String>>()
6862                    .join(",")
6863                    .to_string(),
6864            )]),
6865        };
6866    }
6867    if let Some(ref local_var_str) = pfs_group__regex {
6868        local_var_req_builder = match "multi" {
6869            "multi" => local_var_req_builder.query(
6870                &local_var_str
6871                    .into_iter()
6872                    .map(|p| ("pfs_group__regex".to_owned(), p.to_string()))
6873                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6874            ),
6875            _ => local_var_req_builder.query(&[(
6876                "pfs_group__regex",
6877                &local_var_str
6878                    .into_iter()
6879                    .map(|p| p.to_string())
6880                    .collect::<Vec<String>>()
6881                    .join(",")
6882                    .to_string(),
6883            )]),
6884        };
6885    }
6886    if let Some(ref local_var_str) = q {
6887        local_var_req_builder = local_var_req_builder.query(&[("q", &local_var_str.to_string())]);
6888    }
6889    if let Some(ref local_var_str) = tag {
6890        local_var_req_builder = match "multi" {
6891            "multi" => local_var_req_builder.query(
6892                &local_var_str
6893                    .into_iter()
6894                    .map(|p| ("tag".to_owned(), p.to_string()))
6895                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6896            ),
6897            _ => local_var_req_builder.query(&[(
6898                "tag",
6899                &local_var_str
6900                    .into_iter()
6901                    .map(|p| p.to_string())
6902                    .collect::<Vec<String>>()
6903                    .join(",")
6904                    .to_string(),
6905            )]),
6906        };
6907    }
6908    if let Some(ref local_var_str) = tag__n {
6909        local_var_req_builder = match "multi" {
6910            "multi" => local_var_req_builder.query(
6911                &local_var_str
6912                    .into_iter()
6913                    .map(|p| ("tag__n".to_owned(), p.to_string()))
6914                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6915            ),
6916            _ => local_var_req_builder.query(&[(
6917                "tag__n",
6918                &local_var_str
6919                    .into_iter()
6920                    .map(|p| p.to_string())
6921                    .collect::<Vec<String>>()
6922                    .join(",")
6923                    .to_string(),
6924            )]),
6925        };
6926    }
6927    if let Some(ref local_var_str) = tag_id {
6928        local_var_req_builder = match "multi" {
6929            "multi" => local_var_req_builder.query(
6930                &local_var_str
6931                    .into_iter()
6932                    .map(|p| ("tag_id".to_owned(), p.to_string()))
6933                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6934            ),
6935            _ => local_var_req_builder.query(&[(
6936                "tag_id",
6937                &local_var_str
6938                    .into_iter()
6939                    .map(|p| p.to_string())
6940                    .collect::<Vec<String>>()
6941                    .join(",")
6942                    .to_string(),
6943            )]),
6944        };
6945    }
6946    if let Some(ref local_var_str) = tag_id__n {
6947        local_var_req_builder = match "multi" {
6948            "multi" => local_var_req_builder.query(
6949                &local_var_str
6950                    .into_iter()
6951                    .map(|p| ("tag_id__n".to_owned(), p.to_string()))
6952                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6953            ),
6954            _ => local_var_req_builder.query(&[(
6955                "tag_id__n",
6956                &local_var_str
6957                    .into_iter()
6958                    .map(|p| p.to_string())
6959                    .collect::<Vec<String>>()
6960                    .join(",")
6961                    .to_string(),
6962            )]),
6963        };
6964    }
6965    if let Some(ref local_var_str) = updated_by_request {
6966        local_var_req_builder =
6967            local_var_req_builder.query(&[("updated_by_request", &local_var_str.to_string())]);
6968    }
6969    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
6970        local_var_req_builder =
6971            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
6972    }
6973    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
6974        let local_var_key = local_var_apikey.key.clone();
6975        let local_var_value = match local_var_apikey.prefix {
6976            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
6977            None => local_var_key,
6978        };
6979        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
6980    };
6981
6982    let local_var_req = local_var_req_builder.build()?;
6983    let local_var_resp = local_var_client.execute(local_var_req).await?;
6984
6985    let local_var_status = local_var_resp.status();
6986    let local_var_content = local_var_resp.text().await?;
6987
6988    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
6989        serde_json::from_str(&local_var_content).map_err(Error::from)
6990    } else {
6991        let local_var_entity: Option<VpnIpsecPoliciesListError> =
6992            serde_json::from_str(&local_var_content).ok();
6993        let local_var_error = ResponseContent {
6994            status: local_var_status,
6995            content: local_var_content,
6996            entity: local_var_entity,
6997        };
6998        Err(Error::ResponseError(local_var_error))
6999    }
7000}
7001
7002/// Patch a IPSec policy object.
7003pub async fn vpn_ipsec_policies_partial_update(
7004    configuration: &configuration::Configuration,
7005    id: i32,
7006    patched_writable_ip_sec_policy_request: Option<
7007        crate::models::PatchedWritableIpSecPolicyRequest,
7008    >,
7009) -> Result<crate::models::IpSecPolicy, Error<VpnIpsecPoliciesPartialUpdateError>> {
7010    let local_var_configuration = configuration;
7011
7012    let local_var_client = &local_var_configuration.client;
7013
7014    let local_var_uri_str = format!(
7015        "{}/api/vpn/ipsec-policies/{id}/",
7016        local_var_configuration.base_path,
7017        id = id
7018    );
7019    let mut local_var_req_builder =
7020        local_var_client.request(reqwest::Method::PATCH, local_var_uri_str.as_str());
7021
7022    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
7023        local_var_req_builder =
7024            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
7025    }
7026    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
7027        let local_var_key = local_var_apikey.key.clone();
7028        let local_var_value = match local_var_apikey.prefix {
7029            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
7030            None => local_var_key,
7031        };
7032        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
7033    };
7034    local_var_req_builder = local_var_req_builder.json(&patched_writable_ip_sec_policy_request);
7035
7036    let local_var_req = local_var_req_builder.build()?;
7037    let local_var_resp = local_var_client.execute(local_var_req).await?;
7038
7039    let local_var_status = local_var_resp.status();
7040    let local_var_content = local_var_resp.text().await?;
7041
7042    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
7043        serde_json::from_str(&local_var_content).map_err(Error::from)
7044    } else {
7045        let local_var_entity: Option<VpnIpsecPoliciesPartialUpdateError> =
7046            serde_json::from_str(&local_var_content).ok();
7047        let local_var_error = ResponseContent {
7048            status: local_var_status,
7049            content: local_var_content,
7050            entity: local_var_entity,
7051        };
7052        Err(Error::ResponseError(local_var_error))
7053    }
7054}
7055
7056/// Get a IPSec policy object.
7057pub async fn vpn_ipsec_policies_retrieve(
7058    configuration: &configuration::Configuration,
7059    id: i32,
7060) -> Result<crate::models::IpSecPolicy, Error<VpnIpsecPoliciesRetrieveError>> {
7061    let local_var_configuration = configuration;
7062
7063    let local_var_client = &local_var_configuration.client;
7064
7065    let local_var_uri_str = format!(
7066        "{}/api/vpn/ipsec-policies/{id}/",
7067        local_var_configuration.base_path,
7068        id = id
7069    );
7070    let mut local_var_req_builder =
7071        local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
7072
7073    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
7074        local_var_req_builder =
7075            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
7076    }
7077    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
7078        let local_var_key = local_var_apikey.key.clone();
7079        let local_var_value = match local_var_apikey.prefix {
7080            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
7081            None => local_var_key,
7082        };
7083        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
7084    };
7085
7086    let local_var_req = local_var_req_builder.build()?;
7087    let local_var_resp = local_var_client.execute(local_var_req).await?;
7088
7089    let local_var_status = local_var_resp.status();
7090    let local_var_content = local_var_resp.text().await?;
7091
7092    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
7093        serde_json::from_str(&local_var_content).map_err(Error::from)
7094    } else {
7095        let local_var_entity: Option<VpnIpsecPoliciesRetrieveError> =
7096            serde_json::from_str(&local_var_content).ok();
7097        let local_var_error = ResponseContent {
7098            status: local_var_status,
7099            content: local_var_content,
7100            entity: local_var_entity,
7101        };
7102        Err(Error::ResponseError(local_var_error))
7103    }
7104}
7105
7106/// Put a IPSec policy object.
7107pub async fn vpn_ipsec_policies_update(
7108    configuration: &configuration::Configuration,
7109    id: i32,
7110    writable_ip_sec_policy_request: crate::models::WritableIpSecPolicyRequest,
7111) -> Result<crate::models::IpSecPolicy, Error<VpnIpsecPoliciesUpdateError>> {
7112    let local_var_configuration = configuration;
7113
7114    let local_var_client = &local_var_configuration.client;
7115
7116    let local_var_uri_str = format!(
7117        "{}/api/vpn/ipsec-policies/{id}/",
7118        local_var_configuration.base_path,
7119        id = id
7120    );
7121    let mut local_var_req_builder =
7122        local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());
7123
7124    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
7125        local_var_req_builder =
7126            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
7127    }
7128    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
7129        let local_var_key = local_var_apikey.key.clone();
7130        let local_var_value = match local_var_apikey.prefix {
7131            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
7132            None => local_var_key,
7133        };
7134        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
7135    };
7136    local_var_req_builder = local_var_req_builder.json(&writable_ip_sec_policy_request);
7137
7138    let local_var_req = local_var_req_builder.build()?;
7139    let local_var_resp = local_var_client.execute(local_var_req).await?;
7140
7141    let local_var_status = local_var_resp.status();
7142    let local_var_content = local_var_resp.text().await?;
7143
7144    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
7145        serde_json::from_str(&local_var_content).map_err(Error::from)
7146    } else {
7147        let local_var_entity: Option<VpnIpsecPoliciesUpdateError> =
7148            serde_json::from_str(&local_var_content).ok();
7149        let local_var_error = ResponseContent {
7150            status: local_var_status,
7151            content: local_var_content,
7152            entity: local_var_entity,
7153        };
7154        Err(Error::ResponseError(local_var_error))
7155    }
7156}
7157
7158/// Delete a list of IPSec profile objects.
7159pub async fn vpn_ipsec_profiles_bulk_destroy(
7160    configuration: &configuration::Configuration,
7161    ip_sec_profile_request: Vec<crate::models::IpSecProfileRequest>,
7162) -> Result<(), Error<VpnIpsecProfilesBulkDestroyError>> {
7163    let local_var_configuration = configuration;
7164
7165    let local_var_client = &local_var_configuration.client;
7166
7167    let local_var_uri_str = format!(
7168        "{}/api/vpn/ipsec-profiles/",
7169        local_var_configuration.base_path
7170    );
7171    let mut local_var_req_builder =
7172        local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());
7173
7174    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
7175        local_var_req_builder =
7176            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
7177    }
7178    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
7179        let local_var_key = local_var_apikey.key.clone();
7180        let local_var_value = match local_var_apikey.prefix {
7181            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
7182            None => local_var_key,
7183        };
7184        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
7185    };
7186    local_var_req_builder = local_var_req_builder.json(&ip_sec_profile_request);
7187
7188    let local_var_req = local_var_req_builder.build()?;
7189    let local_var_resp = local_var_client.execute(local_var_req).await?;
7190
7191    let local_var_status = local_var_resp.status();
7192    let local_var_content = local_var_resp.text().await?;
7193
7194    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
7195        Ok(())
7196    } else {
7197        let local_var_entity: Option<VpnIpsecProfilesBulkDestroyError> =
7198            serde_json::from_str(&local_var_content).ok();
7199        let local_var_error = ResponseContent {
7200            status: local_var_status,
7201            content: local_var_content,
7202            entity: local_var_entity,
7203        };
7204        Err(Error::ResponseError(local_var_error))
7205    }
7206}
7207
7208/// Patch a list of IPSec profile objects.
7209pub async fn vpn_ipsec_profiles_bulk_partial_update(
7210    configuration: &configuration::Configuration,
7211    ip_sec_profile_request: Vec<crate::models::IpSecProfileRequest>,
7212) -> Result<Vec<crate::models::IpSecProfile>, Error<VpnIpsecProfilesBulkPartialUpdateError>> {
7213    let local_var_configuration = configuration;
7214
7215    let local_var_client = &local_var_configuration.client;
7216
7217    let local_var_uri_str = format!(
7218        "{}/api/vpn/ipsec-profiles/",
7219        local_var_configuration.base_path
7220    );
7221    let mut local_var_req_builder =
7222        local_var_client.request(reqwest::Method::PATCH, local_var_uri_str.as_str());
7223
7224    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
7225        local_var_req_builder =
7226            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
7227    }
7228    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
7229        let local_var_key = local_var_apikey.key.clone();
7230        let local_var_value = match local_var_apikey.prefix {
7231            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
7232            None => local_var_key,
7233        };
7234        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
7235    };
7236    local_var_req_builder = local_var_req_builder.json(&ip_sec_profile_request);
7237
7238    let local_var_req = local_var_req_builder.build()?;
7239    let local_var_resp = local_var_client.execute(local_var_req).await?;
7240
7241    let local_var_status = local_var_resp.status();
7242    let local_var_content = local_var_resp.text().await?;
7243
7244    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
7245        serde_json::from_str(&local_var_content).map_err(Error::from)
7246    } else {
7247        let local_var_entity: Option<VpnIpsecProfilesBulkPartialUpdateError> =
7248            serde_json::from_str(&local_var_content).ok();
7249        let local_var_error = ResponseContent {
7250            status: local_var_status,
7251            content: local_var_content,
7252            entity: local_var_entity,
7253        };
7254        Err(Error::ResponseError(local_var_error))
7255    }
7256}
7257
7258/// Put a list of IPSec profile objects.
7259pub async fn vpn_ipsec_profiles_bulk_update(
7260    configuration: &configuration::Configuration,
7261    ip_sec_profile_request: Vec<crate::models::IpSecProfileRequest>,
7262) -> Result<Vec<crate::models::IpSecProfile>, Error<VpnIpsecProfilesBulkUpdateError>> {
7263    let local_var_configuration = configuration;
7264
7265    let local_var_client = &local_var_configuration.client;
7266
7267    let local_var_uri_str = format!(
7268        "{}/api/vpn/ipsec-profiles/",
7269        local_var_configuration.base_path
7270    );
7271    let mut local_var_req_builder =
7272        local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());
7273
7274    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
7275        local_var_req_builder =
7276            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
7277    }
7278    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
7279        let local_var_key = local_var_apikey.key.clone();
7280        let local_var_value = match local_var_apikey.prefix {
7281            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
7282            None => local_var_key,
7283        };
7284        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
7285    };
7286    local_var_req_builder = local_var_req_builder.json(&ip_sec_profile_request);
7287
7288    let local_var_req = local_var_req_builder.build()?;
7289    let local_var_resp = local_var_client.execute(local_var_req).await?;
7290
7291    let local_var_status = local_var_resp.status();
7292    let local_var_content = local_var_resp.text().await?;
7293
7294    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
7295        serde_json::from_str(&local_var_content).map_err(Error::from)
7296    } else {
7297        let local_var_entity: Option<VpnIpsecProfilesBulkUpdateError> =
7298            serde_json::from_str(&local_var_content).ok();
7299        let local_var_error = ResponseContent {
7300            status: local_var_status,
7301            content: local_var_content,
7302            entity: local_var_entity,
7303        };
7304        Err(Error::ResponseError(local_var_error))
7305    }
7306}
7307
7308/// Post a list of IPSec profile objects.
7309pub async fn vpn_ipsec_profiles_create(
7310    configuration: &configuration::Configuration,
7311    writable_ip_sec_profile_request: crate::models::WritableIpSecProfileRequest,
7312) -> Result<crate::models::IpSecProfile, Error<VpnIpsecProfilesCreateError>> {
7313    let local_var_configuration = configuration;
7314
7315    let local_var_client = &local_var_configuration.client;
7316
7317    let local_var_uri_str = format!(
7318        "{}/api/vpn/ipsec-profiles/",
7319        local_var_configuration.base_path
7320    );
7321    let mut local_var_req_builder =
7322        local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
7323
7324    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
7325        local_var_req_builder =
7326            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
7327    }
7328    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
7329        let local_var_key = local_var_apikey.key.clone();
7330        let local_var_value = match local_var_apikey.prefix {
7331            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
7332            None => local_var_key,
7333        };
7334        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
7335    };
7336    local_var_req_builder = local_var_req_builder.json(&writable_ip_sec_profile_request);
7337
7338    let local_var_req = local_var_req_builder.build()?;
7339    let local_var_resp = local_var_client.execute(local_var_req).await?;
7340
7341    let local_var_status = local_var_resp.status();
7342    let local_var_content = local_var_resp.text().await?;
7343
7344    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
7345        serde_json::from_str(&local_var_content).map_err(Error::from)
7346    } else {
7347        let local_var_entity: Option<VpnIpsecProfilesCreateError> =
7348            serde_json::from_str(&local_var_content).ok();
7349        let local_var_error = ResponseContent {
7350            status: local_var_status,
7351            content: local_var_content,
7352            entity: local_var_entity,
7353        };
7354        Err(Error::ResponseError(local_var_error))
7355    }
7356}
7357
7358/// Delete a IPSec profile object.
7359pub async fn vpn_ipsec_profiles_destroy(
7360    configuration: &configuration::Configuration,
7361    id: i32,
7362) -> Result<(), Error<VpnIpsecProfilesDestroyError>> {
7363    let local_var_configuration = configuration;
7364
7365    let local_var_client = &local_var_configuration.client;
7366
7367    let local_var_uri_str = format!(
7368        "{}/api/vpn/ipsec-profiles/{id}/",
7369        local_var_configuration.base_path,
7370        id = id
7371    );
7372    let mut local_var_req_builder =
7373        local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());
7374
7375    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
7376        local_var_req_builder =
7377            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
7378    }
7379    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
7380        let local_var_key = local_var_apikey.key.clone();
7381        let local_var_value = match local_var_apikey.prefix {
7382            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
7383            None => local_var_key,
7384        };
7385        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
7386    };
7387
7388    let local_var_req = local_var_req_builder.build()?;
7389    let local_var_resp = local_var_client.execute(local_var_req).await?;
7390
7391    let local_var_status = local_var_resp.status();
7392    let local_var_content = local_var_resp.text().await?;
7393
7394    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
7395        Ok(())
7396    } else {
7397        let local_var_entity: Option<VpnIpsecProfilesDestroyError> =
7398            serde_json::from_str(&local_var_content).ok();
7399        let local_var_error = ResponseContent {
7400            status: local_var_status,
7401            content: local_var_content,
7402            entity: local_var_entity,
7403        };
7404        Err(Error::ResponseError(local_var_error))
7405    }
7406}
7407
7408/// Get a list of IPSec profile objects.
7409pub async fn vpn_ipsec_profiles_list(
7410    configuration: &configuration::Configuration,
7411    created: Option<Vec<String>>,
7412    created__empty: Option<Vec<String>>,
7413    created__gt: Option<Vec<String>>,
7414    created__gte: Option<Vec<String>>,
7415    created__lt: Option<Vec<String>>,
7416    created__lte: Option<Vec<String>>,
7417    created__n: Option<Vec<String>>,
7418    created_by_request: Option<&str>,
7419    description: Option<Vec<String>>,
7420    description__empty: Option<bool>,
7421    description__ic: Option<Vec<String>>,
7422    description__ie: Option<Vec<String>>,
7423    description__iew: Option<Vec<String>>,
7424    description__iregex: Option<Vec<String>>,
7425    description__isw: Option<Vec<String>>,
7426    description__n: Option<Vec<String>>,
7427    description__nic: Option<Vec<String>>,
7428    description__nie: Option<Vec<String>>,
7429    description__niew: Option<Vec<String>>,
7430    description__nisw: Option<Vec<String>>,
7431    description__regex: Option<Vec<String>>,
7432    id: Option<Vec<i32>>,
7433    id__empty: Option<bool>,
7434    id__gt: Option<Vec<i32>>,
7435    id__gte: Option<Vec<i32>>,
7436    id__lt: Option<Vec<i32>>,
7437    id__lte: Option<Vec<i32>>,
7438    id__n: Option<Vec<i32>>,
7439    ike_policy: Option<Vec<String>>,
7440    ike_policy__n: Option<Vec<String>>,
7441    ike_policy_id: Option<Vec<i32>>,
7442    ike_policy_id__n: Option<Vec<i32>>,
7443    ipsec_policy: Option<Vec<String>>,
7444    ipsec_policy__n: Option<Vec<String>>,
7445    ipsec_policy_id: Option<Vec<i32>>,
7446    ipsec_policy_id__n: Option<Vec<i32>>,
7447    last_updated: Option<Vec<String>>,
7448    last_updated__empty: Option<Vec<String>>,
7449    last_updated__gt: Option<Vec<String>>,
7450    last_updated__gte: Option<Vec<String>>,
7451    last_updated__lt: Option<Vec<String>>,
7452    last_updated__lte: Option<Vec<String>>,
7453    last_updated__n: Option<Vec<String>>,
7454    limit: Option<i32>,
7455    mode: Option<Vec<String>>,
7456    mode__empty: Option<bool>,
7457    mode__ic: Option<Vec<String>>,
7458    mode__ie: Option<Vec<String>>,
7459    mode__iew: Option<Vec<String>>,
7460    mode__iregex: Option<Vec<String>>,
7461    mode__isw: Option<Vec<String>>,
7462    mode__n: Option<Vec<String>>,
7463    mode__nic: Option<Vec<String>>,
7464    mode__nie: Option<Vec<String>>,
7465    mode__niew: Option<Vec<String>>,
7466    mode__nisw: Option<Vec<String>>,
7467    mode__regex: Option<Vec<String>>,
7468    modified_by_request: Option<&str>,
7469    name: Option<Vec<String>>,
7470    name__empty: Option<bool>,
7471    name__ic: Option<Vec<String>>,
7472    name__ie: Option<Vec<String>>,
7473    name__iew: Option<Vec<String>>,
7474    name__iregex: Option<Vec<String>>,
7475    name__isw: Option<Vec<String>>,
7476    name__n: Option<Vec<String>>,
7477    name__nic: Option<Vec<String>>,
7478    name__nie: Option<Vec<String>>,
7479    name__niew: Option<Vec<String>>,
7480    name__nisw: Option<Vec<String>>,
7481    name__regex: Option<Vec<String>>,
7482    offset: Option<i32>,
7483    ordering: Option<&str>,
7484    q: Option<&str>,
7485    tag: Option<Vec<String>>,
7486    tag__n: Option<Vec<String>>,
7487    tag_id: Option<Vec<i32>>,
7488    tag_id__n: Option<Vec<i32>>,
7489    updated_by_request: Option<&str>,
7490) -> Result<crate::models::PaginatedIpSecProfileList, Error<VpnIpsecProfilesListError>> {
7491    let local_var_configuration = configuration;
7492
7493    let local_var_client = &local_var_configuration.client;
7494
7495    let local_var_uri_str = format!(
7496        "{}/api/vpn/ipsec-profiles/",
7497        local_var_configuration.base_path
7498    );
7499    let mut local_var_req_builder =
7500        local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
7501
7502    if let Some(ref local_var_str) = created {
7503        local_var_req_builder = match "multi" {
7504            "multi" => local_var_req_builder.query(
7505                &local_var_str
7506                    .into_iter()
7507                    .map(|p| ("created".to_owned(), p.to_string()))
7508                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7509            ),
7510            _ => local_var_req_builder.query(&[(
7511                "created",
7512                &local_var_str
7513                    .into_iter()
7514                    .map(|p| p.to_string())
7515                    .collect::<Vec<String>>()
7516                    .join(",")
7517                    .to_string(),
7518            )]),
7519        };
7520    }
7521    if let Some(ref local_var_str) = created__empty {
7522        local_var_req_builder = match "multi" {
7523            "multi" => local_var_req_builder.query(
7524                &local_var_str
7525                    .into_iter()
7526                    .map(|p| ("created__empty".to_owned(), p.to_string()))
7527                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7528            ),
7529            _ => local_var_req_builder.query(&[(
7530                "created__empty",
7531                &local_var_str
7532                    .into_iter()
7533                    .map(|p| p.to_string())
7534                    .collect::<Vec<String>>()
7535                    .join(",")
7536                    .to_string(),
7537            )]),
7538        };
7539    }
7540    if let Some(ref local_var_str) = created__gt {
7541        local_var_req_builder = match "multi" {
7542            "multi" => local_var_req_builder.query(
7543                &local_var_str
7544                    .into_iter()
7545                    .map(|p| ("created__gt".to_owned(), p.to_string()))
7546                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7547            ),
7548            _ => local_var_req_builder.query(&[(
7549                "created__gt",
7550                &local_var_str
7551                    .into_iter()
7552                    .map(|p| p.to_string())
7553                    .collect::<Vec<String>>()
7554                    .join(",")
7555                    .to_string(),
7556            )]),
7557        };
7558    }
7559    if let Some(ref local_var_str) = created__gte {
7560        local_var_req_builder = match "multi" {
7561            "multi" => local_var_req_builder.query(
7562                &local_var_str
7563                    .into_iter()
7564                    .map(|p| ("created__gte".to_owned(), p.to_string()))
7565                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7566            ),
7567            _ => local_var_req_builder.query(&[(
7568                "created__gte",
7569                &local_var_str
7570                    .into_iter()
7571                    .map(|p| p.to_string())
7572                    .collect::<Vec<String>>()
7573                    .join(",")
7574                    .to_string(),
7575            )]),
7576        };
7577    }
7578    if let Some(ref local_var_str) = created__lt {
7579        local_var_req_builder = match "multi" {
7580            "multi" => local_var_req_builder.query(
7581                &local_var_str
7582                    .into_iter()
7583                    .map(|p| ("created__lt".to_owned(), p.to_string()))
7584                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7585            ),
7586            _ => local_var_req_builder.query(&[(
7587                "created__lt",
7588                &local_var_str
7589                    .into_iter()
7590                    .map(|p| p.to_string())
7591                    .collect::<Vec<String>>()
7592                    .join(",")
7593                    .to_string(),
7594            )]),
7595        };
7596    }
7597    if let Some(ref local_var_str) = created__lte {
7598        local_var_req_builder = match "multi" {
7599            "multi" => local_var_req_builder.query(
7600                &local_var_str
7601                    .into_iter()
7602                    .map(|p| ("created__lte".to_owned(), p.to_string()))
7603                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7604            ),
7605            _ => local_var_req_builder.query(&[(
7606                "created__lte",
7607                &local_var_str
7608                    .into_iter()
7609                    .map(|p| p.to_string())
7610                    .collect::<Vec<String>>()
7611                    .join(",")
7612                    .to_string(),
7613            )]),
7614        };
7615    }
7616    if let Some(ref local_var_str) = created__n {
7617        local_var_req_builder = match "multi" {
7618            "multi" => local_var_req_builder.query(
7619                &local_var_str
7620                    .into_iter()
7621                    .map(|p| ("created__n".to_owned(), p.to_string()))
7622                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7623            ),
7624            _ => local_var_req_builder.query(&[(
7625                "created__n",
7626                &local_var_str
7627                    .into_iter()
7628                    .map(|p| p.to_string())
7629                    .collect::<Vec<String>>()
7630                    .join(",")
7631                    .to_string(),
7632            )]),
7633        };
7634    }
7635    if let Some(ref local_var_str) = created_by_request {
7636        local_var_req_builder =
7637            local_var_req_builder.query(&[("created_by_request", &local_var_str.to_string())]);
7638    }
7639    if let Some(ref local_var_str) = description {
7640        local_var_req_builder = match "multi" {
7641            "multi" => local_var_req_builder.query(
7642                &local_var_str
7643                    .into_iter()
7644                    .map(|p| ("description".to_owned(), p.to_string()))
7645                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7646            ),
7647            _ => local_var_req_builder.query(&[(
7648                "description",
7649                &local_var_str
7650                    .into_iter()
7651                    .map(|p| p.to_string())
7652                    .collect::<Vec<String>>()
7653                    .join(",")
7654                    .to_string(),
7655            )]),
7656        };
7657    }
7658    if let Some(ref local_var_str) = description__empty {
7659        local_var_req_builder =
7660            local_var_req_builder.query(&[("description__empty", &local_var_str.to_string())]);
7661    }
7662    if let Some(ref local_var_str) = description__ic {
7663        local_var_req_builder = match "multi" {
7664            "multi" => local_var_req_builder.query(
7665                &local_var_str
7666                    .into_iter()
7667                    .map(|p| ("description__ic".to_owned(), p.to_string()))
7668                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7669            ),
7670            _ => local_var_req_builder.query(&[(
7671                "description__ic",
7672                &local_var_str
7673                    .into_iter()
7674                    .map(|p| p.to_string())
7675                    .collect::<Vec<String>>()
7676                    .join(",")
7677                    .to_string(),
7678            )]),
7679        };
7680    }
7681    if let Some(ref local_var_str) = description__ie {
7682        local_var_req_builder = match "multi" {
7683            "multi" => local_var_req_builder.query(
7684                &local_var_str
7685                    .into_iter()
7686                    .map(|p| ("description__ie".to_owned(), p.to_string()))
7687                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7688            ),
7689            _ => local_var_req_builder.query(&[(
7690                "description__ie",
7691                &local_var_str
7692                    .into_iter()
7693                    .map(|p| p.to_string())
7694                    .collect::<Vec<String>>()
7695                    .join(",")
7696                    .to_string(),
7697            )]),
7698        };
7699    }
7700    if let Some(ref local_var_str) = description__iew {
7701        local_var_req_builder = match "multi" {
7702            "multi" => local_var_req_builder.query(
7703                &local_var_str
7704                    .into_iter()
7705                    .map(|p| ("description__iew".to_owned(), p.to_string()))
7706                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7707            ),
7708            _ => local_var_req_builder.query(&[(
7709                "description__iew",
7710                &local_var_str
7711                    .into_iter()
7712                    .map(|p| p.to_string())
7713                    .collect::<Vec<String>>()
7714                    .join(",")
7715                    .to_string(),
7716            )]),
7717        };
7718    }
7719    if let Some(ref local_var_str) = description__iregex {
7720        local_var_req_builder = match "multi" {
7721            "multi" => local_var_req_builder.query(
7722                &local_var_str
7723                    .into_iter()
7724                    .map(|p| ("description__iregex".to_owned(), p.to_string()))
7725                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7726            ),
7727            _ => local_var_req_builder.query(&[(
7728                "description__iregex",
7729                &local_var_str
7730                    .into_iter()
7731                    .map(|p| p.to_string())
7732                    .collect::<Vec<String>>()
7733                    .join(",")
7734                    .to_string(),
7735            )]),
7736        };
7737    }
7738    if let Some(ref local_var_str) = description__isw {
7739        local_var_req_builder = match "multi" {
7740            "multi" => local_var_req_builder.query(
7741                &local_var_str
7742                    .into_iter()
7743                    .map(|p| ("description__isw".to_owned(), p.to_string()))
7744                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7745            ),
7746            _ => local_var_req_builder.query(&[(
7747                "description__isw",
7748                &local_var_str
7749                    .into_iter()
7750                    .map(|p| p.to_string())
7751                    .collect::<Vec<String>>()
7752                    .join(",")
7753                    .to_string(),
7754            )]),
7755        };
7756    }
7757    if let Some(ref local_var_str) = description__n {
7758        local_var_req_builder = match "multi" {
7759            "multi" => local_var_req_builder.query(
7760                &local_var_str
7761                    .into_iter()
7762                    .map(|p| ("description__n".to_owned(), p.to_string()))
7763                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7764            ),
7765            _ => local_var_req_builder.query(&[(
7766                "description__n",
7767                &local_var_str
7768                    .into_iter()
7769                    .map(|p| p.to_string())
7770                    .collect::<Vec<String>>()
7771                    .join(",")
7772                    .to_string(),
7773            )]),
7774        };
7775    }
7776    if let Some(ref local_var_str) = description__nic {
7777        local_var_req_builder = match "multi" {
7778            "multi" => local_var_req_builder.query(
7779                &local_var_str
7780                    .into_iter()
7781                    .map(|p| ("description__nic".to_owned(), p.to_string()))
7782                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7783            ),
7784            _ => local_var_req_builder.query(&[(
7785                "description__nic",
7786                &local_var_str
7787                    .into_iter()
7788                    .map(|p| p.to_string())
7789                    .collect::<Vec<String>>()
7790                    .join(",")
7791                    .to_string(),
7792            )]),
7793        };
7794    }
7795    if let Some(ref local_var_str) = description__nie {
7796        local_var_req_builder = match "multi" {
7797            "multi" => local_var_req_builder.query(
7798                &local_var_str
7799                    .into_iter()
7800                    .map(|p| ("description__nie".to_owned(), p.to_string()))
7801                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7802            ),
7803            _ => local_var_req_builder.query(&[(
7804                "description__nie",
7805                &local_var_str
7806                    .into_iter()
7807                    .map(|p| p.to_string())
7808                    .collect::<Vec<String>>()
7809                    .join(",")
7810                    .to_string(),
7811            )]),
7812        };
7813    }
7814    if let Some(ref local_var_str) = description__niew {
7815        local_var_req_builder = match "multi" {
7816            "multi" => local_var_req_builder.query(
7817                &local_var_str
7818                    .into_iter()
7819                    .map(|p| ("description__niew".to_owned(), p.to_string()))
7820                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7821            ),
7822            _ => local_var_req_builder.query(&[(
7823                "description__niew",
7824                &local_var_str
7825                    .into_iter()
7826                    .map(|p| p.to_string())
7827                    .collect::<Vec<String>>()
7828                    .join(",")
7829                    .to_string(),
7830            )]),
7831        };
7832    }
7833    if let Some(ref local_var_str) = description__nisw {
7834        local_var_req_builder = match "multi" {
7835            "multi" => local_var_req_builder.query(
7836                &local_var_str
7837                    .into_iter()
7838                    .map(|p| ("description__nisw".to_owned(), p.to_string()))
7839                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7840            ),
7841            _ => local_var_req_builder.query(&[(
7842                "description__nisw",
7843                &local_var_str
7844                    .into_iter()
7845                    .map(|p| p.to_string())
7846                    .collect::<Vec<String>>()
7847                    .join(",")
7848                    .to_string(),
7849            )]),
7850        };
7851    }
7852    if let Some(ref local_var_str) = description__regex {
7853        local_var_req_builder = match "multi" {
7854            "multi" => local_var_req_builder.query(
7855                &local_var_str
7856                    .into_iter()
7857                    .map(|p| ("description__regex".to_owned(), p.to_string()))
7858                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7859            ),
7860            _ => local_var_req_builder.query(&[(
7861                "description__regex",
7862                &local_var_str
7863                    .into_iter()
7864                    .map(|p| p.to_string())
7865                    .collect::<Vec<String>>()
7866                    .join(",")
7867                    .to_string(),
7868            )]),
7869        };
7870    }
7871    if let Some(ref local_var_str) = id {
7872        local_var_req_builder = match "multi" {
7873            "multi" => local_var_req_builder.query(
7874                &local_var_str
7875                    .into_iter()
7876                    .map(|p| ("id".to_owned(), p.to_string()))
7877                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7878            ),
7879            _ => local_var_req_builder.query(&[(
7880                "id",
7881                &local_var_str
7882                    .into_iter()
7883                    .map(|p| p.to_string())
7884                    .collect::<Vec<String>>()
7885                    .join(",")
7886                    .to_string(),
7887            )]),
7888        };
7889    }
7890    if let Some(ref local_var_str) = id__empty {
7891        local_var_req_builder =
7892            local_var_req_builder.query(&[("id__empty", &local_var_str.to_string())]);
7893    }
7894    if let Some(ref local_var_str) = id__gt {
7895        local_var_req_builder = match "multi" {
7896            "multi" => local_var_req_builder.query(
7897                &local_var_str
7898                    .into_iter()
7899                    .map(|p| ("id__gt".to_owned(), p.to_string()))
7900                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7901            ),
7902            _ => local_var_req_builder.query(&[(
7903                "id__gt",
7904                &local_var_str
7905                    .into_iter()
7906                    .map(|p| p.to_string())
7907                    .collect::<Vec<String>>()
7908                    .join(",")
7909                    .to_string(),
7910            )]),
7911        };
7912    }
7913    if let Some(ref local_var_str) = id__gte {
7914        local_var_req_builder = match "multi" {
7915            "multi" => local_var_req_builder.query(
7916                &local_var_str
7917                    .into_iter()
7918                    .map(|p| ("id__gte".to_owned(), p.to_string()))
7919                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7920            ),
7921            _ => local_var_req_builder.query(&[(
7922                "id__gte",
7923                &local_var_str
7924                    .into_iter()
7925                    .map(|p| p.to_string())
7926                    .collect::<Vec<String>>()
7927                    .join(",")
7928                    .to_string(),
7929            )]),
7930        };
7931    }
7932    if let Some(ref local_var_str) = id__lt {
7933        local_var_req_builder = match "multi" {
7934            "multi" => local_var_req_builder.query(
7935                &local_var_str
7936                    .into_iter()
7937                    .map(|p| ("id__lt".to_owned(), p.to_string()))
7938                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7939            ),
7940            _ => local_var_req_builder.query(&[(
7941                "id__lt",
7942                &local_var_str
7943                    .into_iter()
7944                    .map(|p| p.to_string())
7945                    .collect::<Vec<String>>()
7946                    .join(",")
7947                    .to_string(),
7948            )]),
7949        };
7950    }
7951    if let Some(ref local_var_str) = id__lte {
7952        local_var_req_builder = match "multi" {
7953            "multi" => local_var_req_builder.query(
7954                &local_var_str
7955                    .into_iter()
7956                    .map(|p| ("id__lte".to_owned(), p.to_string()))
7957                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7958            ),
7959            _ => local_var_req_builder.query(&[(
7960                "id__lte",
7961                &local_var_str
7962                    .into_iter()
7963                    .map(|p| p.to_string())
7964                    .collect::<Vec<String>>()
7965                    .join(",")
7966                    .to_string(),
7967            )]),
7968        };
7969    }
7970    if let Some(ref local_var_str) = id__n {
7971        local_var_req_builder = match "multi" {
7972            "multi" => local_var_req_builder.query(
7973                &local_var_str
7974                    .into_iter()
7975                    .map(|p| ("id__n".to_owned(), p.to_string()))
7976                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7977            ),
7978            _ => local_var_req_builder.query(&[(
7979                "id__n",
7980                &local_var_str
7981                    .into_iter()
7982                    .map(|p| p.to_string())
7983                    .collect::<Vec<String>>()
7984                    .join(",")
7985                    .to_string(),
7986            )]),
7987        };
7988    }
7989    if let Some(ref local_var_str) = ike_policy {
7990        local_var_req_builder = match "multi" {
7991            "multi" => local_var_req_builder.query(
7992                &local_var_str
7993                    .into_iter()
7994                    .map(|p| ("ike_policy".to_owned(), p.to_string()))
7995                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7996            ),
7997            _ => local_var_req_builder.query(&[(
7998                "ike_policy",
7999                &local_var_str
8000                    .into_iter()
8001                    .map(|p| p.to_string())
8002                    .collect::<Vec<String>>()
8003                    .join(",")
8004                    .to_string(),
8005            )]),
8006        };
8007    }
8008    if let Some(ref local_var_str) = ike_policy__n {
8009        local_var_req_builder = match "multi" {
8010            "multi" => local_var_req_builder.query(
8011                &local_var_str
8012                    .into_iter()
8013                    .map(|p| ("ike_policy__n".to_owned(), p.to_string()))
8014                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8015            ),
8016            _ => local_var_req_builder.query(&[(
8017                "ike_policy__n",
8018                &local_var_str
8019                    .into_iter()
8020                    .map(|p| p.to_string())
8021                    .collect::<Vec<String>>()
8022                    .join(",")
8023                    .to_string(),
8024            )]),
8025        };
8026    }
8027    if let Some(ref local_var_str) = ike_policy_id {
8028        local_var_req_builder = match "multi" {
8029            "multi" => local_var_req_builder.query(
8030                &local_var_str
8031                    .into_iter()
8032                    .map(|p| ("ike_policy_id".to_owned(), p.to_string()))
8033                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8034            ),
8035            _ => local_var_req_builder.query(&[(
8036                "ike_policy_id",
8037                &local_var_str
8038                    .into_iter()
8039                    .map(|p| p.to_string())
8040                    .collect::<Vec<String>>()
8041                    .join(",")
8042                    .to_string(),
8043            )]),
8044        };
8045    }
8046    if let Some(ref local_var_str) = ike_policy_id__n {
8047        local_var_req_builder = match "multi" {
8048            "multi" => local_var_req_builder.query(
8049                &local_var_str
8050                    .into_iter()
8051                    .map(|p| ("ike_policy_id__n".to_owned(), p.to_string()))
8052                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8053            ),
8054            _ => local_var_req_builder.query(&[(
8055                "ike_policy_id__n",
8056                &local_var_str
8057                    .into_iter()
8058                    .map(|p| p.to_string())
8059                    .collect::<Vec<String>>()
8060                    .join(",")
8061                    .to_string(),
8062            )]),
8063        };
8064    }
8065    if let Some(ref local_var_str) = ipsec_policy {
8066        local_var_req_builder = match "multi" {
8067            "multi" => local_var_req_builder.query(
8068                &local_var_str
8069                    .into_iter()
8070                    .map(|p| ("ipsec_policy".to_owned(), p.to_string()))
8071                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8072            ),
8073            _ => local_var_req_builder.query(&[(
8074                "ipsec_policy",
8075                &local_var_str
8076                    .into_iter()
8077                    .map(|p| p.to_string())
8078                    .collect::<Vec<String>>()
8079                    .join(",")
8080                    .to_string(),
8081            )]),
8082        };
8083    }
8084    if let Some(ref local_var_str) = ipsec_policy__n {
8085        local_var_req_builder = match "multi" {
8086            "multi" => local_var_req_builder.query(
8087                &local_var_str
8088                    .into_iter()
8089                    .map(|p| ("ipsec_policy__n".to_owned(), p.to_string()))
8090                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8091            ),
8092            _ => local_var_req_builder.query(&[(
8093                "ipsec_policy__n",
8094                &local_var_str
8095                    .into_iter()
8096                    .map(|p| p.to_string())
8097                    .collect::<Vec<String>>()
8098                    .join(",")
8099                    .to_string(),
8100            )]),
8101        };
8102    }
8103    if let Some(ref local_var_str) = ipsec_policy_id {
8104        local_var_req_builder = match "multi" {
8105            "multi" => local_var_req_builder.query(
8106                &local_var_str
8107                    .into_iter()
8108                    .map(|p| ("ipsec_policy_id".to_owned(), p.to_string()))
8109                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8110            ),
8111            _ => local_var_req_builder.query(&[(
8112                "ipsec_policy_id",
8113                &local_var_str
8114                    .into_iter()
8115                    .map(|p| p.to_string())
8116                    .collect::<Vec<String>>()
8117                    .join(",")
8118                    .to_string(),
8119            )]),
8120        };
8121    }
8122    if let Some(ref local_var_str) = ipsec_policy_id__n {
8123        local_var_req_builder = match "multi" {
8124            "multi" => local_var_req_builder.query(
8125                &local_var_str
8126                    .into_iter()
8127                    .map(|p| ("ipsec_policy_id__n".to_owned(), p.to_string()))
8128                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8129            ),
8130            _ => local_var_req_builder.query(&[(
8131                "ipsec_policy_id__n",
8132                &local_var_str
8133                    .into_iter()
8134                    .map(|p| p.to_string())
8135                    .collect::<Vec<String>>()
8136                    .join(",")
8137                    .to_string(),
8138            )]),
8139        };
8140    }
8141    if let Some(ref local_var_str) = last_updated {
8142        local_var_req_builder = match "multi" {
8143            "multi" => local_var_req_builder.query(
8144                &local_var_str
8145                    .into_iter()
8146                    .map(|p| ("last_updated".to_owned(), p.to_string()))
8147                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8148            ),
8149            _ => local_var_req_builder.query(&[(
8150                "last_updated",
8151                &local_var_str
8152                    .into_iter()
8153                    .map(|p| p.to_string())
8154                    .collect::<Vec<String>>()
8155                    .join(",")
8156                    .to_string(),
8157            )]),
8158        };
8159    }
8160    if let Some(ref local_var_str) = last_updated__empty {
8161        local_var_req_builder = match "multi" {
8162            "multi" => local_var_req_builder.query(
8163                &local_var_str
8164                    .into_iter()
8165                    .map(|p| ("last_updated__empty".to_owned(), p.to_string()))
8166                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8167            ),
8168            _ => local_var_req_builder.query(&[(
8169                "last_updated__empty",
8170                &local_var_str
8171                    .into_iter()
8172                    .map(|p| p.to_string())
8173                    .collect::<Vec<String>>()
8174                    .join(",")
8175                    .to_string(),
8176            )]),
8177        };
8178    }
8179    if let Some(ref local_var_str) = last_updated__gt {
8180        local_var_req_builder = match "multi" {
8181            "multi" => local_var_req_builder.query(
8182                &local_var_str
8183                    .into_iter()
8184                    .map(|p| ("last_updated__gt".to_owned(), p.to_string()))
8185                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8186            ),
8187            _ => local_var_req_builder.query(&[(
8188                "last_updated__gt",
8189                &local_var_str
8190                    .into_iter()
8191                    .map(|p| p.to_string())
8192                    .collect::<Vec<String>>()
8193                    .join(",")
8194                    .to_string(),
8195            )]),
8196        };
8197    }
8198    if let Some(ref local_var_str) = last_updated__gte {
8199        local_var_req_builder = match "multi" {
8200            "multi" => local_var_req_builder.query(
8201                &local_var_str
8202                    .into_iter()
8203                    .map(|p| ("last_updated__gte".to_owned(), p.to_string()))
8204                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8205            ),
8206            _ => local_var_req_builder.query(&[(
8207                "last_updated__gte",
8208                &local_var_str
8209                    .into_iter()
8210                    .map(|p| p.to_string())
8211                    .collect::<Vec<String>>()
8212                    .join(",")
8213                    .to_string(),
8214            )]),
8215        };
8216    }
8217    if let Some(ref local_var_str) = last_updated__lt {
8218        local_var_req_builder = match "multi" {
8219            "multi" => local_var_req_builder.query(
8220                &local_var_str
8221                    .into_iter()
8222                    .map(|p| ("last_updated__lt".to_owned(), p.to_string()))
8223                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8224            ),
8225            _ => local_var_req_builder.query(&[(
8226                "last_updated__lt",
8227                &local_var_str
8228                    .into_iter()
8229                    .map(|p| p.to_string())
8230                    .collect::<Vec<String>>()
8231                    .join(",")
8232                    .to_string(),
8233            )]),
8234        };
8235    }
8236    if let Some(ref local_var_str) = last_updated__lte {
8237        local_var_req_builder = match "multi" {
8238            "multi" => local_var_req_builder.query(
8239                &local_var_str
8240                    .into_iter()
8241                    .map(|p| ("last_updated__lte".to_owned(), p.to_string()))
8242                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8243            ),
8244            _ => local_var_req_builder.query(&[(
8245                "last_updated__lte",
8246                &local_var_str
8247                    .into_iter()
8248                    .map(|p| p.to_string())
8249                    .collect::<Vec<String>>()
8250                    .join(",")
8251                    .to_string(),
8252            )]),
8253        };
8254    }
8255    if let Some(ref local_var_str) = last_updated__n {
8256        local_var_req_builder = match "multi" {
8257            "multi" => local_var_req_builder.query(
8258                &local_var_str
8259                    .into_iter()
8260                    .map(|p| ("last_updated__n".to_owned(), p.to_string()))
8261                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8262            ),
8263            _ => local_var_req_builder.query(&[(
8264                "last_updated__n",
8265                &local_var_str
8266                    .into_iter()
8267                    .map(|p| p.to_string())
8268                    .collect::<Vec<String>>()
8269                    .join(",")
8270                    .to_string(),
8271            )]),
8272        };
8273    }
8274    if let Some(ref local_var_str) = limit {
8275        local_var_req_builder =
8276            local_var_req_builder.query(&[("limit", &local_var_str.to_string())]);
8277    }
8278    if let Some(ref local_var_str) = mode {
8279        local_var_req_builder = match "multi" {
8280            "multi" => local_var_req_builder.query(
8281                &local_var_str
8282                    .into_iter()
8283                    .map(|p| ("mode".to_owned(), p.to_string()))
8284                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8285            ),
8286            _ => local_var_req_builder.query(&[(
8287                "mode",
8288                &local_var_str
8289                    .into_iter()
8290                    .map(|p| p.to_string())
8291                    .collect::<Vec<String>>()
8292                    .join(",")
8293                    .to_string(),
8294            )]),
8295        };
8296    }
8297    if let Some(ref local_var_str) = mode__empty {
8298        local_var_req_builder =
8299            local_var_req_builder.query(&[("mode__empty", &local_var_str.to_string())]);
8300    }
8301    if let Some(ref local_var_str) = mode__ic {
8302        local_var_req_builder = match "multi" {
8303            "multi" => local_var_req_builder.query(
8304                &local_var_str
8305                    .into_iter()
8306                    .map(|p| ("mode__ic".to_owned(), p.to_string()))
8307                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8308            ),
8309            _ => local_var_req_builder.query(&[(
8310                "mode__ic",
8311                &local_var_str
8312                    .into_iter()
8313                    .map(|p| p.to_string())
8314                    .collect::<Vec<String>>()
8315                    .join(",")
8316                    .to_string(),
8317            )]),
8318        };
8319    }
8320    if let Some(ref local_var_str) = mode__ie {
8321        local_var_req_builder = match "multi" {
8322            "multi" => local_var_req_builder.query(
8323                &local_var_str
8324                    .into_iter()
8325                    .map(|p| ("mode__ie".to_owned(), p.to_string()))
8326                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8327            ),
8328            _ => local_var_req_builder.query(&[(
8329                "mode__ie",
8330                &local_var_str
8331                    .into_iter()
8332                    .map(|p| p.to_string())
8333                    .collect::<Vec<String>>()
8334                    .join(",")
8335                    .to_string(),
8336            )]),
8337        };
8338    }
8339    if let Some(ref local_var_str) = mode__iew {
8340        local_var_req_builder = match "multi" {
8341            "multi" => local_var_req_builder.query(
8342                &local_var_str
8343                    .into_iter()
8344                    .map(|p| ("mode__iew".to_owned(), p.to_string()))
8345                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8346            ),
8347            _ => local_var_req_builder.query(&[(
8348                "mode__iew",
8349                &local_var_str
8350                    .into_iter()
8351                    .map(|p| p.to_string())
8352                    .collect::<Vec<String>>()
8353                    .join(",")
8354                    .to_string(),
8355            )]),
8356        };
8357    }
8358    if let Some(ref local_var_str) = mode__iregex {
8359        local_var_req_builder = match "multi" {
8360            "multi" => local_var_req_builder.query(
8361                &local_var_str
8362                    .into_iter()
8363                    .map(|p| ("mode__iregex".to_owned(), p.to_string()))
8364                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8365            ),
8366            _ => local_var_req_builder.query(&[(
8367                "mode__iregex",
8368                &local_var_str
8369                    .into_iter()
8370                    .map(|p| p.to_string())
8371                    .collect::<Vec<String>>()
8372                    .join(",")
8373                    .to_string(),
8374            )]),
8375        };
8376    }
8377    if let Some(ref local_var_str) = mode__isw {
8378        local_var_req_builder = match "multi" {
8379            "multi" => local_var_req_builder.query(
8380                &local_var_str
8381                    .into_iter()
8382                    .map(|p| ("mode__isw".to_owned(), p.to_string()))
8383                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8384            ),
8385            _ => local_var_req_builder.query(&[(
8386                "mode__isw",
8387                &local_var_str
8388                    .into_iter()
8389                    .map(|p| p.to_string())
8390                    .collect::<Vec<String>>()
8391                    .join(",")
8392                    .to_string(),
8393            )]),
8394        };
8395    }
8396    if let Some(ref local_var_str) = mode__n {
8397        local_var_req_builder = match "multi" {
8398            "multi" => local_var_req_builder.query(
8399                &local_var_str
8400                    .into_iter()
8401                    .map(|p| ("mode__n".to_owned(), p.to_string()))
8402                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8403            ),
8404            _ => local_var_req_builder.query(&[(
8405                "mode__n",
8406                &local_var_str
8407                    .into_iter()
8408                    .map(|p| p.to_string())
8409                    .collect::<Vec<String>>()
8410                    .join(",")
8411                    .to_string(),
8412            )]),
8413        };
8414    }
8415    if let Some(ref local_var_str) = mode__nic {
8416        local_var_req_builder = match "multi" {
8417            "multi" => local_var_req_builder.query(
8418                &local_var_str
8419                    .into_iter()
8420                    .map(|p| ("mode__nic".to_owned(), p.to_string()))
8421                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8422            ),
8423            _ => local_var_req_builder.query(&[(
8424                "mode__nic",
8425                &local_var_str
8426                    .into_iter()
8427                    .map(|p| p.to_string())
8428                    .collect::<Vec<String>>()
8429                    .join(",")
8430                    .to_string(),
8431            )]),
8432        };
8433    }
8434    if let Some(ref local_var_str) = mode__nie {
8435        local_var_req_builder = match "multi" {
8436            "multi" => local_var_req_builder.query(
8437                &local_var_str
8438                    .into_iter()
8439                    .map(|p| ("mode__nie".to_owned(), p.to_string()))
8440                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8441            ),
8442            _ => local_var_req_builder.query(&[(
8443                "mode__nie",
8444                &local_var_str
8445                    .into_iter()
8446                    .map(|p| p.to_string())
8447                    .collect::<Vec<String>>()
8448                    .join(",")
8449                    .to_string(),
8450            )]),
8451        };
8452    }
8453    if let Some(ref local_var_str) = mode__niew {
8454        local_var_req_builder = match "multi" {
8455            "multi" => local_var_req_builder.query(
8456                &local_var_str
8457                    .into_iter()
8458                    .map(|p| ("mode__niew".to_owned(), p.to_string()))
8459                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8460            ),
8461            _ => local_var_req_builder.query(&[(
8462                "mode__niew",
8463                &local_var_str
8464                    .into_iter()
8465                    .map(|p| p.to_string())
8466                    .collect::<Vec<String>>()
8467                    .join(",")
8468                    .to_string(),
8469            )]),
8470        };
8471    }
8472    if let Some(ref local_var_str) = mode__nisw {
8473        local_var_req_builder = match "multi" {
8474            "multi" => local_var_req_builder.query(
8475                &local_var_str
8476                    .into_iter()
8477                    .map(|p| ("mode__nisw".to_owned(), p.to_string()))
8478                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8479            ),
8480            _ => local_var_req_builder.query(&[(
8481                "mode__nisw",
8482                &local_var_str
8483                    .into_iter()
8484                    .map(|p| p.to_string())
8485                    .collect::<Vec<String>>()
8486                    .join(",")
8487                    .to_string(),
8488            )]),
8489        };
8490    }
8491    if let Some(ref local_var_str) = mode__regex {
8492        local_var_req_builder = match "multi" {
8493            "multi" => local_var_req_builder.query(
8494                &local_var_str
8495                    .into_iter()
8496                    .map(|p| ("mode__regex".to_owned(), p.to_string()))
8497                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8498            ),
8499            _ => local_var_req_builder.query(&[(
8500                "mode__regex",
8501                &local_var_str
8502                    .into_iter()
8503                    .map(|p| p.to_string())
8504                    .collect::<Vec<String>>()
8505                    .join(",")
8506                    .to_string(),
8507            )]),
8508        };
8509    }
8510    if let Some(ref local_var_str) = modified_by_request {
8511        local_var_req_builder =
8512            local_var_req_builder.query(&[("modified_by_request", &local_var_str.to_string())]);
8513    }
8514    if let Some(ref local_var_str) = name {
8515        local_var_req_builder = match "multi" {
8516            "multi" => local_var_req_builder.query(
8517                &local_var_str
8518                    .into_iter()
8519                    .map(|p| ("name".to_owned(), p.to_string()))
8520                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8521            ),
8522            _ => local_var_req_builder.query(&[(
8523                "name",
8524                &local_var_str
8525                    .into_iter()
8526                    .map(|p| p.to_string())
8527                    .collect::<Vec<String>>()
8528                    .join(",")
8529                    .to_string(),
8530            )]),
8531        };
8532    }
8533    if let Some(ref local_var_str) = name__empty {
8534        local_var_req_builder =
8535            local_var_req_builder.query(&[("name__empty", &local_var_str.to_string())]);
8536    }
8537    if let Some(ref local_var_str) = name__ic {
8538        local_var_req_builder = match "multi" {
8539            "multi" => local_var_req_builder.query(
8540                &local_var_str
8541                    .into_iter()
8542                    .map(|p| ("name__ic".to_owned(), p.to_string()))
8543                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8544            ),
8545            _ => local_var_req_builder.query(&[(
8546                "name__ic",
8547                &local_var_str
8548                    .into_iter()
8549                    .map(|p| p.to_string())
8550                    .collect::<Vec<String>>()
8551                    .join(",")
8552                    .to_string(),
8553            )]),
8554        };
8555    }
8556    if let Some(ref local_var_str) = name__ie {
8557        local_var_req_builder = match "multi" {
8558            "multi" => local_var_req_builder.query(
8559                &local_var_str
8560                    .into_iter()
8561                    .map(|p| ("name__ie".to_owned(), p.to_string()))
8562                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8563            ),
8564            _ => local_var_req_builder.query(&[(
8565                "name__ie",
8566                &local_var_str
8567                    .into_iter()
8568                    .map(|p| p.to_string())
8569                    .collect::<Vec<String>>()
8570                    .join(",")
8571                    .to_string(),
8572            )]),
8573        };
8574    }
8575    if let Some(ref local_var_str) = name__iew {
8576        local_var_req_builder = match "multi" {
8577            "multi" => local_var_req_builder.query(
8578                &local_var_str
8579                    .into_iter()
8580                    .map(|p| ("name__iew".to_owned(), p.to_string()))
8581                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8582            ),
8583            _ => local_var_req_builder.query(&[(
8584                "name__iew",
8585                &local_var_str
8586                    .into_iter()
8587                    .map(|p| p.to_string())
8588                    .collect::<Vec<String>>()
8589                    .join(",")
8590                    .to_string(),
8591            )]),
8592        };
8593    }
8594    if let Some(ref local_var_str) = name__iregex {
8595        local_var_req_builder = match "multi" {
8596            "multi" => local_var_req_builder.query(
8597                &local_var_str
8598                    .into_iter()
8599                    .map(|p| ("name__iregex".to_owned(), p.to_string()))
8600                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8601            ),
8602            _ => local_var_req_builder.query(&[(
8603                "name__iregex",
8604                &local_var_str
8605                    .into_iter()
8606                    .map(|p| p.to_string())
8607                    .collect::<Vec<String>>()
8608                    .join(",")
8609                    .to_string(),
8610            )]),
8611        };
8612    }
8613    if let Some(ref local_var_str) = name__isw {
8614        local_var_req_builder = match "multi" {
8615            "multi" => local_var_req_builder.query(
8616                &local_var_str
8617                    .into_iter()
8618                    .map(|p| ("name__isw".to_owned(), p.to_string()))
8619                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8620            ),
8621            _ => local_var_req_builder.query(&[(
8622                "name__isw",
8623                &local_var_str
8624                    .into_iter()
8625                    .map(|p| p.to_string())
8626                    .collect::<Vec<String>>()
8627                    .join(",")
8628                    .to_string(),
8629            )]),
8630        };
8631    }
8632    if let Some(ref local_var_str) = name__n {
8633        local_var_req_builder = match "multi" {
8634            "multi" => local_var_req_builder.query(
8635                &local_var_str
8636                    .into_iter()
8637                    .map(|p| ("name__n".to_owned(), p.to_string()))
8638                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8639            ),
8640            _ => local_var_req_builder.query(&[(
8641                "name__n",
8642                &local_var_str
8643                    .into_iter()
8644                    .map(|p| p.to_string())
8645                    .collect::<Vec<String>>()
8646                    .join(",")
8647                    .to_string(),
8648            )]),
8649        };
8650    }
8651    if let Some(ref local_var_str) = name__nic {
8652        local_var_req_builder = match "multi" {
8653            "multi" => local_var_req_builder.query(
8654                &local_var_str
8655                    .into_iter()
8656                    .map(|p| ("name__nic".to_owned(), p.to_string()))
8657                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8658            ),
8659            _ => local_var_req_builder.query(&[(
8660                "name__nic",
8661                &local_var_str
8662                    .into_iter()
8663                    .map(|p| p.to_string())
8664                    .collect::<Vec<String>>()
8665                    .join(",")
8666                    .to_string(),
8667            )]),
8668        };
8669    }
8670    if let Some(ref local_var_str) = name__nie {
8671        local_var_req_builder = match "multi" {
8672            "multi" => local_var_req_builder.query(
8673                &local_var_str
8674                    .into_iter()
8675                    .map(|p| ("name__nie".to_owned(), p.to_string()))
8676                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8677            ),
8678            _ => local_var_req_builder.query(&[(
8679                "name__nie",
8680                &local_var_str
8681                    .into_iter()
8682                    .map(|p| p.to_string())
8683                    .collect::<Vec<String>>()
8684                    .join(",")
8685                    .to_string(),
8686            )]),
8687        };
8688    }
8689    if let Some(ref local_var_str) = name__niew {
8690        local_var_req_builder = match "multi" {
8691            "multi" => local_var_req_builder.query(
8692                &local_var_str
8693                    .into_iter()
8694                    .map(|p| ("name__niew".to_owned(), p.to_string()))
8695                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8696            ),
8697            _ => local_var_req_builder.query(&[(
8698                "name__niew",
8699                &local_var_str
8700                    .into_iter()
8701                    .map(|p| p.to_string())
8702                    .collect::<Vec<String>>()
8703                    .join(",")
8704                    .to_string(),
8705            )]),
8706        };
8707    }
8708    if let Some(ref local_var_str) = name__nisw {
8709        local_var_req_builder = match "multi" {
8710            "multi" => local_var_req_builder.query(
8711                &local_var_str
8712                    .into_iter()
8713                    .map(|p| ("name__nisw".to_owned(), p.to_string()))
8714                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8715            ),
8716            _ => local_var_req_builder.query(&[(
8717                "name__nisw",
8718                &local_var_str
8719                    .into_iter()
8720                    .map(|p| p.to_string())
8721                    .collect::<Vec<String>>()
8722                    .join(",")
8723                    .to_string(),
8724            )]),
8725        };
8726    }
8727    if let Some(ref local_var_str) = name__regex {
8728        local_var_req_builder = match "multi" {
8729            "multi" => local_var_req_builder.query(
8730                &local_var_str
8731                    .into_iter()
8732                    .map(|p| ("name__regex".to_owned(), p.to_string()))
8733                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8734            ),
8735            _ => local_var_req_builder.query(&[(
8736                "name__regex",
8737                &local_var_str
8738                    .into_iter()
8739                    .map(|p| p.to_string())
8740                    .collect::<Vec<String>>()
8741                    .join(",")
8742                    .to_string(),
8743            )]),
8744        };
8745    }
8746    if let Some(ref local_var_str) = offset {
8747        local_var_req_builder =
8748            local_var_req_builder.query(&[("offset", &local_var_str.to_string())]);
8749    }
8750    if let Some(ref local_var_str) = ordering {
8751        local_var_req_builder =
8752            local_var_req_builder.query(&[("ordering", &local_var_str.to_string())]);
8753    }
8754    if let Some(ref local_var_str) = q {
8755        local_var_req_builder = local_var_req_builder.query(&[("q", &local_var_str.to_string())]);
8756    }
8757    if let Some(ref local_var_str) = tag {
8758        local_var_req_builder = match "multi" {
8759            "multi" => local_var_req_builder.query(
8760                &local_var_str
8761                    .into_iter()
8762                    .map(|p| ("tag".to_owned(), p.to_string()))
8763                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8764            ),
8765            _ => local_var_req_builder.query(&[(
8766                "tag",
8767                &local_var_str
8768                    .into_iter()
8769                    .map(|p| p.to_string())
8770                    .collect::<Vec<String>>()
8771                    .join(",")
8772                    .to_string(),
8773            )]),
8774        };
8775    }
8776    if let Some(ref local_var_str) = tag__n {
8777        local_var_req_builder = match "multi" {
8778            "multi" => local_var_req_builder.query(
8779                &local_var_str
8780                    .into_iter()
8781                    .map(|p| ("tag__n".to_owned(), p.to_string()))
8782                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8783            ),
8784            _ => local_var_req_builder.query(&[(
8785                "tag__n",
8786                &local_var_str
8787                    .into_iter()
8788                    .map(|p| p.to_string())
8789                    .collect::<Vec<String>>()
8790                    .join(",")
8791                    .to_string(),
8792            )]),
8793        };
8794    }
8795    if let Some(ref local_var_str) = tag_id {
8796        local_var_req_builder = match "multi" {
8797            "multi" => local_var_req_builder.query(
8798                &local_var_str
8799                    .into_iter()
8800                    .map(|p| ("tag_id".to_owned(), p.to_string()))
8801                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8802            ),
8803            _ => local_var_req_builder.query(&[(
8804                "tag_id",
8805                &local_var_str
8806                    .into_iter()
8807                    .map(|p| p.to_string())
8808                    .collect::<Vec<String>>()
8809                    .join(",")
8810                    .to_string(),
8811            )]),
8812        };
8813    }
8814    if let Some(ref local_var_str) = tag_id__n {
8815        local_var_req_builder = match "multi" {
8816            "multi" => local_var_req_builder.query(
8817                &local_var_str
8818                    .into_iter()
8819                    .map(|p| ("tag_id__n".to_owned(), p.to_string()))
8820                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8821            ),
8822            _ => local_var_req_builder.query(&[(
8823                "tag_id__n",
8824                &local_var_str
8825                    .into_iter()
8826                    .map(|p| p.to_string())
8827                    .collect::<Vec<String>>()
8828                    .join(",")
8829                    .to_string(),
8830            )]),
8831        };
8832    }
8833    if let Some(ref local_var_str) = updated_by_request {
8834        local_var_req_builder =
8835            local_var_req_builder.query(&[("updated_by_request", &local_var_str.to_string())]);
8836    }
8837    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
8838        local_var_req_builder =
8839            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
8840    }
8841    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
8842        let local_var_key = local_var_apikey.key.clone();
8843        let local_var_value = match local_var_apikey.prefix {
8844            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
8845            None => local_var_key,
8846        };
8847        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
8848    };
8849
8850    let local_var_req = local_var_req_builder.build()?;
8851    let local_var_resp = local_var_client.execute(local_var_req).await?;
8852
8853    let local_var_status = local_var_resp.status();
8854    let local_var_content = local_var_resp.text().await?;
8855
8856    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
8857        serde_json::from_str(&local_var_content).map_err(Error::from)
8858    } else {
8859        let local_var_entity: Option<VpnIpsecProfilesListError> =
8860            serde_json::from_str(&local_var_content).ok();
8861        let local_var_error = ResponseContent {
8862            status: local_var_status,
8863            content: local_var_content,
8864            entity: local_var_entity,
8865        };
8866        Err(Error::ResponseError(local_var_error))
8867    }
8868}
8869
8870/// Patch a IPSec profile object.
8871pub async fn vpn_ipsec_profiles_partial_update(
8872    configuration: &configuration::Configuration,
8873    id: i32,
8874    patched_writable_ip_sec_profile_request: Option<
8875        crate::models::PatchedWritableIpSecProfileRequest,
8876    >,
8877) -> Result<crate::models::IpSecProfile, Error<VpnIpsecProfilesPartialUpdateError>> {
8878    let local_var_configuration = configuration;
8879
8880    let local_var_client = &local_var_configuration.client;
8881
8882    let local_var_uri_str = format!(
8883        "{}/api/vpn/ipsec-profiles/{id}/",
8884        local_var_configuration.base_path,
8885        id = id
8886    );
8887    let mut local_var_req_builder =
8888        local_var_client.request(reqwest::Method::PATCH, local_var_uri_str.as_str());
8889
8890    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
8891        local_var_req_builder =
8892            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
8893    }
8894    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
8895        let local_var_key = local_var_apikey.key.clone();
8896        let local_var_value = match local_var_apikey.prefix {
8897            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
8898            None => local_var_key,
8899        };
8900        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
8901    };
8902    local_var_req_builder = local_var_req_builder.json(&patched_writable_ip_sec_profile_request);
8903
8904    let local_var_req = local_var_req_builder.build()?;
8905    let local_var_resp = local_var_client.execute(local_var_req).await?;
8906
8907    let local_var_status = local_var_resp.status();
8908    let local_var_content = local_var_resp.text().await?;
8909
8910    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
8911        serde_json::from_str(&local_var_content).map_err(Error::from)
8912    } else {
8913        let local_var_entity: Option<VpnIpsecProfilesPartialUpdateError> =
8914            serde_json::from_str(&local_var_content).ok();
8915        let local_var_error = ResponseContent {
8916            status: local_var_status,
8917            content: local_var_content,
8918            entity: local_var_entity,
8919        };
8920        Err(Error::ResponseError(local_var_error))
8921    }
8922}
8923
8924/// Get a IPSec profile object.
8925pub async fn vpn_ipsec_profiles_retrieve(
8926    configuration: &configuration::Configuration,
8927    id: i32,
8928) -> Result<crate::models::IpSecProfile, Error<VpnIpsecProfilesRetrieveError>> {
8929    let local_var_configuration = configuration;
8930
8931    let local_var_client = &local_var_configuration.client;
8932
8933    let local_var_uri_str = format!(
8934        "{}/api/vpn/ipsec-profiles/{id}/",
8935        local_var_configuration.base_path,
8936        id = id
8937    );
8938    let mut local_var_req_builder =
8939        local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
8940
8941    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
8942        local_var_req_builder =
8943            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
8944    }
8945    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
8946        let local_var_key = local_var_apikey.key.clone();
8947        let local_var_value = match local_var_apikey.prefix {
8948            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
8949            None => local_var_key,
8950        };
8951        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
8952    };
8953
8954    let local_var_req = local_var_req_builder.build()?;
8955    let local_var_resp = local_var_client.execute(local_var_req).await?;
8956
8957    let local_var_status = local_var_resp.status();
8958    let local_var_content = local_var_resp.text().await?;
8959
8960    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
8961        serde_json::from_str(&local_var_content).map_err(Error::from)
8962    } else {
8963        let local_var_entity: Option<VpnIpsecProfilesRetrieveError> =
8964            serde_json::from_str(&local_var_content).ok();
8965        let local_var_error = ResponseContent {
8966            status: local_var_status,
8967            content: local_var_content,
8968            entity: local_var_entity,
8969        };
8970        Err(Error::ResponseError(local_var_error))
8971    }
8972}
8973
8974/// Put a IPSec profile object.
8975pub async fn vpn_ipsec_profiles_update(
8976    configuration: &configuration::Configuration,
8977    id: i32,
8978    writable_ip_sec_profile_request: crate::models::WritableIpSecProfileRequest,
8979) -> Result<crate::models::IpSecProfile, Error<VpnIpsecProfilesUpdateError>> {
8980    let local_var_configuration = configuration;
8981
8982    let local_var_client = &local_var_configuration.client;
8983
8984    let local_var_uri_str = format!(
8985        "{}/api/vpn/ipsec-profiles/{id}/",
8986        local_var_configuration.base_path,
8987        id = id
8988    );
8989    let mut local_var_req_builder =
8990        local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());
8991
8992    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
8993        local_var_req_builder =
8994            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
8995    }
8996    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
8997        let local_var_key = local_var_apikey.key.clone();
8998        let local_var_value = match local_var_apikey.prefix {
8999            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
9000            None => local_var_key,
9001        };
9002        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
9003    };
9004    local_var_req_builder = local_var_req_builder.json(&writable_ip_sec_profile_request);
9005
9006    let local_var_req = local_var_req_builder.build()?;
9007    let local_var_resp = local_var_client.execute(local_var_req).await?;
9008
9009    let local_var_status = local_var_resp.status();
9010    let local_var_content = local_var_resp.text().await?;
9011
9012    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
9013        serde_json::from_str(&local_var_content).map_err(Error::from)
9014    } else {
9015        let local_var_entity: Option<VpnIpsecProfilesUpdateError> =
9016            serde_json::from_str(&local_var_content).ok();
9017        let local_var_error = ResponseContent {
9018            status: local_var_status,
9019            content: local_var_content,
9020            entity: local_var_entity,
9021        };
9022        Err(Error::ResponseError(local_var_error))
9023    }
9024}
9025
9026/// Delete a list of IPSec proposal objects.
9027pub async fn vpn_ipsec_proposals_bulk_destroy(
9028    configuration: &configuration::Configuration,
9029    ip_sec_proposal_request: Vec<crate::models::IpSecProposalRequest>,
9030) -> Result<(), Error<VpnIpsecProposalsBulkDestroyError>> {
9031    let local_var_configuration = configuration;
9032
9033    let local_var_client = &local_var_configuration.client;
9034
9035    let local_var_uri_str = format!(
9036        "{}/api/vpn/ipsec-proposals/",
9037        local_var_configuration.base_path
9038    );
9039    let mut local_var_req_builder =
9040        local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());
9041
9042    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
9043        local_var_req_builder =
9044            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
9045    }
9046    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
9047        let local_var_key = local_var_apikey.key.clone();
9048        let local_var_value = match local_var_apikey.prefix {
9049            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
9050            None => local_var_key,
9051        };
9052        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
9053    };
9054    local_var_req_builder = local_var_req_builder.json(&ip_sec_proposal_request);
9055
9056    let local_var_req = local_var_req_builder.build()?;
9057    let local_var_resp = local_var_client.execute(local_var_req).await?;
9058
9059    let local_var_status = local_var_resp.status();
9060    let local_var_content = local_var_resp.text().await?;
9061
9062    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
9063        Ok(())
9064    } else {
9065        let local_var_entity: Option<VpnIpsecProposalsBulkDestroyError> =
9066            serde_json::from_str(&local_var_content).ok();
9067        let local_var_error = ResponseContent {
9068            status: local_var_status,
9069            content: local_var_content,
9070            entity: local_var_entity,
9071        };
9072        Err(Error::ResponseError(local_var_error))
9073    }
9074}
9075
9076/// Patch a list of IPSec proposal objects.
9077pub async fn vpn_ipsec_proposals_bulk_partial_update(
9078    configuration: &configuration::Configuration,
9079    ip_sec_proposal_request: Vec<crate::models::IpSecProposalRequest>,
9080) -> Result<Vec<crate::models::IpSecProposal>, Error<VpnIpsecProposalsBulkPartialUpdateError>> {
9081    let local_var_configuration = configuration;
9082
9083    let local_var_client = &local_var_configuration.client;
9084
9085    let local_var_uri_str = format!(
9086        "{}/api/vpn/ipsec-proposals/",
9087        local_var_configuration.base_path
9088    );
9089    let mut local_var_req_builder =
9090        local_var_client.request(reqwest::Method::PATCH, local_var_uri_str.as_str());
9091
9092    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
9093        local_var_req_builder =
9094            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
9095    }
9096    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
9097        let local_var_key = local_var_apikey.key.clone();
9098        let local_var_value = match local_var_apikey.prefix {
9099            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
9100            None => local_var_key,
9101        };
9102        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
9103    };
9104    local_var_req_builder = local_var_req_builder.json(&ip_sec_proposal_request);
9105
9106    let local_var_req = local_var_req_builder.build()?;
9107    let local_var_resp = local_var_client.execute(local_var_req).await?;
9108
9109    let local_var_status = local_var_resp.status();
9110    let local_var_content = local_var_resp.text().await?;
9111
9112    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
9113        serde_json::from_str(&local_var_content).map_err(Error::from)
9114    } else {
9115        let local_var_entity: Option<VpnIpsecProposalsBulkPartialUpdateError> =
9116            serde_json::from_str(&local_var_content).ok();
9117        let local_var_error = ResponseContent {
9118            status: local_var_status,
9119            content: local_var_content,
9120            entity: local_var_entity,
9121        };
9122        Err(Error::ResponseError(local_var_error))
9123    }
9124}
9125
9126/// Put a list of IPSec proposal objects.
9127pub async fn vpn_ipsec_proposals_bulk_update(
9128    configuration: &configuration::Configuration,
9129    ip_sec_proposal_request: Vec<crate::models::IpSecProposalRequest>,
9130) -> Result<Vec<crate::models::IpSecProposal>, Error<VpnIpsecProposalsBulkUpdateError>> {
9131    let local_var_configuration = configuration;
9132
9133    let local_var_client = &local_var_configuration.client;
9134
9135    let local_var_uri_str = format!(
9136        "{}/api/vpn/ipsec-proposals/",
9137        local_var_configuration.base_path
9138    );
9139    let mut local_var_req_builder =
9140        local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());
9141
9142    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
9143        local_var_req_builder =
9144            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
9145    }
9146    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
9147        let local_var_key = local_var_apikey.key.clone();
9148        let local_var_value = match local_var_apikey.prefix {
9149            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
9150            None => local_var_key,
9151        };
9152        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
9153    };
9154    local_var_req_builder = local_var_req_builder.json(&ip_sec_proposal_request);
9155
9156    let local_var_req = local_var_req_builder.build()?;
9157    let local_var_resp = local_var_client.execute(local_var_req).await?;
9158
9159    let local_var_status = local_var_resp.status();
9160    let local_var_content = local_var_resp.text().await?;
9161
9162    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
9163        serde_json::from_str(&local_var_content).map_err(Error::from)
9164    } else {
9165        let local_var_entity: Option<VpnIpsecProposalsBulkUpdateError> =
9166            serde_json::from_str(&local_var_content).ok();
9167        let local_var_error = ResponseContent {
9168            status: local_var_status,
9169            content: local_var_content,
9170            entity: local_var_entity,
9171        };
9172        Err(Error::ResponseError(local_var_error))
9173    }
9174}
9175
9176/// Post a list of IPSec proposal objects.
9177pub async fn vpn_ipsec_proposals_create(
9178    configuration: &configuration::Configuration,
9179    writable_ip_sec_proposal_request: crate::models::WritableIpSecProposalRequest,
9180) -> Result<crate::models::IpSecProposal, Error<VpnIpsecProposalsCreateError>> {
9181    let local_var_configuration = configuration;
9182
9183    let local_var_client = &local_var_configuration.client;
9184
9185    let local_var_uri_str = format!(
9186        "{}/api/vpn/ipsec-proposals/",
9187        local_var_configuration.base_path
9188    );
9189    let mut local_var_req_builder =
9190        local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
9191
9192    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
9193        local_var_req_builder =
9194            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
9195    }
9196    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
9197        let local_var_key = local_var_apikey.key.clone();
9198        let local_var_value = match local_var_apikey.prefix {
9199            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
9200            None => local_var_key,
9201        };
9202        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
9203    };
9204    local_var_req_builder = local_var_req_builder.json(&writable_ip_sec_proposal_request);
9205
9206    let local_var_req = local_var_req_builder.build()?;
9207    let local_var_resp = local_var_client.execute(local_var_req).await?;
9208
9209    let local_var_status = local_var_resp.status();
9210    let local_var_content = local_var_resp.text().await?;
9211
9212    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
9213        serde_json::from_str(&local_var_content).map_err(Error::from)
9214    } else {
9215        let local_var_entity: Option<VpnIpsecProposalsCreateError> =
9216            serde_json::from_str(&local_var_content).ok();
9217        let local_var_error = ResponseContent {
9218            status: local_var_status,
9219            content: local_var_content,
9220            entity: local_var_entity,
9221        };
9222        Err(Error::ResponseError(local_var_error))
9223    }
9224}
9225
9226/// Delete a IPSec proposal object.
9227pub async fn vpn_ipsec_proposals_destroy(
9228    configuration: &configuration::Configuration,
9229    id: i32,
9230) -> Result<(), Error<VpnIpsecProposalsDestroyError>> {
9231    let local_var_configuration = configuration;
9232
9233    let local_var_client = &local_var_configuration.client;
9234
9235    let local_var_uri_str = format!(
9236        "{}/api/vpn/ipsec-proposals/{id}/",
9237        local_var_configuration.base_path,
9238        id = id
9239    );
9240    let mut local_var_req_builder =
9241        local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());
9242
9243    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
9244        local_var_req_builder =
9245            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
9246    }
9247    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
9248        let local_var_key = local_var_apikey.key.clone();
9249        let local_var_value = match local_var_apikey.prefix {
9250            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
9251            None => local_var_key,
9252        };
9253        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
9254    };
9255
9256    let local_var_req = local_var_req_builder.build()?;
9257    let local_var_resp = local_var_client.execute(local_var_req).await?;
9258
9259    let local_var_status = local_var_resp.status();
9260    let local_var_content = local_var_resp.text().await?;
9261
9262    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
9263        Ok(())
9264    } else {
9265        let local_var_entity: Option<VpnIpsecProposalsDestroyError> =
9266            serde_json::from_str(&local_var_content).ok();
9267        let local_var_error = ResponseContent {
9268            status: local_var_status,
9269            content: local_var_content,
9270            entity: local_var_entity,
9271        };
9272        Err(Error::ResponseError(local_var_error))
9273    }
9274}
9275
9276/// Get a list of IPSec proposal objects.
9277pub async fn vpn_ipsec_proposals_list(
9278    configuration: &configuration::Configuration,
9279    authentication_algorithm: Option<Vec<String>>,
9280    authentication_algorithm__empty: Option<bool>,
9281    authentication_algorithm__ic: Option<Vec<String>>,
9282    authentication_algorithm__ie: Option<Vec<String>>,
9283    authentication_algorithm__iew: Option<Vec<String>>,
9284    authentication_algorithm__iregex: Option<Vec<String>>,
9285    authentication_algorithm__isw: Option<Vec<String>>,
9286    authentication_algorithm__n: Option<Vec<String>>,
9287    authentication_algorithm__nic: Option<Vec<String>>,
9288    authentication_algorithm__nie: Option<Vec<String>>,
9289    authentication_algorithm__niew: Option<Vec<String>>,
9290    authentication_algorithm__nisw: Option<Vec<String>>,
9291    authentication_algorithm__regex: Option<Vec<String>>,
9292    created: Option<Vec<String>>,
9293    created__empty: Option<Vec<String>>,
9294    created__gt: Option<Vec<String>>,
9295    created__gte: Option<Vec<String>>,
9296    created__lt: Option<Vec<String>>,
9297    created__lte: Option<Vec<String>>,
9298    created__n: Option<Vec<String>>,
9299    created_by_request: Option<&str>,
9300    description: Option<Vec<String>>,
9301    description__empty: Option<bool>,
9302    description__ic: Option<Vec<String>>,
9303    description__ie: Option<Vec<String>>,
9304    description__iew: Option<Vec<String>>,
9305    description__iregex: Option<Vec<String>>,
9306    description__isw: Option<Vec<String>>,
9307    description__n: Option<Vec<String>>,
9308    description__nic: Option<Vec<String>>,
9309    description__nie: Option<Vec<String>>,
9310    description__niew: Option<Vec<String>>,
9311    description__nisw: Option<Vec<String>>,
9312    description__regex: Option<Vec<String>>,
9313    encryption_algorithm: Option<Vec<String>>,
9314    encryption_algorithm__empty: Option<bool>,
9315    encryption_algorithm__ic: Option<Vec<String>>,
9316    encryption_algorithm__ie: Option<Vec<String>>,
9317    encryption_algorithm__iew: Option<Vec<String>>,
9318    encryption_algorithm__iregex: Option<Vec<String>>,
9319    encryption_algorithm__isw: Option<Vec<String>>,
9320    encryption_algorithm__n: Option<Vec<String>>,
9321    encryption_algorithm__nic: Option<Vec<String>>,
9322    encryption_algorithm__nie: Option<Vec<String>>,
9323    encryption_algorithm__niew: Option<Vec<String>>,
9324    encryption_algorithm__nisw: Option<Vec<String>>,
9325    encryption_algorithm__regex: Option<Vec<String>>,
9326    id: Option<Vec<i32>>,
9327    id__empty: Option<bool>,
9328    id__gt: Option<Vec<i32>>,
9329    id__gte: Option<Vec<i32>>,
9330    id__lt: Option<Vec<i32>>,
9331    id__lte: Option<Vec<i32>>,
9332    id__n: Option<Vec<i32>>,
9333    ipsec_policy: Option<Vec<String>>,
9334    ipsec_policy__n: Option<Vec<String>>,
9335    ipsec_policy_id: Option<Vec<i32>>,
9336    ipsec_policy_id__n: Option<Vec<i32>>,
9337    last_updated: Option<Vec<String>>,
9338    last_updated__empty: Option<Vec<String>>,
9339    last_updated__gt: Option<Vec<String>>,
9340    last_updated__gte: Option<Vec<String>>,
9341    last_updated__lt: Option<Vec<String>>,
9342    last_updated__lte: Option<Vec<String>>,
9343    last_updated__n: Option<Vec<String>>,
9344    limit: Option<i32>,
9345    modified_by_request: Option<&str>,
9346    name: Option<Vec<String>>,
9347    name__empty: Option<bool>,
9348    name__ic: Option<Vec<String>>,
9349    name__ie: Option<Vec<String>>,
9350    name__iew: Option<Vec<String>>,
9351    name__iregex: Option<Vec<String>>,
9352    name__isw: Option<Vec<String>>,
9353    name__n: Option<Vec<String>>,
9354    name__nic: Option<Vec<String>>,
9355    name__nie: Option<Vec<String>>,
9356    name__niew: Option<Vec<String>>,
9357    name__nisw: Option<Vec<String>>,
9358    name__regex: Option<Vec<String>>,
9359    offset: Option<i32>,
9360    ordering: Option<&str>,
9361    q: Option<&str>,
9362    sa_lifetime_data: Option<Vec<i32>>,
9363    sa_lifetime_data__empty: Option<bool>,
9364    sa_lifetime_data__gt: Option<Vec<i32>>,
9365    sa_lifetime_data__gte: Option<Vec<i32>>,
9366    sa_lifetime_data__lt: Option<Vec<i32>>,
9367    sa_lifetime_data__lte: Option<Vec<i32>>,
9368    sa_lifetime_data__n: Option<Vec<i32>>,
9369    sa_lifetime_seconds: Option<Vec<i32>>,
9370    sa_lifetime_seconds__empty: Option<bool>,
9371    sa_lifetime_seconds__gt: Option<Vec<i32>>,
9372    sa_lifetime_seconds__gte: Option<Vec<i32>>,
9373    sa_lifetime_seconds__lt: Option<Vec<i32>>,
9374    sa_lifetime_seconds__lte: Option<Vec<i32>>,
9375    sa_lifetime_seconds__n: Option<Vec<i32>>,
9376    tag: Option<Vec<String>>,
9377    tag__n: Option<Vec<String>>,
9378    tag_id: Option<Vec<i32>>,
9379    tag_id__n: Option<Vec<i32>>,
9380    updated_by_request: Option<&str>,
9381) -> Result<crate::models::PaginatedIpSecProposalList, Error<VpnIpsecProposalsListError>> {
9382    let local_var_configuration = configuration;
9383
9384    let local_var_client = &local_var_configuration.client;
9385
9386    let local_var_uri_str = format!(
9387        "{}/api/vpn/ipsec-proposals/",
9388        local_var_configuration.base_path
9389    );
9390    let mut local_var_req_builder =
9391        local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
9392
9393    if let Some(ref local_var_str) = authentication_algorithm {
9394        local_var_req_builder = match "multi" {
9395            "multi" => local_var_req_builder.query(
9396                &local_var_str
9397                    .into_iter()
9398                    .map(|p| ("authentication_algorithm".to_owned(), p.to_string()))
9399                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9400            ),
9401            _ => local_var_req_builder.query(&[(
9402                "authentication_algorithm",
9403                &local_var_str
9404                    .into_iter()
9405                    .map(|p| p.to_string())
9406                    .collect::<Vec<String>>()
9407                    .join(",")
9408                    .to_string(),
9409            )]),
9410        };
9411    }
9412    if let Some(ref local_var_str) = authentication_algorithm__empty {
9413        local_var_req_builder = local_var_req_builder.query(&[(
9414            "authentication_algorithm__empty",
9415            &local_var_str.to_string(),
9416        )]);
9417    }
9418    if let Some(ref local_var_str) = authentication_algorithm__ic {
9419        local_var_req_builder = match "multi" {
9420            "multi" => local_var_req_builder.query(
9421                &local_var_str
9422                    .into_iter()
9423                    .map(|p| ("authentication_algorithm__ic".to_owned(), p.to_string()))
9424                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9425            ),
9426            _ => local_var_req_builder.query(&[(
9427                "authentication_algorithm__ic",
9428                &local_var_str
9429                    .into_iter()
9430                    .map(|p| p.to_string())
9431                    .collect::<Vec<String>>()
9432                    .join(",")
9433                    .to_string(),
9434            )]),
9435        };
9436    }
9437    if let Some(ref local_var_str) = authentication_algorithm__ie {
9438        local_var_req_builder = match "multi" {
9439            "multi" => local_var_req_builder.query(
9440                &local_var_str
9441                    .into_iter()
9442                    .map(|p| ("authentication_algorithm__ie".to_owned(), p.to_string()))
9443                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9444            ),
9445            _ => local_var_req_builder.query(&[(
9446                "authentication_algorithm__ie",
9447                &local_var_str
9448                    .into_iter()
9449                    .map(|p| p.to_string())
9450                    .collect::<Vec<String>>()
9451                    .join(",")
9452                    .to_string(),
9453            )]),
9454        };
9455    }
9456    if let Some(ref local_var_str) = authentication_algorithm__iew {
9457        local_var_req_builder = match "multi" {
9458            "multi" => local_var_req_builder.query(
9459                &local_var_str
9460                    .into_iter()
9461                    .map(|p| ("authentication_algorithm__iew".to_owned(), p.to_string()))
9462                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9463            ),
9464            _ => local_var_req_builder.query(&[(
9465                "authentication_algorithm__iew",
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) = authentication_algorithm__iregex {
9476        local_var_req_builder = match "multi" {
9477            "multi" => local_var_req_builder.query(
9478                &local_var_str
9479                    .into_iter()
9480                    .map(|p| ("authentication_algorithm__iregex".to_owned(), p.to_string()))
9481                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9482            ),
9483            _ => local_var_req_builder.query(&[(
9484                "authentication_algorithm__iregex",
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) = authentication_algorithm__isw {
9495        local_var_req_builder = match "multi" {
9496            "multi" => local_var_req_builder.query(
9497                &local_var_str
9498                    .into_iter()
9499                    .map(|p| ("authentication_algorithm__isw".to_owned(), p.to_string()))
9500                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9501            ),
9502            _ => local_var_req_builder.query(&[(
9503                "authentication_algorithm__isw",
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) = authentication_algorithm__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| ("authentication_algorithm__n".to_owned(), p.to_string()))
9519                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9520            ),
9521            _ => local_var_req_builder.query(&[(
9522                "authentication_algorithm__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) = authentication_algorithm__nic {
9533        local_var_req_builder = match "multi" {
9534            "multi" => local_var_req_builder.query(
9535                &local_var_str
9536                    .into_iter()
9537                    .map(|p| ("authentication_algorithm__nic".to_owned(), p.to_string()))
9538                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9539            ),
9540            _ => local_var_req_builder.query(&[(
9541                "authentication_algorithm__nic",
9542                &local_var_str
9543                    .into_iter()
9544                    .map(|p| p.to_string())
9545                    .collect::<Vec<String>>()
9546                    .join(",")
9547                    .to_string(),
9548            )]),
9549        };
9550    }
9551    if let Some(ref local_var_str) = authentication_algorithm__nie {
9552        local_var_req_builder = match "multi" {
9553            "multi" => local_var_req_builder.query(
9554                &local_var_str
9555                    .into_iter()
9556                    .map(|p| ("authentication_algorithm__nie".to_owned(), p.to_string()))
9557                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9558            ),
9559            _ => local_var_req_builder.query(&[(
9560                "authentication_algorithm__nie",
9561                &local_var_str
9562                    .into_iter()
9563                    .map(|p| p.to_string())
9564                    .collect::<Vec<String>>()
9565                    .join(",")
9566                    .to_string(),
9567            )]),
9568        };
9569    }
9570    if let Some(ref local_var_str) = authentication_algorithm__niew {
9571        local_var_req_builder = match "multi" {
9572            "multi" => local_var_req_builder.query(
9573                &local_var_str
9574                    .into_iter()
9575                    .map(|p| ("authentication_algorithm__niew".to_owned(), p.to_string()))
9576                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9577            ),
9578            _ => local_var_req_builder.query(&[(
9579                "authentication_algorithm__niew",
9580                &local_var_str
9581                    .into_iter()
9582                    .map(|p| p.to_string())
9583                    .collect::<Vec<String>>()
9584                    .join(",")
9585                    .to_string(),
9586            )]),
9587        };
9588    }
9589    if let Some(ref local_var_str) = authentication_algorithm__nisw {
9590        local_var_req_builder = match "multi" {
9591            "multi" => local_var_req_builder.query(
9592                &local_var_str
9593                    .into_iter()
9594                    .map(|p| ("authentication_algorithm__nisw".to_owned(), p.to_string()))
9595                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9596            ),
9597            _ => local_var_req_builder.query(&[(
9598                "authentication_algorithm__nisw",
9599                &local_var_str
9600                    .into_iter()
9601                    .map(|p| p.to_string())
9602                    .collect::<Vec<String>>()
9603                    .join(",")
9604                    .to_string(),
9605            )]),
9606        };
9607    }
9608    if let Some(ref local_var_str) = authentication_algorithm__regex {
9609        local_var_req_builder = match "multi" {
9610            "multi" => local_var_req_builder.query(
9611                &local_var_str
9612                    .into_iter()
9613                    .map(|p| ("authentication_algorithm__regex".to_owned(), p.to_string()))
9614                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9615            ),
9616            _ => local_var_req_builder.query(&[(
9617                "authentication_algorithm__regex",
9618                &local_var_str
9619                    .into_iter()
9620                    .map(|p| p.to_string())
9621                    .collect::<Vec<String>>()
9622                    .join(",")
9623                    .to_string(),
9624            )]),
9625        };
9626    }
9627    if let Some(ref local_var_str) = created {
9628        local_var_req_builder = match "multi" {
9629            "multi" => local_var_req_builder.query(
9630                &local_var_str
9631                    .into_iter()
9632                    .map(|p| ("created".to_owned(), p.to_string()))
9633                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9634            ),
9635            _ => local_var_req_builder.query(&[(
9636                "created",
9637                &local_var_str
9638                    .into_iter()
9639                    .map(|p| p.to_string())
9640                    .collect::<Vec<String>>()
9641                    .join(",")
9642                    .to_string(),
9643            )]),
9644        };
9645    }
9646    if let Some(ref local_var_str) = created__empty {
9647        local_var_req_builder = match "multi" {
9648            "multi" => local_var_req_builder.query(
9649                &local_var_str
9650                    .into_iter()
9651                    .map(|p| ("created__empty".to_owned(), p.to_string()))
9652                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9653            ),
9654            _ => local_var_req_builder.query(&[(
9655                "created__empty",
9656                &local_var_str
9657                    .into_iter()
9658                    .map(|p| p.to_string())
9659                    .collect::<Vec<String>>()
9660                    .join(",")
9661                    .to_string(),
9662            )]),
9663        };
9664    }
9665    if let Some(ref local_var_str) = created__gt {
9666        local_var_req_builder = match "multi" {
9667            "multi" => local_var_req_builder.query(
9668                &local_var_str
9669                    .into_iter()
9670                    .map(|p| ("created__gt".to_owned(), p.to_string()))
9671                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9672            ),
9673            _ => local_var_req_builder.query(&[(
9674                "created__gt",
9675                &local_var_str
9676                    .into_iter()
9677                    .map(|p| p.to_string())
9678                    .collect::<Vec<String>>()
9679                    .join(",")
9680                    .to_string(),
9681            )]),
9682        };
9683    }
9684    if let Some(ref local_var_str) = created__gte {
9685        local_var_req_builder = match "multi" {
9686            "multi" => local_var_req_builder.query(
9687                &local_var_str
9688                    .into_iter()
9689                    .map(|p| ("created__gte".to_owned(), p.to_string()))
9690                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9691            ),
9692            _ => local_var_req_builder.query(&[(
9693                "created__gte",
9694                &local_var_str
9695                    .into_iter()
9696                    .map(|p| p.to_string())
9697                    .collect::<Vec<String>>()
9698                    .join(",")
9699                    .to_string(),
9700            )]),
9701        };
9702    }
9703    if let Some(ref local_var_str) = created__lt {
9704        local_var_req_builder = match "multi" {
9705            "multi" => local_var_req_builder.query(
9706                &local_var_str
9707                    .into_iter()
9708                    .map(|p| ("created__lt".to_owned(), p.to_string()))
9709                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9710            ),
9711            _ => local_var_req_builder.query(&[(
9712                "created__lt",
9713                &local_var_str
9714                    .into_iter()
9715                    .map(|p| p.to_string())
9716                    .collect::<Vec<String>>()
9717                    .join(",")
9718                    .to_string(),
9719            )]),
9720        };
9721    }
9722    if let Some(ref local_var_str) = created__lte {
9723        local_var_req_builder = match "multi" {
9724            "multi" => local_var_req_builder.query(
9725                &local_var_str
9726                    .into_iter()
9727                    .map(|p| ("created__lte".to_owned(), p.to_string()))
9728                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9729            ),
9730            _ => local_var_req_builder.query(&[(
9731                "created__lte",
9732                &local_var_str
9733                    .into_iter()
9734                    .map(|p| p.to_string())
9735                    .collect::<Vec<String>>()
9736                    .join(",")
9737                    .to_string(),
9738            )]),
9739        };
9740    }
9741    if let Some(ref local_var_str) = created__n {
9742        local_var_req_builder = match "multi" {
9743            "multi" => local_var_req_builder.query(
9744                &local_var_str
9745                    .into_iter()
9746                    .map(|p| ("created__n".to_owned(), p.to_string()))
9747                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9748            ),
9749            _ => local_var_req_builder.query(&[(
9750                "created__n",
9751                &local_var_str
9752                    .into_iter()
9753                    .map(|p| p.to_string())
9754                    .collect::<Vec<String>>()
9755                    .join(",")
9756                    .to_string(),
9757            )]),
9758        };
9759    }
9760    if let Some(ref local_var_str) = created_by_request {
9761        local_var_req_builder =
9762            local_var_req_builder.query(&[("created_by_request", &local_var_str.to_string())]);
9763    }
9764    if let Some(ref local_var_str) = description {
9765        local_var_req_builder = match "multi" {
9766            "multi" => local_var_req_builder.query(
9767                &local_var_str
9768                    .into_iter()
9769                    .map(|p| ("description".to_owned(), p.to_string()))
9770                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9771            ),
9772            _ => local_var_req_builder.query(&[(
9773                "description",
9774                &local_var_str
9775                    .into_iter()
9776                    .map(|p| p.to_string())
9777                    .collect::<Vec<String>>()
9778                    .join(",")
9779                    .to_string(),
9780            )]),
9781        };
9782    }
9783    if let Some(ref local_var_str) = description__empty {
9784        local_var_req_builder =
9785            local_var_req_builder.query(&[("description__empty", &local_var_str.to_string())]);
9786    }
9787    if let Some(ref local_var_str) = description__ic {
9788        local_var_req_builder = match "multi" {
9789            "multi" => local_var_req_builder.query(
9790                &local_var_str
9791                    .into_iter()
9792                    .map(|p| ("description__ic".to_owned(), p.to_string()))
9793                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9794            ),
9795            _ => local_var_req_builder.query(&[(
9796                "description__ic",
9797                &local_var_str
9798                    .into_iter()
9799                    .map(|p| p.to_string())
9800                    .collect::<Vec<String>>()
9801                    .join(",")
9802                    .to_string(),
9803            )]),
9804        };
9805    }
9806    if let Some(ref local_var_str) = description__ie {
9807        local_var_req_builder = match "multi" {
9808            "multi" => local_var_req_builder.query(
9809                &local_var_str
9810                    .into_iter()
9811                    .map(|p| ("description__ie".to_owned(), p.to_string()))
9812                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9813            ),
9814            _ => local_var_req_builder.query(&[(
9815                "description__ie",
9816                &local_var_str
9817                    .into_iter()
9818                    .map(|p| p.to_string())
9819                    .collect::<Vec<String>>()
9820                    .join(",")
9821                    .to_string(),
9822            )]),
9823        };
9824    }
9825    if let Some(ref local_var_str) = description__iew {
9826        local_var_req_builder = match "multi" {
9827            "multi" => local_var_req_builder.query(
9828                &local_var_str
9829                    .into_iter()
9830                    .map(|p| ("description__iew".to_owned(), p.to_string()))
9831                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9832            ),
9833            _ => local_var_req_builder.query(&[(
9834                "description__iew",
9835                &local_var_str
9836                    .into_iter()
9837                    .map(|p| p.to_string())
9838                    .collect::<Vec<String>>()
9839                    .join(",")
9840                    .to_string(),
9841            )]),
9842        };
9843    }
9844    if let Some(ref local_var_str) = description__iregex {
9845        local_var_req_builder = match "multi" {
9846            "multi" => local_var_req_builder.query(
9847                &local_var_str
9848                    .into_iter()
9849                    .map(|p| ("description__iregex".to_owned(), p.to_string()))
9850                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9851            ),
9852            _ => local_var_req_builder.query(&[(
9853                "description__iregex",
9854                &local_var_str
9855                    .into_iter()
9856                    .map(|p| p.to_string())
9857                    .collect::<Vec<String>>()
9858                    .join(",")
9859                    .to_string(),
9860            )]),
9861        };
9862    }
9863    if let Some(ref local_var_str) = description__isw {
9864        local_var_req_builder = match "multi" {
9865            "multi" => local_var_req_builder.query(
9866                &local_var_str
9867                    .into_iter()
9868                    .map(|p| ("description__isw".to_owned(), p.to_string()))
9869                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9870            ),
9871            _ => local_var_req_builder.query(&[(
9872                "description__isw",
9873                &local_var_str
9874                    .into_iter()
9875                    .map(|p| p.to_string())
9876                    .collect::<Vec<String>>()
9877                    .join(",")
9878                    .to_string(),
9879            )]),
9880        };
9881    }
9882    if let Some(ref local_var_str) = description__n {
9883        local_var_req_builder = match "multi" {
9884            "multi" => local_var_req_builder.query(
9885                &local_var_str
9886                    .into_iter()
9887                    .map(|p| ("description__n".to_owned(), p.to_string()))
9888                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9889            ),
9890            _ => local_var_req_builder.query(&[(
9891                "description__n",
9892                &local_var_str
9893                    .into_iter()
9894                    .map(|p| p.to_string())
9895                    .collect::<Vec<String>>()
9896                    .join(",")
9897                    .to_string(),
9898            )]),
9899        };
9900    }
9901    if let Some(ref local_var_str) = description__nic {
9902        local_var_req_builder = match "multi" {
9903            "multi" => local_var_req_builder.query(
9904                &local_var_str
9905                    .into_iter()
9906                    .map(|p| ("description__nic".to_owned(), p.to_string()))
9907                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9908            ),
9909            _ => local_var_req_builder.query(&[(
9910                "description__nic",
9911                &local_var_str
9912                    .into_iter()
9913                    .map(|p| p.to_string())
9914                    .collect::<Vec<String>>()
9915                    .join(",")
9916                    .to_string(),
9917            )]),
9918        };
9919    }
9920    if let Some(ref local_var_str) = description__nie {
9921        local_var_req_builder = match "multi" {
9922            "multi" => local_var_req_builder.query(
9923                &local_var_str
9924                    .into_iter()
9925                    .map(|p| ("description__nie".to_owned(), p.to_string()))
9926                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9927            ),
9928            _ => local_var_req_builder.query(&[(
9929                "description__nie",
9930                &local_var_str
9931                    .into_iter()
9932                    .map(|p| p.to_string())
9933                    .collect::<Vec<String>>()
9934                    .join(",")
9935                    .to_string(),
9936            )]),
9937        };
9938    }
9939    if let Some(ref local_var_str) = description__niew {
9940        local_var_req_builder = match "multi" {
9941            "multi" => local_var_req_builder.query(
9942                &local_var_str
9943                    .into_iter()
9944                    .map(|p| ("description__niew".to_owned(), p.to_string()))
9945                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9946            ),
9947            _ => local_var_req_builder.query(&[(
9948                "description__niew",
9949                &local_var_str
9950                    .into_iter()
9951                    .map(|p| p.to_string())
9952                    .collect::<Vec<String>>()
9953                    .join(",")
9954                    .to_string(),
9955            )]),
9956        };
9957    }
9958    if let Some(ref local_var_str) = description__nisw {
9959        local_var_req_builder = match "multi" {
9960            "multi" => local_var_req_builder.query(
9961                &local_var_str
9962                    .into_iter()
9963                    .map(|p| ("description__nisw".to_owned(), p.to_string()))
9964                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9965            ),
9966            _ => local_var_req_builder.query(&[(
9967                "description__nisw",
9968                &local_var_str
9969                    .into_iter()
9970                    .map(|p| p.to_string())
9971                    .collect::<Vec<String>>()
9972                    .join(",")
9973                    .to_string(),
9974            )]),
9975        };
9976    }
9977    if let Some(ref local_var_str) = description__regex {
9978        local_var_req_builder = match "multi" {
9979            "multi" => local_var_req_builder.query(
9980                &local_var_str
9981                    .into_iter()
9982                    .map(|p| ("description__regex".to_owned(), p.to_string()))
9983                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9984            ),
9985            _ => local_var_req_builder.query(&[(
9986                "description__regex",
9987                &local_var_str
9988                    .into_iter()
9989                    .map(|p| p.to_string())
9990                    .collect::<Vec<String>>()
9991                    .join(",")
9992                    .to_string(),
9993            )]),
9994        };
9995    }
9996    if let Some(ref local_var_str) = encryption_algorithm {
9997        local_var_req_builder = match "multi" {
9998            "multi" => local_var_req_builder.query(
9999                &local_var_str
10000                    .into_iter()
10001                    .map(|p| ("encryption_algorithm".to_owned(), p.to_string()))
10002                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10003            ),
10004            _ => local_var_req_builder.query(&[(
10005                "encryption_algorithm",
10006                &local_var_str
10007                    .into_iter()
10008                    .map(|p| p.to_string())
10009                    .collect::<Vec<String>>()
10010                    .join(",")
10011                    .to_string(),
10012            )]),
10013        };
10014    }
10015    if let Some(ref local_var_str) = encryption_algorithm__empty {
10016        local_var_req_builder = local_var_req_builder
10017            .query(&[("encryption_algorithm__empty", &local_var_str.to_string())]);
10018    }
10019    if let Some(ref local_var_str) = encryption_algorithm__ic {
10020        local_var_req_builder = match "multi" {
10021            "multi" => local_var_req_builder.query(
10022                &local_var_str
10023                    .into_iter()
10024                    .map(|p| ("encryption_algorithm__ic".to_owned(), p.to_string()))
10025                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10026            ),
10027            _ => local_var_req_builder.query(&[(
10028                "encryption_algorithm__ic",
10029                &local_var_str
10030                    .into_iter()
10031                    .map(|p| p.to_string())
10032                    .collect::<Vec<String>>()
10033                    .join(",")
10034                    .to_string(),
10035            )]),
10036        };
10037    }
10038    if let Some(ref local_var_str) = encryption_algorithm__ie {
10039        local_var_req_builder = match "multi" {
10040            "multi" => local_var_req_builder.query(
10041                &local_var_str
10042                    .into_iter()
10043                    .map(|p| ("encryption_algorithm__ie".to_owned(), p.to_string()))
10044                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10045            ),
10046            _ => local_var_req_builder.query(&[(
10047                "encryption_algorithm__ie",
10048                &local_var_str
10049                    .into_iter()
10050                    .map(|p| p.to_string())
10051                    .collect::<Vec<String>>()
10052                    .join(",")
10053                    .to_string(),
10054            )]),
10055        };
10056    }
10057    if let Some(ref local_var_str) = encryption_algorithm__iew {
10058        local_var_req_builder = match "multi" {
10059            "multi" => local_var_req_builder.query(
10060                &local_var_str
10061                    .into_iter()
10062                    .map(|p| ("encryption_algorithm__iew".to_owned(), p.to_string()))
10063                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10064            ),
10065            _ => local_var_req_builder.query(&[(
10066                "encryption_algorithm__iew",
10067                &local_var_str
10068                    .into_iter()
10069                    .map(|p| p.to_string())
10070                    .collect::<Vec<String>>()
10071                    .join(",")
10072                    .to_string(),
10073            )]),
10074        };
10075    }
10076    if let Some(ref local_var_str) = encryption_algorithm__iregex {
10077        local_var_req_builder = match "multi" {
10078            "multi" => local_var_req_builder.query(
10079                &local_var_str
10080                    .into_iter()
10081                    .map(|p| ("encryption_algorithm__iregex".to_owned(), p.to_string()))
10082                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10083            ),
10084            _ => local_var_req_builder.query(&[(
10085                "encryption_algorithm__iregex",
10086                &local_var_str
10087                    .into_iter()
10088                    .map(|p| p.to_string())
10089                    .collect::<Vec<String>>()
10090                    .join(",")
10091                    .to_string(),
10092            )]),
10093        };
10094    }
10095    if let Some(ref local_var_str) = encryption_algorithm__isw {
10096        local_var_req_builder = match "multi" {
10097            "multi" => local_var_req_builder.query(
10098                &local_var_str
10099                    .into_iter()
10100                    .map(|p| ("encryption_algorithm__isw".to_owned(), p.to_string()))
10101                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10102            ),
10103            _ => local_var_req_builder.query(&[(
10104                "encryption_algorithm__isw",
10105                &local_var_str
10106                    .into_iter()
10107                    .map(|p| p.to_string())
10108                    .collect::<Vec<String>>()
10109                    .join(",")
10110                    .to_string(),
10111            )]),
10112        };
10113    }
10114    if let Some(ref local_var_str) = encryption_algorithm__n {
10115        local_var_req_builder = match "multi" {
10116            "multi" => local_var_req_builder.query(
10117                &local_var_str
10118                    .into_iter()
10119                    .map(|p| ("encryption_algorithm__n".to_owned(), p.to_string()))
10120                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10121            ),
10122            _ => local_var_req_builder.query(&[(
10123                "encryption_algorithm__n",
10124                &local_var_str
10125                    .into_iter()
10126                    .map(|p| p.to_string())
10127                    .collect::<Vec<String>>()
10128                    .join(",")
10129                    .to_string(),
10130            )]),
10131        };
10132    }
10133    if let Some(ref local_var_str) = encryption_algorithm__nic {
10134        local_var_req_builder = match "multi" {
10135            "multi" => local_var_req_builder.query(
10136                &local_var_str
10137                    .into_iter()
10138                    .map(|p| ("encryption_algorithm__nic".to_owned(), p.to_string()))
10139                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10140            ),
10141            _ => local_var_req_builder.query(&[(
10142                "encryption_algorithm__nic",
10143                &local_var_str
10144                    .into_iter()
10145                    .map(|p| p.to_string())
10146                    .collect::<Vec<String>>()
10147                    .join(",")
10148                    .to_string(),
10149            )]),
10150        };
10151    }
10152    if let Some(ref local_var_str) = encryption_algorithm__nie {
10153        local_var_req_builder = match "multi" {
10154            "multi" => local_var_req_builder.query(
10155                &local_var_str
10156                    .into_iter()
10157                    .map(|p| ("encryption_algorithm__nie".to_owned(), p.to_string()))
10158                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10159            ),
10160            _ => local_var_req_builder.query(&[(
10161                "encryption_algorithm__nie",
10162                &local_var_str
10163                    .into_iter()
10164                    .map(|p| p.to_string())
10165                    .collect::<Vec<String>>()
10166                    .join(",")
10167                    .to_string(),
10168            )]),
10169        };
10170    }
10171    if let Some(ref local_var_str) = encryption_algorithm__niew {
10172        local_var_req_builder = match "multi" {
10173            "multi" => local_var_req_builder.query(
10174                &local_var_str
10175                    .into_iter()
10176                    .map(|p| ("encryption_algorithm__niew".to_owned(), p.to_string()))
10177                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10178            ),
10179            _ => local_var_req_builder.query(&[(
10180                "encryption_algorithm__niew",
10181                &local_var_str
10182                    .into_iter()
10183                    .map(|p| p.to_string())
10184                    .collect::<Vec<String>>()
10185                    .join(",")
10186                    .to_string(),
10187            )]),
10188        };
10189    }
10190    if let Some(ref local_var_str) = encryption_algorithm__nisw {
10191        local_var_req_builder = match "multi" {
10192            "multi" => local_var_req_builder.query(
10193                &local_var_str
10194                    .into_iter()
10195                    .map(|p| ("encryption_algorithm__nisw".to_owned(), p.to_string()))
10196                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10197            ),
10198            _ => local_var_req_builder.query(&[(
10199                "encryption_algorithm__nisw",
10200                &local_var_str
10201                    .into_iter()
10202                    .map(|p| p.to_string())
10203                    .collect::<Vec<String>>()
10204                    .join(",")
10205                    .to_string(),
10206            )]),
10207        };
10208    }
10209    if let Some(ref local_var_str) = encryption_algorithm__regex {
10210        local_var_req_builder = match "multi" {
10211            "multi" => local_var_req_builder.query(
10212                &local_var_str
10213                    .into_iter()
10214                    .map(|p| ("encryption_algorithm__regex".to_owned(), p.to_string()))
10215                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10216            ),
10217            _ => local_var_req_builder.query(&[(
10218                "encryption_algorithm__regex",
10219                &local_var_str
10220                    .into_iter()
10221                    .map(|p| p.to_string())
10222                    .collect::<Vec<String>>()
10223                    .join(",")
10224                    .to_string(),
10225            )]),
10226        };
10227    }
10228    if let Some(ref local_var_str) = id {
10229        local_var_req_builder = match "multi" {
10230            "multi" => local_var_req_builder.query(
10231                &local_var_str
10232                    .into_iter()
10233                    .map(|p| ("id".to_owned(), p.to_string()))
10234                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10235            ),
10236            _ => local_var_req_builder.query(&[(
10237                "id",
10238                &local_var_str
10239                    .into_iter()
10240                    .map(|p| p.to_string())
10241                    .collect::<Vec<String>>()
10242                    .join(",")
10243                    .to_string(),
10244            )]),
10245        };
10246    }
10247    if let Some(ref local_var_str) = id__empty {
10248        local_var_req_builder =
10249            local_var_req_builder.query(&[("id__empty", &local_var_str.to_string())]);
10250    }
10251    if let Some(ref local_var_str) = id__gt {
10252        local_var_req_builder = match "multi" {
10253            "multi" => local_var_req_builder.query(
10254                &local_var_str
10255                    .into_iter()
10256                    .map(|p| ("id__gt".to_owned(), p.to_string()))
10257                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10258            ),
10259            _ => local_var_req_builder.query(&[(
10260                "id__gt",
10261                &local_var_str
10262                    .into_iter()
10263                    .map(|p| p.to_string())
10264                    .collect::<Vec<String>>()
10265                    .join(",")
10266                    .to_string(),
10267            )]),
10268        };
10269    }
10270    if let Some(ref local_var_str) = id__gte {
10271        local_var_req_builder = match "multi" {
10272            "multi" => local_var_req_builder.query(
10273                &local_var_str
10274                    .into_iter()
10275                    .map(|p| ("id__gte".to_owned(), p.to_string()))
10276                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10277            ),
10278            _ => local_var_req_builder.query(&[(
10279                "id__gte",
10280                &local_var_str
10281                    .into_iter()
10282                    .map(|p| p.to_string())
10283                    .collect::<Vec<String>>()
10284                    .join(",")
10285                    .to_string(),
10286            )]),
10287        };
10288    }
10289    if let Some(ref local_var_str) = id__lt {
10290        local_var_req_builder = match "multi" {
10291            "multi" => local_var_req_builder.query(
10292                &local_var_str
10293                    .into_iter()
10294                    .map(|p| ("id__lt".to_owned(), p.to_string()))
10295                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10296            ),
10297            _ => local_var_req_builder.query(&[(
10298                "id__lt",
10299                &local_var_str
10300                    .into_iter()
10301                    .map(|p| p.to_string())
10302                    .collect::<Vec<String>>()
10303                    .join(",")
10304                    .to_string(),
10305            )]),
10306        };
10307    }
10308    if let Some(ref local_var_str) = id__lte {
10309        local_var_req_builder = match "multi" {
10310            "multi" => local_var_req_builder.query(
10311                &local_var_str
10312                    .into_iter()
10313                    .map(|p| ("id__lte".to_owned(), p.to_string()))
10314                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10315            ),
10316            _ => local_var_req_builder.query(&[(
10317                "id__lte",
10318                &local_var_str
10319                    .into_iter()
10320                    .map(|p| p.to_string())
10321                    .collect::<Vec<String>>()
10322                    .join(",")
10323                    .to_string(),
10324            )]),
10325        };
10326    }
10327    if let Some(ref local_var_str) = id__n {
10328        local_var_req_builder = match "multi" {
10329            "multi" => local_var_req_builder.query(
10330                &local_var_str
10331                    .into_iter()
10332                    .map(|p| ("id__n".to_owned(), p.to_string()))
10333                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10334            ),
10335            _ => local_var_req_builder.query(&[(
10336                "id__n",
10337                &local_var_str
10338                    .into_iter()
10339                    .map(|p| p.to_string())
10340                    .collect::<Vec<String>>()
10341                    .join(",")
10342                    .to_string(),
10343            )]),
10344        };
10345    }
10346    if let Some(ref local_var_str) = ipsec_policy {
10347        local_var_req_builder = match "multi" {
10348            "multi" => local_var_req_builder.query(
10349                &local_var_str
10350                    .into_iter()
10351                    .map(|p| ("ipsec_policy".to_owned(), p.to_string()))
10352                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10353            ),
10354            _ => local_var_req_builder.query(&[(
10355                "ipsec_policy",
10356                &local_var_str
10357                    .into_iter()
10358                    .map(|p| p.to_string())
10359                    .collect::<Vec<String>>()
10360                    .join(",")
10361                    .to_string(),
10362            )]),
10363        };
10364    }
10365    if let Some(ref local_var_str) = ipsec_policy__n {
10366        local_var_req_builder = match "multi" {
10367            "multi" => local_var_req_builder.query(
10368                &local_var_str
10369                    .into_iter()
10370                    .map(|p| ("ipsec_policy__n".to_owned(), p.to_string()))
10371                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10372            ),
10373            _ => local_var_req_builder.query(&[(
10374                "ipsec_policy__n",
10375                &local_var_str
10376                    .into_iter()
10377                    .map(|p| p.to_string())
10378                    .collect::<Vec<String>>()
10379                    .join(",")
10380                    .to_string(),
10381            )]),
10382        };
10383    }
10384    if let Some(ref local_var_str) = ipsec_policy_id {
10385        local_var_req_builder = match "multi" {
10386            "multi" => local_var_req_builder.query(
10387                &local_var_str
10388                    .into_iter()
10389                    .map(|p| ("ipsec_policy_id".to_owned(), p.to_string()))
10390                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10391            ),
10392            _ => local_var_req_builder.query(&[(
10393                "ipsec_policy_id",
10394                &local_var_str
10395                    .into_iter()
10396                    .map(|p| p.to_string())
10397                    .collect::<Vec<String>>()
10398                    .join(",")
10399                    .to_string(),
10400            )]),
10401        };
10402    }
10403    if let Some(ref local_var_str) = ipsec_policy_id__n {
10404        local_var_req_builder = match "multi" {
10405            "multi" => local_var_req_builder.query(
10406                &local_var_str
10407                    .into_iter()
10408                    .map(|p| ("ipsec_policy_id__n".to_owned(), p.to_string()))
10409                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10410            ),
10411            _ => local_var_req_builder.query(&[(
10412                "ipsec_policy_id__n",
10413                &local_var_str
10414                    .into_iter()
10415                    .map(|p| p.to_string())
10416                    .collect::<Vec<String>>()
10417                    .join(",")
10418                    .to_string(),
10419            )]),
10420        };
10421    }
10422    if let Some(ref local_var_str) = last_updated {
10423        local_var_req_builder = match "multi" {
10424            "multi" => local_var_req_builder.query(
10425                &local_var_str
10426                    .into_iter()
10427                    .map(|p| ("last_updated".to_owned(), p.to_string()))
10428                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10429            ),
10430            _ => local_var_req_builder.query(&[(
10431                "last_updated",
10432                &local_var_str
10433                    .into_iter()
10434                    .map(|p| p.to_string())
10435                    .collect::<Vec<String>>()
10436                    .join(",")
10437                    .to_string(),
10438            )]),
10439        };
10440    }
10441    if let Some(ref local_var_str) = last_updated__empty {
10442        local_var_req_builder = match "multi" {
10443            "multi" => local_var_req_builder.query(
10444                &local_var_str
10445                    .into_iter()
10446                    .map(|p| ("last_updated__empty".to_owned(), p.to_string()))
10447                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10448            ),
10449            _ => local_var_req_builder.query(&[(
10450                "last_updated__empty",
10451                &local_var_str
10452                    .into_iter()
10453                    .map(|p| p.to_string())
10454                    .collect::<Vec<String>>()
10455                    .join(",")
10456                    .to_string(),
10457            )]),
10458        };
10459    }
10460    if let Some(ref local_var_str) = last_updated__gt {
10461        local_var_req_builder = match "multi" {
10462            "multi" => local_var_req_builder.query(
10463                &local_var_str
10464                    .into_iter()
10465                    .map(|p| ("last_updated__gt".to_owned(), p.to_string()))
10466                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10467            ),
10468            _ => local_var_req_builder.query(&[(
10469                "last_updated__gt",
10470                &local_var_str
10471                    .into_iter()
10472                    .map(|p| p.to_string())
10473                    .collect::<Vec<String>>()
10474                    .join(",")
10475                    .to_string(),
10476            )]),
10477        };
10478    }
10479    if let Some(ref local_var_str) = last_updated__gte {
10480        local_var_req_builder = match "multi" {
10481            "multi" => local_var_req_builder.query(
10482                &local_var_str
10483                    .into_iter()
10484                    .map(|p| ("last_updated__gte".to_owned(), p.to_string()))
10485                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10486            ),
10487            _ => local_var_req_builder.query(&[(
10488                "last_updated__gte",
10489                &local_var_str
10490                    .into_iter()
10491                    .map(|p| p.to_string())
10492                    .collect::<Vec<String>>()
10493                    .join(",")
10494                    .to_string(),
10495            )]),
10496        };
10497    }
10498    if let Some(ref local_var_str) = last_updated__lt {
10499        local_var_req_builder = match "multi" {
10500            "multi" => local_var_req_builder.query(
10501                &local_var_str
10502                    .into_iter()
10503                    .map(|p| ("last_updated__lt".to_owned(), p.to_string()))
10504                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10505            ),
10506            _ => local_var_req_builder.query(&[(
10507                "last_updated__lt",
10508                &local_var_str
10509                    .into_iter()
10510                    .map(|p| p.to_string())
10511                    .collect::<Vec<String>>()
10512                    .join(",")
10513                    .to_string(),
10514            )]),
10515        };
10516    }
10517    if let Some(ref local_var_str) = last_updated__lte {
10518        local_var_req_builder = match "multi" {
10519            "multi" => local_var_req_builder.query(
10520                &local_var_str
10521                    .into_iter()
10522                    .map(|p| ("last_updated__lte".to_owned(), p.to_string()))
10523                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10524            ),
10525            _ => local_var_req_builder.query(&[(
10526                "last_updated__lte",
10527                &local_var_str
10528                    .into_iter()
10529                    .map(|p| p.to_string())
10530                    .collect::<Vec<String>>()
10531                    .join(",")
10532                    .to_string(),
10533            )]),
10534        };
10535    }
10536    if let Some(ref local_var_str) = last_updated__n {
10537        local_var_req_builder = match "multi" {
10538            "multi" => local_var_req_builder.query(
10539                &local_var_str
10540                    .into_iter()
10541                    .map(|p| ("last_updated__n".to_owned(), p.to_string()))
10542                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10543            ),
10544            _ => local_var_req_builder.query(&[(
10545                "last_updated__n",
10546                &local_var_str
10547                    .into_iter()
10548                    .map(|p| p.to_string())
10549                    .collect::<Vec<String>>()
10550                    .join(",")
10551                    .to_string(),
10552            )]),
10553        };
10554    }
10555    if let Some(ref local_var_str) = limit {
10556        local_var_req_builder =
10557            local_var_req_builder.query(&[("limit", &local_var_str.to_string())]);
10558    }
10559    if let Some(ref local_var_str) = modified_by_request {
10560        local_var_req_builder =
10561            local_var_req_builder.query(&[("modified_by_request", &local_var_str.to_string())]);
10562    }
10563    if let Some(ref local_var_str) = name {
10564        local_var_req_builder = match "multi" {
10565            "multi" => local_var_req_builder.query(
10566                &local_var_str
10567                    .into_iter()
10568                    .map(|p| ("name".to_owned(), p.to_string()))
10569                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10570            ),
10571            _ => local_var_req_builder.query(&[(
10572                "name",
10573                &local_var_str
10574                    .into_iter()
10575                    .map(|p| p.to_string())
10576                    .collect::<Vec<String>>()
10577                    .join(",")
10578                    .to_string(),
10579            )]),
10580        };
10581    }
10582    if let Some(ref local_var_str) = name__empty {
10583        local_var_req_builder =
10584            local_var_req_builder.query(&[("name__empty", &local_var_str.to_string())]);
10585    }
10586    if let Some(ref local_var_str) = name__ic {
10587        local_var_req_builder = match "multi" {
10588            "multi" => local_var_req_builder.query(
10589                &local_var_str
10590                    .into_iter()
10591                    .map(|p| ("name__ic".to_owned(), p.to_string()))
10592                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10593            ),
10594            _ => local_var_req_builder.query(&[(
10595                "name__ic",
10596                &local_var_str
10597                    .into_iter()
10598                    .map(|p| p.to_string())
10599                    .collect::<Vec<String>>()
10600                    .join(",")
10601                    .to_string(),
10602            )]),
10603        };
10604    }
10605    if let Some(ref local_var_str) = name__ie {
10606        local_var_req_builder = match "multi" {
10607            "multi" => local_var_req_builder.query(
10608                &local_var_str
10609                    .into_iter()
10610                    .map(|p| ("name__ie".to_owned(), p.to_string()))
10611                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10612            ),
10613            _ => local_var_req_builder.query(&[(
10614                "name__ie",
10615                &local_var_str
10616                    .into_iter()
10617                    .map(|p| p.to_string())
10618                    .collect::<Vec<String>>()
10619                    .join(",")
10620                    .to_string(),
10621            )]),
10622        };
10623    }
10624    if let Some(ref local_var_str) = name__iew {
10625        local_var_req_builder = match "multi" {
10626            "multi" => local_var_req_builder.query(
10627                &local_var_str
10628                    .into_iter()
10629                    .map(|p| ("name__iew".to_owned(), p.to_string()))
10630                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10631            ),
10632            _ => local_var_req_builder.query(&[(
10633                "name__iew",
10634                &local_var_str
10635                    .into_iter()
10636                    .map(|p| p.to_string())
10637                    .collect::<Vec<String>>()
10638                    .join(",")
10639                    .to_string(),
10640            )]),
10641        };
10642    }
10643    if let Some(ref local_var_str) = name__iregex {
10644        local_var_req_builder = match "multi" {
10645            "multi" => local_var_req_builder.query(
10646                &local_var_str
10647                    .into_iter()
10648                    .map(|p| ("name__iregex".to_owned(), p.to_string()))
10649                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10650            ),
10651            _ => local_var_req_builder.query(&[(
10652                "name__iregex",
10653                &local_var_str
10654                    .into_iter()
10655                    .map(|p| p.to_string())
10656                    .collect::<Vec<String>>()
10657                    .join(",")
10658                    .to_string(),
10659            )]),
10660        };
10661    }
10662    if let Some(ref local_var_str) = name__isw {
10663        local_var_req_builder = match "multi" {
10664            "multi" => local_var_req_builder.query(
10665                &local_var_str
10666                    .into_iter()
10667                    .map(|p| ("name__isw".to_owned(), p.to_string()))
10668                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10669            ),
10670            _ => local_var_req_builder.query(&[(
10671                "name__isw",
10672                &local_var_str
10673                    .into_iter()
10674                    .map(|p| p.to_string())
10675                    .collect::<Vec<String>>()
10676                    .join(",")
10677                    .to_string(),
10678            )]),
10679        };
10680    }
10681    if let Some(ref local_var_str) = name__n {
10682        local_var_req_builder = match "multi" {
10683            "multi" => local_var_req_builder.query(
10684                &local_var_str
10685                    .into_iter()
10686                    .map(|p| ("name__n".to_owned(), p.to_string()))
10687                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10688            ),
10689            _ => local_var_req_builder.query(&[(
10690                "name__n",
10691                &local_var_str
10692                    .into_iter()
10693                    .map(|p| p.to_string())
10694                    .collect::<Vec<String>>()
10695                    .join(",")
10696                    .to_string(),
10697            )]),
10698        };
10699    }
10700    if let Some(ref local_var_str) = name__nic {
10701        local_var_req_builder = match "multi" {
10702            "multi" => local_var_req_builder.query(
10703                &local_var_str
10704                    .into_iter()
10705                    .map(|p| ("name__nic".to_owned(), p.to_string()))
10706                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10707            ),
10708            _ => local_var_req_builder.query(&[(
10709                "name__nic",
10710                &local_var_str
10711                    .into_iter()
10712                    .map(|p| p.to_string())
10713                    .collect::<Vec<String>>()
10714                    .join(",")
10715                    .to_string(),
10716            )]),
10717        };
10718    }
10719    if let Some(ref local_var_str) = name__nie {
10720        local_var_req_builder = match "multi" {
10721            "multi" => local_var_req_builder.query(
10722                &local_var_str
10723                    .into_iter()
10724                    .map(|p| ("name__nie".to_owned(), p.to_string()))
10725                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10726            ),
10727            _ => local_var_req_builder.query(&[(
10728                "name__nie",
10729                &local_var_str
10730                    .into_iter()
10731                    .map(|p| p.to_string())
10732                    .collect::<Vec<String>>()
10733                    .join(",")
10734                    .to_string(),
10735            )]),
10736        };
10737    }
10738    if let Some(ref local_var_str) = name__niew {
10739        local_var_req_builder = match "multi" {
10740            "multi" => local_var_req_builder.query(
10741                &local_var_str
10742                    .into_iter()
10743                    .map(|p| ("name__niew".to_owned(), p.to_string()))
10744                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10745            ),
10746            _ => local_var_req_builder.query(&[(
10747                "name__niew",
10748                &local_var_str
10749                    .into_iter()
10750                    .map(|p| p.to_string())
10751                    .collect::<Vec<String>>()
10752                    .join(",")
10753                    .to_string(),
10754            )]),
10755        };
10756    }
10757    if let Some(ref local_var_str) = name__nisw {
10758        local_var_req_builder = match "multi" {
10759            "multi" => local_var_req_builder.query(
10760                &local_var_str
10761                    .into_iter()
10762                    .map(|p| ("name__nisw".to_owned(), p.to_string()))
10763                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10764            ),
10765            _ => local_var_req_builder.query(&[(
10766                "name__nisw",
10767                &local_var_str
10768                    .into_iter()
10769                    .map(|p| p.to_string())
10770                    .collect::<Vec<String>>()
10771                    .join(",")
10772                    .to_string(),
10773            )]),
10774        };
10775    }
10776    if let Some(ref local_var_str) = name__regex {
10777        local_var_req_builder = match "multi" {
10778            "multi" => local_var_req_builder.query(
10779                &local_var_str
10780                    .into_iter()
10781                    .map(|p| ("name__regex".to_owned(), p.to_string()))
10782                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10783            ),
10784            _ => local_var_req_builder.query(&[(
10785                "name__regex",
10786                &local_var_str
10787                    .into_iter()
10788                    .map(|p| p.to_string())
10789                    .collect::<Vec<String>>()
10790                    .join(",")
10791                    .to_string(),
10792            )]),
10793        };
10794    }
10795    if let Some(ref local_var_str) = offset {
10796        local_var_req_builder =
10797            local_var_req_builder.query(&[("offset", &local_var_str.to_string())]);
10798    }
10799    if let Some(ref local_var_str) = ordering {
10800        local_var_req_builder =
10801            local_var_req_builder.query(&[("ordering", &local_var_str.to_string())]);
10802    }
10803    if let Some(ref local_var_str) = q {
10804        local_var_req_builder = local_var_req_builder.query(&[("q", &local_var_str.to_string())]);
10805    }
10806    if let Some(ref local_var_str) = sa_lifetime_data {
10807        local_var_req_builder = match "multi" {
10808            "multi" => local_var_req_builder.query(
10809                &local_var_str
10810                    .into_iter()
10811                    .map(|p| ("sa_lifetime_data".to_owned(), p.to_string()))
10812                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10813            ),
10814            _ => local_var_req_builder.query(&[(
10815                "sa_lifetime_data",
10816                &local_var_str
10817                    .into_iter()
10818                    .map(|p| p.to_string())
10819                    .collect::<Vec<String>>()
10820                    .join(",")
10821                    .to_string(),
10822            )]),
10823        };
10824    }
10825    if let Some(ref local_var_str) = sa_lifetime_data__empty {
10826        local_var_req_builder =
10827            local_var_req_builder.query(&[("sa_lifetime_data__empty", &local_var_str.to_string())]);
10828    }
10829    if let Some(ref local_var_str) = sa_lifetime_data__gt {
10830        local_var_req_builder = match "multi" {
10831            "multi" => local_var_req_builder.query(
10832                &local_var_str
10833                    .into_iter()
10834                    .map(|p| ("sa_lifetime_data__gt".to_owned(), p.to_string()))
10835                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10836            ),
10837            _ => local_var_req_builder.query(&[(
10838                "sa_lifetime_data__gt",
10839                &local_var_str
10840                    .into_iter()
10841                    .map(|p| p.to_string())
10842                    .collect::<Vec<String>>()
10843                    .join(",")
10844                    .to_string(),
10845            )]),
10846        };
10847    }
10848    if let Some(ref local_var_str) = sa_lifetime_data__gte {
10849        local_var_req_builder = match "multi" {
10850            "multi" => local_var_req_builder.query(
10851                &local_var_str
10852                    .into_iter()
10853                    .map(|p| ("sa_lifetime_data__gte".to_owned(), p.to_string()))
10854                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10855            ),
10856            _ => local_var_req_builder.query(&[(
10857                "sa_lifetime_data__gte",
10858                &local_var_str
10859                    .into_iter()
10860                    .map(|p| p.to_string())
10861                    .collect::<Vec<String>>()
10862                    .join(",")
10863                    .to_string(),
10864            )]),
10865        };
10866    }
10867    if let Some(ref local_var_str) = sa_lifetime_data__lt {
10868        local_var_req_builder = match "multi" {
10869            "multi" => local_var_req_builder.query(
10870                &local_var_str
10871                    .into_iter()
10872                    .map(|p| ("sa_lifetime_data__lt".to_owned(), p.to_string()))
10873                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10874            ),
10875            _ => local_var_req_builder.query(&[(
10876                "sa_lifetime_data__lt",
10877                &local_var_str
10878                    .into_iter()
10879                    .map(|p| p.to_string())
10880                    .collect::<Vec<String>>()
10881                    .join(",")
10882                    .to_string(),
10883            )]),
10884        };
10885    }
10886    if let Some(ref local_var_str) = sa_lifetime_data__lte {
10887        local_var_req_builder = match "multi" {
10888            "multi" => local_var_req_builder.query(
10889                &local_var_str
10890                    .into_iter()
10891                    .map(|p| ("sa_lifetime_data__lte".to_owned(), p.to_string()))
10892                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10893            ),
10894            _ => local_var_req_builder.query(&[(
10895                "sa_lifetime_data__lte",
10896                &local_var_str
10897                    .into_iter()
10898                    .map(|p| p.to_string())
10899                    .collect::<Vec<String>>()
10900                    .join(",")
10901                    .to_string(),
10902            )]),
10903        };
10904    }
10905    if let Some(ref local_var_str) = sa_lifetime_data__n {
10906        local_var_req_builder = match "multi" {
10907            "multi" => local_var_req_builder.query(
10908                &local_var_str
10909                    .into_iter()
10910                    .map(|p| ("sa_lifetime_data__n".to_owned(), p.to_string()))
10911                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10912            ),
10913            _ => local_var_req_builder.query(&[(
10914                "sa_lifetime_data__n",
10915                &local_var_str
10916                    .into_iter()
10917                    .map(|p| p.to_string())
10918                    .collect::<Vec<String>>()
10919                    .join(",")
10920                    .to_string(),
10921            )]),
10922        };
10923    }
10924    if let Some(ref local_var_str) = sa_lifetime_seconds {
10925        local_var_req_builder = match "multi" {
10926            "multi" => local_var_req_builder.query(
10927                &local_var_str
10928                    .into_iter()
10929                    .map(|p| ("sa_lifetime_seconds".to_owned(), p.to_string()))
10930                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10931            ),
10932            _ => local_var_req_builder.query(&[(
10933                "sa_lifetime_seconds",
10934                &local_var_str
10935                    .into_iter()
10936                    .map(|p| p.to_string())
10937                    .collect::<Vec<String>>()
10938                    .join(",")
10939                    .to_string(),
10940            )]),
10941        };
10942    }
10943    if let Some(ref local_var_str) = sa_lifetime_seconds__empty {
10944        local_var_req_builder = local_var_req_builder
10945            .query(&[("sa_lifetime_seconds__empty", &local_var_str.to_string())]);
10946    }
10947    if let Some(ref local_var_str) = sa_lifetime_seconds__gt {
10948        local_var_req_builder = match "multi" {
10949            "multi" => local_var_req_builder.query(
10950                &local_var_str
10951                    .into_iter()
10952                    .map(|p| ("sa_lifetime_seconds__gt".to_owned(), p.to_string()))
10953                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10954            ),
10955            _ => local_var_req_builder.query(&[(
10956                "sa_lifetime_seconds__gt",
10957                &local_var_str
10958                    .into_iter()
10959                    .map(|p| p.to_string())
10960                    .collect::<Vec<String>>()
10961                    .join(",")
10962                    .to_string(),
10963            )]),
10964        };
10965    }
10966    if let Some(ref local_var_str) = sa_lifetime_seconds__gte {
10967        local_var_req_builder = match "multi" {
10968            "multi" => local_var_req_builder.query(
10969                &local_var_str
10970                    .into_iter()
10971                    .map(|p| ("sa_lifetime_seconds__gte".to_owned(), p.to_string()))
10972                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10973            ),
10974            _ => local_var_req_builder.query(&[(
10975                "sa_lifetime_seconds__gte",
10976                &local_var_str
10977                    .into_iter()
10978                    .map(|p| p.to_string())
10979                    .collect::<Vec<String>>()
10980                    .join(",")
10981                    .to_string(),
10982            )]),
10983        };
10984    }
10985    if let Some(ref local_var_str) = sa_lifetime_seconds__lt {
10986        local_var_req_builder = match "multi" {
10987            "multi" => local_var_req_builder.query(
10988                &local_var_str
10989                    .into_iter()
10990                    .map(|p| ("sa_lifetime_seconds__lt".to_owned(), p.to_string()))
10991                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10992            ),
10993            _ => local_var_req_builder.query(&[(
10994                "sa_lifetime_seconds__lt",
10995                &local_var_str
10996                    .into_iter()
10997                    .map(|p| p.to_string())
10998                    .collect::<Vec<String>>()
10999                    .join(",")
11000                    .to_string(),
11001            )]),
11002        };
11003    }
11004    if let Some(ref local_var_str) = sa_lifetime_seconds__lte {
11005        local_var_req_builder = match "multi" {
11006            "multi" => local_var_req_builder.query(
11007                &local_var_str
11008                    .into_iter()
11009                    .map(|p| ("sa_lifetime_seconds__lte".to_owned(), p.to_string()))
11010                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11011            ),
11012            _ => local_var_req_builder.query(&[(
11013                "sa_lifetime_seconds__lte",
11014                &local_var_str
11015                    .into_iter()
11016                    .map(|p| p.to_string())
11017                    .collect::<Vec<String>>()
11018                    .join(",")
11019                    .to_string(),
11020            )]),
11021        };
11022    }
11023    if let Some(ref local_var_str) = sa_lifetime_seconds__n {
11024        local_var_req_builder = match "multi" {
11025            "multi" => local_var_req_builder.query(
11026                &local_var_str
11027                    .into_iter()
11028                    .map(|p| ("sa_lifetime_seconds__n".to_owned(), p.to_string()))
11029                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11030            ),
11031            _ => local_var_req_builder.query(&[(
11032                "sa_lifetime_seconds__n",
11033                &local_var_str
11034                    .into_iter()
11035                    .map(|p| p.to_string())
11036                    .collect::<Vec<String>>()
11037                    .join(",")
11038                    .to_string(),
11039            )]),
11040        };
11041    }
11042    if let Some(ref local_var_str) = tag {
11043        local_var_req_builder = match "multi" {
11044            "multi" => local_var_req_builder.query(
11045                &local_var_str
11046                    .into_iter()
11047                    .map(|p| ("tag".to_owned(), p.to_string()))
11048                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11049            ),
11050            _ => local_var_req_builder.query(&[(
11051                "tag",
11052                &local_var_str
11053                    .into_iter()
11054                    .map(|p| p.to_string())
11055                    .collect::<Vec<String>>()
11056                    .join(",")
11057                    .to_string(),
11058            )]),
11059        };
11060    }
11061    if let Some(ref local_var_str) = tag__n {
11062        local_var_req_builder = match "multi" {
11063            "multi" => local_var_req_builder.query(
11064                &local_var_str
11065                    .into_iter()
11066                    .map(|p| ("tag__n".to_owned(), p.to_string()))
11067                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11068            ),
11069            _ => local_var_req_builder.query(&[(
11070                "tag__n",
11071                &local_var_str
11072                    .into_iter()
11073                    .map(|p| p.to_string())
11074                    .collect::<Vec<String>>()
11075                    .join(",")
11076                    .to_string(),
11077            )]),
11078        };
11079    }
11080    if let Some(ref local_var_str) = tag_id {
11081        local_var_req_builder = match "multi" {
11082            "multi" => local_var_req_builder.query(
11083                &local_var_str
11084                    .into_iter()
11085                    .map(|p| ("tag_id".to_owned(), p.to_string()))
11086                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11087            ),
11088            _ => local_var_req_builder.query(&[(
11089                "tag_id",
11090                &local_var_str
11091                    .into_iter()
11092                    .map(|p| p.to_string())
11093                    .collect::<Vec<String>>()
11094                    .join(",")
11095                    .to_string(),
11096            )]),
11097        };
11098    }
11099    if let Some(ref local_var_str) = tag_id__n {
11100        local_var_req_builder = match "multi" {
11101            "multi" => local_var_req_builder.query(
11102                &local_var_str
11103                    .into_iter()
11104                    .map(|p| ("tag_id__n".to_owned(), p.to_string()))
11105                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11106            ),
11107            _ => local_var_req_builder.query(&[(
11108                "tag_id__n",
11109                &local_var_str
11110                    .into_iter()
11111                    .map(|p| p.to_string())
11112                    .collect::<Vec<String>>()
11113                    .join(",")
11114                    .to_string(),
11115            )]),
11116        };
11117    }
11118    if let Some(ref local_var_str) = updated_by_request {
11119        local_var_req_builder =
11120            local_var_req_builder.query(&[("updated_by_request", &local_var_str.to_string())]);
11121    }
11122    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
11123        local_var_req_builder =
11124            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
11125    }
11126    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
11127        let local_var_key = local_var_apikey.key.clone();
11128        let local_var_value = match local_var_apikey.prefix {
11129            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
11130            None => local_var_key,
11131        };
11132        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
11133    };
11134
11135    let local_var_req = local_var_req_builder.build()?;
11136    let local_var_resp = local_var_client.execute(local_var_req).await?;
11137
11138    let local_var_status = local_var_resp.status();
11139    let local_var_content = local_var_resp.text().await?;
11140
11141    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
11142        serde_json::from_str(&local_var_content).map_err(Error::from)
11143    } else {
11144        let local_var_entity: Option<VpnIpsecProposalsListError> =
11145            serde_json::from_str(&local_var_content).ok();
11146        let local_var_error = ResponseContent {
11147            status: local_var_status,
11148            content: local_var_content,
11149            entity: local_var_entity,
11150        };
11151        Err(Error::ResponseError(local_var_error))
11152    }
11153}
11154
11155/// Patch a IPSec proposal object.
11156pub async fn vpn_ipsec_proposals_partial_update(
11157    configuration: &configuration::Configuration,
11158    id: i32,
11159    patched_writable_ip_sec_proposal_request: Option<
11160        crate::models::PatchedWritableIpSecProposalRequest,
11161    >,
11162) -> Result<crate::models::IpSecProposal, Error<VpnIpsecProposalsPartialUpdateError>> {
11163    let local_var_configuration = configuration;
11164
11165    let local_var_client = &local_var_configuration.client;
11166
11167    let local_var_uri_str = format!(
11168        "{}/api/vpn/ipsec-proposals/{id}/",
11169        local_var_configuration.base_path,
11170        id = id
11171    );
11172    let mut local_var_req_builder =
11173        local_var_client.request(reqwest::Method::PATCH, local_var_uri_str.as_str());
11174
11175    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
11176        local_var_req_builder =
11177            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
11178    }
11179    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
11180        let local_var_key = local_var_apikey.key.clone();
11181        let local_var_value = match local_var_apikey.prefix {
11182            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
11183            None => local_var_key,
11184        };
11185        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
11186    };
11187    local_var_req_builder = local_var_req_builder.json(&patched_writable_ip_sec_proposal_request);
11188
11189    let local_var_req = local_var_req_builder.build()?;
11190    let local_var_resp = local_var_client.execute(local_var_req).await?;
11191
11192    let local_var_status = local_var_resp.status();
11193    let local_var_content = local_var_resp.text().await?;
11194
11195    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
11196        serde_json::from_str(&local_var_content).map_err(Error::from)
11197    } else {
11198        let local_var_entity: Option<VpnIpsecProposalsPartialUpdateError> =
11199            serde_json::from_str(&local_var_content).ok();
11200        let local_var_error = ResponseContent {
11201            status: local_var_status,
11202            content: local_var_content,
11203            entity: local_var_entity,
11204        };
11205        Err(Error::ResponseError(local_var_error))
11206    }
11207}
11208
11209/// Get a IPSec proposal object.
11210pub async fn vpn_ipsec_proposals_retrieve(
11211    configuration: &configuration::Configuration,
11212    id: i32,
11213) -> Result<crate::models::IpSecProposal, Error<VpnIpsecProposalsRetrieveError>> {
11214    let local_var_configuration = configuration;
11215
11216    let local_var_client = &local_var_configuration.client;
11217
11218    let local_var_uri_str = format!(
11219        "{}/api/vpn/ipsec-proposals/{id}/",
11220        local_var_configuration.base_path,
11221        id = id
11222    );
11223    let mut local_var_req_builder =
11224        local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
11225
11226    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
11227        local_var_req_builder =
11228            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
11229    }
11230    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
11231        let local_var_key = local_var_apikey.key.clone();
11232        let local_var_value = match local_var_apikey.prefix {
11233            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
11234            None => local_var_key,
11235        };
11236        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
11237    };
11238
11239    let local_var_req = local_var_req_builder.build()?;
11240    let local_var_resp = local_var_client.execute(local_var_req).await?;
11241
11242    let local_var_status = local_var_resp.status();
11243    let local_var_content = local_var_resp.text().await?;
11244
11245    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
11246        serde_json::from_str(&local_var_content).map_err(Error::from)
11247    } else {
11248        let local_var_entity: Option<VpnIpsecProposalsRetrieveError> =
11249            serde_json::from_str(&local_var_content).ok();
11250        let local_var_error = ResponseContent {
11251            status: local_var_status,
11252            content: local_var_content,
11253            entity: local_var_entity,
11254        };
11255        Err(Error::ResponseError(local_var_error))
11256    }
11257}
11258
11259/// Put a IPSec proposal object.
11260pub async fn vpn_ipsec_proposals_update(
11261    configuration: &configuration::Configuration,
11262    id: i32,
11263    writable_ip_sec_proposal_request: crate::models::WritableIpSecProposalRequest,
11264) -> Result<crate::models::IpSecProposal, Error<VpnIpsecProposalsUpdateError>> {
11265    let local_var_configuration = configuration;
11266
11267    let local_var_client = &local_var_configuration.client;
11268
11269    let local_var_uri_str = format!(
11270        "{}/api/vpn/ipsec-proposals/{id}/",
11271        local_var_configuration.base_path,
11272        id = id
11273    );
11274    let mut local_var_req_builder =
11275        local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());
11276
11277    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
11278        local_var_req_builder =
11279            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
11280    }
11281    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
11282        let local_var_key = local_var_apikey.key.clone();
11283        let local_var_value = match local_var_apikey.prefix {
11284            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
11285            None => local_var_key,
11286        };
11287        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
11288    };
11289    local_var_req_builder = local_var_req_builder.json(&writable_ip_sec_proposal_request);
11290
11291    let local_var_req = local_var_req_builder.build()?;
11292    let local_var_resp = local_var_client.execute(local_var_req).await?;
11293
11294    let local_var_status = local_var_resp.status();
11295    let local_var_content = local_var_resp.text().await?;
11296
11297    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
11298        serde_json::from_str(&local_var_content).map_err(Error::from)
11299    } else {
11300        let local_var_entity: Option<VpnIpsecProposalsUpdateError> =
11301            serde_json::from_str(&local_var_content).ok();
11302        let local_var_error = ResponseContent {
11303            status: local_var_status,
11304            content: local_var_content,
11305            entity: local_var_entity,
11306        };
11307        Err(Error::ResponseError(local_var_error))
11308    }
11309}
11310
11311/// Delete a list of L2VPN termination objects.
11312pub async fn vpn_l2vpn_terminations_bulk_destroy(
11313    configuration: &configuration::Configuration,
11314    l2_vpn_termination_request: Vec<crate::models::L2VpnTerminationRequest>,
11315) -> Result<(), Error<VpnL2vpnTerminationsBulkDestroyError>> {
11316    let local_var_configuration = configuration;
11317
11318    let local_var_client = &local_var_configuration.client;
11319
11320    let local_var_uri_str = format!(
11321        "{}/api/vpn/l2vpn-terminations/",
11322        local_var_configuration.base_path
11323    );
11324    let mut local_var_req_builder =
11325        local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());
11326
11327    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
11328        local_var_req_builder =
11329            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
11330    }
11331    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
11332        let local_var_key = local_var_apikey.key.clone();
11333        let local_var_value = match local_var_apikey.prefix {
11334            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
11335            None => local_var_key,
11336        };
11337        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
11338    };
11339    local_var_req_builder = local_var_req_builder.json(&l2_vpn_termination_request);
11340
11341    let local_var_req = local_var_req_builder.build()?;
11342    let local_var_resp = local_var_client.execute(local_var_req).await?;
11343
11344    let local_var_status = local_var_resp.status();
11345    let local_var_content = local_var_resp.text().await?;
11346
11347    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
11348        Ok(())
11349    } else {
11350        let local_var_entity: Option<VpnL2vpnTerminationsBulkDestroyError> =
11351            serde_json::from_str(&local_var_content).ok();
11352        let local_var_error = ResponseContent {
11353            status: local_var_status,
11354            content: local_var_content,
11355            entity: local_var_entity,
11356        };
11357        Err(Error::ResponseError(local_var_error))
11358    }
11359}
11360
11361/// Patch a list of L2VPN termination objects.
11362pub async fn vpn_l2vpn_terminations_bulk_partial_update(
11363    configuration: &configuration::Configuration,
11364    l2_vpn_termination_request: Vec<crate::models::L2VpnTerminationRequest>,
11365) -> Result<Vec<crate::models::L2VpnTermination>, Error<VpnL2vpnTerminationsBulkPartialUpdateError>>
11366{
11367    let local_var_configuration = configuration;
11368
11369    let local_var_client = &local_var_configuration.client;
11370
11371    let local_var_uri_str = format!(
11372        "{}/api/vpn/l2vpn-terminations/",
11373        local_var_configuration.base_path
11374    );
11375    let mut local_var_req_builder =
11376        local_var_client.request(reqwest::Method::PATCH, local_var_uri_str.as_str());
11377
11378    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
11379        local_var_req_builder =
11380            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
11381    }
11382    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
11383        let local_var_key = local_var_apikey.key.clone();
11384        let local_var_value = match local_var_apikey.prefix {
11385            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
11386            None => local_var_key,
11387        };
11388        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
11389    };
11390    local_var_req_builder = local_var_req_builder.json(&l2_vpn_termination_request);
11391
11392    let local_var_req = local_var_req_builder.build()?;
11393    let local_var_resp = local_var_client.execute(local_var_req).await?;
11394
11395    let local_var_status = local_var_resp.status();
11396    let local_var_content = local_var_resp.text().await?;
11397
11398    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
11399        serde_json::from_str(&local_var_content).map_err(Error::from)
11400    } else {
11401        let local_var_entity: Option<VpnL2vpnTerminationsBulkPartialUpdateError> =
11402            serde_json::from_str(&local_var_content).ok();
11403        let local_var_error = ResponseContent {
11404            status: local_var_status,
11405            content: local_var_content,
11406            entity: local_var_entity,
11407        };
11408        Err(Error::ResponseError(local_var_error))
11409    }
11410}
11411
11412/// Put a list of L2VPN termination objects.
11413pub async fn vpn_l2vpn_terminations_bulk_update(
11414    configuration: &configuration::Configuration,
11415    l2_vpn_termination_request: Vec<crate::models::L2VpnTerminationRequest>,
11416) -> Result<Vec<crate::models::L2VpnTermination>, Error<VpnL2vpnTerminationsBulkUpdateError>> {
11417    let local_var_configuration = configuration;
11418
11419    let local_var_client = &local_var_configuration.client;
11420
11421    let local_var_uri_str = format!(
11422        "{}/api/vpn/l2vpn-terminations/",
11423        local_var_configuration.base_path
11424    );
11425    let mut local_var_req_builder =
11426        local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());
11427
11428    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
11429        local_var_req_builder =
11430            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
11431    }
11432    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
11433        let local_var_key = local_var_apikey.key.clone();
11434        let local_var_value = match local_var_apikey.prefix {
11435            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
11436            None => local_var_key,
11437        };
11438        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
11439    };
11440    local_var_req_builder = local_var_req_builder.json(&l2_vpn_termination_request);
11441
11442    let local_var_req = local_var_req_builder.build()?;
11443    let local_var_resp = local_var_client.execute(local_var_req).await?;
11444
11445    let local_var_status = local_var_resp.status();
11446    let local_var_content = local_var_resp.text().await?;
11447
11448    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
11449        serde_json::from_str(&local_var_content).map_err(Error::from)
11450    } else {
11451        let local_var_entity: Option<VpnL2vpnTerminationsBulkUpdateError> =
11452            serde_json::from_str(&local_var_content).ok();
11453        let local_var_error = ResponseContent {
11454            status: local_var_status,
11455            content: local_var_content,
11456            entity: local_var_entity,
11457        };
11458        Err(Error::ResponseError(local_var_error))
11459    }
11460}
11461
11462/// Post a list of L2VPN termination objects.
11463pub async fn vpn_l2vpn_terminations_create(
11464    configuration: &configuration::Configuration,
11465    l2_vpn_termination_request: crate::models::L2VpnTerminationRequest,
11466) -> Result<crate::models::L2VpnTermination, Error<VpnL2vpnTerminationsCreateError>> {
11467    let local_var_configuration = configuration;
11468
11469    let local_var_client = &local_var_configuration.client;
11470
11471    let local_var_uri_str = format!(
11472        "{}/api/vpn/l2vpn-terminations/",
11473        local_var_configuration.base_path
11474    );
11475    let mut local_var_req_builder =
11476        local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
11477
11478    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
11479        local_var_req_builder =
11480            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
11481    }
11482    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
11483        let local_var_key = local_var_apikey.key.clone();
11484        let local_var_value = match local_var_apikey.prefix {
11485            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
11486            None => local_var_key,
11487        };
11488        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
11489    };
11490    local_var_req_builder = local_var_req_builder.json(&l2_vpn_termination_request);
11491
11492    let local_var_req = local_var_req_builder.build()?;
11493    let local_var_resp = local_var_client.execute(local_var_req).await?;
11494
11495    let local_var_status = local_var_resp.status();
11496    let local_var_content = local_var_resp.text().await?;
11497
11498    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
11499        serde_json::from_str(&local_var_content).map_err(Error::from)
11500    } else {
11501        let local_var_entity: Option<VpnL2vpnTerminationsCreateError> =
11502            serde_json::from_str(&local_var_content).ok();
11503        let local_var_error = ResponseContent {
11504            status: local_var_status,
11505            content: local_var_content,
11506            entity: local_var_entity,
11507        };
11508        Err(Error::ResponseError(local_var_error))
11509    }
11510}
11511
11512/// Delete a L2VPN termination object.
11513pub async fn vpn_l2vpn_terminations_destroy(
11514    configuration: &configuration::Configuration,
11515    id: i32,
11516) -> Result<(), Error<VpnL2vpnTerminationsDestroyError>> {
11517    let local_var_configuration = configuration;
11518
11519    let local_var_client = &local_var_configuration.client;
11520
11521    let local_var_uri_str = format!(
11522        "{}/api/vpn/l2vpn-terminations/{id}/",
11523        local_var_configuration.base_path,
11524        id = id
11525    );
11526    let mut local_var_req_builder =
11527        local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());
11528
11529    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
11530        local_var_req_builder =
11531            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
11532    }
11533    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
11534        let local_var_key = local_var_apikey.key.clone();
11535        let local_var_value = match local_var_apikey.prefix {
11536            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
11537            None => local_var_key,
11538        };
11539        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
11540    };
11541
11542    let local_var_req = local_var_req_builder.build()?;
11543    let local_var_resp = local_var_client.execute(local_var_req).await?;
11544
11545    let local_var_status = local_var_resp.status();
11546    let local_var_content = local_var_resp.text().await?;
11547
11548    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
11549        Ok(())
11550    } else {
11551        let local_var_entity: Option<VpnL2vpnTerminationsDestroyError> =
11552            serde_json::from_str(&local_var_content).ok();
11553        let local_var_error = ResponseContent {
11554            status: local_var_status,
11555            content: local_var_content,
11556            entity: local_var_entity,
11557        };
11558        Err(Error::ResponseError(local_var_error))
11559    }
11560}
11561
11562/// Get a list of L2VPN termination objects.
11563pub async fn vpn_l2vpn_terminations_list(
11564    configuration: &configuration::Configuration,
11565    assigned_object_id: Option<Vec<i32>>,
11566    assigned_object_id__empty: Option<bool>,
11567    assigned_object_id__gt: Option<Vec<i32>>,
11568    assigned_object_id__gte: Option<Vec<i32>>,
11569    assigned_object_id__lt: Option<Vec<i32>>,
11570    assigned_object_id__lte: Option<Vec<i32>>,
11571    assigned_object_id__n: Option<Vec<i32>>,
11572    assigned_object_type: Option<&str>,
11573    assigned_object_type__n: Option<&str>,
11574    created: Option<Vec<String>>,
11575    created__empty: Option<Vec<String>>,
11576    created__gt: Option<Vec<String>>,
11577    created__gte: Option<Vec<String>>,
11578    created__lt: Option<Vec<String>>,
11579    created__lte: Option<Vec<String>>,
11580    created__n: Option<Vec<String>>,
11581    created_by_request: Option<&str>,
11582    device: Option<Vec<String>>,
11583    device__n: Option<Vec<String>>,
11584    device_id: Option<Vec<i32>>,
11585    device_id__n: Option<Vec<i32>>,
11586    id: Option<Vec<i32>>,
11587    id__empty: Option<bool>,
11588    id__gt: Option<Vec<i32>>,
11589    id__gte: Option<Vec<i32>>,
11590    id__lt: Option<Vec<i32>>,
11591    id__lte: Option<Vec<i32>>,
11592    id__n: Option<Vec<i32>>,
11593    interface: Option<Vec<String>>,
11594    interface__n: Option<Vec<String>>,
11595    interface_id: Option<Vec<i32>>,
11596    interface_id__n: Option<Vec<i32>>,
11597    l2vpn: Option<Vec<String>>,
11598    l2vpn__n: Option<Vec<String>>,
11599    l2vpn_id: Option<Vec<i32>>,
11600    l2vpn_id__n: Option<Vec<i32>>,
11601    last_updated: Option<Vec<String>>,
11602    last_updated__empty: Option<Vec<String>>,
11603    last_updated__gt: Option<Vec<String>>,
11604    last_updated__gte: Option<Vec<String>>,
11605    last_updated__lt: Option<Vec<String>>,
11606    last_updated__lte: Option<Vec<String>>,
11607    last_updated__n: Option<Vec<String>>,
11608    limit: Option<i32>,
11609    modified_by_request: Option<&str>,
11610    offset: Option<i32>,
11611    ordering: Option<&str>,
11612    q: Option<&str>,
11613    region: Option<Vec<String>>,
11614    region_id: Option<Vec<i32>>,
11615    site: Option<Vec<String>>,
11616    site_id: Option<Vec<i32>>,
11617    tag: Option<Vec<String>>,
11618    tag__n: Option<Vec<String>>,
11619    tag_id: Option<Vec<i32>>,
11620    tag_id__n: Option<Vec<i32>>,
11621    updated_by_request: Option<&str>,
11622    virtual_machine: Option<Vec<String>>,
11623    virtual_machine__n: Option<Vec<String>>,
11624    virtual_machine_id: Option<Vec<i32>>,
11625    virtual_machine_id__n: Option<Vec<i32>>,
11626    vlan: Option<Vec<String>>,
11627    vlan__n: Option<Vec<String>>,
11628    vlan_id: Option<Vec<i32>>,
11629    vlan_id__n: Option<Vec<i32>>,
11630    vlan_vid: Option<i32>,
11631    vlan_vid__empty: Option<i32>,
11632    vlan_vid__gt: Option<i32>,
11633    vlan_vid__gte: Option<i32>,
11634    vlan_vid__lt: Option<i32>,
11635    vlan_vid__lte: Option<i32>,
11636    vlan_vid__n: Option<i32>,
11637    vminterface: Option<Vec<String>>,
11638    vminterface__n: Option<Vec<String>>,
11639    vminterface_id: Option<Vec<i32>>,
11640    vminterface_id__n: Option<Vec<i32>>,
11641) -> Result<crate::models::PaginatedL2VpnTerminationList, Error<VpnL2vpnTerminationsListError>> {
11642    let local_var_configuration = configuration;
11643
11644    let local_var_client = &local_var_configuration.client;
11645
11646    let local_var_uri_str = format!(
11647        "{}/api/vpn/l2vpn-terminations/",
11648        local_var_configuration.base_path
11649    );
11650    let mut local_var_req_builder =
11651        local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
11652
11653    if let Some(ref local_var_str) = assigned_object_id {
11654        local_var_req_builder = match "multi" {
11655            "multi" => local_var_req_builder.query(
11656                &local_var_str
11657                    .into_iter()
11658                    .map(|p| ("assigned_object_id".to_owned(), p.to_string()))
11659                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11660            ),
11661            _ => local_var_req_builder.query(&[(
11662                "assigned_object_id",
11663                &local_var_str
11664                    .into_iter()
11665                    .map(|p| p.to_string())
11666                    .collect::<Vec<String>>()
11667                    .join(",")
11668                    .to_string(),
11669            )]),
11670        };
11671    }
11672    if let Some(ref local_var_str) = assigned_object_id__empty {
11673        local_var_req_builder = local_var_req_builder
11674            .query(&[("assigned_object_id__empty", &local_var_str.to_string())]);
11675    }
11676    if let Some(ref local_var_str) = assigned_object_id__gt {
11677        local_var_req_builder = match "multi" {
11678            "multi" => local_var_req_builder.query(
11679                &local_var_str
11680                    .into_iter()
11681                    .map(|p| ("assigned_object_id__gt".to_owned(), p.to_string()))
11682                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11683            ),
11684            _ => local_var_req_builder.query(&[(
11685                "assigned_object_id__gt",
11686                &local_var_str
11687                    .into_iter()
11688                    .map(|p| p.to_string())
11689                    .collect::<Vec<String>>()
11690                    .join(",")
11691                    .to_string(),
11692            )]),
11693        };
11694    }
11695    if let Some(ref local_var_str) = assigned_object_id__gte {
11696        local_var_req_builder = match "multi" {
11697            "multi" => local_var_req_builder.query(
11698                &local_var_str
11699                    .into_iter()
11700                    .map(|p| ("assigned_object_id__gte".to_owned(), p.to_string()))
11701                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11702            ),
11703            _ => local_var_req_builder.query(&[(
11704                "assigned_object_id__gte",
11705                &local_var_str
11706                    .into_iter()
11707                    .map(|p| p.to_string())
11708                    .collect::<Vec<String>>()
11709                    .join(",")
11710                    .to_string(),
11711            )]),
11712        };
11713    }
11714    if let Some(ref local_var_str) = assigned_object_id__lt {
11715        local_var_req_builder = match "multi" {
11716            "multi" => local_var_req_builder.query(
11717                &local_var_str
11718                    .into_iter()
11719                    .map(|p| ("assigned_object_id__lt".to_owned(), p.to_string()))
11720                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11721            ),
11722            _ => local_var_req_builder.query(&[(
11723                "assigned_object_id__lt",
11724                &local_var_str
11725                    .into_iter()
11726                    .map(|p| p.to_string())
11727                    .collect::<Vec<String>>()
11728                    .join(",")
11729                    .to_string(),
11730            )]),
11731        };
11732    }
11733    if let Some(ref local_var_str) = assigned_object_id__lte {
11734        local_var_req_builder = match "multi" {
11735            "multi" => local_var_req_builder.query(
11736                &local_var_str
11737                    .into_iter()
11738                    .map(|p| ("assigned_object_id__lte".to_owned(), p.to_string()))
11739                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11740            ),
11741            _ => local_var_req_builder.query(&[(
11742                "assigned_object_id__lte",
11743                &local_var_str
11744                    .into_iter()
11745                    .map(|p| p.to_string())
11746                    .collect::<Vec<String>>()
11747                    .join(",")
11748                    .to_string(),
11749            )]),
11750        };
11751    }
11752    if let Some(ref local_var_str) = assigned_object_id__n {
11753        local_var_req_builder = match "multi" {
11754            "multi" => local_var_req_builder.query(
11755                &local_var_str
11756                    .into_iter()
11757                    .map(|p| ("assigned_object_id__n".to_owned(), p.to_string()))
11758                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11759            ),
11760            _ => local_var_req_builder.query(&[(
11761                "assigned_object_id__n",
11762                &local_var_str
11763                    .into_iter()
11764                    .map(|p| p.to_string())
11765                    .collect::<Vec<String>>()
11766                    .join(",")
11767                    .to_string(),
11768            )]),
11769        };
11770    }
11771    if let Some(ref local_var_str) = assigned_object_type {
11772        local_var_req_builder =
11773            local_var_req_builder.query(&[("assigned_object_type", &local_var_str.to_string())]);
11774    }
11775    if let Some(ref local_var_str) = assigned_object_type__n {
11776        local_var_req_builder =
11777            local_var_req_builder.query(&[("assigned_object_type__n", &local_var_str.to_string())]);
11778    }
11779    if let Some(ref local_var_str) = created {
11780        local_var_req_builder = match "multi" {
11781            "multi" => local_var_req_builder.query(
11782                &local_var_str
11783                    .into_iter()
11784                    .map(|p| ("created".to_owned(), p.to_string()))
11785                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11786            ),
11787            _ => local_var_req_builder.query(&[(
11788                "created",
11789                &local_var_str
11790                    .into_iter()
11791                    .map(|p| p.to_string())
11792                    .collect::<Vec<String>>()
11793                    .join(",")
11794                    .to_string(),
11795            )]),
11796        };
11797    }
11798    if let Some(ref local_var_str) = created__empty {
11799        local_var_req_builder = match "multi" {
11800            "multi" => local_var_req_builder.query(
11801                &local_var_str
11802                    .into_iter()
11803                    .map(|p| ("created__empty".to_owned(), p.to_string()))
11804                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11805            ),
11806            _ => local_var_req_builder.query(&[(
11807                "created__empty",
11808                &local_var_str
11809                    .into_iter()
11810                    .map(|p| p.to_string())
11811                    .collect::<Vec<String>>()
11812                    .join(",")
11813                    .to_string(),
11814            )]),
11815        };
11816    }
11817    if let Some(ref local_var_str) = created__gt {
11818        local_var_req_builder = match "multi" {
11819            "multi" => local_var_req_builder.query(
11820                &local_var_str
11821                    .into_iter()
11822                    .map(|p| ("created__gt".to_owned(), p.to_string()))
11823                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11824            ),
11825            _ => local_var_req_builder.query(&[(
11826                "created__gt",
11827                &local_var_str
11828                    .into_iter()
11829                    .map(|p| p.to_string())
11830                    .collect::<Vec<String>>()
11831                    .join(",")
11832                    .to_string(),
11833            )]),
11834        };
11835    }
11836    if let Some(ref local_var_str) = created__gte {
11837        local_var_req_builder = match "multi" {
11838            "multi" => local_var_req_builder.query(
11839                &local_var_str
11840                    .into_iter()
11841                    .map(|p| ("created__gte".to_owned(), p.to_string()))
11842                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11843            ),
11844            _ => local_var_req_builder.query(&[(
11845                "created__gte",
11846                &local_var_str
11847                    .into_iter()
11848                    .map(|p| p.to_string())
11849                    .collect::<Vec<String>>()
11850                    .join(",")
11851                    .to_string(),
11852            )]),
11853        };
11854    }
11855    if let Some(ref local_var_str) = created__lt {
11856        local_var_req_builder = match "multi" {
11857            "multi" => local_var_req_builder.query(
11858                &local_var_str
11859                    .into_iter()
11860                    .map(|p| ("created__lt".to_owned(), p.to_string()))
11861                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11862            ),
11863            _ => local_var_req_builder.query(&[(
11864                "created__lt",
11865                &local_var_str
11866                    .into_iter()
11867                    .map(|p| p.to_string())
11868                    .collect::<Vec<String>>()
11869                    .join(",")
11870                    .to_string(),
11871            )]),
11872        };
11873    }
11874    if let Some(ref local_var_str) = created__lte {
11875        local_var_req_builder = match "multi" {
11876            "multi" => local_var_req_builder.query(
11877                &local_var_str
11878                    .into_iter()
11879                    .map(|p| ("created__lte".to_owned(), p.to_string()))
11880                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11881            ),
11882            _ => local_var_req_builder.query(&[(
11883                "created__lte",
11884                &local_var_str
11885                    .into_iter()
11886                    .map(|p| p.to_string())
11887                    .collect::<Vec<String>>()
11888                    .join(",")
11889                    .to_string(),
11890            )]),
11891        };
11892    }
11893    if let Some(ref local_var_str) = created__n {
11894        local_var_req_builder = match "multi" {
11895            "multi" => local_var_req_builder.query(
11896                &local_var_str
11897                    .into_iter()
11898                    .map(|p| ("created__n".to_owned(), p.to_string()))
11899                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11900            ),
11901            _ => local_var_req_builder.query(&[(
11902                "created__n",
11903                &local_var_str
11904                    .into_iter()
11905                    .map(|p| p.to_string())
11906                    .collect::<Vec<String>>()
11907                    .join(",")
11908                    .to_string(),
11909            )]),
11910        };
11911    }
11912    if let Some(ref local_var_str) = created_by_request {
11913        local_var_req_builder =
11914            local_var_req_builder.query(&[("created_by_request", &local_var_str.to_string())]);
11915    }
11916    if let Some(ref local_var_str) = device {
11917        local_var_req_builder = match "multi" {
11918            "multi" => local_var_req_builder.query(
11919                &local_var_str
11920                    .into_iter()
11921                    .map(|p| ("device".to_owned(), p.to_string()))
11922                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11923            ),
11924            _ => local_var_req_builder.query(&[(
11925                "device",
11926                &local_var_str
11927                    .into_iter()
11928                    .map(|p| p.to_string())
11929                    .collect::<Vec<String>>()
11930                    .join(",")
11931                    .to_string(),
11932            )]),
11933        };
11934    }
11935    if let Some(ref local_var_str) = device__n {
11936        local_var_req_builder = match "multi" {
11937            "multi" => local_var_req_builder.query(
11938                &local_var_str
11939                    .into_iter()
11940                    .map(|p| ("device__n".to_owned(), p.to_string()))
11941                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11942            ),
11943            _ => local_var_req_builder.query(&[(
11944                "device__n",
11945                &local_var_str
11946                    .into_iter()
11947                    .map(|p| p.to_string())
11948                    .collect::<Vec<String>>()
11949                    .join(",")
11950                    .to_string(),
11951            )]),
11952        };
11953    }
11954    if let Some(ref local_var_str) = device_id {
11955        local_var_req_builder = match "multi" {
11956            "multi" => local_var_req_builder.query(
11957                &local_var_str
11958                    .into_iter()
11959                    .map(|p| ("device_id".to_owned(), p.to_string()))
11960                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11961            ),
11962            _ => local_var_req_builder.query(&[(
11963                "device_id",
11964                &local_var_str
11965                    .into_iter()
11966                    .map(|p| p.to_string())
11967                    .collect::<Vec<String>>()
11968                    .join(",")
11969                    .to_string(),
11970            )]),
11971        };
11972    }
11973    if let Some(ref local_var_str) = device_id__n {
11974        local_var_req_builder = match "multi" {
11975            "multi" => local_var_req_builder.query(
11976                &local_var_str
11977                    .into_iter()
11978                    .map(|p| ("device_id__n".to_owned(), p.to_string()))
11979                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11980            ),
11981            _ => local_var_req_builder.query(&[(
11982                "device_id__n",
11983                &local_var_str
11984                    .into_iter()
11985                    .map(|p| p.to_string())
11986                    .collect::<Vec<String>>()
11987                    .join(",")
11988                    .to_string(),
11989            )]),
11990        };
11991    }
11992    if let Some(ref local_var_str) = id {
11993        local_var_req_builder = match "multi" {
11994            "multi" => local_var_req_builder.query(
11995                &local_var_str
11996                    .into_iter()
11997                    .map(|p| ("id".to_owned(), p.to_string()))
11998                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11999            ),
12000            _ => local_var_req_builder.query(&[(
12001                "id",
12002                &local_var_str
12003                    .into_iter()
12004                    .map(|p| p.to_string())
12005                    .collect::<Vec<String>>()
12006                    .join(",")
12007                    .to_string(),
12008            )]),
12009        };
12010    }
12011    if let Some(ref local_var_str) = id__empty {
12012        local_var_req_builder =
12013            local_var_req_builder.query(&[("id__empty", &local_var_str.to_string())]);
12014    }
12015    if let Some(ref local_var_str) = id__gt {
12016        local_var_req_builder = match "multi" {
12017            "multi" => local_var_req_builder.query(
12018                &local_var_str
12019                    .into_iter()
12020                    .map(|p| ("id__gt".to_owned(), p.to_string()))
12021                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12022            ),
12023            _ => local_var_req_builder.query(&[(
12024                "id__gt",
12025                &local_var_str
12026                    .into_iter()
12027                    .map(|p| p.to_string())
12028                    .collect::<Vec<String>>()
12029                    .join(",")
12030                    .to_string(),
12031            )]),
12032        };
12033    }
12034    if let Some(ref local_var_str) = id__gte {
12035        local_var_req_builder = match "multi" {
12036            "multi" => local_var_req_builder.query(
12037                &local_var_str
12038                    .into_iter()
12039                    .map(|p| ("id__gte".to_owned(), p.to_string()))
12040                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12041            ),
12042            _ => local_var_req_builder.query(&[(
12043                "id__gte",
12044                &local_var_str
12045                    .into_iter()
12046                    .map(|p| p.to_string())
12047                    .collect::<Vec<String>>()
12048                    .join(",")
12049                    .to_string(),
12050            )]),
12051        };
12052    }
12053    if let Some(ref local_var_str) = id__lt {
12054        local_var_req_builder = match "multi" {
12055            "multi" => local_var_req_builder.query(
12056                &local_var_str
12057                    .into_iter()
12058                    .map(|p| ("id__lt".to_owned(), p.to_string()))
12059                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12060            ),
12061            _ => local_var_req_builder.query(&[(
12062                "id__lt",
12063                &local_var_str
12064                    .into_iter()
12065                    .map(|p| p.to_string())
12066                    .collect::<Vec<String>>()
12067                    .join(",")
12068                    .to_string(),
12069            )]),
12070        };
12071    }
12072    if let Some(ref local_var_str) = id__lte {
12073        local_var_req_builder = match "multi" {
12074            "multi" => local_var_req_builder.query(
12075                &local_var_str
12076                    .into_iter()
12077                    .map(|p| ("id__lte".to_owned(), p.to_string()))
12078                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12079            ),
12080            _ => local_var_req_builder.query(&[(
12081                "id__lte",
12082                &local_var_str
12083                    .into_iter()
12084                    .map(|p| p.to_string())
12085                    .collect::<Vec<String>>()
12086                    .join(",")
12087                    .to_string(),
12088            )]),
12089        };
12090    }
12091    if let Some(ref local_var_str) = id__n {
12092        local_var_req_builder = match "multi" {
12093            "multi" => local_var_req_builder.query(
12094                &local_var_str
12095                    .into_iter()
12096                    .map(|p| ("id__n".to_owned(), p.to_string()))
12097                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12098            ),
12099            _ => local_var_req_builder.query(&[(
12100                "id__n",
12101                &local_var_str
12102                    .into_iter()
12103                    .map(|p| p.to_string())
12104                    .collect::<Vec<String>>()
12105                    .join(",")
12106                    .to_string(),
12107            )]),
12108        };
12109    }
12110    if let Some(ref local_var_str) = interface {
12111        local_var_req_builder = match "multi" {
12112            "multi" => local_var_req_builder.query(
12113                &local_var_str
12114                    .into_iter()
12115                    .map(|p| ("interface".to_owned(), p.to_string()))
12116                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12117            ),
12118            _ => local_var_req_builder.query(&[(
12119                "interface",
12120                &local_var_str
12121                    .into_iter()
12122                    .map(|p| p.to_string())
12123                    .collect::<Vec<String>>()
12124                    .join(",")
12125                    .to_string(),
12126            )]),
12127        };
12128    }
12129    if let Some(ref local_var_str) = interface__n {
12130        local_var_req_builder = match "multi" {
12131            "multi" => local_var_req_builder.query(
12132                &local_var_str
12133                    .into_iter()
12134                    .map(|p| ("interface__n".to_owned(), p.to_string()))
12135                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12136            ),
12137            _ => local_var_req_builder.query(&[(
12138                "interface__n",
12139                &local_var_str
12140                    .into_iter()
12141                    .map(|p| p.to_string())
12142                    .collect::<Vec<String>>()
12143                    .join(",")
12144                    .to_string(),
12145            )]),
12146        };
12147    }
12148    if let Some(ref local_var_str) = interface_id {
12149        local_var_req_builder = match "multi" {
12150            "multi" => local_var_req_builder.query(
12151                &local_var_str
12152                    .into_iter()
12153                    .map(|p| ("interface_id".to_owned(), p.to_string()))
12154                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12155            ),
12156            _ => local_var_req_builder.query(&[(
12157                "interface_id",
12158                &local_var_str
12159                    .into_iter()
12160                    .map(|p| p.to_string())
12161                    .collect::<Vec<String>>()
12162                    .join(",")
12163                    .to_string(),
12164            )]),
12165        };
12166    }
12167    if let Some(ref local_var_str) = interface_id__n {
12168        local_var_req_builder = match "multi" {
12169            "multi" => local_var_req_builder.query(
12170                &local_var_str
12171                    .into_iter()
12172                    .map(|p| ("interface_id__n".to_owned(), p.to_string()))
12173                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12174            ),
12175            _ => local_var_req_builder.query(&[(
12176                "interface_id__n",
12177                &local_var_str
12178                    .into_iter()
12179                    .map(|p| p.to_string())
12180                    .collect::<Vec<String>>()
12181                    .join(",")
12182                    .to_string(),
12183            )]),
12184        };
12185    }
12186    if let Some(ref local_var_str) = l2vpn {
12187        local_var_req_builder = match "multi" {
12188            "multi" => local_var_req_builder.query(
12189                &local_var_str
12190                    .into_iter()
12191                    .map(|p| ("l2vpn".to_owned(), p.to_string()))
12192                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12193            ),
12194            _ => local_var_req_builder.query(&[(
12195                "l2vpn",
12196                &local_var_str
12197                    .into_iter()
12198                    .map(|p| p.to_string())
12199                    .collect::<Vec<String>>()
12200                    .join(",")
12201                    .to_string(),
12202            )]),
12203        };
12204    }
12205    if let Some(ref local_var_str) = l2vpn__n {
12206        local_var_req_builder = match "multi" {
12207            "multi" => local_var_req_builder.query(
12208                &local_var_str
12209                    .into_iter()
12210                    .map(|p| ("l2vpn__n".to_owned(), p.to_string()))
12211                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12212            ),
12213            _ => local_var_req_builder.query(&[(
12214                "l2vpn__n",
12215                &local_var_str
12216                    .into_iter()
12217                    .map(|p| p.to_string())
12218                    .collect::<Vec<String>>()
12219                    .join(",")
12220                    .to_string(),
12221            )]),
12222        };
12223    }
12224    if let Some(ref local_var_str) = l2vpn_id {
12225        local_var_req_builder = match "multi" {
12226            "multi" => local_var_req_builder.query(
12227                &local_var_str
12228                    .into_iter()
12229                    .map(|p| ("l2vpn_id".to_owned(), p.to_string()))
12230                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12231            ),
12232            _ => local_var_req_builder.query(&[(
12233                "l2vpn_id",
12234                &local_var_str
12235                    .into_iter()
12236                    .map(|p| p.to_string())
12237                    .collect::<Vec<String>>()
12238                    .join(",")
12239                    .to_string(),
12240            )]),
12241        };
12242    }
12243    if let Some(ref local_var_str) = l2vpn_id__n {
12244        local_var_req_builder = match "multi" {
12245            "multi" => local_var_req_builder.query(
12246                &local_var_str
12247                    .into_iter()
12248                    .map(|p| ("l2vpn_id__n".to_owned(), p.to_string()))
12249                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12250            ),
12251            _ => local_var_req_builder.query(&[(
12252                "l2vpn_id__n",
12253                &local_var_str
12254                    .into_iter()
12255                    .map(|p| p.to_string())
12256                    .collect::<Vec<String>>()
12257                    .join(",")
12258                    .to_string(),
12259            )]),
12260        };
12261    }
12262    if let Some(ref local_var_str) = last_updated {
12263        local_var_req_builder = match "multi" {
12264            "multi" => local_var_req_builder.query(
12265                &local_var_str
12266                    .into_iter()
12267                    .map(|p| ("last_updated".to_owned(), p.to_string()))
12268                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12269            ),
12270            _ => local_var_req_builder.query(&[(
12271                "last_updated",
12272                &local_var_str
12273                    .into_iter()
12274                    .map(|p| p.to_string())
12275                    .collect::<Vec<String>>()
12276                    .join(",")
12277                    .to_string(),
12278            )]),
12279        };
12280    }
12281    if let Some(ref local_var_str) = last_updated__empty {
12282        local_var_req_builder = match "multi" {
12283            "multi" => local_var_req_builder.query(
12284                &local_var_str
12285                    .into_iter()
12286                    .map(|p| ("last_updated__empty".to_owned(), p.to_string()))
12287                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12288            ),
12289            _ => local_var_req_builder.query(&[(
12290                "last_updated__empty",
12291                &local_var_str
12292                    .into_iter()
12293                    .map(|p| p.to_string())
12294                    .collect::<Vec<String>>()
12295                    .join(",")
12296                    .to_string(),
12297            )]),
12298        };
12299    }
12300    if let Some(ref local_var_str) = last_updated__gt {
12301        local_var_req_builder = match "multi" {
12302            "multi" => local_var_req_builder.query(
12303                &local_var_str
12304                    .into_iter()
12305                    .map(|p| ("last_updated__gt".to_owned(), p.to_string()))
12306                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12307            ),
12308            _ => local_var_req_builder.query(&[(
12309                "last_updated__gt",
12310                &local_var_str
12311                    .into_iter()
12312                    .map(|p| p.to_string())
12313                    .collect::<Vec<String>>()
12314                    .join(",")
12315                    .to_string(),
12316            )]),
12317        };
12318    }
12319    if let Some(ref local_var_str) = last_updated__gte {
12320        local_var_req_builder = match "multi" {
12321            "multi" => local_var_req_builder.query(
12322                &local_var_str
12323                    .into_iter()
12324                    .map(|p| ("last_updated__gte".to_owned(), p.to_string()))
12325                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12326            ),
12327            _ => local_var_req_builder.query(&[(
12328                "last_updated__gte",
12329                &local_var_str
12330                    .into_iter()
12331                    .map(|p| p.to_string())
12332                    .collect::<Vec<String>>()
12333                    .join(",")
12334                    .to_string(),
12335            )]),
12336        };
12337    }
12338    if let Some(ref local_var_str) = last_updated__lt {
12339        local_var_req_builder = match "multi" {
12340            "multi" => local_var_req_builder.query(
12341                &local_var_str
12342                    .into_iter()
12343                    .map(|p| ("last_updated__lt".to_owned(), p.to_string()))
12344                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12345            ),
12346            _ => local_var_req_builder.query(&[(
12347                "last_updated__lt",
12348                &local_var_str
12349                    .into_iter()
12350                    .map(|p| p.to_string())
12351                    .collect::<Vec<String>>()
12352                    .join(",")
12353                    .to_string(),
12354            )]),
12355        };
12356    }
12357    if let Some(ref local_var_str) = last_updated__lte {
12358        local_var_req_builder = match "multi" {
12359            "multi" => local_var_req_builder.query(
12360                &local_var_str
12361                    .into_iter()
12362                    .map(|p| ("last_updated__lte".to_owned(), p.to_string()))
12363                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12364            ),
12365            _ => local_var_req_builder.query(&[(
12366                "last_updated__lte",
12367                &local_var_str
12368                    .into_iter()
12369                    .map(|p| p.to_string())
12370                    .collect::<Vec<String>>()
12371                    .join(",")
12372                    .to_string(),
12373            )]),
12374        };
12375    }
12376    if let Some(ref local_var_str) = last_updated__n {
12377        local_var_req_builder = match "multi" {
12378            "multi" => local_var_req_builder.query(
12379                &local_var_str
12380                    .into_iter()
12381                    .map(|p| ("last_updated__n".to_owned(), p.to_string()))
12382                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12383            ),
12384            _ => local_var_req_builder.query(&[(
12385                "last_updated__n",
12386                &local_var_str
12387                    .into_iter()
12388                    .map(|p| p.to_string())
12389                    .collect::<Vec<String>>()
12390                    .join(",")
12391                    .to_string(),
12392            )]),
12393        };
12394    }
12395    if let Some(ref local_var_str) = limit {
12396        local_var_req_builder =
12397            local_var_req_builder.query(&[("limit", &local_var_str.to_string())]);
12398    }
12399    if let Some(ref local_var_str) = modified_by_request {
12400        local_var_req_builder =
12401            local_var_req_builder.query(&[("modified_by_request", &local_var_str.to_string())]);
12402    }
12403    if let Some(ref local_var_str) = offset {
12404        local_var_req_builder =
12405            local_var_req_builder.query(&[("offset", &local_var_str.to_string())]);
12406    }
12407    if let Some(ref local_var_str) = ordering {
12408        local_var_req_builder =
12409            local_var_req_builder.query(&[("ordering", &local_var_str.to_string())]);
12410    }
12411    if let Some(ref local_var_str) = q {
12412        local_var_req_builder = local_var_req_builder.query(&[("q", &local_var_str.to_string())]);
12413    }
12414    if let Some(ref local_var_str) = region {
12415        local_var_req_builder = match "multi" {
12416            "multi" => local_var_req_builder.query(
12417                &local_var_str
12418                    .into_iter()
12419                    .map(|p| ("region".to_owned(), p.to_string()))
12420                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12421            ),
12422            _ => local_var_req_builder.query(&[(
12423                "region",
12424                &local_var_str
12425                    .into_iter()
12426                    .map(|p| p.to_string())
12427                    .collect::<Vec<String>>()
12428                    .join(",")
12429                    .to_string(),
12430            )]),
12431        };
12432    }
12433    if let Some(ref local_var_str) = region_id {
12434        local_var_req_builder = match "multi" {
12435            "multi" => local_var_req_builder.query(
12436                &local_var_str
12437                    .into_iter()
12438                    .map(|p| ("region_id".to_owned(), p.to_string()))
12439                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12440            ),
12441            _ => local_var_req_builder.query(&[(
12442                "region_id",
12443                &local_var_str
12444                    .into_iter()
12445                    .map(|p| p.to_string())
12446                    .collect::<Vec<String>>()
12447                    .join(",")
12448                    .to_string(),
12449            )]),
12450        };
12451    }
12452    if let Some(ref local_var_str) = site {
12453        local_var_req_builder = match "multi" {
12454            "multi" => local_var_req_builder.query(
12455                &local_var_str
12456                    .into_iter()
12457                    .map(|p| ("site".to_owned(), p.to_string()))
12458                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12459            ),
12460            _ => local_var_req_builder.query(&[(
12461                "site",
12462                &local_var_str
12463                    .into_iter()
12464                    .map(|p| p.to_string())
12465                    .collect::<Vec<String>>()
12466                    .join(",")
12467                    .to_string(),
12468            )]),
12469        };
12470    }
12471    if let Some(ref local_var_str) = site_id {
12472        local_var_req_builder = match "multi" {
12473            "multi" => local_var_req_builder.query(
12474                &local_var_str
12475                    .into_iter()
12476                    .map(|p| ("site_id".to_owned(), p.to_string()))
12477                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12478            ),
12479            _ => local_var_req_builder.query(&[(
12480                "site_id",
12481                &local_var_str
12482                    .into_iter()
12483                    .map(|p| p.to_string())
12484                    .collect::<Vec<String>>()
12485                    .join(",")
12486                    .to_string(),
12487            )]),
12488        };
12489    }
12490    if let Some(ref local_var_str) = tag {
12491        local_var_req_builder = match "multi" {
12492            "multi" => local_var_req_builder.query(
12493                &local_var_str
12494                    .into_iter()
12495                    .map(|p| ("tag".to_owned(), p.to_string()))
12496                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12497            ),
12498            _ => local_var_req_builder.query(&[(
12499                "tag",
12500                &local_var_str
12501                    .into_iter()
12502                    .map(|p| p.to_string())
12503                    .collect::<Vec<String>>()
12504                    .join(",")
12505                    .to_string(),
12506            )]),
12507        };
12508    }
12509    if let Some(ref local_var_str) = tag__n {
12510        local_var_req_builder = match "multi" {
12511            "multi" => local_var_req_builder.query(
12512                &local_var_str
12513                    .into_iter()
12514                    .map(|p| ("tag__n".to_owned(), p.to_string()))
12515                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12516            ),
12517            _ => local_var_req_builder.query(&[(
12518                "tag__n",
12519                &local_var_str
12520                    .into_iter()
12521                    .map(|p| p.to_string())
12522                    .collect::<Vec<String>>()
12523                    .join(",")
12524                    .to_string(),
12525            )]),
12526        };
12527    }
12528    if let Some(ref local_var_str) = tag_id {
12529        local_var_req_builder = match "multi" {
12530            "multi" => local_var_req_builder.query(
12531                &local_var_str
12532                    .into_iter()
12533                    .map(|p| ("tag_id".to_owned(), p.to_string()))
12534                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12535            ),
12536            _ => local_var_req_builder.query(&[(
12537                "tag_id",
12538                &local_var_str
12539                    .into_iter()
12540                    .map(|p| p.to_string())
12541                    .collect::<Vec<String>>()
12542                    .join(",")
12543                    .to_string(),
12544            )]),
12545        };
12546    }
12547    if let Some(ref local_var_str) = tag_id__n {
12548        local_var_req_builder = match "multi" {
12549            "multi" => local_var_req_builder.query(
12550                &local_var_str
12551                    .into_iter()
12552                    .map(|p| ("tag_id__n".to_owned(), p.to_string()))
12553                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12554            ),
12555            _ => local_var_req_builder.query(&[(
12556                "tag_id__n",
12557                &local_var_str
12558                    .into_iter()
12559                    .map(|p| p.to_string())
12560                    .collect::<Vec<String>>()
12561                    .join(",")
12562                    .to_string(),
12563            )]),
12564        };
12565    }
12566    if let Some(ref local_var_str) = updated_by_request {
12567        local_var_req_builder =
12568            local_var_req_builder.query(&[("updated_by_request", &local_var_str.to_string())]);
12569    }
12570    if let Some(ref local_var_str) = virtual_machine {
12571        local_var_req_builder = match "multi" {
12572            "multi" => local_var_req_builder.query(
12573                &local_var_str
12574                    .into_iter()
12575                    .map(|p| ("virtual_machine".to_owned(), p.to_string()))
12576                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12577            ),
12578            _ => local_var_req_builder.query(&[(
12579                "virtual_machine",
12580                &local_var_str
12581                    .into_iter()
12582                    .map(|p| p.to_string())
12583                    .collect::<Vec<String>>()
12584                    .join(",")
12585                    .to_string(),
12586            )]),
12587        };
12588    }
12589    if let Some(ref local_var_str) = virtual_machine__n {
12590        local_var_req_builder = match "multi" {
12591            "multi" => local_var_req_builder.query(
12592                &local_var_str
12593                    .into_iter()
12594                    .map(|p| ("virtual_machine__n".to_owned(), p.to_string()))
12595                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12596            ),
12597            _ => local_var_req_builder.query(&[(
12598                "virtual_machine__n",
12599                &local_var_str
12600                    .into_iter()
12601                    .map(|p| p.to_string())
12602                    .collect::<Vec<String>>()
12603                    .join(",")
12604                    .to_string(),
12605            )]),
12606        };
12607    }
12608    if let Some(ref local_var_str) = virtual_machine_id {
12609        local_var_req_builder = match "multi" {
12610            "multi" => local_var_req_builder.query(
12611                &local_var_str
12612                    .into_iter()
12613                    .map(|p| ("virtual_machine_id".to_owned(), p.to_string()))
12614                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12615            ),
12616            _ => local_var_req_builder.query(&[(
12617                "virtual_machine_id",
12618                &local_var_str
12619                    .into_iter()
12620                    .map(|p| p.to_string())
12621                    .collect::<Vec<String>>()
12622                    .join(",")
12623                    .to_string(),
12624            )]),
12625        };
12626    }
12627    if let Some(ref local_var_str) = virtual_machine_id__n {
12628        local_var_req_builder = match "multi" {
12629            "multi" => local_var_req_builder.query(
12630                &local_var_str
12631                    .into_iter()
12632                    .map(|p| ("virtual_machine_id__n".to_owned(), p.to_string()))
12633                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12634            ),
12635            _ => local_var_req_builder.query(&[(
12636                "virtual_machine_id__n",
12637                &local_var_str
12638                    .into_iter()
12639                    .map(|p| p.to_string())
12640                    .collect::<Vec<String>>()
12641                    .join(",")
12642                    .to_string(),
12643            )]),
12644        };
12645    }
12646    if let Some(ref local_var_str) = vlan {
12647        local_var_req_builder = match "multi" {
12648            "multi" => local_var_req_builder.query(
12649                &local_var_str
12650                    .into_iter()
12651                    .map(|p| ("vlan".to_owned(), p.to_string()))
12652                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12653            ),
12654            _ => local_var_req_builder.query(&[(
12655                "vlan",
12656                &local_var_str
12657                    .into_iter()
12658                    .map(|p| p.to_string())
12659                    .collect::<Vec<String>>()
12660                    .join(",")
12661                    .to_string(),
12662            )]),
12663        };
12664    }
12665    if let Some(ref local_var_str) = vlan__n {
12666        local_var_req_builder = match "multi" {
12667            "multi" => local_var_req_builder.query(
12668                &local_var_str
12669                    .into_iter()
12670                    .map(|p| ("vlan__n".to_owned(), p.to_string()))
12671                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12672            ),
12673            _ => local_var_req_builder.query(&[(
12674                "vlan__n",
12675                &local_var_str
12676                    .into_iter()
12677                    .map(|p| p.to_string())
12678                    .collect::<Vec<String>>()
12679                    .join(",")
12680                    .to_string(),
12681            )]),
12682        };
12683    }
12684    if let Some(ref local_var_str) = vlan_id {
12685        local_var_req_builder = match "multi" {
12686            "multi" => local_var_req_builder.query(
12687                &local_var_str
12688                    .into_iter()
12689                    .map(|p| ("vlan_id".to_owned(), p.to_string()))
12690                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12691            ),
12692            _ => local_var_req_builder.query(&[(
12693                "vlan_id",
12694                &local_var_str
12695                    .into_iter()
12696                    .map(|p| p.to_string())
12697                    .collect::<Vec<String>>()
12698                    .join(",")
12699                    .to_string(),
12700            )]),
12701        };
12702    }
12703    if let Some(ref local_var_str) = vlan_id__n {
12704        local_var_req_builder = match "multi" {
12705            "multi" => local_var_req_builder.query(
12706                &local_var_str
12707                    .into_iter()
12708                    .map(|p| ("vlan_id__n".to_owned(), p.to_string()))
12709                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12710            ),
12711            _ => local_var_req_builder.query(&[(
12712                "vlan_id__n",
12713                &local_var_str
12714                    .into_iter()
12715                    .map(|p| p.to_string())
12716                    .collect::<Vec<String>>()
12717                    .join(",")
12718                    .to_string(),
12719            )]),
12720        };
12721    }
12722    if let Some(ref local_var_str) = vlan_vid {
12723        local_var_req_builder =
12724            local_var_req_builder.query(&[("vlan_vid", &local_var_str.to_string())]);
12725    }
12726    if let Some(ref local_var_str) = vlan_vid__empty {
12727        local_var_req_builder =
12728            local_var_req_builder.query(&[("vlan_vid__empty", &local_var_str.to_string())]);
12729    }
12730    if let Some(ref local_var_str) = vlan_vid__gt {
12731        local_var_req_builder =
12732            local_var_req_builder.query(&[("vlan_vid__gt", &local_var_str.to_string())]);
12733    }
12734    if let Some(ref local_var_str) = vlan_vid__gte {
12735        local_var_req_builder =
12736            local_var_req_builder.query(&[("vlan_vid__gte", &local_var_str.to_string())]);
12737    }
12738    if let Some(ref local_var_str) = vlan_vid__lt {
12739        local_var_req_builder =
12740            local_var_req_builder.query(&[("vlan_vid__lt", &local_var_str.to_string())]);
12741    }
12742    if let Some(ref local_var_str) = vlan_vid__lte {
12743        local_var_req_builder =
12744            local_var_req_builder.query(&[("vlan_vid__lte", &local_var_str.to_string())]);
12745    }
12746    if let Some(ref local_var_str) = vlan_vid__n {
12747        local_var_req_builder =
12748            local_var_req_builder.query(&[("vlan_vid__n", &local_var_str.to_string())]);
12749    }
12750    if let Some(ref local_var_str) = vminterface {
12751        local_var_req_builder = match "multi" {
12752            "multi" => local_var_req_builder.query(
12753                &local_var_str
12754                    .into_iter()
12755                    .map(|p| ("vminterface".to_owned(), p.to_string()))
12756                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12757            ),
12758            _ => local_var_req_builder.query(&[(
12759                "vminterface",
12760                &local_var_str
12761                    .into_iter()
12762                    .map(|p| p.to_string())
12763                    .collect::<Vec<String>>()
12764                    .join(",")
12765                    .to_string(),
12766            )]),
12767        };
12768    }
12769    if let Some(ref local_var_str) = vminterface__n {
12770        local_var_req_builder = match "multi" {
12771            "multi" => local_var_req_builder.query(
12772                &local_var_str
12773                    .into_iter()
12774                    .map(|p| ("vminterface__n".to_owned(), p.to_string()))
12775                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12776            ),
12777            _ => local_var_req_builder.query(&[(
12778                "vminterface__n",
12779                &local_var_str
12780                    .into_iter()
12781                    .map(|p| p.to_string())
12782                    .collect::<Vec<String>>()
12783                    .join(",")
12784                    .to_string(),
12785            )]),
12786        };
12787    }
12788    if let Some(ref local_var_str) = vminterface_id {
12789        local_var_req_builder = match "multi" {
12790            "multi" => local_var_req_builder.query(
12791                &local_var_str
12792                    .into_iter()
12793                    .map(|p| ("vminterface_id".to_owned(), p.to_string()))
12794                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12795            ),
12796            _ => local_var_req_builder.query(&[(
12797                "vminterface_id",
12798                &local_var_str
12799                    .into_iter()
12800                    .map(|p| p.to_string())
12801                    .collect::<Vec<String>>()
12802                    .join(",")
12803                    .to_string(),
12804            )]),
12805        };
12806    }
12807    if let Some(ref local_var_str) = vminterface_id__n {
12808        local_var_req_builder = match "multi" {
12809            "multi" => local_var_req_builder.query(
12810                &local_var_str
12811                    .into_iter()
12812                    .map(|p| ("vminterface_id__n".to_owned(), p.to_string()))
12813                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12814            ),
12815            _ => local_var_req_builder.query(&[(
12816                "vminterface_id__n",
12817                &local_var_str
12818                    .into_iter()
12819                    .map(|p| p.to_string())
12820                    .collect::<Vec<String>>()
12821                    .join(",")
12822                    .to_string(),
12823            )]),
12824        };
12825    }
12826    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
12827        local_var_req_builder =
12828            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
12829    }
12830    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
12831        let local_var_key = local_var_apikey.key.clone();
12832        let local_var_value = match local_var_apikey.prefix {
12833            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
12834            None => local_var_key,
12835        };
12836        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
12837    };
12838
12839    let local_var_req = local_var_req_builder.build()?;
12840    let local_var_resp = local_var_client.execute(local_var_req).await?;
12841
12842    let local_var_status = local_var_resp.status();
12843    let local_var_content = local_var_resp.text().await?;
12844
12845    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
12846        serde_json::from_str(&local_var_content).map_err(Error::from)
12847    } else {
12848        let local_var_entity: Option<VpnL2vpnTerminationsListError> =
12849            serde_json::from_str(&local_var_content).ok();
12850        let local_var_error = ResponseContent {
12851            status: local_var_status,
12852            content: local_var_content,
12853            entity: local_var_entity,
12854        };
12855        Err(Error::ResponseError(local_var_error))
12856    }
12857}
12858
12859/// Patch a L2VPN termination object.
12860pub async fn vpn_l2vpn_terminations_partial_update(
12861    configuration: &configuration::Configuration,
12862    id: i32,
12863    patched_l2_vpn_termination_request: Option<crate::models::PatchedL2VpnTerminationRequest>,
12864) -> Result<crate::models::L2VpnTermination, Error<VpnL2vpnTerminationsPartialUpdateError>> {
12865    let local_var_configuration = configuration;
12866
12867    let local_var_client = &local_var_configuration.client;
12868
12869    let local_var_uri_str = format!(
12870        "{}/api/vpn/l2vpn-terminations/{id}/",
12871        local_var_configuration.base_path,
12872        id = id
12873    );
12874    let mut local_var_req_builder =
12875        local_var_client.request(reqwest::Method::PATCH, local_var_uri_str.as_str());
12876
12877    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
12878        local_var_req_builder =
12879            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
12880    }
12881    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
12882        let local_var_key = local_var_apikey.key.clone();
12883        let local_var_value = match local_var_apikey.prefix {
12884            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
12885            None => local_var_key,
12886        };
12887        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
12888    };
12889    local_var_req_builder = local_var_req_builder.json(&patched_l2_vpn_termination_request);
12890
12891    let local_var_req = local_var_req_builder.build()?;
12892    let local_var_resp = local_var_client.execute(local_var_req).await?;
12893
12894    let local_var_status = local_var_resp.status();
12895    let local_var_content = local_var_resp.text().await?;
12896
12897    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
12898        serde_json::from_str(&local_var_content).map_err(Error::from)
12899    } else {
12900        let local_var_entity: Option<VpnL2vpnTerminationsPartialUpdateError> =
12901            serde_json::from_str(&local_var_content).ok();
12902        let local_var_error = ResponseContent {
12903            status: local_var_status,
12904            content: local_var_content,
12905            entity: local_var_entity,
12906        };
12907        Err(Error::ResponseError(local_var_error))
12908    }
12909}
12910
12911/// Get a L2VPN termination object.
12912pub async fn vpn_l2vpn_terminations_retrieve(
12913    configuration: &configuration::Configuration,
12914    id: i32,
12915) -> Result<crate::models::L2VpnTermination, Error<VpnL2vpnTerminationsRetrieveError>> {
12916    let local_var_configuration = configuration;
12917
12918    let local_var_client = &local_var_configuration.client;
12919
12920    let local_var_uri_str = format!(
12921        "{}/api/vpn/l2vpn-terminations/{id}/",
12922        local_var_configuration.base_path,
12923        id = id
12924    );
12925    let mut local_var_req_builder =
12926        local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
12927
12928    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
12929        local_var_req_builder =
12930            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
12931    }
12932    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
12933        let local_var_key = local_var_apikey.key.clone();
12934        let local_var_value = match local_var_apikey.prefix {
12935            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
12936            None => local_var_key,
12937        };
12938        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
12939    };
12940
12941    let local_var_req = local_var_req_builder.build()?;
12942    let local_var_resp = local_var_client.execute(local_var_req).await?;
12943
12944    let local_var_status = local_var_resp.status();
12945    let local_var_content = local_var_resp.text().await?;
12946
12947    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
12948        serde_json::from_str(&local_var_content).map_err(Error::from)
12949    } else {
12950        let local_var_entity: Option<VpnL2vpnTerminationsRetrieveError> =
12951            serde_json::from_str(&local_var_content).ok();
12952        let local_var_error = ResponseContent {
12953            status: local_var_status,
12954            content: local_var_content,
12955            entity: local_var_entity,
12956        };
12957        Err(Error::ResponseError(local_var_error))
12958    }
12959}
12960
12961/// Put a L2VPN termination object.
12962pub async fn vpn_l2vpn_terminations_update(
12963    configuration: &configuration::Configuration,
12964    id: i32,
12965    l2_vpn_termination_request: crate::models::L2VpnTerminationRequest,
12966) -> Result<crate::models::L2VpnTermination, Error<VpnL2vpnTerminationsUpdateError>> {
12967    let local_var_configuration = configuration;
12968
12969    let local_var_client = &local_var_configuration.client;
12970
12971    let local_var_uri_str = format!(
12972        "{}/api/vpn/l2vpn-terminations/{id}/",
12973        local_var_configuration.base_path,
12974        id = id
12975    );
12976    let mut local_var_req_builder =
12977        local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());
12978
12979    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
12980        local_var_req_builder =
12981            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
12982    }
12983    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
12984        let local_var_key = local_var_apikey.key.clone();
12985        let local_var_value = match local_var_apikey.prefix {
12986            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
12987            None => local_var_key,
12988        };
12989        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
12990    };
12991    local_var_req_builder = local_var_req_builder.json(&l2_vpn_termination_request);
12992
12993    let local_var_req = local_var_req_builder.build()?;
12994    let local_var_resp = local_var_client.execute(local_var_req).await?;
12995
12996    let local_var_status = local_var_resp.status();
12997    let local_var_content = local_var_resp.text().await?;
12998
12999    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
13000        serde_json::from_str(&local_var_content).map_err(Error::from)
13001    } else {
13002        let local_var_entity: Option<VpnL2vpnTerminationsUpdateError> =
13003            serde_json::from_str(&local_var_content).ok();
13004        let local_var_error = ResponseContent {
13005            status: local_var_status,
13006            content: local_var_content,
13007            entity: local_var_entity,
13008        };
13009        Err(Error::ResponseError(local_var_error))
13010    }
13011}
13012
13013/// Delete a list of L2VPN objects.
13014pub async fn vpn_l2vpns_bulk_destroy(
13015    configuration: &configuration::Configuration,
13016    l2_vpn_request: Vec<crate::models::L2VpnRequest>,
13017) -> Result<(), Error<VpnL2vpnsBulkDestroyError>> {
13018    let local_var_configuration = configuration;
13019
13020    let local_var_client = &local_var_configuration.client;
13021
13022    let local_var_uri_str = format!("{}/api/vpn/l2vpns/", local_var_configuration.base_path);
13023    let mut local_var_req_builder =
13024        local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());
13025
13026    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
13027        local_var_req_builder =
13028            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
13029    }
13030    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
13031        let local_var_key = local_var_apikey.key.clone();
13032        let local_var_value = match local_var_apikey.prefix {
13033            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
13034            None => local_var_key,
13035        };
13036        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
13037    };
13038    local_var_req_builder = local_var_req_builder.json(&l2_vpn_request);
13039
13040    let local_var_req = local_var_req_builder.build()?;
13041    let local_var_resp = local_var_client.execute(local_var_req).await?;
13042
13043    let local_var_status = local_var_resp.status();
13044    let local_var_content = local_var_resp.text().await?;
13045
13046    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
13047        Ok(())
13048    } else {
13049        let local_var_entity: Option<VpnL2vpnsBulkDestroyError> =
13050            serde_json::from_str(&local_var_content).ok();
13051        let local_var_error = ResponseContent {
13052            status: local_var_status,
13053            content: local_var_content,
13054            entity: local_var_entity,
13055        };
13056        Err(Error::ResponseError(local_var_error))
13057    }
13058}
13059
13060/// Patch a list of L2VPN objects.
13061pub async fn vpn_l2vpns_bulk_partial_update(
13062    configuration: &configuration::Configuration,
13063    l2_vpn_request: Vec<crate::models::L2VpnRequest>,
13064) -> Result<Vec<crate::models::L2Vpn>, Error<VpnL2vpnsBulkPartialUpdateError>> {
13065    let local_var_configuration = configuration;
13066
13067    let local_var_client = &local_var_configuration.client;
13068
13069    let local_var_uri_str = format!("{}/api/vpn/l2vpns/", local_var_configuration.base_path);
13070    let mut local_var_req_builder =
13071        local_var_client.request(reqwest::Method::PATCH, local_var_uri_str.as_str());
13072
13073    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
13074        local_var_req_builder =
13075            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
13076    }
13077    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
13078        let local_var_key = local_var_apikey.key.clone();
13079        let local_var_value = match local_var_apikey.prefix {
13080            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
13081            None => local_var_key,
13082        };
13083        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
13084    };
13085    local_var_req_builder = local_var_req_builder.json(&l2_vpn_request);
13086
13087    let local_var_req = local_var_req_builder.build()?;
13088    let local_var_resp = local_var_client.execute(local_var_req).await?;
13089
13090    let local_var_status = local_var_resp.status();
13091    let local_var_content = local_var_resp.text().await?;
13092
13093    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
13094        serde_json::from_str(&local_var_content).map_err(Error::from)
13095    } else {
13096        let local_var_entity: Option<VpnL2vpnsBulkPartialUpdateError> =
13097            serde_json::from_str(&local_var_content).ok();
13098        let local_var_error = ResponseContent {
13099            status: local_var_status,
13100            content: local_var_content,
13101            entity: local_var_entity,
13102        };
13103        Err(Error::ResponseError(local_var_error))
13104    }
13105}
13106
13107/// Put a list of L2VPN objects.
13108pub async fn vpn_l2vpns_bulk_update(
13109    configuration: &configuration::Configuration,
13110    l2_vpn_request: Vec<crate::models::L2VpnRequest>,
13111) -> Result<Vec<crate::models::L2Vpn>, Error<VpnL2vpnsBulkUpdateError>> {
13112    let local_var_configuration = configuration;
13113
13114    let local_var_client = &local_var_configuration.client;
13115
13116    let local_var_uri_str = format!("{}/api/vpn/l2vpns/", local_var_configuration.base_path);
13117    let mut local_var_req_builder =
13118        local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());
13119
13120    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
13121        local_var_req_builder =
13122            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
13123    }
13124    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
13125        let local_var_key = local_var_apikey.key.clone();
13126        let local_var_value = match local_var_apikey.prefix {
13127            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
13128            None => local_var_key,
13129        };
13130        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
13131    };
13132    local_var_req_builder = local_var_req_builder.json(&l2_vpn_request);
13133
13134    let local_var_req = local_var_req_builder.build()?;
13135    let local_var_resp = local_var_client.execute(local_var_req).await?;
13136
13137    let local_var_status = local_var_resp.status();
13138    let local_var_content = local_var_resp.text().await?;
13139
13140    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
13141        serde_json::from_str(&local_var_content).map_err(Error::from)
13142    } else {
13143        let local_var_entity: Option<VpnL2vpnsBulkUpdateError> =
13144            serde_json::from_str(&local_var_content).ok();
13145        let local_var_error = ResponseContent {
13146            status: local_var_status,
13147            content: local_var_content,
13148            entity: local_var_entity,
13149        };
13150        Err(Error::ResponseError(local_var_error))
13151    }
13152}
13153
13154/// Post a list of L2VPN objects.
13155pub async fn vpn_l2vpns_create(
13156    configuration: &configuration::Configuration,
13157    writable_l2_vpn_request: crate::models::WritableL2VpnRequest,
13158) -> Result<crate::models::L2Vpn, Error<VpnL2vpnsCreateError>> {
13159    let local_var_configuration = configuration;
13160
13161    let local_var_client = &local_var_configuration.client;
13162
13163    let local_var_uri_str = format!("{}/api/vpn/l2vpns/", local_var_configuration.base_path);
13164    let mut local_var_req_builder =
13165        local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
13166
13167    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
13168        local_var_req_builder =
13169            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
13170    }
13171    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
13172        let local_var_key = local_var_apikey.key.clone();
13173        let local_var_value = match local_var_apikey.prefix {
13174            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
13175            None => local_var_key,
13176        };
13177        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
13178    };
13179    local_var_req_builder = local_var_req_builder.json(&writable_l2_vpn_request);
13180
13181    let local_var_req = local_var_req_builder.build()?;
13182    let local_var_resp = local_var_client.execute(local_var_req).await?;
13183
13184    let local_var_status = local_var_resp.status();
13185    let local_var_content = local_var_resp.text().await?;
13186
13187    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
13188        serde_json::from_str(&local_var_content).map_err(Error::from)
13189    } else {
13190        let local_var_entity: Option<VpnL2vpnsCreateError> =
13191            serde_json::from_str(&local_var_content).ok();
13192        let local_var_error = ResponseContent {
13193            status: local_var_status,
13194            content: local_var_content,
13195            entity: local_var_entity,
13196        };
13197        Err(Error::ResponseError(local_var_error))
13198    }
13199}
13200
13201/// Delete a L2VPN object.
13202pub async fn vpn_l2vpns_destroy(
13203    configuration: &configuration::Configuration,
13204    id: i32,
13205) -> Result<(), Error<VpnL2vpnsDestroyError>> {
13206    let local_var_configuration = configuration;
13207
13208    let local_var_client = &local_var_configuration.client;
13209
13210    let local_var_uri_str = format!(
13211        "{}/api/vpn/l2vpns/{id}/",
13212        local_var_configuration.base_path,
13213        id = id
13214    );
13215    let mut local_var_req_builder =
13216        local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());
13217
13218    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
13219        local_var_req_builder =
13220            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
13221    }
13222    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
13223        let local_var_key = local_var_apikey.key.clone();
13224        let local_var_value = match local_var_apikey.prefix {
13225            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
13226            None => local_var_key,
13227        };
13228        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
13229    };
13230
13231    let local_var_req = local_var_req_builder.build()?;
13232    let local_var_resp = local_var_client.execute(local_var_req).await?;
13233
13234    let local_var_status = local_var_resp.status();
13235    let local_var_content = local_var_resp.text().await?;
13236
13237    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
13238        Ok(())
13239    } else {
13240        let local_var_entity: Option<VpnL2vpnsDestroyError> =
13241            serde_json::from_str(&local_var_content).ok();
13242        let local_var_error = ResponseContent {
13243            status: local_var_status,
13244            content: local_var_content,
13245            entity: local_var_entity,
13246        };
13247        Err(Error::ResponseError(local_var_error))
13248    }
13249}
13250
13251/// Get a list of L2VPN objects.
13252pub async fn vpn_l2vpns_list(
13253    configuration: &configuration::Configuration,
13254    contact: Option<Vec<i32>>,
13255    contact__n: Option<Vec<i32>>,
13256    contact_group: Option<Vec<String>>,
13257    contact_group__n: Option<Vec<String>>,
13258    contact_role: Option<Vec<i32>>,
13259    contact_role__n: Option<Vec<i32>>,
13260    created: Option<Vec<String>>,
13261    created__empty: Option<Vec<String>>,
13262    created__gt: Option<Vec<String>>,
13263    created__gte: Option<Vec<String>>,
13264    created__lt: Option<Vec<String>>,
13265    created__lte: Option<Vec<String>>,
13266    created__n: Option<Vec<String>>,
13267    created_by_request: Option<&str>,
13268    description: Option<Vec<String>>,
13269    description__empty: Option<bool>,
13270    description__ic: Option<Vec<String>>,
13271    description__ie: Option<Vec<String>>,
13272    description__iew: Option<Vec<String>>,
13273    description__iregex: Option<Vec<String>>,
13274    description__isw: Option<Vec<String>>,
13275    description__n: Option<Vec<String>>,
13276    description__nic: Option<Vec<String>>,
13277    description__nie: Option<Vec<String>>,
13278    description__niew: Option<Vec<String>>,
13279    description__nisw: Option<Vec<String>>,
13280    description__regex: Option<Vec<String>>,
13281    export_target: Option<Vec<String>>,
13282    export_target__n: Option<Vec<String>>,
13283    export_target_id: Option<Vec<i32>>,
13284    export_target_id__n: Option<Vec<i32>>,
13285    id: Option<Vec<i32>>,
13286    id__empty: Option<bool>,
13287    id__gt: Option<Vec<i32>>,
13288    id__gte: Option<Vec<i32>>,
13289    id__lt: Option<Vec<i32>>,
13290    id__lte: Option<Vec<i32>>,
13291    id__n: Option<Vec<i32>>,
13292    identifier: Option<Vec<i32>>,
13293    identifier__empty: Option<bool>,
13294    identifier__gt: Option<Vec<i32>>,
13295    identifier__gte: Option<Vec<i32>>,
13296    identifier__lt: Option<Vec<i32>>,
13297    identifier__lte: Option<Vec<i32>>,
13298    identifier__n: Option<Vec<i32>>,
13299    import_target: Option<Vec<String>>,
13300    import_target__n: Option<Vec<String>>,
13301    import_target_id: Option<Vec<i32>>,
13302    import_target_id__n: Option<Vec<i32>>,
13303    last_updated: Option<Vec<String>>,
13304    last_updated__empty: Option<Vec<String>>,
13305    last_updated__gt: Option<Vec<String>>,
13306    last_updated__gte: Option<Vec<String>>,
13307    last_updated__lt: Option<Vec<String>>,
13308    last_updated__lte: Option<Vec<String>>,
13309    last_updated__n: Option<Vec<String>>,
13310    limit: Option<i32>,
13311    modified_by_request: Option<&str>,
13312    name: Option<Vec<String>>,
13313    name__empty: Option<bool>,
13314    name__ic: Option<Vec<String>>,
13315    name__ie: Option<Vec<String>>,
13316    name__iew: Option<Vec<String>>,
13317    name__iregex: Option<Vec<String>>,
13318    name__isw: Option<Vec<String>>,
13319    name__n: Option<Vec<String>>,
13320    name__nic: Option<Vec<String>>,
13321    name__nie: Option<Vec<String>>,
13322    name__niew: Option<Vec<String>>,
13323    name__nisw: Option<Vec<String>>,
13324    name__regex: Option<Vec<String>>,
13325    offset: Option<i32>,
13326    ordering: Option<&str>,
13327    q: Option<&str>,
13328    slug: Option<Vec<String>>,
13329    slug__empty: Option<bool>,
13330    slug__ic: Option<Vec<String>>,
13331    slug__ie: Option<Vec<String>>,
13332    slug__iew: Option<Vec<String>>,
13333    slug__iregex: Option<Vec<String>>,
13334    slug__isw: Option<Vec<String>>,
13335    slug__n: Option<Vec<String>>,
13336    slug__nic: Option<Vec<String>>,
13337    slug__nie: Option<Vec<String>>,
13338    slug__niew: Option<Vec<String>>,
13339    slug__nisw: Option<Vec<String>>,
13340    slug__regex: Option<Vec<String>>,
13341    status: Option<Vec<String>>,
13342    status__empty: Option<bool>,
13343    status__ic: Option<Vec<String>>,
13344    status__ie: Option<Vec<String>>,
13345    status__iew: Option<Vec<String>>,
13346    status__iregex: Option<Vec<String>>,
13347    status__isw: Option<Vec<String>>,
13348    status__n: Option<Vec<String>>,
13349    status__nic: Option<Vec<String>>,
13350    status__nie: Option<Vec<String>>,
13351    status__niew: Option<Vec<String>>,
13352    status__nisw: Option<Vec<String>>,
13353    status__regex: Option<Vec<String>>,
13354    tag: Option<Vec<String>>,
13355    tag__n: Option<Vec<String>>,
13356    tag_id: Option<Vec<i32>>,
13357    tag_id__n: Option<Vec<i32>>,
13358    tenant: Option<Vec<String>>,
13359    tenant__n: Option<Vec<String>>,
13360    tenant_group: Option<Vec<String>>,
13361    tenant_group__n: Option<Vec<String>>,
13362    tenant_group_id: Option<Vec<String>>,
13363    tenant_group_id__n: Option<Vec<String>>,
13364    tenant_id: Option<Vec<i32>>,
13365    tenant_id__n: Option<Vec<i32>>,
13366    r#type: Option<Vec<String>>,
13367    type__empty: Option<bool>,
13368    type__ic: Option<Vec<String>>,
13369    type__ie: Option<Vec<String>>,
13370    type__iew: Option<Vec<String>>,
13371    type__iregex: Option<Vec<String>>,
13372    type__isw: Option<Vec<String>>,
13373    type__n: Option<Vec<String>>,
13374    type__nic: Option<Vec<String>>,
13375    type__nie: Option<Vec<String>>,
13376    type__niew: Option<Vec<String>>,
13377    type__nisw: Option<Vec<String>>,
13378    type__regex: Option<Vec<String>>,
13379    updated_by_request: Option<&str>,
13380) -> Result<crate::models::PaginatedL2VpnList, Error<VpnL2vpnsListError>> {
13381    let local_var_configuration = configuration;
13382
13383    let local_var_client = &local_var_configuration.client;
13384
13385    let local_var_uri_str = format!("{}/api/vpn/l2vpns/", local_var_configuration.base_path);
13386    let mut local_var_req_builder =
13387        local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
13388
13389    if let Some(ref local_var_str) = contact {
13390        local_var_req_builder = match "multi" {
13391            "multi" => local_var_req_builder.query(
13392                &local_var_str
13393                    .into_iter()
13394                    .map(|p| ("contact".to_owned(), p.to_string()))
13395                    .collect::<Vec<(std::string::String, std::string::String)>>(),
13396            ),
13397            _ => local_var_req_builder.query(&[(
13398                "contact",
13399                &local_var_str
13400                    .into_iter()
13401                    .map(|p| p.to_string())
13402                    .collect::<Vec<String>>()
13403                    .join(",")
13404                    .to_string(),
13405            )]),
13406        };
13407    }
13408    if let Some(ref local_var_str) = contact__n {
13409        local_var_req_builder = match "multi" {
13410            "multi" => local_var_req_builder.query(
13411                &local_var_str
13412                    .into_iter()
13413                    .map(|p| ("contact__n".to_owned(), p.to_string()))
13414                    .collect::<Vec<(std::string::String, std::string::String)>>(),
13415            ),
13416            _ => local_var_req_builder.query(&[(
13417                "contact__n",
13418                &local_var_str
13419                    .into_iter()
13420                    .map(|p| p.to_string())
13421                    .collect::<Vec<String>>()
13422                    .join(",")
13423                    .to_string(),
13424            )]),
13425        };
13426    }
13427    if let Some(ref local_var_str) = contact_group {
13428        local_var_req_builder = match "multi" {
13429            "multi" => local_var_req_builder.query(
13430                &local_var_str
13431                    .into_iter()
13432                    .map(|p| ("contact_group".to_owned(), p.to_string()))
13433                    .collect::<Vec<(std::string::String, std::string::String)>>(),
13434            ),
13435            _ => local_var_req_builder.query(&[(
13436                "contact_group",
13437                &local_var_str
13438                    .into_iter()
13439                    .map(|p| p.to_string())
13440                    .collect::<Vec<String>>()
13441                    .join(",")
13442                    .to_string(),
13443            )]),
13444        };
13445    }
13446    if let Some(ref local_var_str) = contact_group__n {
13447        local_var_req_builder = match "multi" {
13448            "multi" => local_var_req_builder.query(
13449                &local_var_str
13450                    .into_iter()
13451                    .map(|p| ("contact_group__n".to_owned(), p.to_string()))
13452                    .collect::<Vec<(std::string::String, std::string::String)>>(),
13453            ),
13454            _ => local_var_req_builder.query(&[(
13455                "contact_group__n",
13456                &local_var_str
13457                    .into_iter()
13458                    .map(|p| p.to_string())
13459                    .collect::<Vec<String>>()
13460                    .join(",")
13461                    .to_string(),
13462            )]),
13463        };
13464    }
13465    if let Some(ref local_var_str) = contact_role {
13466        local_var_req_builder = match "multi" {
13467            "multi" => local_var_req_builder.query(
13468                &local_var_str
13469                    .into_iter()
13470                    .map(|p| ("contact_role".to_owned(), p.to_string()))
13471                    .collect::<Vec<(std::string::String, std::string::String)>>(),
13472            ),
13473            _ => local_var_req_builder.query(&[(
13474                "contact_role",
13475                &local_var_str
13476                    .into_iter()
13477                    .map(|p| p.to_string())
13478                    .collect::<Vec<String>>()
13479                    .join(",")
13480                    .to_string(),
13481            )]),
13482        };
13483    }
13484    if let Some(ref local_var_str) = contact_role__n {
13485        local_var_req_builder = match "multi" {
13486            "multi" => local_var_req_builder.query(
13487                &local_var_str
13488                    .into_iter()
13489                    .map(|p| ("contact_role__n".to_owned(), p.to_string()))
13490                    .collect::<Vec<(std::string::String, std::string::String)>>(),
13491            ),
13492            _ => local_var_req_builder.query(&[(
13493                "contact_role__n",
13494                &local_var_str
13495                    .into_iter()
13496                    .map(|p| p.to_string())
13497                    .collect::<Vec<String>>()
13498                    .join(",")
13499                    .to_string(),
13500            )]),
13501        };
13502    }
13503    if let Some(ref local_var_str) = created {
13504        local_var_req_builder = match "multi" {
13505            "multi" => local_var_req_builder.query(
13506                &local_var_str
13507                    .into_iter()
13508                    .map(|p| ("created".to_owned(), p.to_string()))
13509                    .collect::<Vec<(std::string::String, std::string::String)>>(),
13510            ),
13511            _ => local_var_req_builder.query(&[(
13512                "created",
13513                &local_var_str
13514                    .into_iter()
13515                    .map(|p| p.to_string())
13516                    .collect::<Vec<String>>()
13517                    .join(",")
13518                    .to_string(),
13519            )]),
13520        };
13521    }
13522    if let Some(ref local_var_str) = created__empty {
13523        local_var_req_builder = match "multi" {
13524            "multi" => local_var_req_builder.query(
13525                &local_var_str
13526                    .into_iter()
13527                    .map(|p| ("created__empty".to_owned(), p.to_string()))
13528                    .collect::<Vec<(std::string::String, std::string::String)>>(),
13529            ),
13530            _ => local_var_req_builder.query(&[(
13531                "created__empty",
13532                &local_var_str
13533                    .into_iter()
13534                    .map(|p| p.to_string())
13535                    .collect::<Vec<String>>()
13536                    .join(",")
13537                    .to_string(),
13538            )]),
13539        };
13540    }
13541    if let Some(ref local_var_str) = created__gt {
13542        local_var_req_builder = match "multi" {
13543            "multi" => local_var_req_builder.query(
13544                &local_var_str
13545                    .into_iter()
13546                    .map(|p| ("created__gt".to_owned(), p.to_string()))
13547                    .collect::<Vec<(std::string::String, std::string::String)>>(),
13548            ),
13549            _ => local_var_req_builder.query(&[(
13550                "created__gt",
13551                &local_var_str
13552                    .into_iter()
13553                    .map(|p| p.to_string())
13554                    .collect::<Vec<String>>()
13555                    .join(",")
13556                    .to_string(),
13557            )]),
13558        };
13559    }
13560    if let Some(ref local_var_str) = created__gte {
13561        local_var_req_builder = match "multi" {
13562            "multi" => local_var_req_builder.query(
13563                &local_var_str
13564                    .into_iter()
13565                    .map(|p| ("created__gte".to_owned(), p.to_string()))
13566                    .collect::<Vec<(std::string::String, std::string::String)>>(),
13567            ),
13568            _ => local_var_req_builder.query(&[(
13569                "created__gte",
13570                &local_var_str
13571                    .into_iter()
13572                    .map(|p| p.to_string())
13573                    .collect::<Vec<String>>()
13574                    .join(",")
13575                    .to_string(),
13576            )]),
13577        };
13578    }
13579    if let Some(ref local_var_str) = created__lt {
13580        local_var_req_builder = match "multi" {
13581            "multi" => local_var_req_builder.query(
13582                &local_var_str
13583                    .into_iter()
13584                    .map(|p| ("created__lt".to_owned(), p.to_string()))
13585                    .collect::<Vec<(std::string::String, std::string::String)>>(),
13586            ),
13587            _ => local_var_req_builder.query(&[(
13588                "created__lt",
13589                &local_var_str
13590                    .into_iter()
13591                    .map(|p| p.to_string())
13592                    .collect::<Vec<String>>()
13593                    .join(",")
13594                    .to_string(),
13595            )]),
13596        };
13597    }
13598    if let Some(ref local_var_str) = created__lte {
13599        local_var_req_builder = match "multi" {
13600            "multi" => local_var_req_builder.query(
13601                &local_var_str
13602                    .into_iter()
13603                    .map(|p| ("created__lte".to_owned(), p.to_string()))
13604                    .collect::<Vec<(std::string::String, std::string::String)>>(),
13605            ),
13606            _ => local_var_req_builder.query(&[(
13607                "created__lte",
13608                &local_var_str
13609                    .into_iter()
13610                    .map(|p| p.to_string())
13611                    .collect::<Vec<String>>()
13612                    .join(",")
13613                    .to_string(),
13614            )]),
13615        };
13616    }
13617    if let Some(ref local_var_str) = created__n {
13618        local_var_req_builder = match "multi" {
13619            "multi" => local_var_req_builder.query(
13620                &local_var_str
13621                    .into_iter()
13622                    .map(|p| ("created__n".to_owned(), p.to_string()))
13623                    .collect::<Vec<(std::string::String, std::string::String)>>(),
13624            ),
13625            _ => local_var_req_builder.query(&[(
13626                "created__n",
13627                &local_var_str
13628                    .into_iter()
13629                    .map(|p| p.to_string())
13630                    .collect::<Vec<String>>()
13631                    .join(",")
13632                    .to_string(),
13633            )]),
13634        };
13635    }
13636    if let Some(ref local_var_str) = created_by_request {
13637        local_var_req_builder =
13638            local_var_req_builder.query(&[("created_by_request", &local_var_str.to_string())]);
13639    }
13640    if let Some(ref local_var_str) = description {
13641        local_var_req_builder = match "multi" {
13642            "multi" => local_var_req_builder.query(
13643                &local_var_str
13644                    .into_iter()
13645                    .map(|p| ("description".to_owned(), p.to_string()))
13646                    .collect::<Vec<(std::string::String, std::string::String)>>(),
13647            ),
13648            _ => local_var_req_builder.query(&[(
13649                "description",
13650                &local_var_str
13651                    .into_iter()
13652                    .map(|p| p.to_string())
13653                    .collect::<Vec<String>>()
13654                    .join(",")
13655                    .to_string(),
13656            )]),
13657        };
13658    }
13659    if let Some(ref local_var_str) = description__empty {
13660        local_var_req_builder =
13661            local_var_req_builder.query(&[("description__empty", &local_var_str.to_string())]);
13662    }
13663    if let Some(ref local_var_str) = description__ic {
13664        local_var_req_builder = match "multi" {
13665            "multi" => local_var_req_builder.query(
13666                &local_var_str
13667                    .into_iter()
13668                    .map(|p| ("description__ic".to_owned(), p.to_string()))
13669                    .collect::<Vec<(std::string::String, std::string::String)>>(),
13670            ),
13671            _ => local_var_req_builder.query(&[(
13672                "description__ic",
13673                &local_var_str
13674                    .into_iter()
13675                    .map(|p| p.to_string())
13676                    .collect::<Vec<String>>()
13677                    .join(",")
13678                    .to_string(),
13679            )]),
13680        };
13681    }
13682    if let Some(ref local_var_str) = description__ie {
13683        local_var_req_builder = match "multi" {
13684            "multi" => local_var_req_builder.query(
13685                &local_var_str
13686                    .into_iter()
13687                    .map(|p| ("description__ie".to_owned(), p.to_string()))
13688                    .collect::<Vec<(std::string::String, std::string::String)>>(),
13689            ),
13690            _ => local_var_req_builder.query(&[(
13691                "description__ie",
13692                &local_var_str
13693                    .into_iter()
13694                    .map(|p| p.to_string())
13695                    .collect::<Vec<String>>()
13696                    .join(",")
13697                    .to_string(),
13698            )]),
13699        };
13700    }
13701    if let Some(ref local_var_str) = description__iew {
13702        local_var_req_builder = match "multi" {
13703            "multi" => local_var_req_builder.query(
13704                &local_var_str
13705                    .into_iter()
13706                    .map(|p| ("description__iew".to_owned(), p.to_string()))
13707                    .collect::<Vec<(std::string::String, std::string::String)>>(),
13708            ),
13709            _ => local_var_req_builder.query(&[(
13710                "description__iew",
13711                &local_var_str
13712                    .into_iter()
13713                    .map(|p| p.to_string())
13714                    .collect::<Vec<String>>()
13715                    .join(",")
13716                    .to_string(),
13717            )]),
13718        };
13719    }
13720    if let Some(ref local_var_str) = description__iregex {
13721        local_var_req_builder = match "multi" {
13722            "multi" => local_var_req_builder.query(
13723                &local_var_str
13724                    .into_iter()
13725                    .map(|p| ("description__iregex".to_owned(), p.to_string()))
13726                    .collect::<Vec<(std::string::String, std::string::String)>>(),
13727            ),
13728            _ => local_var_req_builder.query(&[(
13729                "description__iregex",
13730                &local_var_str
13731                    .into_iter()
13732                    .map(|p| p.to_string())
13733                    .collect::<Vec<String>>()
13734                    .join(",")
13735                    .to_string(),
13736            )]),
13737        };
13738    }
13739    if let Some(ref local_var_str) = description__isw {
13740        local_var_req_builder = match "multi" {
13741            "multi" => local_var_req_builder.query(
13742                &local_var_str
13743                    .into_iter()
13744                    .map(|p| ("description__isw".to_owned(), p.to_string()))
13745                    .collect::<Vec<(std::string::String, std::string::String)>>(),
13746            ),
13747            _ => local_var_req_builder.query(&[(
13748                "description__isw",
13749                &local_var_str
13750                    .into_iter()
13751                    .map(|p| p.to_string())
13752                    .collect::<Vec<String>>()
13753                    .join(",")
13754                    .to_string(),
13755            )]),
13756        };
13757    }
13758    if let Some(ref local_var_str) = description__n {
13759        local_var_req_builder = match "multi" {
13760            "multi" => local_var_req_builder.query(
13761                &local_var_str
13762                    .into_iter()
13763                    .map(|p| ("description__n".to_owned(), p.to_string()))
13764                    .collect::<Vec<(std::string::String, std::string::String)>>(),
13765            ),
13766            _ => local_var_req_builder.query(&[(
13767                "description__n",
13768                &local_var_str
13769                    .into_iter()
13770                    .map(|p| p.to_string())
13771                    .collect::<Vec<String>>()
13772                    .join(",")
13773                    .to_string(),
13774            )]),
13775        };
13776    }
13777    if let Some(ref local_var_str) = description__nic {
13778        local_var_req_builder = match "multi" {
13779            "multi" => local_var_req_builder.query(
13780                &local_var_str
13781                    .into_iter()
13782                    .map(|p| ("description__nic".to_owned(), p.to_string()))
13783                    .collect::<Vec<(std::string::String, std::string::String)>>(),
13784            ),
13785            _ => local_var_req_builder.query(&[(
13786                "description__nic",
13787                &local_var_str
13788                    .into_iter()
13789                    .map(|p| p.to_string())
13790                    .collect::<Vec<String>>()
13791                    .join(",")
13792                    .to_string(),
13793            )]),
13794        };
13795    }
13796    if let Some(ref local_var_str) = description__nie {
13797        local_var_req_builder = match "multi" {
13798            "multi" => local_var_req_builder.query(
13799                &local_var_str
13800                    .into_iter()
13801                    .map(|p| ("description__nie".to_owned(), p.to_string()))
13802                    .collect::<Vec<(std::string::String, std::string::String)>>(),
13803            ),
13804            _ => local_var_req_builder.query(&[(
13805                "description__nie",
13806                &local_var_str
13807                    .into_iter()
13808                    .map(|p| p.to_string())
13809                    .collect::<Vec<String>>()
13810                    .join(",")
13811                    .to_string(),
13812            )]),
13813        };
13814    }
13815    if let Some(ref local_var_str) = description__niew {
13816        local_var_req_builder = match "multi" {
13817            "multi" => local_var_req_builder.query(
13818                &local_var_str
13819                    .into_iter()
13820                    .map(|p| ("description__niew".to_owned(), p.to_string()))
13821                    .collect::<Vec<(std::string::String, std::string::String)>>(),
13822            ),
13823            _ => local_var_req_builder.query(&[(
13824                "description__niew",
13825                &local_var_str
13826                    .into_iter()
13827                    .map(|p| p.to_string())
13828                    .collect::<Vec<String>>()
13829                    .join(",")
13830                    .to_string(),
13831            )]),
13832        };
13833    }
13834    if let Some(ref local_var_str) = description__nisw {
13835        local_var_req_builder = match "multi" {
13836            "multi" => local_var_req_builder.query(
13837                &local_var_str
13838                    .into_iter()
13839                    .map(|p| ("description__nisw".to_owned(), p.to_string()))
13840                    .collect::<Vec<(std::string::String, std::string::String)>>(),
13841            ),
13842            _ => local_var_req_builder.query(&[(
13843                "description__nisw",
13844                &local_var_str
13845                    .into_iter()
13846                    .map(|p| p.to_string())
13847                    .collect::<Vec<String>>()
13848                    .join(",")
13849                    .to_string(),
13850            )]),
13851        };
13852    }
13853    if let Some(ref local_var_str) = description__regex {
13854        local_var_req_builder = match "multi" {
13855            "multi" => local_var_req_builder.query(
13856                &local_var_str
13857                    .into_iter()
13858                    .map(|p| ("description__regex".to_owned(), p.to_string()))
13859                    .collect::<Vec<(std::string::String, std::string::String)>>(),
13860            ),
13861            _ => local_var_req_builder.query(&[(
13862                "description__regex",
13863                &local_var_str
13864                    .into_iter()
13865                    .map(|p| p.to_string())
13866                    .collect::<Vec<String>>()
13867                    .join(",")
13868                    .to_string(),
13869            )]),
13870        };
13871    }
13872    if let Some(ref local_var_str) = export_target {
13873        local_var_req_builder = match "multi" {
13874            "multi" => local_var_req_builder.query(
13875                &local_var_str
13876                    .into_iter()
13877                    .map(|p| ("export_target".to_owned(), p.to_string()))
13878                    .collect::<Vec<(std::string::String, std::string::String)>>(),
13879            ),
13880            _ => local_var_req_builder.query(&[(
13881                "export_target",
13882                &local_var_str
13883                    .into_iter()
13884                    .map(|p| p.to_string())
13885                    .collect::<Vec<String>>()
13886                    .join(",")
13887                    .to_string(),
13888            )]),
13889        };
13890    }
13891    if let Some(ref local_var_str) = export_target__n {
13892        local_var_req_builder = match "multi" {
13893            "multi" => local_var_req_builder.query(
13894                &local_var_str
13895                    .into_iter()
13896                    .map(|p| ("export_target__n".to_owned(), p.to_string()))
13897                    .collect::<Vec<(std::string::String, std::string::String)>>(),
13898            ),
13899            _ => local_var_req_builder.query(&[(
13900                "export_target__n",
13901                &local_var_str
13902                    .into_iter()
13903                    .map(|p| p.to_string())
13904                    .collect::<Vec<String>>()
13905                    .join(",")
13906                    .to_string(),
13907            )]),
13908        };
13909    }
13910    if let Some(ref local_var_str) = export_target_id {
13911        local_var_req_builder = match "multi" {
13912            "multi" => local_var_req_builder.query(
13913                &local_var_str
13914                    .into_iter()
13915                    .map(|p| ("export_target_id".to_owned(), p.to_string()))
13916                    .collect::<Vec<(std::string::String, std::string::String)>>(),
13917            ),
13918            _ => local_var_req_builder.query(&[(
13919                "export_target_id",
13920                &local_var_str
13921                    .into_iter()
13922                    .map(|p| p.to_string())
13923                    .collect::<Vec<String>>()
13924                    .join(",")
13925                    .to_string(),
13926            )]),
13927        };
13928    }
13929    if let Some(ref local_var_str) = export_target_id__n {
13930        local_var_req_builder = match "multi" {
13931            "multi" => local_var_req_builder.query(
13932                &local_var_str
13933                    .into_iter()
13934                    .map(|p| ("export_target_id__n".to_owned(), p.to_string()))
13935                    .collect::<Vec<(std::string::String, std::string::String)>>(),
13936            ),
13937            _ => local_var_req_builder.query(&[(
13938                "export_target_id__n",
13939                &local_var_str
13940                    .into_iter()
13941                    .map(|p| p.to_string())
13942                    .collect::<Vec<String>>()
13943                    .join(",")
13944                    .to_string(),
13945            )]),
13946        };
13947    }
13948    if let Some(ref local_var_str) = id {
13949        local_var_req_builder = match "multi" {
13950            "multi" => local_var_req_builder.query(
13951                &local_var_str
13952                    .into_iter()
13953                    .map(|p| ("id".to_owned(), p.to_string()))
13954                    .collect::<Vec<(std::string::String, std::string::String)>>(),
13955            ),
13956            _ => local_var_req_builder.query(&[(
13957                "id",
13958                &local_var_str
13959                    .into_iter()
13960                    .map(|p| p.to_string())
13961                    .collect::<Vec<String>>()
13962                    .join(",")
13963                    .to_string(),
13964            )]),
13965        };
13966    }
13967    if let Some(ref local_var_str) = id__empty {
13968        local_var_req_builder =
13969            local_var_req_builder.query(&[("id__empty", &local_var_str.to_string())]);
13970    }
13971    if let Some(ref local_var_str) = id__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| ("id__gt".to_owned(), p.to_string()))
13977                    .collect::<Vec<(std::string::String, std::string::String)>>(),
13978            ),
13979            _ => local_var_req_builder.query(&[(
13980                "id__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) = id__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| ("id__gte".to_owned(), p.to_string()))
13996                    .collect::<Vec<(std::string::String, std::string::String)>>(),
13997            ),
13998            _ => local_var_req_builder.query(&[(
13999                "id__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) = id__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| ("id__lt".to_owned(), p.to_string()))
14015                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14016            ),
14017            _ => local_var_req_builder.query(&[(
14018                "id__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) = id__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| ("id__lte".to_owned(), p.to_string()))
14034                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14035            ),
14036            _ => local_var_req_builder.query(&[(
14037                "id__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) = id__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| ("id__n".to_owned(), p.to_string()))
14053                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14054            ),
14055            _ => local_var_req_builder.query(&[(
14056                "id__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) = identifier {
14067        local_var_req_builder = match "multi" {
14068            "multi" => local_var_req_builder.query(
14069                &local_var_str
14070                    .into_iter()
14071                    .map(|p| ("identifier".to_owned(), p.to_string()))
14072                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14073            ),
14074            _ => local_var_req_builder.query(&[(
14075                "identifier",
14076                &local_var_str
14077                    .into_iter()
14078                    .map(|p| p.to_string())
14079                    .collect::<Vec<String>>()
14080                    .join(",")
14081                    .to_string(),
14082            )]),
14083        };
14084    }
14085    if let Some(ref local_var_str) = identifier__empty {
14086        local_var_req_builder =
14087            local_var_req_builder.query(&[("identifier__empty", &local_var_str.to_string())]);
14088    }
14089    if let Some(ref local_var_str) = identifier__gt {
14090        local_var_req_builder = match "multi" {
14091            "multi" => local_var_req_builder.query(
14092                &local_var_str
14093                    .into_iter()
14094                    .map(|p| ("identifier__gt".to_owned(), p.to_string()))
14095                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14096            ),
14097            _ => local_var_req_builder.query(&[(
14098                "identifier__gt",
14099                &local_var_str
14100                    .into_iter()
14101                    .map(|p| p.to_string())
14102                    .collect::<Vec<String>>()
14103                    .join(",")
14104                    .to_string(),
14105            )]),
14106        };
14107    }
14108    if let Some(ref local_var_str) = identifier__gte {
14109        local_var_req_builder = match "multi" {
14110            "multi" => local_var_req_builder.query(
14111                &local_var_str
14112                    .into_iter()
14113                    .map(|p| ("identifier__gte".to_owned(), p.to_string()))
14114                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14115            ),
14116            _ => local_var_req_builder.query(&[(
14117                "identifier__gte",
14118                &local_var_str
14119                    .into_iter()
14120                    .map(|p| p.to_string())
14121                    .collect::<Vec<String>>()
14122                    .join(",")
14123                    .to_string(),
14124            )]),
14125        };
14126    }
14127    if let Some(ref local_var_str) = identifier__lt {
14128        local_var_req_builder = match "multi" {
14129            "multi" => local_var_req_builder.query(
14130                &local_var_str
14131                    .into_iter()
14132                    .map(|p| ("identifier__lt".to_owned(), p.to_string()))
14133                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14134            ),
14135            _ => local_var_req_builder.query(&[(
14136                "identifier__lt",
14137                &local_var_str
14138                    .into_iter()
14139                    .map(|p| p.to_string())
14140                    .collect::<Vec<String>>()
14141                    .join(",")
14142                    .to_string(),
14143            )]),
14144        };
14145    }
14146    if let Some(ref local_var_str) = identifier__lte {
14147        local_var_req_builder = match "multi" {
14148            "multi" => local_var_req_builder.query(
14149                &local_var_str
14150                    .into_iter()
14151                    .map(|p| ("identifier__lte".to_owned(), p.to_string()))
14152                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14153            ),
14154            _ => local_var_req_builder.query(&[(
14155                "identifier__lte",
14156                &local_var_str
14157                    .into_iter()
14158                    .map(|p| p.to_string())
14159                    .collect::<Vec<String>>()
14160                    .join(",")
14161                    .to_string(),
14162            )]),
14163        };
14164    }
14165    if let Some(ref local_var_str) = identifier__n {
14166        local_var_req_builder = match "multi" {
14167            "multi" => local_var_req_builder.query(
14168                &local_var_str
14169                    .into_iter()
14170                    .map(|p| ("identifier__n".to_owned(), p.to_string()))
14171                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14172            ),
14173            _ => local_var_req_builder.query(&[(
14174                "identifier__n",
14175                &local_var_str
14176                    .into_iter()
14177                    .map(|p| p.to_string())
14178                    .collect::<Vec<String>>()
14179                    .join(",")
14180                    .to_string(),
14181            )]),
14182        };
14183    }
14184    if let Some(ref local_var_str) = import_target {
14185        local_var_req_builder = match "multi" {
14186            "multi" => local_var_req_builder.query(
14187                &local_var_str
14188                    .into_iter()
14189                    .map(|p| ("import_target".to_owned(), p.to_string()))
14190                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14191            ),
14192            _ => local_var_req_builder.query(&[(
14193                "import_target",
14194                &local_var_str
14195                    .into_iter()
14196                    .map(|p| p.to_string())
14197                    .collect::<Vec<String>>()
14198                    .join(",")
14199                    .to_string(),
14200            )]),
14201        };
14202    }
14203    if let Some(ref local_var_str) = import_target__n {
14204        local_var_req_builder = match "multi" {
14205            "multi" => local_var_req_builder.query(
14206                &local_var_str
14207                    .into_iter()
14208                    .map(|p| ("import_target__n".to_owned(), p.to_string()))
14209                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14210            ),
14211            _ => local_var_req_builder.query(&[(
14212                "import_target__n",
14213                &local_var_str
14214                    .into_iter()
14215                    .map(|p| p.to_string())
14216                    .collect::<Vec<String>>()
14217                    .join(",")
14218                    .to_string(),
14219            )]),
14220        };
14221    }
14222    if let Some(ref local_var_str) = import_target_id {
14223        local_var_req_builder = match "multi" {
14224            "multi" => local_var_req_builder.query(
14225                &local_var_str
14226                    .into_iter()
14227                    .map(|p| ("import_target_id".to_owned(), p.to_string()))
14228                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14229            ),
14230            _ => local_var_req_builder.query(&[(
14231                "import_target_id",
14232                &local_var_str
14233                    .into_iter()
14234                    .map(|p| p.to_string())
14235                    .collect::<Vec<String>>()
14236                    .join(",")
14237                    .to_string(),
14238            )]),
14239        };
14240    }
14241    if let Some(ref local_var_str) = import_target_id__n {
14242        local_var_req_builder = match "multi" {
14243            "multi" => local_var_req_builder.query(
14244                &local_var_str
14245                    .into_iter()
14246                    .map(|p| ("import_target_id__n".to_owned(), p.to_string()))
14247                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14248            ),
14249            _ => local_var_req_builder.query(&[(
14250                "import_target_id__n",
14251                &local_var_str
14252                    .into_iter()
14253                    .map(|p| p.to_string())
14254                    .collect::<Vec<String>>()
14255                    .join(",")
14256                    .to_string(),
14257            )]),
14258        };
14259    }
14260    if let Some(ref local_var_str) = last_updated {
14261        local_var_req_builder = match "multi" {
14262            "multi" => local_var_req_builder.query(
14263                &local_var_str
14264                    .into_iter()
14265                    .map(|p| ("last_updated".to_owned(), p.to_string()))
14266                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14267            ),
14268            _ => local_var_req_builder.query(&[(
14269                "last_updated",
14270                &local_var_str
14271                    .into_iter()
14272                    .map(|p| p.to_string())
14273                    .collect::<Vec<String>>()
14274                    .join(",")
14275                    .to_string(),
14276            )]),
14277        };
14278    }
14279    if let Some(ref local_var_str) = last_updated__empty {
14280        local_var_req_builder = match "multi" {
14281            "multi" => local_var_req_builder.query(
14282                &local_var_str
14283                    .into_iter()
14284                    .map(|p| ("last_updated__empty".to_owned(), p.to_string()))
14285                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14286            ),
14287            _ => local_var_req_builder.query(&[(
14288                "last_updated__empty",
14289                &local_var_str
14290                    .into_iter()
14291                    .map(|p| p.to_string())
14292                    .collect::<Vec<String>>()
14293                    .join(",")
14294                    .to_string(),
14295            )]),
14296        };
14297    }
14298    if let Some(ref local_var_str) = last_updated__gt {
14299        local_var_req_builder = match "multi" {
14300            "multi" => local_var_req_builder.query(
14301                &local_var_str
14302                    .into_iter()
14303                    .map(|p| ("last_updated__gt".to_owned(), p.to_string()))
14304                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14305            ),
14306            _ => local_var_req_builder.query(&[(
14307                "last_updated__gt",
14308                &local_var_str
14309                    .into_iter()
14310                    .map(|p| p.to_string())
14311                    .collect::<Vec<String>>()
14312                    .join(",")
14313                    .to_string(),
14314            )]),
14315        };
14316    }
14317    if let Some(ref local_var_str) = last_updated__gte {
14318        local_var_req_builder = match "multi" {
14319            "multi" => local_var_req_builder.query(
14320                &local_var_str
14321                    .into_iter()
14322                    .map(|p| ("last_updated__gte".to_owned(), p.to_string()))
14323                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14324            ),
14325            _ => local_var_req_builder.query(&[(
14326                "last_updated__gte",
14327                &local_var_str
14328                    .into_iter()
14329                    .map(|p| p.to_string())
14330                    .collect::<Vec<String>>()
14331                    .join(",")
14332                    .to_string(),
14333            )]),
14334        };
14335    }
14336    if let Some(ref local_var_str) = last_updated__lt {
14337        local_var_req_builder = match "multi" {
14338            "multi" => local_var_req_builder.query(
14339                &local_var_str
14340                    .into_iter()
14341                    .map(|p| ("last_updated__lt".to_owned(), p.to_string()))
14342                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14343            ),
14344            _ => local_var_req_builder.query(&[(
14345                "last_updated__lt",
14346                &local_var_str
14347                    .into_iter()
14348                    .map(|p| p.to_string())
14349                    .collect::<Vec<String>>()
14350                    .join(",")
14351                    .to_string(),
14352            )]),
14353        };
14354    }
14355    if let Some(ref local_var_str) = last_updated__lte {
14356        local_var_req_builder = match "multi" {
14357            "multi" => local_var_req_builder.query(
14358                &local_var_str
14359                    .into_iter()
14360                    .map(|p| ("last_updated__lte".to_owned(), p.to_string()))
14361                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14362            ),
14363            _ => local_var_req_builder.query(&[(
14364                "last_updated__lte",
14365                &local_var_str
14366                    .into_iter()
14367                    .map(|p| p.to_string())
14368                    .collect::<Vec<String>>()
14369                    .join(",")
14370                    .to_string(),
14371            )]),
14372        };
14373    }
14374    if let Some(ref local_var_str) = last_updated__n {
14375        local_var_req_builder = match "multi" {
14376            "multi" => local_var_req_builder.query(
14377                &local_var_str
14378                    .into_iter()
14379                    .map(|p| ("last_updated__n".to_owned(), p.to_string()))
14380                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14381            ),
14382            _ => local_var_req_builder.query(&[(
14383                "last_updated__n",
14384                &local_var_str
14385                    .into_iter()
14386                    .map(|p| p.to_string())
14387                    .collect::<Vec<String>>()
14388                    .join(",")
14389                    .to_string(),
14390            )]),
14391        };
14392    }
14393    if let Some(ref local_var_str) = limit {
14394        local_var_req_builder =
14395            local_var_req_builder.query(&[("limit", &local_var_str.to_string())]);
14396    }
14397    if let Some(ref local_var_str) = modified_by_request {
14398        local_var_req_builder =
14399            local_var_req_builder.query(&[("modified_by_request", &local_var_str.to_string())]);
14400    }
14401    if let Some(ref local_var_str) = name {
14402        local_var_req_builder = match "multi" {
14403            "multi" => local_var_req_builder.query(
14404                &local_var_str
14405                    .into_iter()
14406                    .map(|p| ("name".to_owned(), p.to_string()))
14407                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14408            ),
14409            _ => local_var_req_builder.query(&[(
14410                "name",
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) = name__empty {
14421        local_var_req_builder =
14422            local_var_req_builder.query(&[("name__empty", &local_var_str.to_string())]);
14423    }
14424    if let Some(ref local_var_str) = name__ic {
14425        local_var_req_builder = match "multi" {
14426            "multi" => local_var_req_builder.query(
14427                &local_var_str
14428                    .into_iter()
14429                    .map(|p| ("name__ic".to_owned(), p.to_string()))
14430                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14431            ),
14432            _ => local_var_req_builder.query(&[(
14433                "name__ic",
14434                &local_var_str
14435                    .into_iter()
14436                    .map(|p| p.to_string())
14437                    .collect::<Vec<String>>()
14438                    .join(",")
14439                    .to_string(),
14440            )]),
14441        };
14442    }
14443    if let Some(ref local_var_str) = name__ie {
14444        local_var_req_builder = match "multi" {
14445            "multi" => local_var_req_builder.query(
14446                &local_var_str
14447                    .into_iter()
14448                    .map(|p| ("name__ie".to_owned(), p.to_string()))
14449                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14450            ),
14451            _ => local_var_req_builder.query(&[(
14452                "name__ie",
14453                &local_var_str
14454                    .into_iter()
14455                    .map(|p| p.to_string())
14456                    .collect::<Vec<String>>()
14457                    .join(",")
14458                    .to_string(),
14459            )]),
14460        };
14461    }
14462    if let Some(ref local_var_str) = name__iew {
14463        local_var_req_builder = match "multi" {
14464            "multi" => local_var_req_builder.query(
14465                &local_var_str
14466                    .into_iter()
14467                    .map(|p| ("name__iew".to_owned(), p.to_string()))
14468                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14469            ),
14470            _ => local_var_req_builder.query(&[(
14471                "name__iew",
14472                &local_var_str
14473                    .into_iter()
14474                    .map(|p| p.to_string())
14475                    .collect::<Vec<String>>()
14476                    .join(",")
14477                    .to_string(),
14478            )]),
14479        };
14480    }
14481    if let Some(ref local_var_str) = name__iregex {
14482        local_var_req_builder = match "multi" {
14483            "multi" => local_var_req_builder.query(
14484                &local_var_str
14485                    .into_iter()
14486                    .map(|p| ("name__iregex".to_owned(), p.to_string()))
14487                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14488            ),
14489            _ => local_var_req_builder.query(&[(
14490                "name__iregex",
14491                &local_var_str
14492                    .into_iter()
14493                    .map(|p| p.to_string())
14494                    .collect::<Vec<String>>()
14495                    .join(",")
14496                    .to_string(),
14497            )]),
14498        };
14499    }
14500    if let Some(ref local_var_str) = name__isw {
14501        local_var_req_builder = match "multi" {
14502            "multi" => local_var_req_builder.query(
14503                &local_var_str
14504                    .into_iter()
14505                    .map(|p| ("name__isw".to_owned(), p.to_string()))
14506                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14507            ),
14508            _ => local_var_req_builder.query(&[(
14509                "name__isw",
14510                &local_var_str
14511                    .into_iter()
14512                    .map(|p| p.to_string())
14513                    .collect::<Vec<String>>()
14514                    .join(",")
14515                    .to_string(),
14516            )]),
14517        };
14518    }
14519    if let Some(ref local_var_str) = name__n {
14520        local_var_req_builder = match "multi" {
14521            "multi" => local_var_req_builder.query(
14522                &local_var_str
14523                    .into_iter()
14524                    .map(|p| ("name__n".to_owned(), p.to_string()))
14525                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14526            ),
14527            _ => local_var_req_builder.query(&[(
14528                "name__n",
14529                &local_var_str
14530                    .into_iter()
14531                    .map(|p| p.to_string())
14532                    .collect::<Vec<String>>()
14533                    .join(",")
14534                    .to_string(),
14535            )]),
14536        };
14537    }
14538    if let Some(ref local_var_str) = name__nic {
14539        local_var_req_builder = match "multi" {
14540            "multi" => local_var_req_builder.query(
14541                &local_var_str
14542                    .into_iter()
14543                    .map(|p| ("name__nic".to_owned(), p.to_string()))
14544                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14545            ),
14546            _ => local_var_req_builder.query(&[(
14547                "name__nic",
14548                &local_var_str
14549                    .into_iter()
14550                    .map(|p| p.to_string())
14551                    .collect::<Vec<String>>()
14552                    .join(",")
14553                    .to_string(),
14554            )]),
14555        };
14556    }
14557    if let Some(ref local_var_str) = name__nie {
14558        local_var_req_builder = match "multi" {
14559            "multi" => local_var_req_builder.query(
14560                &local_var_str
14561                    .into_iter()
14562                    .map(|p| ("name__nie".to_owned(), p.to_string()))
14563                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14564            ),
14565            _ => local_var_req_builder.query(&[(
14566                "name__nie",
14567                &local_var_str
14568                    .into_iter()
14569                    .map(|p| p.to_string())
14570                    .collect::<Vec<String>>()
14571                    .join(",")
14572                    .to_string(),
14573            )]),
14574        };
14575    }
14576    if let Some(ref local_var_str) = name__niew {
14577        local_var_req_builder = match "multi" {
14578            "multi" => local_var_req_builder.query(
14579                &local_var_str
14580                    .into_iter()
14581                    .map(|p| ("name__niew".to_owned(), p.to_string()))
14582                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14583            ),
14584            _ => local_var_req_builder.query(&[(
14585                "name__niew",
14586                &local_var_str
14587                    .into_iter()
14588                    .map(|p| p.to_string())
14589                    .collect::<Vec<String>>()
14590                    .join(",")
14591                    .to_string(),
14592            )]),
14593        };
14594    }
14595    if let Some(ref local_var_str) = name__nisw {
14596        local_var_req_builder = match "multi" {
14597            "multi" => local_var_req_builder.query(
14598                &local_var_str
14599                    .into_iter()
14600                    .map(|p| ("name__nisw".to_owned(), p.to_string()))
14601                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14602            ),
14603            _ => local_var_req_builder.query(&[(
14604                "name__nisw",
14605                &local_var_str
14606                    .into_iter()
14607                    .map(|p| p.to_string())
14608                    .collect::<Vec<String>>()
14609                    .join(",")
14610                    .to_string(),
14611            )]),
14612        };
14613    }
14614    if let Some(ref local_var_str) = name__regex {
14615        local_var_req_builder = match "multi" {
14616            "multi" => local_var_req_builder.query(
14617                &local_var_str
14618                    .into_iter()
14619                    .map(|p| ("name__regex".to_owned(), p.to_string()))
14620                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14621            ),
14622            _ => local_var_req_builder.query(&[(
14623                "name__regex",
14624                &local_var_str
14625                    .into_iter()
14626                    .map(|p| p.to_string())
14627                    .collect::<Vec<String>>()
14628                    .join(",")
14629                    .to_string(),
14630            )]),
14631        };
14632    }
14633    if let Some(ref local_var_str) = offset {
14634        local_var_req_builder =
14635            local_var_req_builder.query(&[("offset", &local_var_str.to_string())]);
14636    }
14637    if let Some(ref local_var_str) = ordering {
14638        local_var_req_builder =
14639            local_var_req_builder.query(&[("ordering", &local_var_str.to_string())]);
14640    }
14641    if let Some(ref local_var_str) = q {
14642        local_var_req_builder = local_var_req_builder.query(&[("q", &local_var_str.to_string())]);
14643    }
14644    if let Some(ref local_var_str) = slug {
14645        local_var_req_builder = match "multi" {
14646            "multi" => local_var_req_builder.query(
14647                &local_var_str
14648                    .into_iter()
14649                    .map(|p| ("slug".to_owned(), p.to_string()))
14650                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14651            ),
14652            _ => local_var_req_builder.query(&[(
14653                "slug",
14654                &local_var_str
14655                    .into_iter()
14656                    .map(|p| p.to_string())
14657                    .collect::<Vec<String>>()
14658                    .join(",")
14659                    .to_string(),
14660            )]),
14661        };
14662    }
14663    if let Some(ref local_var_str) = slug__empty {
14664        local_var_req_builder =
14665            local_var_req_builder.query(&[("slug__empty", &local_var_str.to_string())]);
14666    }
14667    if let Some(ref local_var_str) = slug__ic {
14668        local_var_req_builder = match "multi" {
14669            "multi" => local_var_req_builder.query(
14670                &local_var_str
14671                    .into_iter()
14672                    .map(|p| ("slug__ic".to_owned(), p.to_string()))
14673                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14674            ),
14675            _ => local_var_req_builder.query(&[(
14676                "slug__ic",
14677                &local_var_str
14678                    .into_iter()
14679                    .map(|p| p.to_string())
14680                    .collect::<Vec<String>>()
14681                    .join(",")
14682                    .to_string(),
14683            )]),
14684        };
14685    }
14686    if let Some(ref local_var_str) = slug__ie {
14687        local_var_req_builder = match "multi" {
14688            "multi" => local_var_req_builder.query(
14689                &local_var_str
14690                    .into_iter()
14691                    .map(|p| ("slug__ie".to_owned(), p.to_string()))
14692                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14693            ),
14694            _ => local_var_req_builder.query(&[(
14695                "slug__ie",
14696                &local_var_str
14697                    .into_iter()
14698                    .map(|p| p.to_string())
14699                    .collect::<Vec<String>>()
14700                    .join(",")
14701                    .to_string(),
14702            )]),
14703        };
14704    }
14705    if let Some(ref local_var_str) = slug__iew {
14706        local_var_req_builder = match "multi" {
14707            "multi" => local_var_req_builder.query(
14708                &local_var_str
14709                    .into_iter()
14710                    .map(|p| ("slug__iew".to_owned(), p.to_string()))
14711                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14712            ),
14713            _ => local_var_req_builder.query(&[(
14714                "slug__iew",
14715                &local_var_str
14716                    .into_iter()
14717                    .map(|p| p.to_string())
14718                    .collect::<Vec<String>>()
14719                    .join(",")
14720                    .to_string(),
14721            )]),
14722        };
14723    }
14724    if let Some(ref local_var_str) = slug__iregex {
14725        local_var_req_builder = match "multi" {
14726            "multi" => local_var_req_builder.query(
14727                &local_var_str
14728                    .into_iter()
14729                    .map(|p| ("slug__iregex".to_owned(), p.to_string()))
14730                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14731            ),
14732            _ => local_var_req_builder.query(&[(
14733                "slug__iregex",
14734                &local_var_str
14735                    .into_iter()
14736                    .map(|p| p.to_string())
14737                    .collect::<Vec<String>>()
14738                    .join(",")
14739                    .to_string(),
14740            )]),
14741        };
14742    }
14743    if let Some(ref local_var_str) = slug__isw {
14744        local_var_req_builder = match "multi" {
14745            "multi" => local_var_req_builder.query(
14746                &local_var_str
14747                    .into_iter()
14748                    .map(|p| ("slug__isw".to_owned(), p.to_string()))
14749                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14750            ),
14751            _ => local_var_req_builder.query(&[(
14752                "slug__isw",
14753                &local_var_str
14754                    .into_iter()
14755                    .map(|p| p.to_string())
14756                    .collect::<Vec<String>>()
14757                    .join(",")
14758                    .to_string(),
14759            )]),
14760        };
14761    }
14762    if let Some(ref local_var_str) = slug__n {
14763        local_var_req_builder = match "multi" {
14764            "multi" => local_var_req_builder.query(
14765                &local_var_str
14766                    .into_iter()
14767                    .map(|p| ("slug__n".to_owned(), p.to_string()))
14768                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14769            ),
14770            _ => local_var_req_builder.query(&[(
14771                "slug__n",
14772                &local_var_str
14773                    .into_iter()
14774                    .map(|p| p.to_string())
14775                    .collect::<Vec<String>>()
14776                    .join(",")
14777                    .to_string(),
14778            )]),
14779        };
14780    }
14781    if let Some(ref local_var_str) = slug__nic {
14782        local_var_req_builder = match "multi" {
14783            "multi" => local_var_req_builder.query(
14784                &local_var_str
14785                    .into_iter()
14786                    .map(|p| ("slug__nic".to_owned(), p.to_string()))
14787                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14788            ),
14789            _ => local_var_req_builder.query(&[(
14790                "slug__nic",
14791                &local_var_str
14792                    .into_iter()
14793                    .map(|p| p.to_string())
14794                    .collect::<Vec<String>>()
14795                    .join(",")
14796                    .to_string(),
14797            )]),
14798        };
14799    }
14800    if let Some(ref local_var_str) = slug__nie {
14801        local_var_req_builder = match "multi" {
14802            "multi" => local_var_req_builder.query(
14803                &local_var_str
14804                    .into_iter()
14805                    .map(|p| ("slug__nie".to_owned(), p.to_string()))
14806                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14807            ),
14808            _ => local_var_req_builder.query(&[(
14809                "slug__nie",
14810                &local_var_str
14811                    .into_iter()
14812                    .map(|p| p.to_string())
14813                    .collect::<Vec<String>>()
14814                    .join(",")
14815                    .to_string(),
14816            )]),
14817        };
14818    }
14819    if let Some(ref local_var_str) = slug__niew {
14820        local_var_req_builder = match "multi" {
14821            "multi" => local_var_req_builder.query(
14822                &local_var_str
14823                    .into_iter()
14824                    .map(|p| ("slug__niew".to_owned(), p.to_string()))
14825                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14826            ),
14827            _ => local_var_req_builder.query(&[(
14828                "slug__niew",
14829                &local_var_str
14830                    .into_iter()
14831                    .map(|p| p.to_string())
14832                    .collect::<Vec<String>>()
14833                    .join(",")
14834                    .to_string(),
14835            )]),
14836        };
14837    }
14838    if let Some(ref local_var_str) = slug__nisw {
14839        local_var_req_builder = match "multi" {
14840            "multi" => local_var_req_builder.query(
14841                &local_var_str
14842                    .into_iter()
14843                    .map(|p| ("slug__nisw".to_owned(), p.to_string()))
14844                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14845            ),
14846            _ => local_var_req_builder.query(&[(
14847                "slug__nisw",
14848                &local_var_str
14849                    .into_iter()
14850                    .map(|p| p.to_string())
14851                    .collect::<Vec<String>>()
14852                    .join(",")
14853                    .to_string(),
14854            )]),
14855        };
14856    }
14857    if let Some(ref local_var_str) = slug__regex {
14858        local_var_req_builder = match "multi" {
14859            "multi" => local_var_req_builder.query(
14860                &local_var_str
14861                    .into_iter()
14862                    .map(|p| ("slug__regex".to_owned(), p.to_string()))
14863                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14864            ),
14865            _ => local_var_req_builder.query(&[(
14866                "slug__regex",
14867                &local_var_str
14868                    .into_iter()
14869                    .map(|p| p.to_string())
14870                    .collect::<Vec<String>>()
14871                    .join(",")
14872                    .to_string(),
14873            )]),
14874        };
14875    }
14876    if let Some(ref local_var_str) = status {
14877        local_var_req_builder = match "multi" {
14878            "multi" => local_var_req_builder.query(
14879                &local_var_str
14880                    .into_iter()
14881                    .map(|p| ("status".to_owned(), p.to_string()))
14882                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14883            ),
14884            _ => local_var_req_builder.query(&[(
14885                "status",
14886                &local_var_str
14887                    .into_iter()
14888                    .map(|p| p.to_string())
14889                    .collect::<Vec<String>>()
14890                    .join(",")
14891                    .to_string(),
14892            )]),
14893        };
14894    }
14895    if let Some(ref local_var_str) = status__empty {
14896        local_var_req_builder =
14897            local_var_req_builder.query(&[("status__empty", &local_var_str.to_string())]);
14898    }
14899    if let Some(ref local_var_str) = status__ic {
14900        local_var_req_builder = match "multi" {
14901            "multi" => local_var_req_builder.query(
14902                &local_var_str
14903                    .into_iter()
14904                    .map(|p| ("status__ic".to_owned(), p.to_string()))
14905                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14906            ),
14907            _ => local_var_req_builder.query(&[(
14908                "status__ic",
14909                &local_var_str
14910                    .into_iter()
14911                    .map(|p| p.to_string())
14912                    .collect::<Vec<String>>()
14913                    .join(",")
14914                    .to_string(),
14915            )]),
14916        };
14917    }
14918    if let Some(ref local_var_str) = status__ie {
14919        local_var_req_builder = match "multi" {
14920            "multi" => local_var_req_builder.query(
14921                &local_var_str
14922                    .into_iter()
14923                    .map(|p| ("status__ie".to_owned(), p.to_string()))
14924                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14925            ),
14926            _ => local_var_req_builder.query(&[(
14927                "status__ie",
14928                &local_var_str
14929                    .into_iter()
14930                    .map(|p| p.to_string())
14931                    .collect::<Vec<String>>()
14932                    .join(",")
14933                    .to_string(),
14934            )]),
14935        };
14936    }
14937    if let Some(ref local_var_str) = status__iew {
14938        local_var_req_builder = match "multi" {
14939            "multi" => local_var_req_builder.query(
14940                &local_var_str
14941                    .into_iter()
14942                    .map(|p| ("status__iew".to_owned(), p.to_string()))
14943                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14944            ),
14945            _ => local_var_req_builder.query(&[(
14946                "status__iew",
14947                &local_var_str
14948                    .into_iter()
14949                    .map(|p| p.to_string())
14950                    .collect::<Vec<String>>()
14951                    .join(",")
14952                    .to_string(),
14953            )]),
14954        };
14955    }
14956    if let Some(ref local_var_str) = status__iregex {
14957        local_var_req_builder = match "multi" {
14958            "multi" => local_var_req_builder.query(
14959                &local_var_str
14960                    .into_iter()
14961                    .map(|p| ("status__iregex".to_owned(), p.to_string()))
14962                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14963            ),
14964            _ => local_var_req_builder.query(&[(
14965                "status__iregex",
14966                &local_var_str
14967                    .into_iter()
14968                    .map(|p| p.to_string())
14969                    .collect::<Vec<String>>()
14970                    .join(",")
14971                    .to_string(),
14972            )]),
14973        };
14974    }
14975    if let Some(ref local_var_str) = status__isw {
14976        local_var_req_builder = match "multi" {
14977            "multi" => local_var_req_builder.query(
14978                &local_var_str
14979                    .into_iter()
14980                    .map(|p| ("status__isw".to_owned(), p.to_string()))
14981                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14982            ),
14983            _ => local_var_req_builder.query(&[(
14984                "status__isw",
14985                &local_var_str
14986                    .into_iter()
14987                    .map(|p| p.to_string())
14988                    .collect::<Vec<String>>()
14989                    .join(",")
14990                    .to_string(),
14991            )]),
14992        };
14993    }
14994    if let Some(ref local_var_str) = status__n {
14995        local_var_req_builder = match "multi" {
14996            "multi" => local_var_req_builder.query(
14997                &local_var_str
14998                    .into_iter()
14999                    .map(|p| ("status__n".to_owned(), p.to_string()))
15000                    .collect::<Vec<(std::string::String, std::string::String)>>(),
15001            ),
15002            _ => local_var_req_builder.query(&[(
15003                "status__n",
15004                &local_var_str
15005                    .into_iter()
15006                    .map(|p| p.to_string())
15007                    .collect::<Vec<String>>()
15008                    .join(",")
15009                    .to_string(),
15010            )]),
15011        };
15012    }
15013    if let Some(ref local_var_str) = status__nic {
15014        local_var_req_builder = match "multi" {
15015            "multi" => local_var_req_builder.query(
15016                &local_var_str
15017                    .into_iter()
15018                    .map(|p| ("status__nic".to_owned(), p.to_string()))
15019                    .collect::<Vec<(std::string::String, std::string::String)>>(),
15020            ),
15021            _ => local_var_req_builder.query(&[(
15022                "status__nic",
15023                &local_var_str
15024                    .into_iter()
15025                    .map(|p| p.to_string())
15026                    .collect::<Vec<String>>()
15027                    .join(",")
15028                    .to_string(),
15029            )]),
15030        };
15031    }
15032    if let Some(ref local_var_str) = status__nie {
15033        local_var_req_builder = match "multi" {
15034            "multi" => local_var_req_builder.query(
15035                &local_var_str
15036                    .into_iter()
15037                    .map(|p| ("status__nie".to_owned(), p.to_string()))
15038                    .collect::<Vec<(std::string::String, std::string::String)>>(),
15039            ),
15040            _ => local_var_req_builder.query(&[(
15041                "status__nie",
15042                &local_var_str
15043                    .into_iter()
15044                    .map(|p| p.to_string())
15045                    .collect::<Vec<String>>()
15046                    .join(",")
15047                    .to_string(),
15048            )]),
15049        };
15050    }
15051    if let Some(ref local_var_str) = status__niew {
15052        local_var_req_builder = match "multi" {
15053            "multi" => local_var_req_builder.query(
15054                &local_var_str
15055                    .into_iter()
15056                    .map(|p| ("status__niew".to_owned(), p.to_string()))
15057                    .collect::<Vec<(std::string::String, std::string::String)>>(),
15058            ),
15059            _ => local_var_req_builder.query(&[(
15060                "status__niew",
15061                &local_var_str
15062                    .into_iter()
15063                    .map(|p| p.to_string())
15064                    .collect::<Vec<String>>()
15065                    .join(",")
15066                    .to_string(),
15067            )]),
15068        };
15069    }
15070    if let Some(ref local_var_str) = status__nisw {
15071        local_var_req_builder = match "multi" {
15072            "multi" => local_var_req_builder.query(
15073                &local_var_str
15074                    .into_iter()
15075                    .map(|p| ("status__nisw".to_owned(), p.to_string()))
15076                    .collect::<Vec<(std::string::String, std::string::String)>>(),
15077            ),
15078            _ => local_var_req_builder.query(&[(
15079                "status__nisw",
15080                &local_var_str
15081                    .into_iter()
15082                    .map(|p| p.to_string())
15083                    .collect::<Vec<String>>()
15084                    .join(",")
15085                    .to_string(),
15086            )]),
15087        };
15088    }
15089    if let Some(ref local_var_str) = status__regex {
15090        local_var_req_builder = match "multi" {
15091            "multi" => local_var_req_builder.query(
15092                &local_var_str
15093                    .into_iter()
15094                    .map(|p| ("status__regex".to_owned(), p.to_string()))
15095                    .collect::<Vec<(std::string::String, std::string::String)>>(),
15096            ),
15097            _ => local_var_req_builder.query(&[(
15098                "status__regex",
15099                &local_var_str
15100                    .into_iter()
15101                    .map(|p| p.to_string())
15102                    .collect::<Vec<String>>()
15103                    .join(",")
15104                    .to_string(),
15105            )]),
15106        };
15107    }
15108    if let Some(ref local_var_str) = tag {
15109        local_var_req_builder = match "multi" {
15110            "multi" => local_var_req_builder.query(
15111                &local_var_str
15112                    .into_iter()
15113                    .map(|p| ("tag".to_owned(), p.to_string()))
15114                    .collect::<Vec<(std::string::String, std::string::String)>>(),
15115            ),
15116            _ => local_var_req_builder.query(&[(
15117                "tag",
15118                &local_var_str
15119                    .into_iter()
15120                    .map(|p| p.to_string())
15121                    .collect::<Vec<String>>()
15122                    .join(",")
15123                    .to_string(),
15124            )]),
15125        };
15126    }
15127    if let Some(ref local_var_str) = tag__n {
15128        local_var_req_builder = match "multi" {
15129            "multi" => local_var_req_builder.query(
15130                &local_var_str
15131                    .into_iter()
15132                    .map(|p| ("tag__n".to_owned(), p.to_string()))
15133                    .collect::<Vec<(std::string::String, std::string::String)>>(),
15134            ),
15135            _ => local_var_req_builder.query(&[(
15136                "tag__n",
15137                &local_var_str
15138                    .into_iter()
15139                    .map(|p| p.to_string())
15140                    .collect::<Vec<String>>()
15141                    .join(",")
15142                    .to_string(),
15143            )]),
15144        };
15145    }
15146    if let Some(ref local_var_str) = tag_id {
15147        local_var_req_builder = match "multi" {
15148            "multi" => local_var_req_builder.query(
15149                &local_var_str
15150                    .into_iter()
15151                    .map(|p| ("tag_id".to_owned(), p.to_string()))
15152                    .collect::<Vec<(std::string::String, std::string::String)>>(),
15153            ),
15154            _ => local_var_req_builder.query(&[(
15155                "tag_id",
15156                &local_var_str
15157                    .into_iter()
15158                    .map(|p| p.to_string())
15159                    .collect::<Vec<String>>()
15160                    .join(",")
15161                    .to_string(),
15162            )]),
15163        };
15164    }
15165    if let Some(ref local_var_str) = tag_id__n {
15166        local_var_req_builder = match "multi" {
15167            "multi" => local_var_req_builder.query(
15168                &local_var_str
15169                    .into_iter()
15170                    .map(|p| ("tag_id__n".to_owned(), p.to_string()))
15171                    .collect::<Vec<(std::string::String, std::string::String)>>(),
15172            ),
15173            _ => local_var_req_builder.query(&[(
15174                "tag_id__n",
15175                &local_var_str
15176                    .into_iter()
15177                    .map(|p| p.to_string())
15178                    .collect::<Vec<String>>()
15179                    .join(",")
15180                    .to_string(),
15181            )]),
15182        };
15183    }
15184    if let Some(ref local_var_str) = tenant {
15185        local_var_req_builder = match "multi" {
15186            "multi" => local_var_req_builder.query(
15187                &local_var_str
15188                    .into_iter()
15189                    .map(|p| ("tenant".to_owned(), p.to_string()))
15190                    .collect::<Vec<(std::string::String, std::string::String)>>(),
15191            ),
15192            _ => local_var_req_builder.query(&[(
15193                "tenant",
15194                &local_var_str
15195                    .into_iter()
15196                    .map(|p| p.to_string())
15197                    .collect::<Vec<String>>()
15198                    .join(",")
15199                    .to_string(),
15200            )]),
15201        };
15202    }
15203    if let Some(ref local_var_str) = tenant__n {
15204        local_var_req_builder = match "multi" {
15205            "multi" => local_var_req_builder.query(
15206                &local_var_str
15207                    .into_iter()
15208                    .map(|p| ("tenant__n".to_owned(), p.to_string()))
15209                    .collect::<Vec<(std::string::String, std::string::String)>>(),
15210            ),
15211            _ => local_var_req_builder.query(&[(
15212                "tenant__n",
15213                &local_var_str
15214                    .into_iter()
15215                    .map(|p| p.to_string())
15216                    .collect::<Vec<String>>()
15217                    .join(",")
15218                    .to_string(),
15219            )]),
15220        };
15221    }
15222    if let Some(ref local_var_str) = tenant_group {
15223        local_var_req_builder = match "multi" {
15224            "multi" => local_var_req_builder.query(
15225                &local_var_str
15226                    .into_iter()
15227                    .map(|p| ("tenant_group".to_owned(), p.to_string()))
15228                    .collect::<Vec<(std::string::String, std::string::String)>>(),
15229            ),
15230            _ => local_var_req_builder.query(&[(
15231                "tenant_group",
15232                &local_var_str
15233                    .into_iter()
15234                    .map(|p| p.to_string())
15235                    .collect::<Vec<String>>()
15236                    .join(",")
15237                    .to_string(),
15238            )]),
15239        };
15240    }
15241    if let Some(ref local_var_str) = tenant_group__n {
15242        local_var_req_builder = match "multi" {
15243            "multi" => local_var_req_builder.query(
15244                &local_var_str
15245                    .into_iter()
15246                    .map(|p| ("tenant_group__n".to_owned(), p.to_string()))
15247                    .collect::<Vec<(std::string::String, std::string::String)>>(),
15248            ),
15249            _ => local_var_req_builder.query(&[(
15250                "tenant_group__n",
15251                &local_var_str
15252                    .into_iter()
15253                    .map(|p| p.to_string())
15254                    .collect::<Vec<String>>()
15255                    .join(",")
15256                    .to_string(),
15257            )]),
15258        };
15259    }
15260    if let Some(ref local_var_str) = tenant_group_id {
15261        local_var_req_builder = match "multi" {
15262            "multi" => local_var_req_builder.query(
15263                &local_var_str
15264                    .into_iter()
15265                    .map(|p| ("tenant_group_id".to_owned(), p.to_string()))
15266                    .collect::<Vec<(std::string::String, std::string::String)>>(),
15267            ),
15268            _ => local_var_req_builder.query(&[(
15269                "tenant_group_id",
15270                &local_var_str
15271                    .into_iter()
15272                    .map(|p| p.to_string())
15273                    .collect::<Vec<String>>()
15274                    .join(",")
15275                    .to_string(),
15276            )]),
15277        };
15278    }
15279    if let Some(ref local_var_str) = tenant_group_id__n {
15280        local_var_req_builder = match "multi" {
15281            "multi" => local_var_req_builder.query(
15282                &local_var_str
15283                    .into_iter()
15284                    .map(|p| ("tenant_group_id__n".to_owned(), p.to_string()))
15285                    .collect::<Vec<(std::string::String, std::string::String)>>(),
15286            ),
15287            _ => local_var_req_builder.query(&[(
15288                "tenant_group_id__n",
15289                &local_var_str
15290                    .into_iter()
15291                    .map(|p| p.to_string())
15292                    .collect::<Vec<String>>()
15293                    .join(",")
15294                    .to_string(),
15295            )]),
15296        };
15297    }
15298    if let Some(ref local_var_str) = tenant_id {
15299        local_var_req_builder = match "multi" {
15300            "multi" => local_var_req_builder.query(
15301                &local_var_str
15302                    .into_iter()
15303                    .map(|p| ("tenant_id".to_owned(), p.to_string()))
15304                    .collect::<Vec<(std::string::String, std::string::String)>>(),
15305            ),
15306            _ => local_var_req_builder.query(&[(
15307                "tenant_id",
15308                &local_var_str
15309                    .into_iter()
15310                    .map(|p| p.to_string())
15311                    .collect::<Vec<String>>()
15312                    .join(",")
15313                    .to_string(),
15314            )]),
15315        };
15316    }
15317    if let Some(ref local_var_str) = tenant_id__n {
15318        local_var_req_builder = match "multi" {
15319            "multi" => local_var_req_builder.query(
15320                &local_var_str
15321                    .into_iter()
15322                    .map(|p| ("tenant_id__n".to_owned(), p.to_string()))
15323                    .collect::<Vec<(std::string::String, std::string::String)>>(),
15324            ),
15325            _ => local_var_req_builder.query(&[(
15326                "tenant_id__n",
15327                &local_var_str
15328                    .into_iter()
15329                    .map(|p| p.to_string())
15330                    .collect::<Vec<String>>()
15331                    .join(",")
15332                    .to_string(),
15333            )]),
15334        };
15335    }
15336    if let Some(ref local_var_str) = r#type {
15337        local_var_req_builder = match "multi" {
15338            "multi" => local_var_req_builder.query(
15339                &local_var_str
15340                    .into_iter()
15341                    .map(|p| ("type".to_owned(), p.to_string()))
15342                    .collect::<Vec<(std::string::String, std::string::String)>>(),
15343            ),
15344            _ => local_var_req_builder.query(&[(
15345                "type",
15346                &local_var_str
15347                    .into_iter()
15348                    .map(|p| p.to_string())
15349                    .collect::<Vec<String>>()
15350                    .join(",")
15351                    .to_string(),
15352            )]),
15353        };
15354    }
15355    if let Some(ref local_var_str) = type__empty {
15356        local_var_req_builder =
15357            local_var_req_builder.query(&[("type__empty", &local_var_str.to_string())]);
15358    }
15359    if let Some(ref local_var_str) = type__ic {
15360        local_var_req_builder = match "multi" {
15361            "multi" => local_var_req_builder.query(
15362                &local_var_str
15363                    .into_iter()
15364                    .map(|p| ("type__ic".to_owned(), p.to_string()))
15365                    .collect::<Vec<(std::string::String, std::string::String)>>(),
15366            ),
15367            _ => local_var_req_builder.query(&[(
15368                "type__ic",
15369                &local_var_str
15370                    .into_iter()
15371                    .map(|p| p.to_string())
15372                    .collect::<Vec<String>>()
15373                    .join(",")
15374                    .to_string(),
15375            )]),
15376        };
15377    }
15378    if let Some(ref local_var_str) = type__ie {
15379        local_var_req_builder = match "multi" {
15380            "multi" => local_var_req_builder.query(
15381                &local_var_str
15382                    .into_iter()
15383                    .map(|p| ("type__ie".to_owned(), p.to_string()))
15384                    .collect::<Vec<(std::string::String, std::string::String)>>(),
15385            ),
15386            _ => local_var_req_builder.query(&[(
15387                "type__ie",
15388                &local_var_str
15389                    .into_iter()
15390                    .map(|p| p.to_string())
15391                    .collect::<Vec<String>>()
15392                    .join(",")
15393                    .to_string(),
15394            )]),
15395        };
15396    }
15397    if let Some(ref local_var_str) = type__iew {
15398        local_var_req_builder = match "multi" {
15399            "multi" => local_var_req_builder.query(
15400                &local_var_str
15401                    .into_iter()
15402                    .map(|p| ("type__iew".to_owned(), p.to_string()))
15403                    .collect::<Vec<(std::string::String, std::string::String)>>(),
15404            ),
15405            _ => local_var_req_builder.query(&[(
15406                "type__iew",
15407                &local_var_str
15408                    .into_iter()
15409                    .map(|p| p.to_string())
15410                    .collect::<Vec<String>>()
15411                    .join(",")
15412                    .to_string(),
15413            )]),
15414        };
15415    }
15416    if let Some(ref local_var_str) = type__iregex {
15417        local_var_req_builder = match "multi" {
15418            "multi" => local_var_req_builder.query(
15419                &local_var_str
15420                    .into_iter()
15421                    .map(|p| ("type__iregex".to_owned(), p.to_string()))
15422                    .collect::<Vec<(std::string::String, std::string::String)>>(),
15423            ),
15424            _ => local_var_req_builder.query(&[(
15425                "type__iregex",
15426                &local_var_str
15427                    .into_iter()
15428                    .map(|p| p.to_string())
15429                    .collect::<Vec<String>>()
15430                    .join(",")
15431                    .to_string(),
15432            )]),
15433        };
15434    }
15435    if let Some(ref local_var_str) = type__isw {
15436        local_var_req_builder = match "multi" {
15437            "multi" => local_var_req_builder.query(
15438                &local_var_str
15439                    .into_iter()
15440                    .map(|p| ("type__isw".to_owned(), p.to_string()))
15441                    .collect::<Vec<(std::string::String, std::string::String)>>(),
15442            ),
15443            _ => local_var_req_builder.query(&[(
15444                "type__isw",
15445                &local_var_str
15446                    .into_iter()
15447                    .map(|p| p.to_string())
15448                    .collect::<Vec<String>>()
15449                    .join(",")
15450                    .to_string(),
15451            )]),
15452        };
15453    }
15454    if let Some(ref local_var_str) = type__n {
15455        local_var_req_builder = match "multi" {
15456            "multi" => local_var_req_builder.query(
15457                &local_var_str
15458                    .into_iter()
15459                    .map(|p| ("type__n".to_owned(), p.to_string()))
15460                    .collect::<Vec<(std::string::String, std::string::String)>>(),
15461            ),
15462            _ => local_var_req_builder.query(&[(
15463                "type__n",
15464                &local_var_str
15465                    .into_iter()
15466                    .map(|p| p.to_string())
15467                    .collect::<Vec<String>>()
15468                    .join(",")
15469                    .to_string(),
15470            )]),
15471        };
15472    }
15473    if let Some(ref local_var_str) = type__nic {
15474        local_var_req_builder = match "multi" {
15475            "multi" => local_var_req_builder.query(
15476                &local_var_str
15477                    .into_iter()
15478                    .map(|p| ("type__nic".to_owned(), p.to_string()))
15479                    .collect::<Vec<(std::string::String, std::string::String)>>(),
15480            ),
15481            _ => local_var_req_builder.query(&[(
15482                "type__nic",
15483                &local_var_str
15484                    .into_iter()
15485                    .map(|p| p.to_string())
15486                    .collect::<Vec<String>>()
15487                    .join(",")
15488                    .to_string(),
15489            )]),
15490        };
15491    }
15492    if let Some(ref local_var_str) = type__nie {
15493        local_var_req_builder = match "multi" {
15494            "multi" => local_var_req_builder.query(
15495                &local_var_str
15496                    .into_iter()
15497                    .map(|p| ("type__nie".to_owned(), p.to_string()))
15498                    .collect::<Vec<(std::string::String, std::string::String)>>(),
15499            ),
15500            _ => local_var_req_builder.query(&[(
15501                "type__nie",
15502                &local_var_str
15503                    .into_iter()
15504                    .map(|p| p.to_string())
15505                    .collect::<Vec<String>>()
15506                    .join(",")
15507                    .to_string(),
15508            )]),
15509        };
15510    }
15511    if let Some(ref local_var_str) = type__niew {
15512        local_var_req_builder = match "multi" {
15513            "multi" => local_var_req_builder.query(
15514                &local_var_str
15515                    .into_iter()
15516                    .map(|p| ("type__niew".to_owned(), p.to_string()))
15517                    .collect::<Vec<(std::string::String, std::string::String)>>(),
15518            ),
15519            _ => local_var_req_builder.query(&[(
15520                "type__niew",
15521                &local_var_str
15522                    .into_iter()
15523                    .map(|p| p.to_string())
15524                    .collect::<Vec<String>>()
15525                    .join(",")
15526                    .to_string(),
15527            )]),
15528        };
15529    }
15530    if let Some(ref local_var_str) = type__nisw {
15531        local_var_req_builder = match "multi" {
15532            "multi" => local_var_req_builder.query(
15533                &local_var_str
15534                    .into_iter()
15535                    .map(|p| ("type__nisw".to_owned(), p.to_string()))
15536                    .collect::<Vec<(std::string::String, std::string::String)>>(),
15537            ),
15538            _ => local_var_req_builder.query(&[(
15539                "type__nisw",
15540                &local_var_str
15541                    .into_iter()
15542                    .map(|p| p.to_string())
15543                    .collect::<Vec<String>>()
15544                    .join(",")
15545                    .to_string(),
15546            )]),
15547        };
15548    }
15549    if let Some(ref local_var_str) = type__regex {
15550        local_var_req_builder = match "multi" {
15551            "multi" => local_var_req_builder.query(
15552                &local_var_str
15553                    .into_iter()
15554                    .map(|p| ("type__regex".to_owned(), p.to_string()))
15555                    .collect::<Vec<(std::string::String, std::string::String)>>(),
15556            ),
15557            _ => local_var_req_builder.query(&[(
15558                "type__regex",
15559                &local_var_str
15560                    .into_iter()
15561                    .map(|p| p.to_string())
15562                    .collect::<Vec<String>>()
15563                    .join(",")
15564                    .to_string(),
15565            )]),
15566        };
15567    }
15568    if let Some(ref local_var_str) = updated_by_request {
15569        local_var_req_builder =
15570            local_var_req_builder.query(&[("updated_by_request", &local_var_str.to_string())]);
15571    }
15572    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
15573        local_var_req_builder =
15574            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
15575    }
15576    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
15577        let local_var_key = local_var_apikey.key.clone();
15578        let local_var_value = match local_var_apikey.prefix {
15579            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
15580            None => local_var_key,
15581        };
15582        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
15583    };
15584
15585    let local_var_req = local_var_req_builder.build()?;
15586    let local_var_resp = local_var_client.execute(local_var_req).await?;
15587
15588    let local_var_status = local_var_resp.status();
15589    let local_var_content = local_var_resp.text().await?;
15590
15591    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
15592        serde_json::from_str(&local_var_content).map_err(Error::from)
15593    } else {
15594        let local_var_entity: Option<VpnL2vpnsListError> =
15595            serde_json::from_str(&local_var_content).ok();
15596        let local_var_error = ResponseContent {
15597            status: local_var_status,
15598            content: local_var_content,
15599            entity: local_var_entity,
15600        };
15601        Err(Error::ResponseError(local_var_error))
15602    }
15603}
15604
15605/// Patch a L2VPN object.
15606pub async fn vpn_l2vpns_partial_update(
15607    configuration: &configuration::Configuration,
15608    id: i32,
15609    patched_writable_l2_vpn_request: Option<crate::models::PatchedWritableL2VpnRequest>,
15610) -> Result<crate::models::L2Vpn, Error<VpnL2vpnsPartialUpdateError>> {
15611    let local_var_configuration = configuration;
15612
15613    let local_var_client = &local_var_configuration.client;
15614
15615    let local_var_uri_str = format!(
15616        "{}/api/vpn/l2vpns/{id}/",
15617        local_var_configuration.base_path,
15618        id = id
15619    );
15620    let mut local_var_req_builder =
15621        local_var_client.request(reqwest::Method::PATCH, local_var_uri_str.as_str());
15622
15623    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
15624        local_var_req_builder =
15625            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
15626    }
15627    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
15628        let local_var_key = local_var_apikey.key.clone();
15629        let local_var_value = match local_var_apikey.prefix {
15630            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
15631            None => local_var_key,
15632        };
15633        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
15634    };
15635    local_var_req_builder = local_var_req_builder.json(&patched_writable_l2_vpn_request);
15636
15637    let local_var_req = local_var_req_builder.build()?;
15638    let local_var_resp = local_var_client.execute(local_var_req).await?;
15639
15640    let local_var_status = local_var_resp.status();
15641    let local_var_content = local_var_resp.text().await?;
15642
15643    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
15644        serde_json::from_str(&local_var_content).map_err(Error::from)
15645    } else {
15646        let local_var_entity: Option<VpnL2vpnsPartialUpdateError> =
15647            serde_json::from_str(&local_var_content).ok();
15648        let local_var_error = ResponseContent {
15649            status: local_var_status,
15650            content: local_var_content,
15651            entity: local_var_entity,
15652        };
15653        Err(Error::ResponseError(local_var_error))
15654    }
15655}
15656
15657/// Get a L2VPN object.
15658pub async fn vpn_l2vpns_retrieve(
15659    configuration: &configuration::Configuration,
15660    id: i32,
15661) -> Result<crate::models::L2Vpn, Error<VpnL2vpnsRetrieveError>> {
15662    let local_var_configuration = configuration;
15663
15664    let local_var_client = &local_var_configuration.client;
15665
15666    let local_var_uri_str = format!(
15667        "{}/api/vpn/l2vpns/{id}/",
15668        local_var_configuration.base_path,
15669        id = id
15670    );
15671    let mut local_var_req_builder =
15672        local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
15673
15674    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
15675        local_var_req_builder =
15676            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
15677    }
15678    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
15679        let local_var_key = local_var_apikey.key.clone();
15680        let local_var_value = match local_var_apikey.prefix {
15681            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
15682            None => local_var_key,
15683        };
15684        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
15685    };
15686
15687    let local_var_req = local_var_req_builder.build()?;
15688    let local_var_resp = local_var_client.execute(local_var_req).await?;
15689
15690    let local_var_status = local_var_resp.status();
15691    let local_var_content = local_var_resp.text().await?;
15692
15693    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
15694        serde_json::from_str(&local_var_content).map_err(Error::from)
15695    } else {
15696        let local_var_entity: Option<VpnL2vpnsRetrieveError> =
15697            serde_json::from_str(&local_var_content).ok();
15698        let local_var_error = ResponseContent {
15699            status: local_var_status,
15700            content: local_var_content,
15701            entity: local_var_entity,
15702        };
15703        Err(Error::ResponseError(local_var_error))
15704    }
15705}
15706
15707/// Put a L2VPN object.
15708pub async fn vpn_l2vpns_update(
15709    configuration: &configuration::Configuration,
15710    id: i32,
15711    writable_l2_vpn_request: crate::models::WritableL2VpnRequest,
15712) -> Result<crate::models::L2Vpn, Error<VpnL2vpnsUpdateError>> {
15713    let local_var_configuration = configuration;
15714
15715    let local_var_client = &local_var_configuration.client;
15716
15717    let local_var_uri_str = format!(
15718        "{}/api/vpn/l2vpns/{id}/",
15719        local_var_configuration.base_path,
15720        id = id
15721    );
15722    let mut local_var_req_builder =
15723        local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());
15724
15725    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
15726        local_var_req_builder =
15727            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
15728    }
15729    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
15730        let local_var_key = local_var_apikey.key.clone();
15731        let local_var_value = match local_var_apikey.prefix {
15732            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
15733            None => local_var_key,
15734        };
15735        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
15736    };
15737    local_var_req_builder = local_var_req_builder.json(&writable_l2_vpn_request);
15738
15739    let local_var_req = local_var_req_builder.build()?;
15740    let local_var_resp = local_var_client.execute(local_var_req).await?;
15741
15742    let local_var_status = local_var_resp.status();
15743    let local_var_content = local_var_resp.text().await?;
15744
15745    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
15746        serde_json::from_str(&local_var_content).map_err(Error::from)
15747    } else {
15748        let local_var_entity: Option<VpnL2vpnsUpdateError> =
15749            serde_json::from_str(&local_var_content).ok();
15750        let local_var_error = ResponseContent {
15751            status: local_var_status,
15752            content: local_var_content,
15753            entity: local_var_entity,
15754        };
15755        Err(Error::ResponseError(local_var_error))
15756    }
15757}
15758
15759/// Delete a list of tunnel group objects.
15760pub async fn vpn_tunnel_groups_bulk_destroy(
15761    configuration: &configuration::Configuration,
15762    tunnel_group_request: Vec<crate::models::TunnelGroupRequest>,
15763) -> Result<(), Error<VpnTunnelGroupsBulkDestroyError>> {
15764    let local_var_configuration = configuration;
15765
15766    let local_var_client = &local_var_configuration.client;
15767
15768    let local_var_uri_str = format!(
15769        "{}/api/vpn/tunnel-groups/",
15770        local_var_configuration.base_path
15771    );
15772    let mut local_var_req_builder =
15773        local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());
15774
15775    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
15776        local_var_req_builder =
15777            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
15778    }
15779    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
15780        let local_var_key = local_var_apikey.key.clone();
15781        let local_var_value = match local_var_apikey.prefix {
15782            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
15783            None => local_var_key,
15784        };
15785        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
15786    };
15787    local_var_req_builder = local_var_req_builder.json(&tunnel_group_request);
15788
15789    let local_var_req = local_var_req_builder.build()?;
15790    let local_var_resp = local_var_client.execute(local_var_req).await?;
15791
15792    let local_var_status = local_var_resp.status();
15793    let local_var_content = local_var_resp.text().await?;
15794
15795    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
15796        Ok(())
15797    } else {
15798        let local_var_entity: Option<VpnTunnelGroupsBulkDestroyError> =
15799            serde_json::from_str(&local_var_content).ok();
15800        let local_var_error = ResponseContent {
15801            status: local_var_status,
15802            content: local_var_content,
15803            entity: local_var_entity,
15804        };
15805        Err(Error::ResponseError(local_var_error))
15806    }
15807}
15808
15809/// Patch a list of tunnel group objects.
15810pub async fn vpn_tunnel_groups_bulk_partial_update(
15811    configuration: &configuration::Configuration,
15812    tunnel_group_request: Vec<crate::models::TunnelGroupRequest>,
15813) -> Result<Vec<crate::models::TunnelGroup>, Error<VpnTunnelGroupsBulkPartialUpdateError>> {
15814    let local_var_configuration = configuration;
15815
15816    let local_var_client = &local_var_configuration.client;
15817
15818    let local_var_uri_str = format!(
15819        "{}/api/vpn/tunnel-groups/",
15820        local_var_configuration.base_path
15821    );
15822    let mut local_var_req_builder =
15823        local_var_client.request(reqwest::Method::PATCH, local_var_uri_str.as_str());
15824
15825    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
15826        local_var_req_builder =
15827            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
15828    }
15829    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
15830        let local_var_key = local_var_apikey.key.clone();
15831        let local_var_value = match local_var_apikey.prefix {
15832            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
15833            None => local_var_key,
15834        };
15835        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
15836    };
15837    local_var_req_builder = local_var_req_builder.json(&tunnel_group_request);
15838
15839    let local_var_req = local_var_req_builder.build()?;
15840    let local_var_resp = local_var_client.execute(local_var_req).await?;
15841
15842    let local_var_status = local_var_resp.status();
15843    let local_var_content = local_var_resp.text().await?;
15844
15845    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
15846        serde_json::from_str(&local_var_content).map_err(Error::from)
15847    } else {
15848        let local_var_entity: Option<VpnTunnelGroupsBulkPartialUpdateError> =
15849            serde_json::from_str(&local_var_content).ok();
15850        let local_var_error = ResponseContent {
15851            status: local_var_status,
15852            content: local_var_content,
15853            entity: local_var_entity,
15854        };
15855        Err(Error::ResponseError(local_var_error))
15856    }
15857}
15858
15859/// Put a list of tunnel group objects.
15860pub async fn vpn_tunnel_groups_bulk_update(
15861    configuration: &configuration::Configuration,
15862    tunnel_group_request: Vec<crate::models::TunnelGroupRequest>,
15863) -> Result<Vec<crate::models::TunnelGroup>, Error<VpnTunnelGroupsBulkUpdateError>> {
15864    let local_var_configuration = configuration;
15865
15866    let local_var_client = &local_var_configuration.client;
15867
15868    let local_var_uri_str = format!(
15869        "{}/api/vpn/tunnel-groups/",
15870        local_var_configuration.base_path
15871    );
15872    let mut local_var_req_builder =
15873        local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());
15874
15875    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
15876        local_var_req_builder =
15877            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
15878    }
15879    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
15880        let local_var_key = local_var_apikey.key.clone();
15881        let local_var_value = match local_var_apikey.prefix {
15882            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
15883            None => local_var_key,
15884        };
15885        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
15886    };
15887    local_var_req_builder = local_var_req_builder.json(&tunnel_group_request);
15888
15889    let local_var_req = local_var_req_builder.build()?;
15890    let local_var_resp = local_var_client.execute(local_var_req).await?;
15891
15892    let local_var_status = local_var_resp.status();
15893    let local_var_content = local_var_resp.text().await?;
15894
15895    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
15896        serde_json::from_str(&local_var_content).map_err(Error::from)
15897    } else {
15898        let local_var_entity: Option<VpnTunnelGroupsBulkUpdateError> =
15899            serde_json::from_str(&local_var_content).ok();
15900        let local_var_error = ResponseContent {
15901            status: local_var_status,
15902            content: local_var_content,
15903            entity: local_var_entity,
15904        };
15905        Err(Error::ResponseError(local_var_error))
15906    }
15907}
15908
15909/// Post a list of tunnel group objects.
15910pub async fn vpn_tunnel_groups_create(
15911    configuration: &configuration::Configuration,
15912    tunnel_group_request: crate::models::TunnelGroupRequest,
15913) -> Result<crate::models::TunnelGroup, Error<VpnTunnelGroupsCreateError>> {
15914    let local_var_configuration = configuration;
15915
15916    let local_var_client = &local_var_configuration.client;
15917
15918    let local_var_uri_str = format!(
15919        "{}/api/vpn/tunnel-groups/",
15920        local_var_configuration.base_path
15921    );
15922    let mut local_var_req_builder =
15923        local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
15924
15925    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
15926        local_var_req_builder =
15927            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
15928    }
15929    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
15930        let local_var_key = local_var_apikey.key.clone();
15931        let local_var_value = match local_var_apikey.prefix {
15932            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
15933            None => local_var_key,
15934        };
15935        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
15936    };
15937    local_var_req_builder = local_var_req_builder.json(&tunnel_group_request);
15938
15939    let local_var_req = local_var_req_builder.build()?;
15940    let local_var_resp = local_var_client.execute(local_var_req).await?;
15941
15942    let local_var_status = local_var_resp.status();
15943    let local_var_content = local_var_resp.text().await?;
15944
15945    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
15946        serde_json::from_str(&local_var_content).map_err(Error::from)
15947    } else {
15948        let local_var_entity: Option<VpnTunnelGroupsCreateError> =
15949            serde_json::from_str(&local_var_content).ok();
15950        let local_var_error = ResponseContent {
15951            status: local_var_status,
15952            content: local_var_content,
15953            entity: local_var_entity,
15954        };
15955        Err(Error::ResponseError(local_var_error))
15956    }
15957}
15958
15959/// Delete a tunnel group object.
15960pub async fn vpn_tunnel_groups_destroy(
15961    configuration: &configuration::Configuration,
15962    id: i32,
15963) -> Result<(), Error<VpnTunnelGroupsDestroyError>> {
15964    let local_var_configuration = configuration;
15965
15966    let local_var_client = &local_var_configuration.client;
15967
15968    let local_var_uri_str = format!(
15969        "{}/api/vpn/tunnel-groups/{id}/",
15970        local_var_configuration.base_path,
15971        id = id
15972    );
15973    let mut local_var_req_builder =
15974        local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());
15975
15976    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
15977        local_var_req_builder =
15978            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
15979    }
15980    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
15981        let local_var_key = local_var_apikey.key.clone();
15982        let local_var_value = match local_var_apikey.prefix {
15983            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
15984            None => local_var_key,
15985        };
15986        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
15987    };
15988
15989    let local_var_req = local_var_req_builder.build()?;
15990    let local_var_resp = local_var_client.execute(local_var_req).await?;
15991
15992    let local_var_status = local_var_resp.status();
15993    let local_var_content = local_var_resp.text().await?;
15994
15995    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
15996        Ok(())
15997    } else {
15998        let local_var_entity: Option<VpnTunnelGroupsDestroyError> =
15999            serde_json::from_str(&local_var_content).ok();
16000        let local_var_error = ResponseContent {
16001            status: local_var_status,
16002            content: local_var_content,
16003            entity: local_var_entity,
16004        };
16005        Err(Error::ResponseError(local_var_error))
16006    }
16007}
16008
16009/// Get a list of tunnel group objects.
16010pub async fn vpn_tunnel_groups_list(
16011    configuration: &configuration::Configuration,
16012    contact: Option<Vec<i32>>,
16013    contact__n: Option<Vec<i32>>,
16014    contact_group: Option<Vec<String>>,
16015    contact_group__n: Option<Vec<String>>,
16016    contact_role: Option<Vec<i32>>,
16017    contact_role__n: Option<Vec<i32>>,
16018    created: Option<Vec<String>>,
16019    created__empty: Option<Vec<String>>,
16020    created__gt: Option<Vec<String>>,
16021    created__gte: Option<Vec<String>>,
16022    created__lt: Option<Vec<String>>,
16023    created__lte: Option<Vec<String>>,
16024    created__n: Option<Vec<String>>,
16025    created_by_request: Option<&str>,
16026    description: Option<Vec<String>>,
16027    description__empty: Option<bool>,
16028    description__ic: Option<Vec<String>>,
16029    description__ie: Option<Vec<String>>,
16030    description__iew: Option<Vec<String>>,
16031    description__iregex: Option<Vec<String>>,
16032    description__isw: Option<Vec<String>>,
16033    description__n: Option<Vec<String>>,
16034    description__nic: Option<Vec<String>>,
16035    description__nie: Option<Vec<String>>,
16036    description__niew: Option<Vec<String>>,
16037    description__nisw: Option<Vec<String>>,
16038    description__regex: Option<Vec<String>>,
16039    id: Option<Vec<i32>>,
16040    id__empty: Option<bool>,
16041    id__gt: Option<Vec<i32>>,
16042    id__gte: Option<Vec<i32>>,
16043    id__lt: Option<Vec<i32>>,
16044    id__lte: Option<Vec<i32>>,
16045    id__n: Option<Vec<i32>>,
16046    last_updated: Option<Vec<String>>,
16047    last_updated__empty: Option<Vec<String>>,
16048    last_updated__gt: Option<Vec<String>>,
16049    last_updated__gte: Option<Vec<String>>,
16050    last_updated__lt: Option<Vec<String>>,
16051    last_updated__lte: Option<Vec<String>>,
16052    last_updated__n: Option<Vec<String>>,
16053    limit: Option<i32>,
16054    modified_by_request: Option<&str>,
16055    name: Option<Vec<String>>,
16056    name__empty: Option<bool>,
16057    name__ic: Option<Vec<String>>,
16058    name__ie: Option<Vec<String>>,
16059    name__iew: Option<Vec<String>>,
16060    name__iregex: Option<Vec<String>>,
16061    name__isw: Option<Vec<String>>,
16062    name__n: Option<Vec<String>>,
16063    name__nic: Option<Vec<String>>,
16064    name__nie: Option<Vec<String>>,
16065    name__niew: Option<Vec<String>>,
16066    name__nisw: Option<Vec<String>>,
16067    name__regex: Option<Vec<String>>,
16068    offset: Option<i32>,
16069    ordering: Option<&str>,
16070    q: Option<&str>,
16071    slug: Option<Vec<String>>,
16072    slug__empty: Option<bool>,
16073    slug__ic: Option<Vec<String>>,
16074    slug__ie: Option<Vec<String>>,
16075    slug__iew: Option<Vec<String>>,
16076    slug__iregex: Option<Vec<String>>,
16077    slug__isw: Option<Vec<String>>,
16078    slug__n: Option<Vec<String>>,
16079    slug__nic: Option<Vec<String>>,
16080    slug__nie: Option<Vec<String>>,
16081    slug__niew: Option<Vec<String>>,
16082    slug__nisw: Option<Vec<String>>,
16083    slug__regex: Option<Vec<String>>,
16084    tag: Option<Vec<String>>,
16085    tag__n: Option<Vec<String>>,
16086    tag_id: Option<Vec<i32>>,
16087    tag_id__n: Option<Vec<i32>>,
16088    updated_by_request: Option<&str>,
16089) -> Result<crate::models::PaginatedTunnelGroupList, Error<VpnTunnelGroupsListError>> {
16090    let local_var_configuration = configuration;
16091
16092    let local_var_client = &local_var_configuration.client;
16093
16094    let local_var_uri_str = format!(
16095        "{}/api/vpn/tunnel-groups/",
16096        local_var_configuration.base_path
16097    );
16098    let mut local_var_req_builder =
16099        local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
16100
16101    if let Some(ref local_var_str) = contact {
16102        local_var_req_builder = match "multi" {
16103            "multi" => local_var_req_builder.query(
16104                &local_var_str
16105                    .into_iter()
16106                    .map(|p| ("contact".to_owned(), p.to_string()))
16107                    .collect::<Vec<(std::string::String, std::string::String)>>(),
16108            ),
16109            _ => local_var_req_builder.query(&[(
16110                "contact",
16111                &local_var_str
16112                    .into_iter()
16113                    .map(|p| p.to_string())
16114                    .collect::<Vec<String>>()
16115                    .join(",")
16116                    .to_string(),
16117            )]),
16118        };
16119    }
16120    if let Some(ref local_var_str) = contact__n {
16121        local_var_req_builder = match "multi" {
16122            "multi" => local_var_req_builder.query(
16123                &local_var_str
16124                    .into_iter()
16125                    .map(|p| ("contact__n".to_owned(), p.to_string()))
16126                    .collect::<Vec<(std::string::String, std::string::String)>>(),
16127            ),
16128            _ => local_var_req_builder.query(&[(
16129                "contact__n",
16130                &local_var_str
16131                    .into_iter()
16132                    .map(|p| p.to_string())
16133                    .collect::<Vec<String>>()
16134                    .join(",")
16135                    .to_string(),
16136            )]),
16137        };
16138    }
16139    if let Some(ref local_var_str) = contact_group {
16140        local_var_req_builder = match "multi" {
16141            "multi" => local_var_req_builder.query(
16142                &local_var_str
16143                    .into_iter()
16144                    .map(|p| ("contact_group".to_owned(), p.to_string()))
16145                    .collect::<Vec<(std::string::String, std::string::String)>>(),
16146            ),
16147            _ => local_var_req_builder.query(&[(
16148                "contact_group",
16149                &local_var_str
16150                    .into_iter()
16151                    .map(|p| p.to_string())
16152                    .collect::<Vec<String>>()
16153                    .join(",")
16154                    .to_string(),
16155            )]),
16156        };
16157    }
16158    if let Some(ref local_var_str) = contact_group__n {
16159        local_var_req_builder = match "multi" {
16160            "multi" => local_var_req_builder.query(
16161                &local_var_str
16162                    .into_iter()
16163                    .map(|p| ("contact_group__n".to_owned(), p.to_string()))
16164                    .collect::<Vec<(std::string::String, std::string::String)>>(),
16165            ),
16166            _ => local_var_req_builder.query(&[(
16167                "contact_group__n",
16168                &local_var_str
16169                    .into_iter()
16170                    .map(|p| p.to_string())
16171                    .collect::<Vec<String>>()
16172                    .join(",")
16173                    .to_string(),
16174            )]),
16175        };
16176    }
16177    if let Some(ref local_var_str) = contact_role {
16178        local_var_req_builder = match "multi" {
16179            "multi" => local_var_req_builder.query(
16180                &local_var_str
16181                    .into_iter()
16182                    .map(|p| ("contact_role".to_owned(), p.to_string()))
16183                    .collect::<Vec<(std::string::String, std::string::String)>>(),
16184            ),
16185            _ => local_var_req_builder.query(&[(
16186                "contact_role",
16187                &local_var_str
16188                    .into_iter()
16189                    .map(|p| p.to_string())
16190                    .collect::<Vec<String>>()
16191                    .join(",")
16192                    .to_string(),
16193            )]),
16194        };
16195    }
16196    if let Some(ref local_var_str) = contact_role__n {
16197        local_var_req_builder = match "multi" {
16198            "multi" => local_var_req_builder.query(
16199                &local_var_str
16200                    .into_iter()
16201                    .map(|p| ("contact_role__n".to_owned(), p.to_string()))
16202                    .collect::<Vec<(std::string::String, std::string::String)>>(),
16203            ),
16204            _ => local_var_req_builder.query(&[(
16205                "contact_role__n",
16206                &local_var_str
16207                    .into_iter()
16208                    .map(|p| p.to_string())
16209                    .collect::<Vec<String>>()
16210                    .join(",")
16211                    .to_string(),
16212            )]),
16213        };
16214    }
16215    if let Some(ref local_var_str) = created {
16216        local_var_req_builder = match "multi" {
16217            "multi" => local_var_req_builder.query(
16218                &local_var_str
16219                    .into_iter()
16220                    .map(|p| ("created".to_owned(), p.to_string()))
16221                    .collect::<Vec<(std::string::String, std::string::String)>>(),
16222            ),
16223            _ => local_var_req_builder.query(&[(
16224                "created",
16225                &local_var_str
16226                    .into_iter()
16227                    .map(|p| p.to_string())
16228                    .collect::<Vec<String>>()
16229                    .join(",")
16230                    .to_string(),
16231            )]),
16232        };
16233    }
16234    if let Some(ref local_var_str) = created__empty {
16235        local_var_req_builder = match "multi" {
16236            "multi" => local_var_req_builder.query(
16237                &local_var_str
16238                    .into_iter()
16239                    .map(|p| ("created__empty".to_owned(), p.to_string()))
16240                    .collect::<Vec<(std::string::String, std::string::String)>>(),
16241            ),
16242            _ => local_var_req_builder.query(&[(
16243                "created__empty",
16244                &local_var_str
16245                    .into_iter()
16246                    .map(|p| p.to_string())
16247                    .collect::<Vec<String>>()
16248                    .join(",")
16249                    .to_string(),
16250            )]),
16251        };
16252    }
16253    if let Some(ref local_var_str) = created__gt {
16254        local_var_req_builder = match "multi" {
16255            "multi" => local_var_req_builder.query(
16256                &local_var_str
16257                    .into_iter()
16258                    .map(|p| ("created__gt".to_owned(), p.to_string()))
16259                    .collect::<Vec<(std::string::String, std::string::String)>>(),
16260            ),
16261            _ => local_var_req_builder.query(&[(
16262                "created__gt",
16263                &local_var_str
16264                    .into_iter()
16265                    .map(|p| p.to_string())
16266                    .collect::<Vec<String>>()
16267                    .join(",")
16268                    .to_string(),
16269            )]),
16270        };
16271    }
16272    if let Some(ref local_var_str) = created__gte {
16273        local_var_req_builder = match "multi" {
16274            "multi" => local_var_req_builder.query(
16275                &local_var_str
16276                    .into_iter()
16277                    .map(|p| ("created__gte".to_owned(), p.to_string()))
16278                    .collect::<Vec<(std::string::String, std::string::String)>>(),
16279            ),
16280            _ => local_var_req_builder.query(&[(
16281                "created__gte",
16282                &local_var_str
16283                    .into_iter()
16284                    .map(|p| p.to_string())
16285                    .collect::<Vec<String>>()
16286                    .join(",")
16287                    .to_string(),
16288            )]),
16289        };
16290    }
16291    if let Some(ref local_var_str) = created__lt {
16292        local_var_req_builder = match "multi" {
16293            "multi" => local_var_req_builder.query(
16294                &local_var_str
16295                    .into_iter()
16296                    .map(|p| ("created__lt".to_owned(), p.to_string()))
16297                    .collect::<Vec<(std::string::String, std::string::String)>>(),
16298            ),
16299            _ => local_var_req_builder.query(&[(
16300                "created__lt",
16301                &local_var_str
16302                    .into_iter()
16303                    .map(|p| p.to_string())
16304                    .collect::<Vec<String>>()
16305                    .join(",")
16306                    .to_string(),
16307            )]),
16308        };
16309    }
16310    if let Some(ref local_var_str) = created__lte {
16311        local_var_req_builder = match "multi" {
16312            "multi" => local_var_req_builder.query(
16313                &local_var_str
16314                    .into_iter()
16315                    .map(|p| ("created__lte".to_owned(), p.to_string()))
16316                    .collect::<Vec<(std::string::String, std::string::String)>>(),
16317            ),
16318            _ => local_var_req_builder.query(&[(
16319                "created__lte",
16320                &local_var_str
16321                    .into_iter()
16322                    .map(|p| p.to_string())
16323                    .collect::<Vec<String>>()
16324                    .join(",")
16325                    .to_string(),
16326            )]),
16327        };
16328    }
16329    if let Some(ref local_var_str) = created__n {
16330        local_var_req_builder = match "multi" {
16331            "multi" => local_var_req_builder.query(
16332                &local_var_str
16333                    .into_iter()
16334                    .map(|p| ("created__n".to_owned(), p.to_string()))
16335                    .collect::<Vec<(std::string::String, std::string::String)>>(),
16336            ),
16337            _ => local_var_req_builder.query(&[(
16338                "created__n",
16339                &local_var_str
16340                    .into_iter()
16341                    .map(|p| p.to_string())
16342                    .collect::<Vec<String>>()
16343                    .join(",")
16344                    .to_string(),
16345            )]),
16346        };
16347    }
16348    if let Some(ref local_var_str) = created_by_request {
16349        local_var_req_builder =
16350            local_var_req_builder.query(&[("created_by_request", &local_var_str.to_string())]);
16351    }
16352    if let Some(ref local_var_str) = description {
16353        local_var_req_builder = match "multi" {
16354            "multi" => local_var_req_builder.query(
16355                &local_var_str
16356                    .into_iter()
16357                    .map(|p| ("description".to_owned(), p.to_string()))
16358                    .collect::<Vec<(std::string::String, std::string::String)>>(),
16359            ),
16360            _ => local_var_req_builder.query(&[(
16361                "description",
16362                &local_var_str
16363                    .into_iter()
16364                    .map(|p| p.to_string())
16365                    .collect::<Vec<String>>()
16366                    .join(",")
16367                    .to_string(),
16368            )]),
16369        };
16370    }
16371    if let Some(ref local_var_str) = description__empty {
16372        local_var_req_builder =
16373            local_var_req_builder.query(&[("description__empty", &local_var_str.to_string())]);
16374    }
16375    if let Some(ref local_var_str) = description__ic {
16376        local_var_req_builder = match "multi" {
16377            "multi" => local_var_req_builder.query(
16378                &local_var_str
16379                    .into_iter()
16380                    .map(|p| ("description__ic".to_owned(), p.to_string()))
16381                    .collect::<Vec<(std::string::String, std::string::String)>>(),
16382            ),
16383            _ => local_var_req_builder.query(&[(
16384                "description__ic",
16385                &local_var_str
16386                    .into_iter()
16387                    .map(|p| p.to_string())
16388                    .collect::<Vec<String>>()
16389                    .join(",")
16390                    .to_string(),
16391            )]),
16392        };
16393    }
16394    if let Some(ref local_var_str) = description__ie {
16395        local_var_req_builder = match "multi" {
16396            "multi" => local_var_req_builder.query(
16397                &local_var_str
16398                    .into_iter()
16399                    .map(|p| ("description__ie".to_owned(), p.to_string()))
16400                    .collect::<Vec<(std::string::String, std::string::String)>>(),
16401            ),
16402            _ => local_var_req_builder.query(&[(
16403                "description__ie",
16404                &local_var_str
16405                    .into_iter()
16406                    .map(|p| p.to_string())
16407                    .collect::<Vec<String>>()
16408                    .join(",")
16409                    .to_string(),
16410            )]),
16411        };
16412    }
16413    if let Some(ref local_var_str) = description__iew {
16414        local_var_req_builder = match "multi" {
16415            "multi" => local_var_req_builder.query(
16416                &local_var_str
16417                    .into_iter()
16418                    .map(|p| ("description__iew".to_owned(), p.to_string()))
16419                    .collect::<Vec<(std::string::String, std::string::String)>>(),
16420            ),
16421            _ => local_var_req_builder.query(&[(
16422                "description__iew",
16423                &local_var_str
16424                    .into_iter()
16425                    .map(|p| p.to_string())
16426                    .collect::<Vec<String>>()
16427                    .join(",")
16428                    .to_string(),
16429            )]),
16430        };
16431    }
16432    if let Some(ref local_var_str) = description__iregex {
16433        local_var_req_builder = match "multi" {
16434            "multi" => local_var_req_builder.query(
16435                &local_var_str
16436                    .into_iter()
16437                    .map(|p| ("description__iregex".to_owned(), p.to_string()))
16438                    .collect::<Vec<(std::string::String, std::string::String)>>(),
16439            ),
16440            _ => local_var_req_builder.query(&[(
16441                "description__iregex",
16442                &local_var_str
16443                    .into_iter()
16444                    .map(|p| p.to_string())
16445                    .collect::<Vec<String>>()
16446                    .join(",")
16447                    .to_string(),
16448            )]),
16449        };
16450    }
16451    if let Some(ref local_var_str) = description__isw {
16452        local_var_req_builder = match "multi" {
16453            "multi" => local_var_req_builder.query(
16454                &local_var_str
16455                    .into_iter()
16456                    .map(|p| ("description__isw".to_owned(), p.to_string()))
16457                    .collect::<Vec<(std::string::String, std::string::String)>>(),
16458            ),
16459            _ => local_var_req_builder.query(&[(
16460                "description__isw",
16461                &local_var_str
16462                    .into_iter()
16463                    .map(|p| p.to_string())
16464                    .collect::<Vec<String>>()
16465                    .join(",")
16466                    .to_string(),
16467            )]),
16468        };
16469    }
16470    if let Some(ref local_var_str) = description__n {
16471        local_var_req_builder = match "multi" {
16472            "multi" => local_var_req_builder.query(
16473                &local_var_str
16474                    .into_iter()
16475                    .map(|p| ("description__n".to_owned(), p.to_string()))
16476                    .collect::<Vec<(std::string::String, std::string::String)>>(),
16477            ),
16478            _ => local_var_req_builder.query(&[(
16479                "description__n",
16480                &local_var_str
16481                    .into_iter()
16482                    .map(|p| p.to_string())
16483                    .collect::<Vec<String>>()
16484                    .join(",")
16485                    .to_string(),
16486            )]),
16487        };
16488    }
16489    if let Some(ref local_var_str) = description__nic {
16490        local_var_req_builder = match "multi" {
16491            "multi" => local_var_req_builder.query(
16492                &local_var_str
16493                    .into_iter()
16494                    .map(|p| ("description__nic".to_owned(), p.to_string()))
16495                    .collect::<Vec<(std::string::String, std::string::String)>>(),
16496            ),
16497            _ => local_var_req_builder.query(&[(
16498                "description__nic",
16499                &local_var_str
16500                    .into_iter()
16501                    .map(|p| p.to_string())
16502                    .collect::<Vec<String>>()
16503                    .join(",")
16504                    .to_string(),
16505            )]),
16506        };
16507    }
16508    if let Some(ref local_var_str) = description__nie {
16509        local_var_req_builder = match "multi" {
16510            "multi" => local_var_req_builder.query(
16511                &local_var_str
16512                    .into_iter()
16513                    .map(|p| ("description__nie".to_owned(), p.to_string()))
16514                    .collect::<Vec<(std::string::String, std::string::String)>>(),
16515            ),
16516            _ => local_var_req_builder.query(&[(
16517                "description__nie",
16518                &local_var_str
16519                    .into_iter()
16520                    .map(|p| p.to_string())
16521                    .collect::<Vec<String>>()
16522                    .join(",")
16523                    .to_string(),
16524            )]),
16525        };
16526    }
16527    if let Some(ref local_var_str) = description__niew {
16528        local_var_req_builder = match "multi" {
16529            "multi" => local_var_req_builder.query(
16530                &local_var_str
16531                    .into_iter()
16532                    .map(|p| ("description__niew".to_owned(), p.to_string()))
16533                    .collect::<Vec<(std::string::String, std::string::String)>>(),
16534            ),
16535            _ => local_var_req_builder.query(&[(
16536                "description__niew",
16537                &local_var_str
16538                    .into_iter()
16539                    .map(|p| p.to_string())
16540                    .collect::<Vec<String>>()
16541                    .join(",")
16542                    .to_string(),
16543            )]),
16544        };
16545    }
16546    if let Some(ref local_var_str) = description__nisw {
16547        local_var_req_builder = match "multi" {
16548            "multi" => local_var_req_builder.query(
16549                &local_var_str
16550                    .into_iter()
16551                    .map(|p| ("description__nisw".to_owned(), p.to_string()))
16552                    .collect::<Vec<(std::string::String, std::string::String)>>(),
16553            ),
16554            _ => local_var_req_builder.query(&[(
16555                "description__nisw",
16556                &local_var_str
16557                    .into_iter()
16558                    .map(|p| p.to_string())
16559                    .collect::<Vec<String>>()
16560                    .join(",")
16561                    .to_string(),
16562            )]),
16563        };
16564    }
16565    if let Some(ref local_var_str) = description__regex {
16566        local_var_req_builder = match "multi" {
16567            "multi" => local_var_req_builder.query(
16568                &local_var_str
16569                    .into_iter()
16570                    .map(|p| ("description__regex".to_owned(), p.to_string()))
16571                    .collect::<Vec<(std::string::String, std::string::String)>>(),
16572            ),
16573            _ => local_var_req_builder.query(&[(
16574                "description__regex",
16575                &local_var_str
16576                    .into_iter()
16577                    .map(|p| p.to_string())
16578                    .collect::<Vec<String>>()
16579                    .join(",")
16580                    .to_string(),
16581            )]),
16582        };
16583    }
16584    if let Some(ref local_var_str) = id {
16585        local_var_req_builder = match "multi" {
16586            "multi" => local_var_req_builder.query(
16587                &local_var_str
16588                    .into_iter()
16589                    .map(|p| ("id".to_owned(), p.to_string()))
16590                    .collect::<Vec<(std::string::String, std::string::String)>>(),
16591            ),
16592            _ => local_var_req_builder.query(&[(
16593                "id",
16594                &local_var_str
16595                    .into_iter()
16596                    .map(|p| p.to_string())
16597                    .collect::<Vec<String>>()
16598                    .join(",")
16599                    .to_string(),
16600            )]),
16601        };
16602    }
16603    if let Some(ref local_var_str) = id__empty {
16604        local_var_req_builder =
16605            local_var_req_builder.query(&[("id__empty", &local_var_str.to_string())]);
16606    }
16607    if let Some(ref local_var_str) = id__gt {
16608        local_var_req_builder = match "multi" {
16609            "multi" => local_var_req_builder.query(
16610                &local_var_str
16611                    .into_iter()
16612                    .map(|p| ("id__gt".to_owned(), p.to_string()))
16613                    .collect::<Vec<(std::string::String, std::string::String)>>(),
16614            ),
16615            _ => local_var_req_builder.query(&[(
16616                "id__gt",
16617                &local_var_str
16618                    .into_iter()
16619                    .map(|p| p.to_string())
16620                    .collect::<Vec<String>>()
16621                    .join(",")
16622                    .to_string(),
16623            )]),
16624        };
16625    }
16626    if let Some(ref local_var_str) = id__gte {
16627        local_var_req_builder = match "multi" {
16628            "multi" => local_var_req_builder.query(
16629                &local_var_str
16630                    .into_iter()
16631                    .map(|p| ("id__gte".to_owned(), p.to_string()))
16632                    .collect::<Vec<(std::string::String, std::string::String)>>(),
16633            ),
16634            _ => local_var_req_builder.query(&[(
16635                "id__gte",
16636                &local_var_str
16637                    .into_iter()
16638                    .map(|p| p.to_string())
16639                    .collect::<Vec<String>>()
16640                    .join(",")
16641                    .to_string(),
16642            )]),
16643        };
16644    }
16645    if let Some(ref local_var_str) = id__lt {
16646        local_var_req_builder = match "multi" {
16647            "multi" => local_var_req_builder.query(
16648                &local_var_str
16649                    .into_iter()
16650                    .map(|p| ("id__lt".to_owned(), p.to_string()))
16651                    .collect::<Vec<(std::string::String, std::string::String)>>(),
16652            ),
16653            _ => local_var_req_builder.query(&[(
16654                "id__lt",
16655                &local_var_str
16656                    .into_iter()
16657                    .map(|p| p.to_string())
16658                    .collect::<Vec<String>>()
16659                    .join(",")
16660                    .to_string(),
16661            )]),
16662        };
16663    }
16664    if let Some(ref local_var_str) = id__lte {
16665        local_var_req_builder = match "multi" {
16666            "multi" => local_var_req_builder.query(
16667                &local_var_str
16668                    .into_iter()
16669                    .map(|p| ("id__lte".to_owned(), p.to_string()))
16670                    .collect::<Vec<(std::string::String, std::string::String)>>(),
16671            ),
16672            _ => local_var_req_builder.query(&[(
16673                "id__lte",
16674                &local_var_str
16675                    .into_iter()
16676                    .map(|p| p.to_string())
16677                    .collect::<Vec<String>>()
16678                    .join(",")
16679                    .to_string(),
16680            )]),
16681        };
16682    }
16683    if let Some(ref local_var_str) = id__n {
16684        local_var_req_builder = match "multi" {
16685            "multi" => local_var_req_builder.query(
16686                &local_var_str
16687                    .into_iter()
16688                    .map(|p| ("id__n".to_owned(), p.to_string()))
16689                    .collect::<Vec<(std::string::String, std::string::String)>>(),
16690            ),
16691            _ => local_var_req_builder.query(&[(
16692                "id__n",
16693                &local_var_str
16694                    .into_iter()
16695                    .map(|p| p.to_string())
16696                    .collect::<Vec<String>>()
16697                    .join(",")
16698                    .to_string(),
16699            )]),
16700        };
16701    }
16702    if let Some(ref local_var_str) = last_updated {
16703        local_var_req_builder = match "multi" {
16704            "multi" => local_var_req_builder.query(
16705                &local_var_str
16706                    .into_iter()
16707                    .map(|p| ("last_updated".to_owned(), p.to_string()))
16708                    .collect::<Vec<(std::string::String, std::string::String)>>(),
16709            ),
16710            _ => local_var_req_builder.query(&[(
16711                "last_updated",
16712                &local_var_str
16713                    .into_iter()
16714                    .map(|p| p.to_string())
16715                    .collect::<Vec<String>>()
16716                    .join(",")
16717                    .to_string(),
16718            )]),
16719        };
16720    }
16721    if let Some(ref local_var_str) = last_updated__empty {
16722        local_var_req_builder = match "multi" {
16723            "multi" => local_var_req_builder.query(
16724                &local_var_str
16725                    .into_iter()
16726                    .map(|p| ("last_updated__empty".to_owned(), p.to_string()))
16727                    .collect::<Vec<(std::string::String, std::string::String)>>(),
16728            ),
16729            _ => local_var_req_builder.query(&[(
16730                "last_updated__empty",
16731                &local_var_str
16732                    .into_iter()
16733                    .map(|p| p.to_string())
16734                    .collect::<Vec<String>>()
16735                    .join(",")
16736                    .to_string(),
16737            )]),
16738        };
16739    }
16740    if let Some(ref local_var_str) = last_updated__gt {
16741        local_var_req_builder = match "multi" {
16742            "multi" => local_var_req_builder.query(
16743                &local_var_str
16744                    .into_iter()
16745                    .map(|p| ("last_updated__gt".to_owned(), p.to_string()))
16746                    .collect::<Vec<(std::string::String, std::string::String)>>(),
16747            ),
16748            _ => local_var_req_builder.query(&[(
16749                "last_updated__gt",
16750                &local_var_str
16751                    .into_iter()
16752                    .map(|p| p.to_string())
16753                    .collect::<Vec<String>>()
16754                    .join(",")
16755                    .to_string(),
16756            )]),
16757        };
16758    }
16759    if let Some(ref local_var_str) = last_updated__gte {
16760        local_var_req_builder = match "multi" {
16761            "multi" => local_var_req_builder.query(
16762                &local_var_str
16763                    .into_iter()
16764                    .map(|p| ("last_updated__gte".to_owned(), p.to_string()))
16765                    .collect::<Vec<(std::string::String, std::string::String)>>(),
16766            ),
16767            _ => local_var_req_builder.query(&[(
16768                "last_updated__gte",
16769                &local_var_str
16770                    .into_iter()
16771                    .map(|p| p.to_string())
16772                    .collect::<Vec<String>>()
16773                    .join(",")
16774                    .to_string(),
16775            )]),
16776        };
16777    }
16778    if let Some(ref local_var_str) = last_updated__lt {
16779        local_var_req_builder = match "multi" {
16780            "multi" => local_var_req_builder.query(
16781                &local_var_str
16782                    .into_iter()
16783                    .map(|p| ("last_updated__lt".to_owned(), p.to_string()))
16784                    .collect::<Vec<(std::string::String, std::string::String)>>(),
16785            ),
16786            _ => local_var_req_builder.query(&[(
16787                "last_updated__lt",
16788                &local_var_str
16789                    .into_iter()
16790                    .map(|p| p.to_string())
16791                    .collect::<Vec<String>>()
16792                    .join(",")
16793                    .to_string(),
16794            )]),
16795        };
16796    }
16797    if let Some(ref local_var_str) = last_updated__lte {
16798        local_var_req_builder = match "multi" {
16799            "multi" => local_var_req_builder.query(
16800                &local_var_str
16801                    .into_iter()
16802                    .map(|p| ("last_updated__lte".to_owned(), p.to_string()))
16803                    .collect::<Vec<(std::string::String, std::string::String)>>(),
16804            ),
16805            _ => local_var_req_builder.query(&[(
16806                "last_updated__lte",
16807                &local_var_str
16808                    .into_iter()
16809                    .map(|p| p.to_string())
16810                    .collect::<Vec<String>>()
16811                    .join(",")
16812                    .to_string(),
16813            )]),
16814        };
16815    }
16816    if let Some(ref local_var_str) = last_updated__n {
16817        local_var_req_builder = match "multi" {
16818            "multi" => local_var_req_builder.query(
16819                &local_var_str
16820                    .into_iter()
16821                    .map(|p| ("last_updated__n".to_owned(), p.to_string()))
16822                    .collect::<Vec<(std::string::String, std::string::String)>>(),
16823            ),
16824            _ => local_var_req_builder.query(&[(
16825                "last_updated__n",
16826                &local_var_str
16827                    .into_iter()
16828                    .map(|p| p.to_string())
16829                    .collect::<Vec<String>>()
16830                    .join(",")
16831                    .to_string(),
16832            )]),
16833        };
16834    }
16835    if let Some(ref local_var_str) = limit {
16836        local_var_req_builder =
16837            local_var_req_builder.query(&[("limit", &local_var_str.to_string())]);
16838    }
16839    if let Some(ref local_var_str) = modified_by_request {
16840        local_var_req_builder =
16841            local_var_req_builder.query(&[("modified_by_request", &local_var_str.to_string())]);
16842    }
16843    if let Some(ref local_var_str) = name {
16844        local_var_req_builder = match "multi" {
16845            "multi" => local_var_req_builder.query(
16846                &local_var_str
16847                    .into_iter()
16848                    .map(|p| ("name".to_owned(), p.to_string()))
16849                    .collect::<Vec<(std::string::String, std::string::String)>>(),
16850            ),
16851            _ => local_var_req_builder.query(&[(
16852                "name",
16853                &local_var_str
16854                    .into_iter()
16855                    .map(|p| p.to_string())
16856                    .collect::<Vec<String>>()
16857                    .join(",")
16858                    .to_string(),
16859            )]),
16860        };
16861    }
16862    if let Some(ref local_var_str) = name__empty {
16863        local_var_req_builder =
16864            local_var_req_builder.query(&[("name__empty", &local_var_str.to_string())]);
16865    }
16866    if let Some(ref local_var_str) = name__ic {
16867        local_var_req_builder = match "multi" {
16868            "multi" => local_var_req_builder.query(
16869                &local_var_str
16870                    .into_iter()
16871                    .map(|p| ("name__ic".to_owned(), p.to_string()))
16872                    .collect::<Vec<(std::string::String, std::string::String)>>(),
16873            ),
16874            _ => local_var_req_builder.query(&[(
16875                "name__ic",
16876                &local_var_str
16877                    .into_iter()
16878                    .map(|p| p.to_string())
16879                    .collect::<Vec<String>>()
16880                    .join(",")
16881                    .to_string(),
16882            )]),
16883        };
16884    }
16885    if let Some(ref local_var_str) = name__ie {
16886        local_var_req_builder = match "multi" {
16887            "multi" => local_var_req_builder.query(
16888                &local_var_str
16889                    .into_iter()
16890                    .map(|p| ("name__ie".to_owned(), p.to_string()))
16891                    .collect::<Vec<(std::string::String, std::string::String)>>(),
16892            ),
16893            _ => local_var_req_builder.query(&[(
16894                "name__ie",
16895                &local_var_str
16896                    .into_iter()
16897                    .map(|p| p.to_string())
16898                    .collect::<Vec<String>>()
16899                    .join(",")
16900                    .to_string(),
16901            )]),
16902        };
16903    }
16904    if let Some(ref local_var_str) = name__iew {
16905        local_var_req_builder = match "multi" {
16906            "multi" => local_var_req_builder.query(
16907                &local_var_str
16908                    .into_iter()
16909                    .map(|p| ("name__iew".to_owned(), p.to_string()))
16910                    .collect::<Vec<(std::string::String, std::string::String)>>(),
16911            ),
16912            _ => local_var_req_builder.query(&[(
16913                "name__iew",
16914                &local_var_str
16915                    .into_iter()
16916                    .map(|p| p.to_string())
16917                    .collect::<Vec<String>>()
16918                    .join(",")
16919                    .to_string(),
16920            )]),
16921        };
16922    }
16923    if let Some(ref local_var_str) = name__iregex {
16924        local_var_req_builder = match "multi" {
16925            "multi" => local_var_req_builder.query(
16926                &local_var_str
16927                    .into_iter()
16928                    .map(|p| ("name__iregex".to_owned(), p.to_string()))
16929                    .collect::<Vec<(std::string::String, std::string::String)>>(),
16930            ),
16931            _ => local_var_req_builder.query(&[(
16932                "name__iregex",
16933                &local_var_str
16934                    .into_iter()
16935                    .map(|p| p.to_string())
16936                    .collect::<Vec<String>>()
16937                    .join(",")
16938                    .to_string(),
16939            )]),
16940        };
16941    }
16942    if let Some(ref local_var_str) = name__isw {
16943        local_var_req_builder = match "multi" {
16944            "multi" => local_var_req_builder.query(
16945                &local_var_str
16946                    .into_iter()
16947                    .map(|p| ("name__isw".to_owned(), p.to_string()))
16948                    .collect::<Vec<(std::string::String, std::string::String)>>(),
16949            ),
16950            _ => local_var_req_builder.query(&[(
16951                "name__isw",
16952                &local_var_str
16953                    .into_iter()
16954                    .map(|p| p.to_string())
16955                    .collect::<Vec<String>>()
16956                    .join(",")
16957                    .to_string(),
16958            )]),
16959        };
16960    }
16961    if let Some(ref local_var_str) = name__n {
16962        local_var_req_builder = match "multi" {
16963            "multi" => local_var_req_builder.query(
16964                &local_var_str
16965                    .into_iter()
16966                    .map(|p| ("name__n".to_owned(), p.to_string()))
16967                    .collect::<Vec<(std::string::String, std::string::String)>>(),
16968            ),
16969            _ => local_var_req_builder.query(&[(
16970                "name__n",
16971                &local_var_str
16972                    .into_iter()
16973                    .map(|p| p.to_string())
16974                    .collect::<Vec<String>>()
16975                    .join(",")
16976                    .to_string(),
16977            )]),
16978        };
16979    }
16980    if let Some(ref local_var_str) = name__nic {
16981        local_var_req_builder = match "multi" {
16982            "multi" => local_var_req_builder.query(
16983                &local_var_str
16984                    .into_iter()
16985                    .map(|p| ("name__nic".to_owned(), p.to_string()))
16986                    .collect::<Vec<(std::string::String, std::string::String)>>(),
16987            ),
16988            _ => local_var_req_builder.query(&[(
16989                "name__nic",
16990                &local_var_str
16991                    .into_iter()
16992                    .map(|p| p.to_string())
16993                    .collect::<Vec<String>>()
16994                    .join(",")
16995                    .to_string(),
16996            )]),
16997        };
16998    }
16999    if let Some(ref local_var_str) = name__nie {
17000        local_var_req_builder = match "multi" {
17001            "multi" => local_var_req_builder.query(
17002                &local_var_str
17003                    .into_iter()
17004                    .map(|p| ("name__nie".to_owned(), p.to_string()))
17005                    .collect::<Vec<(std::string::String, std::string::String)>>(),
17006            ),
17007            _ => local_var_req_builder.query(&[(
17008                "name__nie",
17009                &local_var_str
17010                    .into_iter()
17011                    .map(|p| p.to_string())
17012                    .collect::<Vec<String>>()
17013                    .join(",")
17014                    .to_string(),
17015            )]),
17016        };
17017    }
17018    if let Some(ref local_var_str) = name__niew {
17019        local_var_req_builder = match "multi" {
17020            "multi" => local_var_req_builder.query(
17021                &local_var_str
17022                    .into_iter()
17023                    .map(|p| ("name__niew".to_owned(), p.to_string()))
17024                    .collect::<Vec<(std::string::String, std::string::String)>>(),
17025            ),
17026            _ => local_var_req_builder.query(&[(
17027                "name__niew",
17028                &local_var_str
17029                    .into_iter()
17030                    .map(|p| p.to_string())
17031                    .collect::<Vec<String>>()
17032                    .join(",")
17033                    .to_string(),
17034            )]),
17035        };
17036    }
17037    if let Some(ref local_var_str) = name__nisw {
17038        local_var_req_builder = match "multi" {
17039            "multi" => local_var_req_builder.query(
17040                &local_var_str
17041                    .into_iter()
17042                    .map(|p| ("name__nisw".to_owned(), p.to_string()))
17043                    .collect::<Vec<(std::string::String, std::string::String)>>(),
17044            ),
17045            _ => local_var_req_builder.query(&[(
17046                "name__nisw",
17047                &local_var_str
17048                    .into_iter()
17049                    .map(|p| p.to_string())
17050                    .collect::<Vec<String>>()
17051                    .join(",")
17052                    .to_string(),
17053            )]),
17054        };
17055    }
17056    if let Some(ref local_var_str) = name__regex {
17057        local_var_req_builder = match "multi" {
17058            "multi" => local_var_req_builder.query(
17059                &local_var_str
17060                    .into_iter()
17061                    .map(|p| ("name__regex".to_owned(), p.to_string()))
17062                    .collect::<Vec<(std::string::String, std::string::String)>>(),
17063            ),
17064            _ => local_var_req_builder.query(&[(
17065                "name__regex",
17066                &local_var_str
17067                    .into_iter()
17068                    .map(|p| p.to_string())
17069                    .collect::<Vec<String>>()
17070                    .join(",")
17071                    .to_string(),
17072            )]),
17073        };
17074    }
17075    if let Some(ref local_var_str) = offset {
17076        local_var_req_builder =
17077            local_var_req_builder.query(&[("offset", &local_var_str.to_string())]);
17078    }
17079    if let Some(ref local_var_str) = ordering {
17080        local_var_req_builder =
17081            local_var_req_builder.query(&[("ordering", &local_var_str.to_string())]);
17082    }
17083    if let Some(ref local_var_str) = q {
17084        local_var_req_builder = local_var_req_builder.query(&[("q", &local_var_str.to_string())]);
17085    }
17086    if let Some(ref local_var_str) = slug {
17087        local_var_req_builder = match "multi" {
17088            "multi" => local_var_req_builder.query(
17089                &local_var_str
17090                    .into_iter()
17091                    .map(|p| ("slug".to_owned(), p.to_string()))
17092                    .collect::<Vec<(std::string::String, std::string::String)>>(),
17093            ),
17094            _ => local_var_req_builder.query(&[(
17095                "slug",
17096                &local_var_str
17097                    .into_iter()
17098                    .map(|p| p.to_string())
17099                    .collect::<Vec<String>>()
17100                    .join(",")
17101                    .to_string(),
17102            )]),
17103        };
17104    }
17105    if let Some(ref local_var_str) = slug__empty {
17106        local_var_req_builder =
17107            local_var_req_builder.query(&[("slug__empty", &local_var_str.to_string())]);
17108    }
17109    if let Some(ref local_var_str) = slug__ic {
17110        local_var_req_builder = match "multi" {
17111            "multi" => local_var_req_builder.query(
17112                &local_var_str
17113                    .into_iter()
17114                    .map(|p| ("slug__ic".to_owned(), p.to_string()))
17115                    .collect::<Vec<(std::string::String, std::string::String)>>(),
17116            ),
17117            _ => local_var_req_builder.query(&[(
17118                "slug__ic",
17119                &local_var_str
17120                    .into_iter()
17121                    .map(|p| p.to_string())
17122                    .collect::<Vec<String>>()
17123                    .join(",")
17124                    .to_string(),
17125            )]),
17126        };
17127    }
17128    if let Some(ref local_var_str) = slug__ie {
17129        local_var_req_builder = match "multi" {
17130            "multi" => local_var_req_builder.query(
17131                &local_var_str
17132                    .into_iter()
17133                    .map(|p| ("slug__ie".to_owned(), p.to_string()))
17134                    .collect::<Vec<(std::string::String, std::string::String)>>(),
17135            ),
17136            _ => local_var_req_builder.query(&[(
17137                "slug__ie",
17138                &local_var_str
17139                    .into_iter()
17140                    .map(|p| p.to_string())
17141                    .collect::<Vec<String>>()
17142                    .join(",")
17143                    .to_string(),
17144            )]),
17145        };
17146    }
17147    if let Some(ref local_var_str) = slug__iew {
17148        local_var_req_builder = match "multi" {
17149            "multi" => local_var_req_builder.query(
17150                &local_var_str
17151                    .into_iter()
17152                    .map(|p| ("slug__iew".to_owned(), p.to_string()))
17153                    .collect::<Vec<(std::string::String, std::string::String)>>(),
17154            ),
17155            _ => local_var_req_builder.query(&[(
17156                "slug__iew",
17157                &local_var_str
17158                    .into_iter()
17159                    .map(|p| p.to_string())
17160                    .collect::<Vec<String>>()
17161                    .join(",")
17162                    .to_string(),
17163            )]),
17164        };
17165    }
17166    if let Some(ref local_var_str) = slug__iregex {
17167        local_var_req_builder = match "multi" {
17168            "multi" => local_var_req_builder.query(
17169                &local_var_str
17170                    .into_iter()
17171                    .map(|p| ("slug__iregex".to_owned(), p.to_string()))
17172                    .collect::<Vec<(std::string::String, std::string::String)>>(),
17173            ),
17174            _ => local_var_req_builder.query(&[(
17175                "slug__iregex",
17176                &local_var_str
17177                    .into_iter()
17178                    .map(|p| p.to_string())
17179                    .collect::<Vec<String>>()
17180                    .join(",")
17181                    .to_string(),
17182            )]),
17183        };
17184    }
17185    if let Some(ref local_var_str) = slug__isw {
17186        local_var_req_builder = match "multi" {
17187            "multi" => local_var_req_builder.query(
17188                &local_var_str
17189                    .into_iter()
17190                    .map(|p| ("slug__isw".to_owned(), p.to_string()))
17191                    .collect::<Vec<(std::string::String, std::string::String)>>(),
17192            ),
17193            _ => local_var_req_builder.query(&[(
17194                "slug__isw",
17195                &local_var_str
17196                    .into_iter()
17197                    .map(|p| p.to_string())
17198                    .collect::<Vec<String>>()
17199                    .join(",")
17200                    .to_string(),
17201            )]),
17202        };
17203    }
17204    if let Some(ref local_var_str) = slug__n {
17205        local_var_req_builder = match "multi" {
17206            "multi" => local_var_req_builder.query(
17207                &local_var_str
17208                    .into_iter()
17209                    .map(|p| ("slug__n".to_owned(), p.to_string()))
17210                    .collect::<Vec<(std::string::String, std::string::String)>>(),
17211            ),
17212            _ => local_var_req_builder.query(&[(
17213                "slug__n",
17214                &local_var_str
17215                    .into_iter()
17216                    .map(|p| p.to_string())
17217                    .collect::<Vec<String>>()
17218                    .join(",")
17219                    .to_string(),
17220            )]),
17221        };
17222    }
17223    if let Some(ref local_var_str) = slug__nic {
17224        local_var_req_builder = match "multi" {
17225            "multi" => local_var_req_builder.query(
17226                &local_var_str
17227                    .into_iter()
17228                    .map(|p| ("slug__nic".to_owned(), p.to_string()))
17229                    .collect::<Vec<(std::string::String, std::string::String)>>(),
17230            ),
17231            _ => local_var_req_builder.query(&[(
17232                "slug__nic",
17233                &local_var_str
17234                    .into_iter()
17235                    .map(|p| p.to_string())
17236                    .collect::<Vec<String>>()
17237                    .join(",")
17238                    .to_string(),
17239            )]),
17240        };
17241    }
17242    if let Some(ref local_var_str) = slug__nie {
17243        local_var_req_builder = match "multi" {
17244            "multi" => local_var_req_builder.query(
17245                &local_var_str
17246                    .into_iter()
17247                    .map(|p| ("slug__nie".to_owned(), p.to_string()))
17248                    .collect::<Vec<(std::string::String, std::string::String)>>(),
17249            ),
17250            _ => local_var_req_builder.query(&[(
17251                "slug__nie",
17252                &local_var_str
17253                    .into_iter()
17254                    .map(|p| p.to_string())
17255                    .collect::<Vec<String>>()
17256                    .join(",")
17257                    .to_string(),
17258            )]),
17259        };
17260    }
17261    if let Some(ref local_var_str) = slug__niew {
17262        local_var_req_builder = match "multi" {
17263            "multi" => local_var_req_builder.query(
17264                &local_var_str
17265                    .into_iter()
17266                    .map(|p| ("slug__niew".to_owned(), p.to_string()))
17267                    .collect::<Vec<(std::string::String, std::string::String)>>(),
17268            ),
17269            _ => local_var_req_builder.query(&[(
17270                "slug__niew",
17271                &local_var_str
17272                    .into_iter()
17273                    .map(|p| p.to_string())
17274                    .collect::<Vec<String>>()
17275                    .join(",")
17276                    .to_string(),
17277            )]),
17278        };
17279    }
17280    if let Some(ref local_var_str) = slug__nisw {
17281        local_var_req_builder = match "multi" {
17282            "multi" => local_var_req_builder.query(
17283                &local_var_str
17284                    .into_iter()
17285                    .map(|p| ("slug__nisw".to_owned(), p.to_string()))
17286                    .collect::<Vec<(std::string::String, std::string::String)>>(),
17287            ),
17288            _ => local_var_req_builder.query(&[(
17289                "slug__nisw",
17290                &local_var_str
17291                    .into_iter()
17292                    .map(|p| p.to_string())
17293                    .collect::<Vec<String>>()
17294                    .join(",")
17295                    .to_string(),
17296            )]),
17297        };
17298    }
17299    if let Some(ref local_var_str) = slug__regex {
17300        local_var_req_builder = match "multi" {
17301            "multi" => local_var_req_builder.query(
17302                &local_var_str
17303                    .into_iter()
17304                    .map(|p| ("slug__regex".to_owned(), p.to_string()))
17305                    .collect::<Vec<(std::string::String, std::string::String)>>(),
17306            ),
17307            _ => local_var_req_builder.query(&[(
17308                "slug__regex",
17309                &local_var_str
17310                    .into_iter()
17311                    .map(|p| p.to_string())
17312                    .collect::<Vec<String>>()
17313                    .join(",")
17314                    .to_string(),
17315            )]),
17316        };
17317    }
17318    if let Some(ref local_var_str) = tag {
17319        local_var_req_builder = match "multi" {
17320            "multi" => local_var_req_builder.query(
17321                &local_var_str
17322                    .into_iter()
17323                    .map(|p| ("tag".to_owned(), p.to_string()))
17324                    .collect::<Vec<(std::string::String, std::string::String)>>(),
17325            ),
17326            _ => local_var_req_builder.query(&[(
17327                "tag",
17328                &local_var_str
17329                    .into_iter()
17330                    .map(|p| p.to_string())
17331                    .collect::<Vec<String>>()
17332                    .join(",")
17333                    .to_string(),
17334            )]),
17335        };
17336    }
17337    if let Some(ref local_var_str) = tag__n {
17338        local_var_req_builder = match "multi" {
17339            "multi" => local_var_req_builder.query(
17340                &local_var_str
17341                    .into_iter()
17342                    .map(|p| ("tag__n".to_owned(), p.to_string()))
17343                    .collect::<Vec<(std::string::String, std::string::String)>>(),
17344            ),
17345            _ => local_var_req_builder.query(&[(
17346                "tag__n",
17347                &local_var_str
17348                    .into_iter()
17349                    .map(|p| p.to_string())
17350                    .collect::<Vec<String>>()
17351                    .join(",")
17352                    .to_string(),
17353            )]),
17354        };
17355    }
17356    if let Some(ref local_var_str) = tag_id {
17357        local_var_req_builder = match "multi" {
17358            "multi" => local_var_req_builder.query(
17359                &local_var_str
17360                    .into_iter()
17361                    .map(|p| ("tag_id".to_owned(), p.to_string()))
17362                    .collect::<Vec<(std::string::String, std::string::String)>>(),
17363            ),
17364            _ => local_var_req_builder.query(&[(
17365                "tag_id",
17366                &local_var_str
17367                    .into_iter()
17368                    .map(|p| p.to_string())
17369                    .collect::<Vec<String>>()
17370                    .join(",")
17371                    .to_string(),
17372            )]),
17373        };
17374    }
17375    if let Some(ref local_var_str) = tag_id__n {
17376        local_var_req_builder = match "multi" {
17377            "multi" => local_var_req_builder.query(
17378                &local_var_str
17379                    .into_iter()
17380                    .map(|p| ("tag_id__n".to_owned(), p.to_string()))
17381                    .collect::<Vec<(std::string::String, std::string::String)>>(),
17382            ),
17383            _ => local_var_req_builder.query(&[(
17384                "tag_id__n",
17385                &local_var_str
17386                    .into_iter()
17387                    .map(|p| p.to_string())
17388                    .collect::<Vec<String>>()
17389                    .join(",")
17390                    .to_string(),
17391            )]),
17392        };
17393    }
17394    if let Some(ref local_var_str) = updated_by_request {
17395        local_var_req_builder =
17396            local_var_req_builder.query(&[("updated_by_request", &local_var_str.to_string())]);
17397    }
17398    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
17399        local_var_req_builder =
17400            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
17401    }
17402    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
17403        let local_var_key = local_var_apikey.key.clone();
17404        let local_var_value = match local_var_apikey.prefix {
17405            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
17406            None => local_var_key,
17407        };
17408        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
17409    };
17410
17411    let local_var_req = local_var_req_builder.build()?;
17412    let local_var_resp = local_var_client.execute(local_var_req).await?;
17413
17414    let local_var_status = local_var_resp.status();
17415    let local_var_content = local_var_resp.text().await?;
17416
17417    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
17418        serde_json::from_str(&local_var_content).map_err(Error::from)
17419    } else {
17420        let local_var_entity: Option<VpnTunnelGroupsListError> =
17421            serde_json::from_str(&local_var_content).ok();
17422        let local_var_error = ResponseContent {
17423            status: local_var_status,
17424            content: local_var_content,
17425            entity: local_var_entity,
17426        };
17427        Err(Error::ResponseError(local_var_error))
17428    }
17429}
17430
17431/// Patch a tunnel group object.
17432pub async fn vpn_tunnel_groups_partial_update(
17433    configuration: &configuration::Configuration,
17434    id: i32,
17435    patched_tunnel_group_request: Option<crate::models::PatchedTunnelGroupRequest>,
17436) -> Result<crate::models::TunnelGroup, Error<VpnTunnelGroupsPartialUpdateError>> {
17437    let local_var_configuration = configuration;
17438
17439    let local_var_client = &local_var_configuration.client;
17440
17441    let local_var_uri_str = format!(
17442        "{}/api/vpn/tunnel-groups/{id}/",
17443        local_var_configuration.base_path,
17444        id = id
17445    );
17446    let mut local_var_req_builder =
17447        local_var_client.request(reqwest::Method::PATCH, local_var_uri_str.as_str());
17448
17449    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
17450        local_var_req_builder =
17451            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
17452    }
17453    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
17454        let local_var_key = local_var_apikey.key.clone();
17455        let local_var_value = match local_var_apikey.prefix {
17456            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
17457            None => local_var_key,
17458        };
17459        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
17460    };
17461    local_var_req_builder = local_var_req_builder.json(&patched_tunnel_group_request);
17462
17463    let local_var_req = local_var_req_builder.build()?;
17464    let local_var_resp = local_var_client.execute(local_var_req).await?;
17465
17466    let local_var_status = local_var_resp.status();
17467    let local_var_content = local_var_resp.text().await?;
17468
17469    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
17470        serde_json::from_str(&local_var_content).map_err(Error::from)
17471    } else {
17472        let local_var_entity: Option<VpnTunnelGroupsPartialUpdateError> =
17473            serde_json::from_str(&local_var_content).ok();
17474        let local_var_error = ResponseContent {
17475            status: local_var_status,
17476            content: local_var_content,
17477            entity: local_var_entity,
17478        };
17479        Err(Error::ResponseError(local_var_error))
17480    }
17481}
17482
17483/// Get a tunnel group object.
17484pub async fn vpn_tunnel_groups_retrieve(
17485    configuration: &configuration::Configuration,
17486    id: i32,
17487) -> Result<crate::models::TunnelGroup, Error<VpnTunnelGroupsRetrieveError>> {
17488    let local_var_configuration = configuration;
17489
17490    let local_var_client = &local_var_configuration.client;
17491
17492    let local_var_uri_str = format!(
17493        "{}/api/vpn/tunnel-groups/{id}/",
17494        local_var_configuration.base_path,
17495        id = id
17496    );
17497    let mut local_var_req_builder =
17498        local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
17499
17500    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
17501        local_var_req_builder =
17502            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
17503    }
17504    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
17505        let local_var_key = local_var_apikey.key.clone();
17506        let local_var_value = match local_var_apikey.prefix {
17507            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
17508            None => local_var_key,
17509        };
17510        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
17511    };
17512
17513    let local_var_req = local_var_req_builder.build()?;
17514    let local_var_resp = local_var_client.execute(local_var_req).await?;
17515
17516    let local_var_status = local_var_resp.status();
17517    let local_var_content = local_var_resp.text().await?;
17518
17519    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
17520        serde_json::from_str(&local_var_content).map_err(Error::from)
17521    } else {
17522        let local_var_entity: Option<VpnTunnelGroupsRetrieveError> =
17523            serde_json::from_str(&local_var_content).ok();
17524        let local_var_error = ResponseContent {
17525            status: local_var_status,
17526            content: local_var_content,
17527            entity: local_var_entity,
17528        };
17529        Err(Error::ResponseError(local_var_error))
17530    }
17531}
17532
17533/// Put a tunnel group object.
17534pub async fn vpn_tunnel_groups_update(
17535    configuration: &configuration::Configuration,
17536    id: i32,
17537    tunnel_group_request: crate::models::TunnelGroupRequest,
17538) -> Result<crate::models::TunnelGroup, Error<VpnTunnelGroupsUpdateError>> {
17539    let local_var_configuration = configuration;
17540
17541    let local_var_client = &local_var_configuration.client;
17542
17543    let local_var_uri_str = format!(
17544        "{}/api/vpn/tunnel-groups/{id}/",
17545        local_var_configuration.base_path,
17546        id = id
17547    );
17548    let mut local_var_req_builder =
17549        local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());
17550
17551    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
17552        local_var_req_builder =
17553            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
17554    }
17555    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
17556        let local_var_key = local_var_apikey.key.clone();
17557        let local_var_value = match local_var_apikey.prefix {
17558            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
17559            None => local_var_key,
17560        };
17561        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
17562    };
17563    local_var_req_builder = local_var_req_builder.json(&tunnel_group_request);
17564
17565    let local_var_req = local_var_req_builder.build()?;
17566    let local_var_resp = local_var_client.execute(local_var_req).await?;
17567
17568    let local_var_status = local_var_resp.status();
17569    let local_var_content = local_var_resp.text().await?;
17570
17571    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
17572        serde_json::from_str(&local_var_content).map_err(Error::from)
17573    } else {
17574        let local_var_entity: Option<VpnTunnelGroupsUpdateError> =
17575            serde_json::from_str(&local_var_content).ok();
17576        let local_var_error = ResponseContent {
17577            status: local_var_status,
17578            content: local_var_content,
17579            entity: local_var_entity,
17580        };
17581        Err(Error::ResponseError(local_var_error))
17582    }
17583}
17584
17585/// Delete a list of tunnel termination objects.
17586pub async fn vpn_tunnel_terminations_bulk_destroy(
17587    configuration: &configuration::Configuration,
17588    tunnel_termination_request: Vec<crate::models::TunnelTerminationRequest>,
17589) -> Result<(), Error<VpnTunnelTerminationsBulkDestroyError>> {
17590    let local_var_configuration = configuration;
17591
17592    let local_var_client = &local_var_configuration.client;
17593
17594    let local_var_uri_str = format!(
17595        "{}/api/vpn/tunnel-terminations/",
17596        local_var_configuration.base_path
17597    );
17598    let mut local_var_req_builder =
17599        local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());
17600
17601    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
17602        local_var_req_builder =
17603            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
17604    }
17605    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
17606        let local_var_key = local_var_apikey.key.clone();
17607        let local_var_value = match local_var_apikey.prefix {
17608            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
17609            None => local_var_key,
17610        };
17611        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
17612    };
17613    local_var_req_builder = local_var_req_builder.json(&tunnel_termination_request);
17614
17615    let local_var_req = local_var_req_builder.build()?;
17616    let local_var_resp = local_var_client.execute(local_var_req).await?;
17617
17618    let local_var_status = local_var_resp.status();
17619    let local_var_content = local_var_resp.text().await?;
17620
17621    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
17622        Ok(())
17623    } else {
17624        let local_var_entity: Option<VpnTunnelTerminationsBulkDestroyError> =
17625            serde_json::from_str(&local_var_content).ok();
17626        let local_var_error = ResponseContent {
17627            status: local_var_status,
17628            content: local_var_content,
17629            entity: local_var_entity,
17630        };
17631        Err(Error::ResponseError(local_var_error))
17632    }
17633}
17634
17635/// Patch a list of tunnel termination objects.
17636pub async fn vpn_tunnel_terminations_bulk_partial_update(
17637    configuration: &configuration::Configuration,
17638    tunnel_termination_request: Vec<crate::models::TunnelTerminationRequest>,
17639) -> Result<Vec<crate::models::TunnelTermination>, Error<VpnTunnelTerminationsBulkPartialUpdateError>>
17640{
17641    let local_var_configuration = configuration;
17642
17643    let local_var_client = &local_var_configuration.client;
17644
17645    let local_var_uri_str = format!(
17646        "{}/api/vpn/tunnel-terminations/",
17647        local_var_configuration.base_path
17648    );
17649    let mut local_var_req_builder =
17650        local_var_client.request(reqwest::Method::PATCH, local_var_uri_str.as_str());
17651
17652    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
17653        local_var_req_builder =
17654            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
17655    }
17656    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
17657        let local_var_key = local_var_apikey.key.clone();
17658        let local_var_value = match local_var_apikey.prefix {
17659            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
17660            None => local_var_key,
17661        };
17662        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
17663    };
17664    local_var_req_builder = local_var_req_builder.json(&tunnel_termination_request);
17665
17666    let local_var_req = local_var_req_builder.build()?;
17667    let local_var_resp = local_var_client.execute(local_var_req).await?;
17668
17669    let local_var_status = local_var_resp.status();
17670    let local_var_content = local_var_resp.text().await?;
17671
17672    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
17673        serde_json::from_str(&local_var_content).map_err(Error::from)
17674    } else {
17675        let local_var_entity: Option<VpnTunnelTerminationsBulkPartialUpdateError> =
17676            serde_json::from_str(&local_var_content).ok();
17677        let local_var_error = ResponseContent {
17678            status: local_var_status,
17679            content: local_var_content,
17680            entity: local_var_entity,
17681        };
17682        Err(Error::ResponseError(local_var_error))
17683    }
17684}
17685
17686/// Put a list of tunnel termination objects.
17687pub async fn vpn_tunnel_terminations_bulk_update(
17688    configuration: &configuration::Configuration,
17689    tunnel_termination_request: Vec<crate::models::TunnelTerminationRequest>,
17690) -> Result<Vec<crate::models::TunnelTermination>, Error<VpnTunnelTerminationsBulkUpdateError>> {
17691    let local_var_configuration = configuration;
17692
17693    let local_var_client = &local_var_configuration.client;
17694
17695    let local_var_uri_str = format!(
17696        "{}/api/vpn/tunnel-terminations/",
17697        local_var_configuration.base_path
17698    );
17699    let mut local_var_req_builder =
17700        local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());
17701
17702    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
17703        local_var_req_builder =
17704            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
17705    }
17706    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
17707        let local_var_key = local_var_apikey.key.clone();
17708        let local_var_value = match local_var_apikey.prefix {
17709            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
17710            None => local_var_key,
17711        };
17712        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
17713    };
17714    local_var_req_builder = local_var_req_builder.json(&tunnel_termination_request);
17715
17716    let local_var_req = local_var_req_builder.build()?;
17717    let local_var_resp = local_var_client.execute(local_var_req).await?;
17718
17719    let local_var_status = local_var_resp.status();
17720    let local_var_content = local_var_resp.text().await?;
17721
17722    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
17723        serde_json::from_str(&local_var_content).map_err(Error::from)
17724    } else {
17725        let local_var_entity: Option<VpnTunnelTerminationsBulkUpdateError> =
17726            serde_json::from_str(&local_var_content).ok();
17727        let local_var_error = ResponseContent {
17728            status: local_var_status,
17729            content: local_var_content,
17730            entity: local_var_entity,
17731        };
17732        Err(Error::ResponseError(local_var_error))
17733    }
17734}
17735
17736/// Post a list of tunnel termination objects.
17737pub async fn vpn_tunnel_terminations_create(
17738    configuration: &configuration::Configuration,
17739    writable_tunnel_termination_request: crate::models::WritableTunnelTerminationRequest,
17740) -> Result<crate::models::TunnelTermination, Error<VpnTunnelTerminationsCreateError>> {
17741    let local_var_configuration = configuration;
17742
17743    let local_var_client = &local_var_configuration.client;
17744
17745    let local_var_uri_str = format!(
17746        "{}/api/vpn/tunnel-terminations/",
17747        local_var_configuration.base_path
17748    );
17749    let mut local_var_req_builder =
17750        local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
17751
17752    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
17753        local_var_req_builder =
17754            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
17755    }
17756    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
17757        let local_var_key = local_var_apikey.key.clone();
17758        let local_var_value = match local_var_apikey.prefix {
17759            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
17760            None => local_var_key,
17761        };
17762        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
17763    };
17764    local_var_req_builder = local_var_req_builder.json(&writable_tunnel_termination_request);
17765
17766    let local_var_req = local_var_req_builder.build()?;
17767    let local_var_resp = local_var_client.execute(local_var_req).await?;
17768
17769    let local_var_status = local_var_resp.status();
17770    let local_var_content = local_var_resp.text().await?;
17771
17772    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
17773        serde_json::from_str(&local_var_content).map_err(Error::from)
17774    } else {
17775        let local_var_entity: Option<VpnTunnelTerminationsCreateError> =
17776            serde_json::from_str(&local_var_content).ok();
17777        let local_var_error = ResponseContent {
17778            status: local_var_status,
17779            content: local_var_content,
17780            entity: local_var_entity,
17781        };
17782        Err(Error::ResponseError(local_var_error))
17783    }
17784}
17785
17786/// Delete a tunnel termination object.
17787pub async fn vpn_tunnel_terminations_destroy(
17788    configuration: &configuration::Configuration,
17789    id: i32,
17790) -> Result<(), Error<VpnTunnelTerminationsDestroyError>> {
17791    let local_var_configuration = configuration;
17792
17793    let local_var_client = &local_var_configuration.client;
17794
17795    let local_var_uri_str = format!(
17796        "{}/api/vpn/tunnel-terminations/{id}/",
17797        local_var_configuration.base_path,
17798        id = id
17799    );
17800    let mut local_var_req_builder =
17801        local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());
17802
17803    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
17804        local_var_req_builder =
17805            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
17806    }
17807    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
17808        let local_var_key = local_var_apikey.key.clone();
17809        let local_var_value = match local_var_apikey.prefix {
17810            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
17811            None => local_var_key,
17812        };
17813        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
17814    };
17815
17816    let local_var_req = local_var_req_builder.build()?;
17817    let local_var_resp = local_var_client.execute(local_var_req).await?;
17818
17819    let local_var_status = local_var_resp.status();
17820    let local_var_content = local_var_resp.text().await?;
17821
17822    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
17823        Ok(())
17824    } else {
17825        let local_var_entity: Option<VpnTunnelTerminationsDestroyError> =
17826            serde_json::from_str(&local_var_content).ok();
17827        let local_var_error = ResponseContent {
17828            status: local_var_status,
17829            content: local_var_content,
17830            entity: local_var_entity,
17831        };
17832        Err(Error::ResponseError(local_var_error))
17833    }
17834}
17835
17836/// Get a list of tunnel termination objects.
17837pub async fn vpn_tunnel_terminations_list(
17838    configuration: &configuration::Configuration,
17839    created: Option<Vec<String>>,
17840    created__empty: Option<Vec<String>>,
17841    created__gt: Option<Vec<String>>,
17842    created__gte: Option<Vec<String>>,
17843    created__lt: Option<Vec<String>>,
17844    created__lte: Option<Vec<String>>,
17845    created__n: Option<Vec<String>>,
17846    created_by_request: Option<&str>,
17847    id: Option<Vec<i32>>,
17848    id__empty: Option<bool>,
17849    id__gt: Option<Vec<i32>>,
17850    id__gte: Option<Vec<i32>>,
17851    id__lt: Option<Vec<i32>>,
17852    id__lte: Option<Vec<i32>>,
17853    id__n: Option<Vec<i32>>,
17854    interface: Option<Vec<String>>,
17855    interface__n: Option<Vec<String>>,
17856    interface_id: Option<Vec<i32>>,
17857    interface_id__n: Option<Vec<i32>>,
17858    last_updated: Option<Vec<String>>,
17859    last_updated__empty: Option<Vec<String>>,
17860    last_updated__gt: Option<Vec<String>>,
17861    last_updated__gte: Option<Vec<String>>,
17862    last_updated__lt: Option<Vec<String>>,
17863    last_updated__lte: Option<Vec<String>>,
17864    last_updated__n: Option<Vec<String>>,
17865    limit: Option<i32>,
17866    modified_by_request: Option<&str>,
17867    offset: Option<i32>,
17868    ordering: Option<&str>,
17869    outside_ip_id: Option<Vec<i32>>,
17870    outside_ip_id__n: Option<Vec<i32>>,
17871    q: Option<&str>,
17872    role: Option<Vec<String>>,
17873    role__empty: Option<bool>,
17874    role__ic: Option<Vec<String>>,
17875    role__ie: Option<Vec<String>>,
17876    role__iew: Option<Vec<String>>,
17877    role__iregex: Option<Vec<String>>,
17878    role__isw: Option<Vec<String>>,
17879    role__n: Option<Vec<String>>,
17880    role__nic: Option<Vec<String>>,
17881    role__nie: Option<Vec<String>>,
17882    role__niew: Option<Vec<String>>,
17883    role__nisw: Option<Vec<String>>,
17884    role__regex: Option<Vec<String>>,
17885    tag: Option<Vec<String>>,
17886    tag__n: Option<Vec<String>>,
17887    tag_id: Option<Vec<i32>>,
17888    tag_id__n: Option<Vec<i32>>,
17889    termination_id: Option<Vec<i32>>,
17890    termination_id__empty: Option<bool>,
17891    termination_id__gt: Option<Vec<i32>>,
17892    termination_id__gte: Option<Vec<i32>>,
17893    termination_id__lt: Option<Vec<i32>>,
17894    termination_id__lte: Option<Vec<i32>>,
17895    termination_id__n: Option<Vec<i32>>,
17896    termination_type: Option<&str>,
17897    termination_type__n: Option<&str>,
17898    tunnel: Option<Vec<String>>,
17899    tunnel__n: Option<Vec<String>>,
17900    tunnel_id: Option<Vec<i32>>,
17901    tunnel_id__n: Option<Vec<i32>>,
17902    updated_by_request: Option<&str>,
17903    vminterface: Option<Vec<String>>,
17904    vminterface__n: Option<Vec<String>>,
17905    vminterface_id: Option<Vec<i32>>,
17906    vminterface_id__n: Option<Vec<i32>>,
17907) -> Result<crate::models::PaginatedTunnelTerminationList, Error<VpnTunnelTerminationsListError>> {
17908    let local_var_configuration = configuration;
17909
17910    let local_var_client = &local_var_configuration.client;
17911
17912    let local_var_uri_str = format!(
17913        "{}/api/vpn/tunnel-terminations/",
17914        local_var_configuration.base_path
17915    );
17916    let mut local_var_req_builder =
17917        local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
17918
17919    if let Some(ref local_var_str) = created {
17920        local_var_req_builder = match "multi" {
17921            "multi" => local_var_req_builder.query(
17922                &local_var_str
17923                    .into_iter()
17924                    .map(|p| ("created".to_owned(), p.to_string()))
17925                    .collect::<Vec<(std::string::String, std::string::String)>>(),
17926            ),
17927            _ => local_var_req_builder.query(&[(
17928                "created",
17929                &local_var_str
17930                    .into_iter()
17931                    .map(|p| p.to_string())
17932                    .collect::<Vec<String>>()
17933                    .join(",")
17934                    .to_string(),
17935            )]),
17936        };
17937    }
17938    if let Some(ref local_var_str) = created__empty {
17939        local_var_req_builder = match "multi" {
17940            "multi" => local_var_req_builder.query(
17941                &local_var_str
17942                    .into_iter()
17943                    .map(|p| ("created__empty".to_owned(), p.to_string()))
17944                    .collect::<Vec<(std::string::String, std::string::String)>>(),
17945            ),
17946            _ => local_var_req_builder.query(&[(
17947                "created__empty",
17948                &local_var_str
17949                    .into_iter()
17950                    .map(|p| p.to_string())
17951                    .collect::<Vec<String>>()
17952                    .join(",")
17953                    .to_string(),
17954            )]),
17955        };
17956    }
17957    if let Some(ref local_var_str) = created__gt {
17958        local_var_req_builder = match "multi" {
17959            "multi" => local_var_req_builder.query(
17960                &local_var_str
17961                    .into_iter()
17962                    .map(|p| ("created__gt".to_owned(), p.to_string()))
17963                    .collect::<Vec<(std::string::String, std::string::String)>>(),
17964            ),
17965            _ => local_var_req_builder.query(&[(
17966                "created__gt",
17967                &local_var_str
17968                    .into_iter()
17969                    .map(|p| p.to_string())
17970                    .collect::<Vec<String>>()
17971                    .join(",")
17972                    .to_string(),
17973            )]),
17974        };
17975    }
17976    if let Some(ref local_var_str) = created__gte {
17977        local_var_req_builder = match "multi" {
17978            "multi" => local_var_req_builder.query(
17979                &local_var_str
17980                    .into_iter()
17981                    .map(|p| ("created__gte".to_owned(), p.to_string()))
17982                    .collect::<Vec<(std::string::String, std::string::String)>>(),
17983            ),
17984            _ => local_var_req_builder.query(&[(
17985                "created__gte",
17986                &local_var_str
17987                    .into_iter()
17988                    .map(|p| p.to_string())
17989                    .collect::<Vec<String>>()
17990                    .join(",")
17991                    .to_string(),
17992            )]),
17993        };
17994    }
17995    if let Some(ref local_var_str) = created__lt {
17996        local_var_req_builder = match "multi" {
17997            "multi" => local_var_req_builder.query(
17998                &local_var_str
17999                    .into_iter()
18000                    .map(|p| ("created__lt".to_owned(), p.to_string()))
18001                    .collect::<Vec<(std::string::String, std::string::String)>>(),
18002            ),
18003            _ => local_var_req_builder.query(&[(
18004                "created__lt",
18005                &local_var_str
18006                    .into_iter()
18007                    .map(|p| p.to_string())
18008                    .collect::<Vec<String>>()
18009                    .join(",")
18010                    .to_string(),
18011            )]),
18012        };
18013    }
18014    if let Some(ref local_var_str) = created__lte {
18015        local_var_req_builder = match "multi" {
18016            "multi" => local_var_req_builder.query(
18017                &local_var_str
18018                    .into_iter()
18019                    .map(|p| ("created__lte".to_owned(), p.to_string()))
18020                    .collect::<Vec<(std::string::String, std::string::String)>>(),
18021            ),
18022            _ => local_var_req_builder.query(&[(
18023                "created__lte",
18024                &local_var_str
18025                    .into_iter()
18026                    .map(|p| p.to_string())
18027                    .collect::<Vec<String>>()
18028                    .join(",")
18029                    .to_string(),
18030            )]),
18031        };
18032    }
18033    if let Some(ref local_var_str) = created__n {
18034        local_var_req_builder = match "multi" {
18035            "multi" => local_var_req_builder.query(
18036                &local_var_str
18037                    .into_iter()
18038                    .map(|p| ("created__n".to_owned(), p.to_string()))
18039                    .collect::<Vec<(std::string::String, std::string::String)>>(),
18040            ),
18041            _ => local_var_req_builder.query(&[(
18042                "created__n",
18043                &local_var_str
18044                    .into_iter()
18045                    .map(|p| p.to_string())
18046                    .collect::<Vec<String>>()
18047                    .join(",")
18048                    .to_string(),
18049            )]),
18050        };
18051    }
18052    if let Some(ref local_var_str) = created_by_request {
18053        local_var_req_builder =
18054            local_var_req_builder.query(&[("created_by_request", &local_var_str.to_string())]);
18055    }
18056    if let Some(ref local_var_str) = id {
18057        local_var_req_builder = match "multi" {
18058            "multi" => local_var_req_builder.query(
18059                &local_var_str
18060                    .into_iter()
18061                    .map(|p| ("id".to_owned(), p.to_string()))
18062                    .collect::<Vec<(std::string::String, std::string::String)>>(),
18063            ),
18064            _ => local_var_req_builder.query(&[(
18065                "id",
18066                &local_var_str
18067                    .into_iter()
18068                    .map(|p| p.to_string())
18069                    .collect::<Vec<String>>()
18070                    .join(",")
18071                    .to_string(),
18072            )]),
18073        };
18074    }
18075    if let Some(ref local_var_str) = id__empty {
18076        local_var_req_builder =
18077            local_var_req_builder.query(&[("id__empty", &local_var_str.to_string())]);
18078    }
18079    if let Some(ref local_var_str) = id__gt {
18080        local_var_req_builder = match "multi" {
18081            "multi" => local_var_req_builder.query(
18082                &local_var_str
18083                    .into_iter()
18084                    .map(|p| ("id__gt".to_owned(), p.to_string()))
18085                    .collect::<Vec<(std::string::String, std::string::String)>>(),
18086            ),
18087            _ => local_var_req_builder.query(&[(
18088                "id__gt",
18089                &local_var_str
18090                    .into_iter()
18091                    .map(|p| p.to_string())
18092                    .collect::<Vec<String>>()
18093                    .join(",")
18094                    .to_string(),
18095            )]),
18096        };
18097    }
18098    if let Some(ref local_var_str) = id__gte {
18099        local_var_req_builder = match "multi" {
18100            "multi" => local_var_req_builder.query(
18101                &local_var_str
18102                    .into_iter()
18103                    .map(|p| ("id__gte".to_owned(), p.to_string()))
18104                    .collect::<Vec<(std::string::String, std::string::String)>>(),
18105            ),
18106            _ => local_var_req_builder.query(&[(
18107                "id__gte",
18108                &local_var_str
18109                    .into_iter()
18110                    .map(|p| p.to_string())
18111                    .collect::<Vec<String>>()
18112                    .join(",")
18113                    .to_string(),
18114            )]),
18115        };
18116    }
18117    if let Some(ref local_var_str) = id__lt {
18118        local_var_req_builder = match "multi" {
18119            "multi" => local_var_req_builder.query(
18120                &local_var_str
18121                    .into_iter()
18122                    .map(|p| ("id__lt".to_owned(), p.to_string()))
18123                    .collect::<Vec<(std::string::String, std::string::String)>>(),
18124            ),
18125            _ => local_var_req_builder.query(&[(
18126                "id__lt",
18127                &local_var_str
18128                    .into_iter()
18129                    .map(|p| p.to_string())
18130                    .collect::<Vec<String>>()
18131                    .join(",")
18132                    .to_string(),
18133            )]),
18134        };
18135    }
18136    if let Some(ref local_var_str) = id__lte {
18137        local_var_req_builder = match "multi" {
18138            "multi" => local_var_req_builder.query(
18139                &local_var_str
18140                    .into_iter()
18141                    .map(|p| ("id__lte".to_owned(), p.to_string()))
18142                    .collect::<Vec<(std::string::String, std::string::String)>>(),
18143            ),
18144            _ => local_var_req_builder.query(&[(
18145                "id__lte",
18146                &local_var_str
18147                    .into_iter()
18148                    .map(|p| p.to_string())
18149                    .collect::<Vec<String>>()
18150                    .join(",")
18151                    .to_string(),
18152            )]),
18153        };
18154    }
18155    if let Some(ref local_var_str) = id__n {
18156        local_var_req_builder = match "multi" {
18157            "multi" => local_var_req_builder.query(
18158                &local_var_str
18159                    .into_iter()
18160                    .map(|p| ("id__n".to_owned(), p.to_string()))
18161                    .collect::<Vec<(std::string::String, std::string::String)>>(),
18162            ),
18163            _ => local_var_req_builder.query(&[(
18164                "id__n",
18165                &local_var_str
18166                    .into_iter()
18167                    .map(|p| p.to_string())
18168                    .collect::<Vec<String>>()
18169                    .join(",")
18170                    .to_string(),
18171            )]),
18172        };
18173    }
18174    if let Some(ref local_var_str) = interface {
18175        local_var_req_builder = match "multi" {
18176            "multi" => local_var_req_builder.query(
18177                &local_var_str
18178                    .into_iter()
18179                    .map(|p| ("interface".to_owned(), p.to_string()))
18180                    .collect::<Vec<(std::string::String, std::string::String)>>(),
18181            ),
18182            _ => local_var_req_builder.query(&[(
18183                "interface",
18184                &local_var_str
18185                    .into_iter()
18186                    .map(|p| p.to_string())
18187                    .collect::<Vec<String>>()
18188                    .join(",")
18189                    .to_string(),
18190            )]),
18191        };
18192    }
18193    if let Some(ref local_var_str) = interface__n {
18194        local_var_req_builder = match "multi" {
18195            "multi" => local_var_req_builder.query(
18196                &local_var_str
18197                    .into_iter()
18198                    .map(|p| ("interface__n".to_owned(), p.to_string()))
18199                    .collect::<Vec<(std::string::String, std::string::String)>>(),
18200            ),
18201            _ => local_var_req_builder.query(&[(
18202                "interface__n",
18203                &local_var_str
18204                    .into_iter()
18205                    .map(|p| p.to_string())
18206                    .collect::<Vec<String>>()
18207                    .join(",")
18208                    .to_string(),
18209            )]),
18210        };
18211    }
18212    if let Some(ref local_var_str) = interface_id {
18213        local_var_req_builder = match "multi" {
18214            "multi" => local_var_req_builder.query(
18215                &local_var_str
18216                    .into_iter()
18217                    .map(|p| ("interface_id".to_owned(), p.to_string()))
18218                    .collect::<Vec<(std::string::String, std::string::String)>>(),
18219            ),
18220            _ => local_var_req_builder.query(&[(
18221                "interface_id",
18222                &local_var_str
18223                    .into_iter()
18224                    .map(|p| p.to_string())
18225                    .collect::<Vec<String>>()
18226                    .join(",")
18227                    .to_string(),
18228            )]),
18229        };
18230    }
18231    if let Some(ref local_var_str) = interface_id__n {
18232        local_var_req_builder = match "multi" {
18233            "multi" => local_var_req_builder.query(
18234                &local_var_str
18235                    .into_iter()
18236                    .map(|p| ("interface_id__n".to_owned(), p.to_string()))
18237                    .collect::<Vec<(std::string::String, std::string::String)>>(),
18238            ),
18239            _ => local_var_req_builder.query(&[(
18240                "interface_id__n",
18241                &local_var_str
18242                    .into_iter()
18243                    .map(|p| p.to_string())
18244                    .collect::<Vec<String>>()
18245                    .join(",")
18246                    .to_string(),
18247            )]),
18248        };
18249    }
18250    if let Some(ref local_var_str) = last_updated {
18251        local_var_req_builder = match "multi" {
18252            "multi" => local_var_req_builder.query(
18253                &local_var_str
18254                    .into_iter()
18255                    .map(|p| ("last_updated".to_owned(), p.to_string()))
18256                    .collect::<Vec<(std::string::String, std::string::String)>>(),
18257            ),
18258            _ => local_var_req_builder.query(&[(
18259                "last_updated",
18260                &local_var_str
18261                    .into_iter()
18262                    .map(|p| p.to_string())
18263                    .collect::<Vec<String>>()
18264                    .join(",")
18265                    .to_string(),
18266            )]),
18267        };
18268    }
18269    if let Some(ref local_var_str) = last_updated__empty {
18270        local_var_req_builder = match "multi" {
18271            "multi" => local_var_req_builder.query(
18272                &local_var_str
18273                    .into_iter()
18274                    .map(|p| ("last_updated__empty".to_owned(), p.to_string()))
18275                    .collect::<Vec<(std::string::String, std::string::String)>>(),
18276            ),
18277            _ => local_var_req_builder.query(&[(
18278                "last_updated__empty",
18279                &local_var_str
18280                    .into_iter()
18281                    .map(|p| p.to_string())
18282                    .collect::<Vec<String>>()
18283                    .join(",")
18284                    .to_string(),
18285            )]),
18286        };
18287    }
18288    if let Some(ref local_var_str) = last_updated__gt {
18289        local_var_req_builder = match "multi" {
18290            "multi" => local_var_req_builder.query(
18291                &local_var_str
18292                    .into_iter()
18293                    .map(|p| ("last_updated__gt".to_owned(), p.to_string()))
18294                    .collect::<Vec<(std::string::String, std::string::String)>>(),
18295            ),
18296            _ => local_var_req_builder.query(&[(
18297                "last_updated__gt",
18298                &local_var_str
18299                    .into_iter()
18300                    .map(|p| p.to_string())
18301                    .collect::<Vec<String>>()
18302                    .join(",")
18303                    .to_string(),
18304            )]),
18305        };
18306    }
18307    if let Some(ref local_var_str) = last_updated__gte {
18308        local_var_req_builder = match "multi" {
18309            "multi" => local_var_req_builder.query(
18310                &local_var_str
18311                    .into_iter()
18312                    .map(|p| ("last_updated__gte".to_owned(), p.to_string()))
18313                    .collect::<Vec<(std::string::String, std::string::String)>>(),
18314            ),
18315            _ => local_var_req_builder.query(&[(
18316                "last_updated__gte",
18317                &local_var_str
18318                    .into_iter()
18319                    .map(|p| p.to_string())
18320                    .collect::<Vec<String>>()
18321                    .join(",")
18322                    .to_string(),
18323            )]),
18324        };
18325    }
18326    if let Some(ref local_var_str) = last_updated__lt {
18327        local_var_req_builder = match "multi" {
18328            "multi" => local_var_req_builder.query(
18329                &local_var_str
18330                    .into_iter()
18331                    .map(|p| ("last_updated__lt".to_owned(), p.to_string()))
18332                    .collect::<Vec<(std::string::String, std::string::String)>>(),
18333            ),
18334            _ => local_var_req_builder.query(&[(
18335                "last_updated__lt",
18336                &local_var_str
18337                    .into_iter()
18338                    .map(|p| p.to_string())
18339                    .collect::<Vec<String>>()
18340                    .join(",")
18341                    .to_string(),
18342            )]),
18343        };
18344    }
18345    if let Some(ref local_var_str) = last_updated__lte {
18346        local_var_req_builder = match "multi" {
18347            "multi" => local_var_req_builder.query(
18348                &local_var_str
18349                    .into_iter()
18350                    .map(|p| ("last_updated__lte".to_owned(), p.to_string()))
18351                    .collect::<Vec<(std::string::String, std::string::String)>>(),
18352            ),
18353            _ => local_var_req_builder.query(&[(
18354                "last_updated__lte",
18355                &local_var_str
18356                    .into_iter()
18357                    .map(|p| p.to_string())
18358                    .collect::<Vec<String>>()
18359                    .join(",")
18360                    .to_string(),
18361            )]),
18362        };
18363    }
18364    if let Some(ref local_var_str) = last_updated__n {
18365        local_var_req_builder = match "multi" {
18366            "multi" => local_var_req_builder.query(
18367                &local_var_str
18368                    .into_iter()
18369                    .map(|p| ("last_updated__n".to_owned(), p.to_string()))
18370                    .collect::<Vec<(std::string::String, std::string::String)>>(),
18371            ),
18372            _ => local_var_req_builder.query(&[(
18373                "last_updated__n",
18374                &local_var_str
18375                    .into_iter()
18376                    .map(|p| p.to_string())
18377                    .collect::<Vec<String>>()
18378                    .join(",")
18379                    .to_string(),
18380            )]),
18381        };
18382    }
18383    if let Some(ref local_var_str) = limit {
18384        local_var_req_builder =
18385            local_var_req_builder.query(&[("limit", &local_var_str.to_string())]);
18386    }
18387    if let Some(ref local_var_str) = modified_by_request {
18388        local_var_req_builder =
18389            local_var_req_builder.query(&[("modified_by_request", &local_var_str.to_string())]);
18390    }
18391    if let Some(ref local_var_str) = offset {
18392        local_var_req_builder =
18393            local_var_req_builder.query(&[("offset", &local_var_str.to_string())]);
18394    }
18395    if let Some(ref local_var_str) = ordering {
18396        local_var_req_builder =
18397            local_var_req_builder.query(&[("ordering", &local_var_str.to_string())]);
18398    }
18399    if let Some(ref local_var_str) = outside_ip_id {
18400        local_var_req_builder = match "multi" {
18401            "multi" => local_var_req_builder.query(
18402                &local_var_str
18403                    .into_iter()
18404                    .map(|p| ("outside_ip_id".to_owned(), p.to_string()))
18405                    .collect::<Vec<(std::string::String, std::string::String)>>(),
18406            ),
18407            _ => local_var_req_builder.query(&[(
18408                "outside_ip_id",
18409                &local_var_str
18410                    .into_iter()
18411                    .map(|p| p.to_string())
18412                    .collect::<Vec<String>>()
18413                    .join(",")
18414                    .to_string(),
18415            )]),
18416        };
18417    }
18418    if let Some(ref local_var_str) = outside_ip_id__n {
18419        local_var_req_builder = match "multi" {
18420            "multi" => local_var_req_builder.query(
18421                &local_var_str
18422                    .into_iter()
18423                    .map(|p| ("outside_ip_id__n".to_owned(), p.to_string()))
18424                    .collect::<Vec<(std::string::String, std::string::String)>>(),
18425            ),
18426            _ => local_var_req_builder.query(&[(
18427                "outside_ip_id__n",
18428                &local_var_str
18429                    .into_iter()
18430                    .map(|p| p.to_string())
18431                    .collect::<Vec<String>>()
18432                    .join(",")
18433                    .to_string(),
18434            )]),
18435        };
18436    }
18437    if let Some(ref local_var_str) = q {
18438        local_var_req_builder = local_var_req_builder.query(&[("q", &local_var_str.to_string())]);
18439    }
18440    if let Some(ref local_var_str) = role {
18441        local_var_req_builder = match "multi" {
18442            "multi" => local_var_req_builder.query(
18443                &local_var_str
18444                    .into_iter()
18445                    .map(|p| ("role".to_owned(), p.to_string()))
18446                    .collect::<Vec<(std::string::String, std::string::String)>>(),
18447            ),
18448            _ => local_var_req_builder.query(&[(
18449                "role",
18450                &local_var_str
18451                    .into_iter()
18452                    .map(|p| p.to_string())
18453                    .collect::<Vec<String>>()
18454                    .join(",")
18455                    .to_string(),
18456            )]),
18457        };
18458    }
18459    if let Some(ref local_var_str) = role__empty {
18460        local_var_req_builder =
18461            local_var_req_builder.query(&[("role__empty", &local_var_str.to_string())]);
18462    }
18463    if let Some(ref local_var_str) = role__ic {
18464        local_var_req_builder = match "multi" {
18465            "multi" => local_var_req_builder.query(
18466                &local_var_str
18467                    .into_iter()
18468                    .map(|p| ("role__ic".to_owned(), p.to_string()))
18469                    .collect::<Vec<(std::string::String, std::string::String)>>(),
18470            ),
18471            _ => local_var_req_builder.query(&[(
18472                "role__ic",
18473                &local_var_str
18474                    .into_iter()
18475                    .map(|p| p.to_string())
18476                    .collect::<Vec<String>>()
18477                    .join(",")
18478                    .to_string(),
18479            )]),
18480        };
18481    }
18482    if let Some(ref local_var_str) = role__ie {
18483        local_var_req_builder = match "multi" {
18484            "multi" => local_var_req_builder.query(
18485                &local_var_str
18486                    .into_iter()
18487                    .map(|p| ("role__ie".to_owned(), p.to_string()))
18488                    .collect::<Vec<(std::string::String, std::string::String)>>(),
18489            ),
18490            _ => local_var_req_builder.query(&[(
18491                "role__ie",
18492                &local_var_str
18493                    .into_iter()
18494                    .map(|p| p.to_string())
18495                    .collect::<Vec<String>>()
18496                    .join(",")
18497                    .to_string(),
18498            )]),
18499        };
18500    }
18501    if let Some(ref local_var_str) = role__iew {
18502        local_var_req_builder = match "multi" {
18503            "multi" => local_var_req_builder.query(
18504                &local_var_str
18505                    .into_iter()
18506                    .map(|p| ("role__iew".to_owned(), p.to_string()))
18507                    .collect::<Vec<(std::string::String, std::string::String)>>(),
18508            ),
18509            _ => local_var_req_builder.query(&[(
18510                "role__iew",
18511                &local_var_str
18512                    .into_iter()
18513                    .map(|p| p.to_string())
18514                    .collect::<Vec<String>>()
18515                    .join(",")
18516                    .to_string(),
18517            )]),
18518        };
18519    }
18520    if let Some(ref local_var_str) = role__iregex {
18521        local_var_req_builder = match "multi" {
18522            "multi" => local_var_req_builder.query(
18523                &local_var_str
18524                    .into_iter()
18525                    .map(|p| ("role__iregex".to_owned(), p.to_string()))
18526                    .collect::<Vec<(std::string::String, std::string::String)>>(),
18527            ),
18528            _ => local_var_req_builder.query(&[(
18529                "role__iregex",
18530                &local_var_str
18531                    .into_iter()
18532                    .map(|p| p.to_string())
18533                    .collect::<Vec<String>>()
18534                    .join(",")
18535                    .to_string(),
18536            )]),
18537        };
18538    }
18539    if let Some(ref local_var_str) = role__isw {
18540        local_var_req_builder = match "multi" {
18541            "multi" => local_var_req_builder.query(
18542                &local_var_str
18543                    .into_iter()
18544                    .map(|p| ("role__isw".to_owned(), p.to_string()))
18545                    .collect::<Vec<(std::string::String, std::string::String)>>(),
18546            ),
18547            _ => local_var_req_builder.query(&[(
18548                "role__isw",
18549                &local_var_str
18550                    .into_iter()
18551                    .map(|p| p.to_string())
18552                    .collect::<Vec<String>>()
18553                    .join(",")
18554                    .to_string(),
18555            )]),
18556        };
18557    }
18558    if let Some(ref local_var_str) = role__n {
18559        local_var_req_builder = match "multi" {
18560            "multi" => local_var_req_builder.query(
18561                &local_var_str
18562                    .into_iter()
18563                    .map(|p| ("role__n".to_owned(), p.to_string()))
18564                    .collect::<Vec<(std::string::String, std::string::String)>>(),
18565            ),
18566            _ => local_var_req_builder.query(&[(
18567                "role__n",
18568                &local_var_str
18569                    .into_iter()
18570                    .map(|p| p.to_string())
18571                    .collect::<Vec<String>>()
18572                    .join(",")
18573                    .to_string(),
18574            )]),
18575        };
18576    }
18577    if let Some(ref local_var_str) = role__nic {
18578        local_var_req_builder = match "multi" {
18579            "multi" => local_var_req_builder.query(
18580                &local_var_str
18581                    .into_iter()
18582                    .map(|p| ("role__nic".to_owned(), p.to_string()))
18583                    .collect::<Vec<(std::string::String, std::string::String)>>(),
18584            ),
18585            _ => local_var_req_builder.query(&[(
18586                "role__nic",
18587                &local_var_str
18588                    .into_iter()
18589                    .map(|p| p.to_string())
18590                    .collect::<Vec<String>>()
18591                    .join(",")
18592                    .to_string(),
18593            )]),
18594        };
18595    }
18596    if let Some(ref local_var_str) = role__nie {
18597        local_var_req_builder = match "multi" {
18598            "multi" => local_var_req_builder.query(
18599                &local_var_str
18600                    .into_iter()
18601                    .map(|p| ("role__nie".to_owned(), p.to_string()))
18602                    .collect::<Vec<(std::string::String, std::string::String)>>(),
18603            ),
18604            _ => local_var_req_builder.query(&[(
18605                "role__nie",
18606                &local_var_str
18607                    .into_iter()
18608                    .map(|p| p.to_string())
18609                    .collect::<Vec<String>>()
18610                    .join(",")
18611                    .to_string(),
18612            )]),
18613        };
18614    }
18615    if let Some(ref local_var_str) = role__niew {
18616        local_var_req_builder = match "multi" {
18617            "multi" => local_var_req_builder.query(
18618                &local_var_str
18619                    .into_iter()
18620                    .map(|p| ("role__niew".to_owned(), p.to_string()))
18621                    .collect::<Vec<(std::string::String, std::string::String)>>(),
18622            ),
18623            _ => local_var_req_builder.query(&[(
18624                "role__niew",
18625                &local_var_str
18626                    .into_iter()
18627                    .map(|p| p.to_string())
18628                    .collect::<Vec<String>>()
18629                    .join(",")
18630                    .to_string(),
18631            )]),
18632        };
18633    }
18634    if let Some(ref local_var_str) = role__nisw {
18635        local_var_req_builder = match "multi" {
18636            "multi" => local_var_req_builder.query(
18637                &local_var_str
18638                    .into_iter()
18639                    .map(|p| ("role__nisw".to_owned(), p.to_string()))
18640                    .collect::<Vec<(std::string::String, std::string::String)>>(),
18641            ),
18642            _ => local_var_req_builder.query(&[(
18643                "role__nisw",
18644                &local_var_str
18645                    .into_iter()
18646                    .map(|p| p.to_string())
18647                    .collect::<Vec<String>>()
18648                    .join(",")
18649                    .to_string(),
18650            )]),
18651        };
18652    }
18653    if let Some(ref local_var_str) = role__regex {
18654        local_var_req_builder = match "multi" {
18655            "multi" => local_var_req_builder.query(
18656                &local_var_str
18657                    .into_iter()
18658                    .map(|p| ("role__regex".to_owned(), p.to_string()))
18659                    .collect::<Vec<(std::string::String, std::string::String)>>(),
18660            ),
18661            _ => local_var_req_builder.query(&[(
18662                "role__regex",
18663                &local_var_str
18664                    .into_iter()
18665                    .map(|p| p.to_string())
18666                    .collect::<Vec<String>>()
18667                    .join(",")
18668                    .to_string(),
18669            )]),
18670        };
18671    }
18672    if let Some(ref local_var_str) = tag {
18673        local_var_req_builder = match "multi" {
18674            "multi" => local_var_req_builder.query(
18675                &local_var_str
18676                    .into_iter()
18677                    .map(|p| ("tag".to_owned(), p.to_string()))
18678                    .collect::<Vec<(std::string::String, std::string::String)>>(),
18679            ),
18680            _ => local_var_req_builder.query(&[(
18681                "tag",
18682                &local_var_str
18683                    .into_iter()
18684                    .map(|p| p.to_string())
18685                    .collect::<Vec<String>>()
18686                    .join(",")
18687                    .to_string(),
18688            )]),
18689        };
18690    }
18691    if let Some(ref local_var_str) = tag__n {
18692        local_var_req_builder = match "multi" {
18693            "multi" => local_var_req_builder.query(
18694                &local_var_str
18695                    .into_iter()
18696                    .map(|p| ("tag__n".to_owned(), p.to_string()))
18697                    .collect::<Vec<(std::string::String, std::string::String)>>(),
18698            ),
18699            _ => local_var_req_builder.query(&[(
18700                "tag__n",
18701                &local_var_str
18702                    .into_iter()
18703                    .map(|p| p.to_string())
18704                    .collect::<Vec<String>>()
18705                    .join(",")
18706                    .to_string(),
18707            )]),
18708        };
18709    }
18710    if let Some(ref local_var_str) = tag_id {
18711        local_var_req_builder = match "multi" {
18712            "multi" => local_var_req_builder.query(
18713                &local_var_str
18714                    .into_iter()
18715                    .map(|p| ("tag_id".to_owned(), p.to_string()))
18716                    .collect::<Vec<(std::string::String, std::string::String)>>(),
18717            ),
18718            _ => local_var_req_builder.query(&[(
18719                "tag_id",
18720                &local_var_str
18721                    .into_iter()
18722                    .map(|p| p.to_string())
18723                    .collect::<Vec<String>>()
18724                    .join(",")
18725                    .to_string(),
18726            )]),
18727        };
18728    }
18729    if let Some(ref local_var_str) = tag_id__n {
18730        local_var_req_builder = match "multi" {
18731            "multi" => local_var_req_builder.query(
18732                &local_var_str
18733                    .into_iter()
18734                    .map(|p| ("tag_id__n".to_owned(), p.to_string()))
18735                    .collect::<Vec<(std::string::String, std::string::String)>>(),
18736            ),
18737            _ => local_var_req_builder.query(&[(
18738                "tag_id__n",
18739                &local_var_str
18740                    .into_iter()
18741                    .map(|p| p.to_string())
18742                    .collect::<Vec<String>>()
18743                    .join(",")
18744                    .to_string(),
18745            )]),
18746        };
18747    }
18748    if let Some(ref local_var_str) = termination_id {
18749        local_var_req_builder = match "multi" {
18750            "multi" => local_var_req_builder.query(
18751                &local_var_str
18752                    .into_iter()
18753                    .map(|p| ("termination_id".to_owned(), p.to_string()))
18754                    .collect::<Vec<(std::string::String, std::string::String)>>(),
18755            ),
18756            _ => local_var_req_builder.query(&[(
18757                "termination_id",
18758                &local_var_str
18759                    .into_iter()
18760                    .map(|p| p.to_string())
18761                    .collect::<Vec<String>>()
18762                    .join(",")
18763                    .to_string(),
18764            )]),
18765        };
18766    }
18767    if let Some(ref local_var_str) = termination_id__empty {
18768        local_var_req_builder =
18769            local_var_req_builder.query(&[("termination_id__empty", &local_var_str.to_string())]);
18770    }
18771    if let Some(ref local_var_str) = termination_id__gt {
18772        local_var_req_builder = match "multi" {
18773            "multi" => local_var_req_builder.query(
18774                &local_var_str
18775                    .into_iter()
18776                    .map(|p| ("termination_id__gt".to_owned(), p.to_string()))
18777                    .collect::<Vec<(std::string::String, std::string::String)>>(),
18778            ),
18779            _ => local_var_req_builder.query(&[(
18780                "termination_id__gt",
18781                &local_var_str
18782                    .into_iter()
18783                    .map(|p| p.to_string())
18784                    .collect::<Vec<String>>()
18785                    .join(",")
18786                    .to_string(),
18787            )]),
18788        };
18789    }
18790    if let Some(ref local_var_str) = termination_id__gte {
18791        local_var_req_builder = match "multi" {
18792            "multi" => local_var_req_builder.query(
18793                &local_var_str
18794                    .into_iter()
18795                    .map(|p| ("termination_id__gte".to_owned(), p.to_string()))
18796                    .collect::<Vec<(std::string::String, std::string::String)>>(),
18797            ),
18798            _ => local_var_req_builder.query(&[(
18799                "termination_id__gte",
18800                &local_var_str
18801                    .into_iter()
18802                    .map(|p| p.to_string())
18803                    .collect::<Vec<String>>()
18804                    .join(",")
18805                    .to_string(),
18806            )]),
18807        };
18808    }
18809    if let Some(ref local_var_str) = termination_id__lt {
18810        local_var_req_builder = match "multi" {
18811            "multi" => local_var_req_builder.query(
18812                &local_var_str
18813                    .into_iter()
18814                    .map(|p| ("termination_id__lt".to_owned(), p.to_string()))
18815                    .collect::<Vec<(std::string::String, std::string::String)>>(),
18816            ),
18817            _ => local_var_req_builder.query(&[(
18818                "termination_id__lt",
18819                &local_var_str
18820                    .into_iter()
18821                    .map(|p| p.to_string())
18822                    .collect::<Vec<String>>()
18823                    .join(",")
18824                    .to_string(),
18825            )]),
18826        };
18827    }
18828    if let Some(ref local_var_str) = termination_id__lte {
18829        local_var_req_builder = match "multi" {
18830            "multi" => local_var_req_builder.query(
18831                &local_var_str
18832                    .into_iter()
18833                    .map(|p| ("termination_id__lte".to_owned(), p.to_string()))
18834                    .collect::<Vec<(std::string::String, std::string::String)>>(),
18835            ),
18836            _ => local_var_req_builder.query(&[(
18837                "termination_id__lte",
18838                &local_var_str
18839                    .into_iter()
18840                    .map(|p| p.to_string())
18841                    .collect::<Vec<String>>()
18842                    .join(",")
18843                    .to_string(),
18844            )]),
18845        };
18846    }
18847    if let Some(ref local_var_str) = termination_id__n {
18848        local_var_req_builder = match "multi" {
18849            "multi" => local_var_req_builder.query(
18850                &local_var_str
18851                    .into_iter()
18852                    .map(|p| ("termination_id__n".to_owned(), p.to_string()))
18853                    .collect::<Vec<(std::string::String, std::string::String)>>(),
18854            ),
18855            _ => local_var_req_builder.query(&[(
18856                "termination_id__n",
18857                &local_var_str
18858                    .into_iter()
18859                    .map(|p| p.to_string())
18860                    .collect::<Vec<String>>()
18861                    .join(",")
18862                    .to_string(),
18863            )]),
18864        };
18865    }
18866    if let Some(ref local_var_str) = termination_type {
18867        local_var_req_builder =
18868            local_var_req_builder.query(&[("termination_type", &local_var_str.to_string())]);
18869    }
18870    if let Some(ref local_var_str) = termination_type__n {
18871        local_var_req_builder =
18872            local_var_req_builder.query(&[("termination_type__n", &local_var_str.to_string())]);
18873    }
18874    if let Some(ref local_var_str) = tunnel {
18875        local_var_req_builder = match "multi" {
18876            "multi" => local_var_req_builder.query(
18877                &local_var_str
18878                    .into_iter()
18879                    .map(|p| ("tunnel".to_owned(), p.to_string()))
18880                    .collect::<Vec<(std::string::String, std::string::String)>>(),
18881            ),
18882            _ => local_var_req_builder.query(&[(
18883                "tunnel",
18884                &local_var_str
18885                    .into_iter()
18886                    .map(|p| p.to_string())
18887                    .collect::<Vec<String>>()
18888                    .join(",")
18889                    .to_string(),
18890            )]),
18891        };
18892    }
18893    if let Some(ref local_var_str) = tunnel__n {
18894        local_var_req_builder = match "multi" {
18895            "multi" => local_var_req_builder.query(
18896                &local_var_str
18897                    .into_iter()
18898                    .map(|p| ("tunnel__n".to_owned(), p.to_string()))
18899                    .collect::<Vec<(std::string::String, std::string::String)>>(),
18900            ),
18901            _ => local_var_req_builder.query(&[(
18902                "tunnel__n",
18903                &local_var_str
18904                    .into_iter()
18905                    .map(|p| p.to_string())
18906                    .collect::<Vec<String>>()
18907                    .join(",")
18908                    .to_string(),
18909            )]),
18910        };
18911    }
18912    if let Some(ref local_var_str) = tunnel_id {
18913        local_var_req_builder = match "multi" {
18914            "multi" => local_var_req_builder.query(
18915                &local_var_str
18916                    .into_iter()
18917                    .map(|p| ("tunnel_id".to_owned(), p.to_string()))
18918                    .collect::<Vec<(std::string::String, std::string::String)>>(),
18919            ),
18920            _ => local_var_req_builder.query(&[(
18921                "tunnel_id",
18922                &local_var_str
18923                    .into_iter()
18924                    .map(|p| p.to_string())
18925                    .collect::<Vec<String>>()
18926                    .join(",")
18927                    .to_string(),
18928            )]),
18929        };
18930    }
18931    if let Some(ref local_var_str) = tunnel_id__n {
18932        local_var_req_builder = match "multi" {
18933            "multi" => local_var_req_builder.query(
18934                &local_var_str
18935                    .into_iter()
18936                    .map(|p| ("tunnel_id__n".to_owned(), p.to_string()))
18937                    .collect::<Vec<(std::string::String, std::string::String)>>(),
18938            ),
18939            _ => local_var_req_builder.query(&[(
18940                "tunnel_id__n",
18941                &local_var_str
18942                    .into_iter()
18943                    .map(|p| p.to_string())
18944                    .collect::<Vec<String>>()
18945                    .join(",")
18946                    .to_string(),
18947            )]),
18948        };
18949    }
18950    if let Some(ref local_var_str) = updated_by_request {
18951        local_var_req_builder =
18952            local_var_req_builder.query(&[("updated_by_request", &local_var_str.to_string())]);
18953    }
18954    if let Some(ref local_var_str) = vminterface {
18955        local_var_req_builder = match "multi" {
18956            "multi" => local_var_req_builder.query(
18957                &local_var_str
18958                    .into_iter()
18959                    .map(|p| ("vminterface".to_owned(), p.to_string()))
18960                    .collect::<Vec<(std::string::String, std::string::String)>>(),
18961            ),
18962            _ => local_var_req_builder.query(&[(
18963                "vminterface",
18964                &local_var_str
18965                    .into_iter()
18966                    .map(|p| p.to_string())
18967                    .collect::<Vec<String>>()
18968                    .join(",")
18969                    .to_string(),
18970            )]),
18971        };
18972    }
18973    if let Some(ref local_var_str) = vminterface__n {
18974        local_var_req_builder = match "multi" {
18975            "multi" => local_var_req_builder.query(
18976                &local_var_str
18977                    .into_iter()
18978                    .map(|p| ("vminterface__n".to_owned(), p.to_string()))
18979                    .collect::<Vec<(std::string::String, std::string::String)>>(),
18980            ),
18981            _ => local_var_req_builder.query(&[(
18982                "vminterface__n",
18983                &local_var_str
18984                    .into_iter()
18985                    .map(|p| p.to_string())
18986                    .collect::<Vec<String>>()
18987                    .join(",")
18988                    .to_string(),
18989            )]),
18990        };
18991    }
18992    if let Some(ref local_var_str) = vminterface_id {
18993        local_var_req_builder = match "multi" {
18994            "multi" => local_var_req_builder.query(
18995                &local_var_str
18996                    .into_iter()
18997                    .map(|p| ("vminterface_id".to_owned(), p.to_string()))
18998                    .collect::<Vec<(std::string::String, std::string::String)>>(),
18999            ),
19000            _ => local_var_req_builder.query(&[(
19001                "vminterface_id",
19002                &local_var_str
19003                    .into_iter()
19004                    .map(|p| p.to_string())
19005                    .collect::<Vec<String>>()
19006                    .join(",")
19007                    .to_string(),
19008            )]),
19009        };
19010    }
19011    if let Some(ref local_var_str) = vminterface_id__n {
19012        local_var_req_builder = match "multi" {
19013            "multi" => local_var_req_builder.query(
19014                &local_var_str
19015                    .into_iter()
19016                    .map(|p| ("vminterface_id__n".to_owned(), p.to_string()))
19017                    .collect::<Vec<(std::string::String, std::string::String)>>(),
19018            ),
19019            _ => local_var_req_builder.query(&[(
19020                "vminterface_id__n",
19021                &local_var_str
19022                    .into_iter()
19023                    .map(|p| p.to_string())
19024                    .collect::<Vec<String>>()
19025                    .join(",")
19026                    .to_string(),
19027            )]),
19028        };
19029    }
19030    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
19031        local_var_req_builder =
19032            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
19033    }
19034    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
19035        let local_var_key = local_var_apikey.key.clone();
19036        let local_var_value = match local_var_apikey.prefix {
19037            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
19038            None => local_var_key,
19039        };
19040        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
19041    };
19042
19043    let local_var_req = local_var_req_builder.build()?;
19044    let local_var_resp = local_var_client.execute(local_var_req).await?;
19045
19046    let local_var_status = local_var_resp.status();
19047    let local_var_content = local_var_resp.text().await?;
19048
19049    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
19050        serde_json::from_str(&local_var_content).map_err(Error::from)
19051    } else {
19052        let local_var_entity: Option<VpnTunnelTerminationsListError> =
19053            serde_json::from_str(&local_var_content).ok();
19054        let local_var_error = ResponseContent {
19055            status: local_var_status,
19056            content: local_var_content,
19057            entity: local_var_entity,
19058        };
19059        Err(Error::ResponseError(local_var_error))
19060    }
19061}
19062
19063/// Patch a tunnel termination object.
19064pub async fn vpn_tunnel_terminations_partial_update(
19065    configuration: &configuration::Configuration,
19066    id: i32,
19067    patched_writable_tunnel_termination_request: Option<
19068        crate::models::PatchedWritableTunnelTerminationRequest,
19069    >,
19070) -> Result<crate::models::TunnelTermination, Error<VpnTunnelTerminationsPartialUpdateError>> {
19071    let local_var_configuration = configuration;
19072
19073    let local_var_client = &local_var_configuration.client;
19074
19075    let local_var_uri_str = format!(
19076        "{}/api/vpn/tunnel-terminations/{id}/",
19077        local_var_configuration.base_path,
19078        id = id
19079    );
19080    let mut local_var_req_builder =
19081        local_var_client.request(reqwest::Method::PATCH, local_var_uri_str.as_str());
19082
19083    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
19084        local_var_req_builder =
19085            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
19086    }
19087    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
19088        let local_var_key = local_var_apikey.key.clone();
19089        let local_var_value = match local_var_apikey.prefix {
19090            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
19091            None => local_var_key,
19092        };
19093        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
19094    };
19095    local_var_req_builder =
19096        local_var_req_builder.json(&patched_writable_tunnel_termination_request);
19097
19098    let local_var_req = local_var_req_builder.build()?;
19099    let local_var_resp = local_var_client.execute(local_var_req).await?;
19100
19101    let local_var_status = local_var_resp.status();
19102    let local_var_content = local_var_resp.text().await?;
19103
19104    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
19105        serde_json::from_str(&local_var_content).map_err(Error::from)
19106    } else {
19107        let local_var_entity: Option<VpnTunnelTerminationsPartialUpdateError> =
19108            serde_json::from_str(&local_var_content).ok();
19109        let local_var_error = ResponseContent {
19110            status: local_var_status,
19111            content: local_var_content,
19112            entity: local_var_entity,
19113        };
19114        Err(Error::ResponseError(local_var_error))
19115    }
19116}
19117
19118/// Get a tunnel termination object.
19119pub async fn vpn_tunnel_terminations_retrieve(
19120    configuration: &configuration::Configuration,
19121    id: i32,
19122) -> Result<crate::models::TunnelTermination, Error<VpnTunnelTerminationsRetrieveError>> {
19123    let local_var_configuration = configuration;
19124
19125    let local_var_client = &local_var_configuration.client;
19126
19127    let local_var_uri_str = format!(
19128        "{}/api/vpn/tunnel-terminations/{id}/",
19129        local_var_configuration.base_path,
19130        id = id
19131    );
19132    let mut local_var_req_builder =
19133        local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
19134
19135    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
19136        local_var_req_builder =
19137            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
19138    }
19139    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
19140        let local_var_key = local_var_apikey.key.clone();
19141        let local_var_value = match local_var_apikey.prefix {
19142            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
19143            None => local_var_key,
19144        };
19145        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
19146    };
19147
19148    let local_var_req = local_var_req_builder.build()?;
19149    let local_var_resp = local_var_client.execute(local_var_req).await?;
19150
19151    let local_var_status = local_var_resp.status();
19152    let local_var_content = local_var_resp.text().await?;
19153
19154    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
19155        serde_json::from_str(&local_var_content).map_err(Error::from)
19156    } else {
19157        let local_var_entity: Option<VpnTunnelTerminationsRetrieveError> =
19158            serde_json::from_str(&local_var_content).ok();
19159        let local_var_error = ResponseContent {
19160            status: local_var_status,
19161            content: local_var_content,
19162            entity: local_var_entity,
19163        };
19164        Err(Error::ResponseError(local_var_error))
19165    }
19166}
19167
19168/// Put a tunnel termination object.
19169pub async fn vpn_tunnel_terminations_update(
19170    configuration: &configuration::Configuration,
19171    id: i32,
19172    writable_tunnel_termination_request: crate::models::WritableTunnelTerminationRequest,
19173) -> Result<crate::models::TunnelTermination, Error<VpnTunnelTerminationsUpdateError>> {
19174    let local_var_configuration = configuration;
19175
19176    let local_var_client = &local_var_configuration.client;
19177
19178    let local_var_uri_str = format!(
19179        "{}/api/vpn/tunnel-terminations/{id}/",
19180        local_var_configuration.base_path,
19181        id = id
19182    );
19183    let mut local_var_req_builder =
19184        local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());
19185
19186    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
19187        local_var_req_builder =
19188            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
19189    }
19190    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
19191        let local_var_key = local_var_apikey.key.clone();
19192        let local_var_value = match local_var_apikey.prefix {
19193            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
19194            None => local_var_key,
19195        };
19196        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
19197    };
19198    local_var_req_builder = local_var_req_builder.json(&writable_tunnel_termination_request);
19199
19200    let local_var_req = local_var_req_builder.build()?;
19201    let local_var_resp = local_var_client.execute(local_var_req).await?;
19202
19203    let local_var_status = local_var_resp.status();
19204    let local_var_content = local_var_resp.text().await?;
19205
19206    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
19207        serde_json::from_str(&local_var_content).map_err(Error::from)
19208    } else {
19209        let local_var_entity: Option<VpnTunnelTerminationsUpdateError> =
19210            serde_json::from_str(&local_var_content).ok();
19211        let local_var_error = ResponseContent {
19212            status: local_var_status,
19213            content: local_var_content,
19214            entity: local_var_entity,
19215        };
19216        Err(Error::ResponseError(local_var_error))
19217    }
19218}
19219
19220/// Delete a list of tunnel objects.
19221pub async fn vpn_tunnels_bulk_destroy(
19222    configuration: &configuration::Configuration,
19223    tunnel_request: Vec<crate::models::TunnelRequest>,
19224) -> Result<(), Error<VpnTunnelsBulkDestroyError>> {
19225    let local_var_configuration = configuration;
19226
19227    let local_var_client = &local_var_configuration.client;
19228
19229    let local_var_uri_str = format!("{}/api/vpn/tunnels/", local_var_configuration.base_path);
19230    let mut local_var_req_builder =
19231        local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());
19232
19233    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
19234        local_var_req_builder =
19235            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
19236    }
19237    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
19238        let local_var_key = local_var_apikey.key.clone();
19239        let local_var_value = match local_var_apikey.prefix {
19240            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
19241            None => local_var_key,
19242        };
19243        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
19244    };
19245    local_var_req_builder = local_var_req_builder.json(&tunnel_request);
19246
19247    let local_var_req = local_var_req_builder.build()?;
19248    let local_var_resp = local_var_client.execute(local_var_req).await?;
19249
19250    let local_var_status = local_var_resp.status();
19251    let local_var_content = local_var_resp.text().await?;
19252
19253    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
19254        Ok(())
19255    } else {
19256        let local_var_entity: Option<VpnTunnelsBulkDestroyError> =
19257            serde_json::from_str(&local_var_content).ok();
19258        let local_var_error = ResponseContent {
19259            status: local_var_status,
19260            content: local_var_content,
19261            entity: local_var_entity,
19262        };
19263        Err(Error::ResponseError(local_var_error))
19264    }
19265}
19266
19267/// Patch a list of tunnel objects.
19268pub async fn vpn_tunnels_bulk_partial_update(
19269    configuration: &configuration::Configuration,
19270    tunnel_request: Vec<crate::models::TunnelRequest>,
19271) -> Result<Vec<crate::models::Tunnel>, Error<VpnTunnelsBulkPartialUpdateError>> {
19272    let local_var_configuration = configuration;
19273
19274    let local_var_client = &local_var_configuration.client;
19275
19276    let local_var_uri_str = format!("{}/api/vpn/tunnels/", local_var_configuration.base_path);
19277    let mut local_var_req_builder =
19278        local_var_client.request(reqwest::Method::PATCH, local_var_uri_str.as_str());
19279
19280    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
19281        local_var_req_builder =
19282            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
19283    }
19284    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
19285        let local_var_key = local_var_apikey.key.clone();
19286        let local_var_value = match local_var_apikey.prefix {
19287            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
19288            None => local_var_key,
19289        };
19290        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
19291    };
19292    local_var_req_builder = local_var_req_builder.json(&tunnel_request);
19293
19294    let local_var_req = local_var_req_builder.build()?;
19295    let local_var_resp = local_var_client.execute(local_var_req).await?;
19296
19297    let local_var_status = local_var_resp.status();
19298    let local_var_content = local_var_resp.text().await?;
19299
19300    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
19301        serde_json::from_str(&local_var_content).map_err(Error::from)
19302    } else {
19303        let local_var_entity: Option<VpnTunnelsBulkPartialUpdateError> =
19304            serde_json::from_str(&local_var_content).ok();
19305        let local_var_error = ResponseContent {
19306            status: local_var_status,
19307            content: local_var_content,
19308            entity: local_var_entity,
19309        };
19310        Err(Error::ResponseError(local_var_error))
19311    }
19312}
19313
19314/// Put a list of tunnel objects.
19315pub async fn vpn_tunnels_bulk_update(
19316    configuration: &configuration::Configuration,
19317    tunnel_request: Vec<crate::models::TunnelRequest>,
19318) -> Result<Vec<crate::models::Tunnel>, Error<VpnTunnelsBulkUpdateError>> {
19319    let local_var_configuration = configuration;
19320
19321    let local_var_client = &local_var_configuration.client;
19322
19323    let local_var_uri_str = format!("{}/api/vpn/tunnels/", local_var_configuration.base_path);
19324    let mut local_var_req_builder =
19325        local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());
19326
19327    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
19328        local_var_req_builder =
19329            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
19330    }
19331    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
19332        let local_var_key = local_var_apikey.key.clone();
19333        let local_var_value = match local_var_apikey.prefix {
19334            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
19335            None => local_var_key,
19336        };
19337        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
19338    };
19339    local_var_req_builder = local_var_req_builder.json(&tunnel_request);
19340
19341    let local_var_req = local_var_req_builder.build()?;
19342    let local_var_resp = local_var_client.execute(local_var_req).await?;
19343
19344    let local_var_status = local_var_resp.status();
19345    let local_var_content = local_var_resp.text().await?;
19346
19347    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
19348        serde_json::from_str(&local_var_content).map_err(Error::from)
19349    } else {
19350        let local_var_entity: Option<VpnTunnelsBulkUpdateError> =
19351            serde_json::from_str(&local_var_content).ok();
19352        let local_var_error = ResponseContent {
19353            status: local_var_status,
19354            content: local_var_content,
19355            entity: local_var_entity,
19356        };
19357        Err(Error::ResponseError(local_var_error))
19358    }
19359}
19360
19361/// Post a list of tunnel objects.
19362pub async fn vpn_tunnels_create(
19363    configuration: &configuration::Configuration,
19364    writable_tunnel_request: crate::models::WritableTunnelRequest,
19365) -> Result<crate::models::Tunnel, Error<VpnTunnelsCreateError>> {
19366    let local_var_configuration = configuration;
19367
19368    let local_var_client = &local_var_configuration.client;
19369
19370    let local_var_uri_str = format!("{}/api/vpn/tunnels/", local_var_configuration.base_path);
19371    let mut local_var_req_builder =
19372        local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
19373
19374    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
19375        local_var_req_builder =
19376            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
19377    }
19378    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
19379        let local_var_key = local_var_apikey.key.clone();
19380        let local_var_value = match local_var_apikey.prefix {
19381            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
19382            None => local_var_key,
19383        };
19384        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
19385    };
19386    local_var_req_builder = local_var_req_builder.json(&writable_tunnel_request);
19387
19388    let local_var_req = local_var_req_builder.build()?;
19389    let local_var_resp = local_var_client.execute(local_var_req).await?;
19390
19391    let local_var_status = local_var_resp.status();
19392    let local_var_content = local_var_resp.text().await?;
19393
19394    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
19395        serde_json::from_str(&local_var_content).map_err(Error::from)
19396    } else {
19397        let local_var_entity: Option<VpnTunnelsCreateError> =
19398            serde_json::from_str(&local_var_content).ok();
19399        let local_var_error = ResponseContent {
19400            status: local_var_status,
19401            content: local_var_content,
19402            entity: local_var_entity,
19403        };
19404        Err(Error::ResponseError(local_var_error))
19405    }
19406}
19407
19408/// Delete a tunnel object.
19409pub async fn vpn_tunnels_destroy(
19410    configuration: &configuration::Configuration,
19411    id: i32,
19412) -> Result<(), Error<VpnTunnelsDestroyError>> {
19413    let local_var_configuration = configuration;
19414
19415    let local_var_client = &local_var_configuration.client;
19416
19417    let local_var_uri_str = format!(
19418        "{}/api/vpn/tunnels/{id}/",
19419        local_var_configuration.base_path,
19420        id = id
19421    );
19422    let mut local_var_req_builder =
19423        local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());
19424
19425    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
19426        local_var_req_builder =
19427            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
19428    }
19429    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
19430        let local_var_key = local_var_apikey.key.clone();
19431        let local_var_value = match local_var_apikey.prefix {
19432            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
19433            None => local_var_key,
19434        };
19435        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
19436    };
19437
19438    let local_var_req = local_var_req_builder.build()?;
19439    let local_var_resp = local_var_client.execute(local_var_req).await?;
19440
19441    let local_var_status = local_var_resp.status();
19442    let local_var_content = local_var_resp.text().await?;
19443
19444    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
19445        Ok(())
19446    } else {
19447        let local_var_entity: Option<VpnTunnelsDestroyError> =
19448            serde_json::from_str(&local_var_content).ok();
19449        let local_var_error = ResponseContent {
19450            status: local_var_status,
19451            content: local_var_content,
19452            entity: local_var_entity,
19453        };
19454        Err(Error::ResponseError(local_var_error))
19455    }
19456}
19457
19458/// Get a list of tunnel objects.
19459pub async fn vpn_tunnels_list(
19460    configuration: &configuration::Configuration,
19461    contact: Option<Vec<i32>>,
19462    contact__n: Option<Vec<i32>>,
19463    contact_group: Option<Vec<String>>,
19464    contact_group__n: Option<Vec<String>>,
19465    contact_role: Option<Vec<i32>>,
19466    contact_role__n: Option<Vec<i32>>,
19467    created: Option<Vec<String>>,
19468    created__empty: Option<Vec<String>>,
19469    created__gt: Option<Vec<String>>,
19470    created__gte: Option<Vec<String>>,
19471    created__lt: Option<Vec<String>>,
19472    created__lte: Option<Vec<String>>,
19473    created__n: Option<Vec<String>>,
19474    created_by_request: Option<&str>,
19475    description: Option<Vec<String>>,
19476    description__empty: Option<bool>,
19477    description__ic: Option<Vec<String>>,
19478    description__ie: Option<Vec<String>>,
19479    description__iew: Option<Vec<String>>,
19480    description__iregex: Option<Vec<String>>,
19481    description__isw: Option<Vec<String>>,
19482    description__n: Option<Vec<String>>,
19483    description__nic: Option<Vec<String>>,
19484    description__nie: Option<Vec<String>>,
19485    description__niew: Option<Vec<String>>,
19486    description__nisw: Option<Vec<String>>,
19487    description__regex: Option<Vec<String>>,
19488    encapsulation: Option<Vec<String>>,
19489    encapsulation__empty: Option<bool>,
19490    encapsulation__ic: Option<Vec<String>>,
19491    encapsulation__ie: Option<Vec<String>>,
19492    encapsulation__iew: Option<Vec<String>>,
19493    encapsulation__iregex: Option<Vec<String>>,
19494    encapsulation__isw: Option<Vec<String>>,
19495    encapsulation__n: Option<Vec<String>>,
19496    encapsulation__nic: Option<Vec<String>>,
19497    encapsulation__nie: Option<Vec<String>>,
19498    encapsulation__niew: Option<Vec<String>>,
19499    encapsulation__nisw: Option<Vec<String>>,
19500    encapsulation__regex: Option<Vec<String>>,
19501    group: Option<Vec<String>>,
19502    group__n: Option<Vec<String>>,
19503    group_id: Option<Vec<i32>>,
19504    group_id__n: Option<Vec<i32>>,
19505    id: Option<Vec<i32>>,
19506    id__empty: Option<bool>,
19507    id__gt: Option<Vec<i32>>,
19508    id__gte: Option<Vec<i32>>,
19509    id__lt: Option<Vec<i32>>,
19510    id__lte: Option<Vec<i32>>,
19511    id__n: Option<Vec<i32>>,
19512    ipsec_profile: Option<Vec<String>>,
19513    ipsec_profile__n: Option<Vec<String>>,
19514    ipsec_profile_id: Option<Vec<i32>>,
19515    ipsec_profile_id__n: Option<Vec<i32>>,
19516    last_updated: Option<Vec<String>>,
19517    last_updated__empty: Option<Vec<String>>,
19518    last_updated__gt: Option<Vec<String>>,
19519    last_updated__gte: Option<Vec<String>>,
19520    last_updated__lt: Option<Vec<String>>,
19521    last_updated__lte: Option<Vec<String>>,
19522    last_updated__n: Option<Vec<String>>,
19523    limit: Option<i32>,
19524    modified_by_request: Option<&str>,
19525    name: Option<Vec<String>>,
19526    name__empty: Option<bool>,
19527    name__ic: Option<Vec<String>>,
19528    name__ie: Option<Vec<String>>,
19529    name__iew: Option<Vec<String>>,
19530    name__iregex: Option<Vec<String>>,
19531    name__isw: Option<Vec<String>>,
19532    name__n: Option<Vec<String>>,
19533    name__nic: Option<Vec<String>>,
19534    name__nie: Option<Vec<String>>,
19535    name__niew: Option<Vec<String>>,
19536    name__nisw: Option<Vec<String>>,
19537    name__regex: Option<Vec<String>>,
19538    offset: Option<i32>,
19539    ordering: Option<&str>,
19540    q: Option<&str>,
19541    status: Option<Vec<String>>,
19542    status__empty: Option<bool>,
19543    status__ic: Option<Vec<String>>,
19544    status__ie: Option<Vec<String>>,
19545    status__iew: Option<Vec<String>>,
19546    status__iregex: Option<Vec<String>>,
19547    status__isw: Option<Vec<String>>,
19548    status__n: Option<Vec<String>>,
19549    status__nic: Option<Vec<String>>,
19550    status__nie: Option<Vec<String>>,
19551    status__niew: Option<Vec<String>>,
19552    status__nisw: Option<Vec<String>>,
19553    status__regex: Option<Vec<String>>,
19554    tag: Option<Vec<String>>,
19555    tag__n: Option<Vec<String>>,
19556    tag_id: Option<Vec<i32>>,
19557    tag_id__n: Option<Vec<i32>>,
19558    tenant: Option<Vec<String>>,
19559    tenant__n: Option<Vec<String>>,
19560    tenant_group: Option<Vec<String>>,
19561    tenant_group__n: Option<Vec<String>>,
19562    tenant_group_id: Option<Vec<String>>,
19563    tenant_group_id__n: Option<Vec<String>>,
19564    tenant_id: Option<Vec<i32>>,
19565    tenant_id__n: Option<Vec<i32>>,
19566    tunnel_id: Option<Vec<i32>>,
19567    tunnel_id__empty: Option<bool>,
19568    tunnel_id__gt: Option<Vec<i32>>,
19569    tunnel_id__gte: Option<Vec<i32>>,
19570    tunnel_id__lt: Option<Vec<i32>>,
19571    tunnel_id__lte: Option<Vec<i32>>,
19572    tunnel_id__n: Option<Vec<i32>>,
19573    updated_by_request: Option<&str>,
19574) -> Result<crate::models::PaginatedTunnelList, Error<VpnTunnelsListError>> {
19575    let local_var_configuration = configuration;
19576
19577    let local_var_client = &local_var_configuration.client;
19578
19579    let local_var_uri_str = format!("{}/api/vpn/tunnels/", local_var_configuration.base_path);
19580    let mut local_var_req_builder =
19581        local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
19582
19583    if let Some(ref local_var_str) = contact {
19584        local_var_req_builder = match "multi" {
19585            "multi" => local_var_req_builder.query(
19586                &local_var_str
19587                    .into_iter()
19588                    .map(|p| ("contact".to_owned(), p.to_string()))
19589                    .collect::<Vec<(std::string::String, std::string::String)>>(),
19590            ),
19591            _ => local_var_req_builder.query(&[(
19592                "contact",
19593                &local_var_str
19594                    .into_iter()
19595                    .map(|p| p.to_string())
19596                    .collect::<Vec<String>>()
19597                    .join(",")
19598                    .to_string(),
19599            )]),
19600        };
19601    }
19602    if let Some(ref local_var_str) = contact__n {
19603        local_var_req_builder = match "multi" {
19604            "multi" => local_var_req_builder.query(
19605                &local_var_str
19606                    .into_iter()
19607                    .map(|p| ("contact__n".to_owned(), p.to_string()))
19608                    .collect::<Vec<(std::string::String, std::string::String)>>(),
19609            ),
19610            _ => local_var_req_builder.query(&[(
19611                "contact__n",
19612                &local_var_str
19613                    .into_iter()
19614                    .map(|p| p.to_string())
19615                    .collect::<Vec<String>>()
19616                    .join(",")
19617                    .to_string(),
19618            )]),
19619        };
19620    }
19621    if let Some(ref local_var_str) = contact_group {
19622        local_var_req_builder = match "multi" {
19623            "multi" => local_var_req_builder.query(
19624                &local_var_str
19625                    .into_iter()
19626                    .map(|p| ("contact_group".to_owned(), p.to_string()))
19627                    .collect::<Vec<(std::string::String, std::string::String)>>(),
19628            ),
19629            _ => local_var_req_builder.query(&[(
19630                "contact_group",
19631                &local_var_str
19632                    .into_iter()
19633                    .map(|p| p.to_string())
19634                    .collect::<Vec<String>>()
19635                    .join(",")
19636                    .to_string(),
19637            )]),
19638        };
19639    }
19640    if let Some(ref local_var_str) = contact_group__n {
19641        local_var_req_builder = match "multi" {
19642            "multi" => local_var_req_builder.query(
19643                &local_var_str
19644                    .into_iter()
19645                    .map(|p| ("contact_group__n".to_owned(), p.to_string()))
19646                    .collect::<Vec<(std::string::String, std::string::String)>>(),
19647            ),
19648            _ => local_var_req_builder.query(&[(
19649                "contact_group__n",
19650                &local_var_str
19651                    .into_iter()
19652                    .map(|p| p.to_string())
19653                    .collect::<Vec<String>>()
19654                    .join(",")
19655                    .to_string(),
19656            )]),
19657        };
19658    }
19659    if let Some(ref local_var_str) = contact_role {
19660        local_var_req_builder = match "multi" {
19661            "multi" => local_var_req_builder.query(
19662                &local_var_str
19663                    .into_iter()
19664                    .map(|p| ("contact_role".to_owned(), p.to_string()))
19665                    .collect::<Vec<(std::string::String, std::string::String)>>(),
19666            ),
19667            _ => local_var_req_builder.query(&[(
19668                "contact_role",
19669                &local_var_str
19670                    .into_iter()
19671                    .map(|p| p.to_string())
19672                    .collect::<Vec<String>>()
19673                    .join(",")
19674                    .to_string(),
19675            )]),
19676        };
19677    }
19678    if let Some(ref local_var_str) = contact_role__n {
19679        local_var_req_builder = match "multi" {
19680            "multi" => local_var_req_builder.query(
19681                &local_var_str
19682                    .into_iter()
19683                    .map(|p| ("contact_role__n".to_owned(), p.to_string()))
19684                    .collect::<Vec<(std::string::String, std::string::String)>>(),
19685            ),
19686            _ => local_var_req_builder.query(&[(
19687                "contact_role__n",
19688                &local_var_str
19689                    .into_iter()
19690                    .map(|p| p.to_string())
19691                    .collect::<Vec<String>>()
19692                    .join(",")
19693                    .to_string(),
19694            )]),
19695        };
19696    }
19697    if let Some(ref local_var_str) = created {
19698        local_var_req_builder = match "multi" {
19699            "multi" => local_var_req_builder.query(
19700                &local_var_str
19701                    .into_iter()
19702                    .map(|p| ("created".to_owned(), p.to_string()))
19703                    .collect::<Vec<(std::string::String, std::string::String)>>(),
19704            ),
19705            _ => local_var_req_builder.query(&[(
19706                "created",
19707                &local_var_str
19708                    .into_iter()
19709                    .map(|p| p.to_string())
19710                    .collect::<Vec<String>>()
19711                    .join(",")
19712                    .to_string(),
19713            )]),
19714        };
19715    }
19716    if let Some(ref local_var_str) = created__empty {
19717        local_var_req_builder = match "multi" {
19718            "multi" => local_var_req_builder.query(
19719                &local_var_str
19720                    .into_iter()
19721                    .map(|p| ("created__empty".to_owned(), p.to_string()))
19722                    .collect::<Vec<(std::string::String, std::string::String)>>(),
19723            ),
19724            _ => local_var_req_builder.query(&[(
19725                "created__empty",
19726                &local_var_str
19727                    .into_iter()
19728                    .map(|p| p.to_string())
19729                    .collect::<Vec<String>>()
19730                    .join(",")
19731                    .to_string(),
19732            )]),
19733        };
19734    }
19735    if let Some(ref local_var_str) = created__gt {
19736        local_var_req_builder = match "multi" {
19737            "multi" => local_var_req_builder.query(
19738                &local_var_str
19739                    .into_iter()
19740                    .map(|p| ("created__gt".to_owned(), p.to_string()))
19741                    .collect::<Vec<(std::string::String, std::string::String)>>(),
19742            ),
19743            _ => local_var_req_builder.query(&[(
19744                "created__gt",
19745                &local_var_str
19746                    .into_iter()
19747                    .map(|p| p.to_string())
19748                    .collect::<Vec<String>>()
19749                    .join(",")
19750                    .to_string(),
19751            )]),
19752        };
19753    }
19754    if let Some(ref local_var_str) = created__gte {
19755        local_var_req_builder = match "multi" {
19756            "multi" => local_var_req_builder.query(
19757                &local_var_str
19758                    .into_iter()
19759                    .map(|p| ("created__gte".to_owned(), p.to_string()))
19760                    .collect::<Vec<(std::string::String, std::string::String)>>(),
19761            ),
19762            _ => local_var_req_builder.query(&[(
19763                "created__gte",
19764                &local_var_str
19765                    .into_iter()
19766                    .map(|p| p.to_string())
19767                    .collect::<Vec<String>>()
19768                    .join(",")
19769                    .to_string(),
19770            )]),
19771        };
19772    }
19773    if let Some(ref local_var_str) = created__lt {
19774        local_var_req_builder = match "multi" {
19775            "multi" => local_var_req_builder.query(
19776                &local_var_str
19777                    .into_iter()
19778                    .map(|p| ("created__lt".to_owned(), p.to_string()))
19779                    .collect::<Vec<(std::string::String, std::string::String)>>(),
19780            ),
19781            _ => local_var_req_builder.query(&[(
19782                "created__lt",
19783                &local_var_str
19784                    .into_iter()
19785                    .map(|p| p.to_string())
19786                    .collect::<Vec<String>>()
19787                    .join(",")
19788                    .to_string(),
19789            )]),
19790        };
19791    }
19792    if let Some(ref local_var_str) = created__lte {
19793        local_var_req_builder = match "multi" {
19794            "multi" => local_var_req_builder.query(
19795                &local_var_str
19796                    .into_iter()
19797                    .map(|p| ("created__lte".to_owned(), p.to_string()))
19798                    .collect::<Vec<(std::string::String, std::string::String)>>(),
19799            ),
19800            _ => local_var_req_builder.query(&[(
19801                "created__lte",
19802                &local_var_str
19803                    .into_iter()
19804                    .map(|p| p.to_string())
19805                    .collect::<Vec<String>>()
19806                    .join(",")
19807                    .to_string(),
19808            )]),
19809        };
19810    }
19811    if let Some(ref local_var_str) = created__n {
19812        local_var_req_builder = match "multi" {
19813            "multi" => local_var_req_builder.query(
19814                &local_var_str
19815                    .into_iter()
19816                    .map(|p| ("created__n".to_owned(), p.to_string()))
19817                    .collect::<Vec<(std::string::String, std::string::String)>>(),
19818            ),
19819            _ => local_var_req_builder.query(&[(
19820                "created__n",
19821                &local_var_str
19822                    .into_iter()
19823                    .map(|p| p.to_string())
19824                    .collect::<Vec<String>>()
19825                    .join(",")
19826                    .to_string(),
19827            )]),
19828        };
19829    }
19830    if let Some(ref local_var_str) = created_by_request {
19831        local_var_req_builder =
19832            local_var_req_builder.query(&[("created_by_request", &local_var_str.to_string())]);
19833    }
19834    if let Some(ref local_var_str) = description {
19835        local_var_req_builder = match "multi" {
19836            "multi" => local_var_req_builder.query(
19837                &local_var_str
19838                    .into_iter()
19839                    .map(|p| ("description".to_owned(), p.to_string()))
19840                    .collect::<Vec<(std::string::String, std::string::String)>>(),
19841            ),
19842            _ => local_var_req_builder.query(&[(
19843                "description",
19844                &local_var_str
19845                    .into_iter()
19846                    .map(|p| p.to_string())
19847                    .collect::<Vec<String>>()
19848                    .join(",")
19849                    .to_string(),
19850            )]),
19851        };
19852    }
19853    if let Some(ref local_var_str) = description__empty {
19854        local_var_req_builder =
19855            local_var_req_builder.query(&[("description__empty", &local_var_str.to_string())]);
19856    }
19857    if let Some(ref local_var_str) = description__ic {
19858        local_var_req_builder = match "multi" {
19859            "multi" => local_var_req_builder.query(
19860                &local_var_str
19861                    .into_iter()
19862                    .map(|p| ("description__ic".to_owned(), p.to_string()))
19863                    .collect::<Vec<(std::string::String, std::string::String)>>(),
19864            ),
19865            _ => local_var_req_builder.query(&[(
19866                "description__ic",
19867                &local_var_str
19868                    .into_iter()
19869                    .map(|p| p.to_string())
19870                    .collect::<Vec<String>>()
19871                    .join(",")
19872                    .to_string(),
19873            )]),
19874        };
19875    }
19876    if let Some(ref local_var_str) = description__ie {
19877        local_var_req_builder = match "multi" {
19878            "multi" => local_var_req_builder.query(
19879                &local_var_str
19880                    .into_iter()
19881                    .map(|p| ("description__ie".to_owned(), p.to_string()))
19882                    .collect::<Vec<(std::string::String, std::string::String)>>(),
19883            ),
19884            _ => local_var_req_builder.query(&[(
19885                "description__ie",
19886                &local_var_str
19887                    .into_iter()
19888                    .map(|p| p.to_string())
19889                    .collect::<Vec<String>>()
19890                    .join(",")
19891                    .to_string(),
19892            )]),
19893        };
19894    }
19895    if let Some(ref local_var_str) = description__iew {
19896        local_var_req_builder = match "multi" {
19897            "multi" => local_var_req_builder.query(
19898                &local_var_str
19899                    .into_iter()
19900                    .map(|p| ("description__iew".to_owned(), p.to_string()))
19901                    .collect::<Vec<(std::string::String, std::string::String)>>(),
19902            ),
19903            _ => local_var_req_builder.query(&[(
19904                "description__iew",
19905                &local_var_str
19906                    .into_iter()
19907                    .map(|p| p.to_string())
19908                    .collect::<Vec<String>>()
19909                    .join(",")
19910                    .to_string(),
19911            )]),
19912        };
19913    }
19914    if let Some(ref local_var_str) = description__iregex {
19915        local_var_req_builder = match "multi" {
19916            "multi" => local_var_req_builder.query(
19917                &local_var_str
19918                    .into_iter()
19919                    .map(|p| ("description__iregex".to_owned(), p.to_string()))
19920                    .collect::<Vec<(std::string::String, std::string::String)>>(),
19921            ),
19922            _ => local_var_req_builder.query(&[(
19923                "description__iregex",
19924                &local_var_str
19925                    .into_iter()
19926                    .map(|p| p.to_string())
19927                    .collect::<Vec<String>>()
19928                    .join(",")
19929                    .to_string(),
19930            )]),
19931        };
19932    }
19933    if let Some(ref local_var_str) = description__isw {
19934        local_var_req_builder = match "multi" {
19935            "multi" => local_var_req_builder.query(
19936                &local_var_str
19937                    .into_iter()
19938                    .map(|p| ("description__isw".to_owned(), p.to_string()))
19939                    .collect::<Vec<(std::string::String, std::string::String)>>(),
19940            ),
19941            _ => local_var_req_builder.query(&[(
19942                "description__isw",
19943                &local_var_str
19944                    .into_iter()
19945                    .map(|p| p.to_string())
19946                    .collect::<Vec<String>>()
19947                    .join(",")
19948                    .to_string(),
19949            )]),
19950        };
19951    }
19952    if let Some(ref local_var_str) = description__n {
19953        local_var_req_builder = match "multi" {
19954            "multi" => local_var_req_builder.query(
19955                &local_var_str
19956                    .into_iter()
19957                    .map(|p| ("description__n".to_owned(), p.to_string()))
19958                    .collect::<Vec<(std::string::String, std::string::String)>>(),
19959            ),
19960            _ => local_var_req_builder.query(&[(
19961                "description__n",
19962                &local_var_str
19963                    .into_iter()
19964                    .map(|p| p.to_string())
19965                    .collect::<Vec<String>>()
19966                    .join(",")
19967                    .to_string(),
19968            )]),
19969        };
19970    }
19971    if let Some(ref local_var_str) = description__nic {
19972        local_var_req_builder = match "multi" {
19973            "multi" => local_var_req_builder.query(
19974                &local_var_str
19975                    .into_iter()
19976                    .map(|p| ("description__nic".to_owned(), p.to_string()))
19977                    .collect::<Vec<(std::string::String, std::string::String)>>(),
19978            ),
19979            _ => local_var_req_builder.query(&[(
19980                "description__nic",
19981                &local_var_str
19982                    .into_iter()
19983                    .map(|p| p.to_string())
19984                    .collect::<Vec<String>>()
19985                    .join(",")
19986                    .to_string(),
19987            )]),
19988        };
19989    }
19990    if let Some(ref local_var_str) = description__nie {
19991        local_var_req_builder = match "multi" {
19992            "multi" => local_var_req_builder.query(
19993                &local_var_str
19994                    .into_iter()
19995                    .map(|p| ("description__nie".to_owned(), p.to_string()))
19996                    .collect::<Vec<(std::string::String, std::string::String)>>(),
19997            ),
19998            _ => local_var_req_builder.query(&[(
19999                "description__nie",
20000                &local_var_str
20001                    .into_iter()
20002                    .map(|p| p.to_string())
20003                    .collect::<Vec<String>>()
20004                    .join(",")
20005                    .to_string(),
20006            )]),
20007        };
20008    }
20009    if let Some(ref local_var_str) = description__niew {
20010        local_var_req_builder = match "multi" {
20011            "multi" => local_var_req_builder.query(
20012                &local_var_str
20013                    .into_iter()
20014                    .map(|p| ("description__niew".to_owned(), p.to_string()))
20015                    .collect::<Vec<(std::string::String, std::string::String)>>(),
20016            ),
20017            _ => local_var_req_builder.query(&[(
20018                "description__niew",
20019                &local_var_str
20020                    .into_iter()
20021                    .map(|p| p.to_string())
20022                    .collect::<Vec<String>>()
20023                    .join(",")
20024                    .to_string(),
20025            )]),
20026        };
20027    }
20028    if let Some(ref local_var_str) = description__nisw {
20029        local_var_req_builder = match "multi" {
20030            "multi" => local_var_req_builder.query(
20031                &local_var_str
20032                    .into_iter()
20033                    .map(|p| ("description__nisw".to_owned(), p.to_string()))
20034                    .collect::<Vec<(std::string::String, std::string::String)>>(),
20035            ),
20036            _ => local_var_req_builder.query(&[(
20037                "description__nisw",
20038                &local_var_str
20039                    .into_iter()
20040                    .map(|p| p.to_string())
20041                    .collect::<Vec<String>>()
20042                    .join(",")
20043                    .to_string(),
20044            )]),
20045        };
20046    }
20047    if let Some(ref local_var_str) = description__regex {
20048        local_var_req_builder = match "multi" {
20049            "multi" => local_var_req_builder.query(
20050                &local_var_str
20051                    .into_iter()
20052                    .map(|p| ("description__regex".to_owned(), p.to_string()))
20053                    .collect::<Vec<(std::string::String, std::string::String)>>(),
20054            ),
20055            _ => local_var_req_builder.query(&[(
20056                "description__regex",
20057                &local_var_str
20058                    .into_iter()
20059                    .map(|p| p.to_string())
20060                    .collect::<Vec<String>>()
20061                    .join(",")
20062                    .to_string(),
20063            )]),
20064        };
20065    }
20066    if let Some(ref local_var_str) = encapsulation {
20067        local_var_req_builder = match "multi" {
20068            "multi" => local_var_req_builder.query(
20069                &local_var_str
20070                    .into_iter()
20071                    .map(|p| ("encapsulation".to_owned(), p.to_string()))
20072                    .collect::<Vec<(std::string::String, std::string::String)>>(),
20073            ),
20074            _ => local_var_req_builder.query(&[(
20075                "encapsulation",
20076                &local_var_str
20077                    .into_iter()
20078                    .map(|p| p.to_string())
20079                    .collect::<Vec<String>>()
20080                    .join(",")
20081                    .to_string(),
20082            )]),
20083        };
20084    }
20085    if let Some(ref local_var_str) = encapsulation__empty {
20086        local_var_req_builder =
20087            local_var_req_builder.query(&[("encapsulation__empty", &local_var_str.to_string())]);
20088    }
20089    if let Some(ref local_var_str) = encapsulation__ic {
20090        local_var_req_builder = match "multi" {
20091            "multi" => local_var_req_builder.query(
20092                &local_var_str
20093                    .into_iter()
20094                    .map(|p| ("encapsulation__ic".to_owned(), p.to_string()))
20095                    .collect::<Vec<(std::string::String, std::string::String)>>(),
20096            ),
20097            _ => local_var_req_builder.query(&[(
20098                "encapsulation__ic",
20099                &local_var_str
20100                    .into_iter()
20101                    .map(|p| p.to_string())
20102                    .collect::<Vec<String>>()
20103                    .join(",")
20104                    .to_string(),
20105            )]),
20106        };
20107    }
20108    if let Some(ref local_var_str) = encapsulation__ie {
20109        local_var_req_builder = match "multi" {
20110            "multi" => local_var_req_builder.query(
20111                &local_var_str
20112                    .into_iter()
20113                    .map(|p| ("encapsulation__ie".to_owned(), p.to_string()))
20114                    .collect::<Vec<(std::string::String, std::string::String)>>(),
20115            ),
20116            _ => local_var_req_builder.query(&[(
20117                "encapsulation__ie",
20118                &local_var_str
20119                    .into_iter()
20120                    .map(|p| p.to_string())
20121                    .collect::<Vec<String>>()
20122                    .join(",")
20123                    .to_string(),
20124            )]),
20125        };
20126    }
20127    if let Some(ref local_var_str) = encapsulation__iew {
20128        local_var_req_builder = match "multi" {
20129            "multi" => local_var_req_builder.query(
20130                &local_var_str
20131                    .into_iter()
20132                    .map(|p| ("encapsulation__iew".to_owned(), p.to_string()))
20133                    .collect::<Vec<(std::string::String, std::string::String)>>(),
20134            ),
20135            _ => local_var_req_builder.query(&[(
20136                "encapsulation__iew",
20137                &local_var_str
20138                    .into_iter()
20139                    .map(|p| p.to_string())
20140                    .collect::<Vec<String>>()
20141                    .join(",")
20142                    .to_string(),
20143            )]),
20144        };
20145    }
20146    if let Some(ref local_var_str) = encapsulation__iregex {
20147        local_var_req_builder = match "multi" {
20148            "multi" => local_var_req_builder.query(
20149                &local_var_str
20150                    .into_iter()
20151                    .map(|p| ("encapsulation__iregex".to_owned(), p.to_string()))
20152                    .collect::<Vec<(std::string::String, std::string::String)>>(),
20153            ),
20154            _ => local_var_req_builder.query(&[(
20155                "encapsulation__iregex",
20156                &local_var_str
20157                    .into_iter()
20158                    .map(|p| p.to_string())
20159                    .collect::<Vec<String>>()
20160                    .join(",")
20161                    .to_string(),
20162            )]),
20163        };
20164    }
20165    if let Some(ref local_var_str) = encapsulation__isw {
20166        local_var_req_builder = match "multi" {
20167            "multi" => local_var_req_builder.query(
20168                &local_var_str
20169                    .into_iter()
20170                    .map(|p| ("encapsulation__isw".to_owned(), p.to_string()))
20171                    .collect::<Vec<(std::string::String, std::string::String)>>(),
20172            ),
20173            _ => local_var_req_builder.query(&[(
20174                "encapsulation__isw",
20175                &local_var_str
20176                    .into_iter()
20177                    .map(|p| p.to_string())
20178                    .collect::<Vec<String>>()
20179                    .join(",")
20180                    .to_string(),
20181            )]),
20182        };
20183    }
20184    if let Some(ref local_var_str) = encapsulation__n {
20185        local_var_req_builder = match "multi" {
20186            "multi" => local_var_req_builder.query(
20187                &local_var_str
20188                    .into_iter()
20189                    .map(|p| ("encapsulation__n".to_owned(), p.to_string()))
20190                    .collect::<Vec<(std::string::String, std::string::String)>>(),
20191            ),
20192            _ => local_var_req_builder.query(&[(
20193                "encapsulation__n",
20194                &local_var_str
20195                    .into_iter()
20196                    .map(|p| p.to_string())
20197                    .collect::<Vec<String>>()
20198                    .join(",")
20199                    .to_string(),
20200            )]),
20201        };
20202    }
20203    if let Some(ref local_var_str) = encapsulation__nic {
20204        local_var_req_builder = match "multi" {
20205            "multi" => local_var_req_builder.query(
20206                &local_var_str
20207                    .into_iter()
20208                    .map(|p| ("encapsulation__nic".to_owned(), p.to_string()))
20209                    .collect::<Vec<(std::string::String, std::string::String)>>(),
20210            ),
20211            _ => local_var_req_builder.query(&[(
20212                "encapsulation__nic",
20213                &local_var_str
20214                    .into_iter()
20215                    .map(|p| p.to_string())
20216                    .collect::<Vec<String>>()
20217                    .join(",")
20218                    .to_string(),
20219            )]),
20220        };
20221    }
20222    if let Some(ref local_var_str) = encapsulation__nie {
20223        local_var_req_builder = match "multi" {
20224            "multi" => local_var_req_builder.query(
20225                &local_var_str
20226                    .into_iter()
20227                    .map(|p| ("encapsulation__nie".to_owned(), p.to_string()))
20228                    .collect::<Vec<(std::string::String, std::string::String)>>(),
20229            ),
20230            _ => local_var_req_builder.query(&[(
20231                "encapsulation__nie",
20232                &local_var_str
20233                    .into_iter()
20234                    .map(|p| p.to_string())
20235                    .collect::<Vec<String>>()
20236                    .join(",")
20237                    .to_string(),
20238            )]),
20239        };
20240    }
20241    if let Some(ref local_var_str) = encapsulation__niew {
20242        local_var_req_builder = match "multi" {
20243            "multi" => local_var_req_builder.query(
20244                &local_var_str
20245                    .into_iter()
20246                    .map(|p| ("encapsulation__niew".to_owned(), p.to_string()))
20247                    .collect::<Vec<(std::string::String, std::string::String)>>(),
20248            ),
20249            _ => local_var_req_builder.query(&[(
20250                "encapsulation__niew",
20251                &local_var_str
20252                    .into_iter()
20253                    .map(|p| p.to_string())
20254                    .collect::<Vec<String>>()
20255                    .join(",")
20256                    .to_string(),
20257            )]),
20258        };
20259    }
20260    if let Some(ref local_var_str) = encapsulation__nisw {
20261        local_var_req_builder = match "multi" {
20262            "multi" => local_var_req_builder.query(
20263                &local_var_str
20264                    .into_iter()
20265                    .map(|p| ("encapsulation__nisw".to_owned(), p.to_string()))
20266                    .collect::<Vec<(std::string::String, std::string::String)>>(),
20267            ),
20268            _ => local_var_req_builder.query(&[(
20269                "encapsulation__nisw",
20270                &local_var_str
20271                    .into_iter()
20272                    .map(|p| p.to_string())
20273                    .collect::<Vec<String>>()
20274                    .join(",")
20275                    .to_string(),
20276            )]),
20277        };
20278    }
20279    if let Some(ref local_var_str) = encapsulation__regex {
20280        local_var_req_builder = match "multi" {
20281            "multi" => local_var_req_builder.query(
20282                &local_var_str
20283                    .into_iter()
20284                    .map(|p| ("encapsulation__regex".to_owned(), p.to_string()))
20285                    .collect::<Vec<(std::string::String, std::string::String)>>(),
20286            ),
20287            _ => local_var_req_builder.query(&[(
20288                "encapsulation__regex",
20289                &local_var_str
20290                    .into_iter()
20291                    .map(|p| p.to_string())
20292                    .collect::<Vec<String>>()
20293                    .join(",")
20294                    .to_string(),
20295            )]),
20296        };
20297    }
20298    if let Some(ref local_var_str) = group {
20299        local_var_req_builder = match "multi" {
20300            "multi" => local_var_req_builder.query(
20301                &local_var_str
20302                    .into_iter()
20303                    .map(|p| ("group".to_owned(), p.to_string()))
20304                    .collect::<Vec<(std::string::String, std::string::String)>>(),
20305            ),
20306            _ => local_var_req_builder.query(&[(
20307                "group",
20308                &local_var_str
20309                    .into_iter()
20310                    .map(|p| p.to_string())
20311                    .collect::<Vec<String>>()
20312                    .join(",")
20313                    .to_string(),
20314            )]),
20315        };
20316    }
20317    if let Some(ref local_var_str) = group__n {
20318        local_var_req_builder = match "multi" {
20319            "multi" => local_var_req_builder.query(
20320                &local_var_str
20321                    .into_iter()
20322                    .map(|p| ("group__n".to_owned(), p.to_string()))
20323                    .collect::<Vec<(std::string::String, std::string::String)>>(),
20324            ),
20325            _ => local_var_req_builder.query(&[(
20326                "group__n",
20327                &local_var_str
20328                    .into_iter()
20329                    .map(|p| p.to_string())
20330                    .collect::<Vec<String>>()
20331                    .join(",")
20332                    .to_string(),
20333            )]),
20334        };
20335    }
20336    if let Some(ref local_var_str) = group_id {
20337        local_var_req_builder = match "multi" {
20338            "multi" => local_var_req_builder.query(
20339                &local_var_str
20340                    .into_iter()
20341                    .map(|p| ("group_id".to_owned(), p.to_string()))
20342                    .collect::<Vec<(std::string::String, std::string::String)>>(),
20343            ),
20344            _ => local_var_req_builder.query(&[(
20345                "group_id",
20346                &local_var_str
20347                    .into_iter()
20348                    .map(|p| p.to_string())
20349                    .collect::<Vec<String>>()
20350                    .join(",")
20351                    .to_string(),
20352            )]),
20353        };
20354    }
20355    if let Some(ref local_var_str) = group_id__n {
20356        local_var_req_builder = match "multi" {
20357            "multi" => local_var_req_builder.query(
20358                &local_var_str
20359                    .into_iter()
20360                    .map(|p| ("group_id__n".to_owned(), p.to_string()))
20361                    .collect::<Vec<(std::string::String, std::string::String)>>(),
20362            ),
20363            _ => local_var_req_builder.query(&[(
20364                "group_id__n",
20365                &local_var_str
20366                    .into_iter()
20367                    .map(|p| p.to_string())
20368                    .collect::<Vec<String>>()
20369                    .join(",")
20370                    .to_string(),
20371            )]),
20372        };
20373    }
20374    if let Some(ref local_var_str) = id {
20375        local_var_req_builder = match "multi" {
20376            "multi" => local_var_req_builder.query(
20377                &local_var_str
20378                    .into_iter()
20379                    .map(|p| ("id".to_owned(), p.to_string()))
20380                    .collect::<Vec<(std::string::String, std::string::String)>>(),
20381            ),
20382            _ => local_var_req_builder.query(&[(
20383                "id",
20384                &local_var_str
20385                    .into_iter()
20386                    .map(|p| p.to_string())
20387                    .collect::<Vec<String>>()
20388                    .join(",")
20389                    .to_string(),
20390            )]),
20391        };
20392    }
20393    if let Some(ref local_var_str) = id__empty {
20394        local_var_req_builder =
20395            local_var_req_builder.query(&[("id__empty", &local_var_str.to_string())]);
20396    }
20397    if let Some(ref local_var_str) = id__gt {
20398        local_var_req_builder = match "multi" {
20399            "multi" => local_var_req_builder.query(
20400                &local_var_str
20401                    .into_iter()
20402                    .map(|p| ("id__gt".to_owned(), p.to_string()))
20403                    .collect::<Vec<(std::string::String, std::string::String)>>(),
20404            ),
20405            _ => local_var_req_builder.query(&[(
20406                "id__gt",
20407                &local_var_str
20408                    .into_iter()
20409                    .map(|p| p.to_string())
20410                    .collect::<Vec<String>>()
20411                    .join(",")
20412                    .to_string(),
20413            )]),
20414        };
20415    }
20416    if let Some(ref local_var_str) = id__gte {
20417        local_var_req_builder = match "multi" {
20418            "multi" => local_var_req_builder.query(
20419                &local_var_str
20420                    .into_iter()
20421                    .map(|p| ("id__gte".to_owned(), p.to_string()))
20422                    .collect::<Vec<(std::string::String, std::string::String)>>(),
20423            ),
20424            _ => local_var_req_builder.query(&[(
20425                "id__gte",
20426                &local_var_str
20427                    .into_iter()
20428                    .map(|p| p.to_string())
20429                    .collect::<Vec<String>>()
20430                    .join(",")
20431                    .to_string(),
20432            )]),
20433        };
20434    }
20435    if let Some(ref local_var_str) = id__lt {
20436        local_var_req_builder = match "multi" {
20437            "multi" => local_var_req_builder.query(
20438                &local_var_str
20439                    .into_iter()
20440                    .map(|p| ("id__lt".to_owned(), p.to_string()))
20441                    .collect::<Vec<(std::string::String, std::string::String)>>(),
20442            ),
20443            _ => local_var_req_builder.query(&[(
20444                "id__lt",
20445                &local_var_str
20446                    .into_iter()
20447                    .map(|p| p.to_string())
20448                    .collect::<Vec<String>>()
20449                    .join(",")
20450                    .to_string(),
20451            )]),
20452        };
20453    }
20454    if let Some(ref local_var_str) = id__lte {
20455        local_var_req_builder = match "multi" {
20456            "multi" => local_var_req_builder.query(
20457                &local_var_str
20458                    .into_iter()
20459                    .map(|p| ("id__lte".to_owned(), p.to_string()))
20460                    .collect::<Vec<(std::string::String, std::string::String)>>(),
20461            ),
20462            _ => local_var_req_builder.query(&[(
20463                "id__lte",
20464                &local_var_str
20465                    .into_iter()
20466                    .map(|p| p.to_string())
20467                    .collect::<Vec<String>>()
20468                    .join(",")
20469                    .to_string(),
20470            )]),
20471        };
20472    }
20473    if let Some(ref local_var_str) = id__n {
20474        local_var_req_builder = match "multi" {
20475            "multi" => local_var_req_builder.query(
20476                &local_var_str
20477                    .into_iter()
20478                    .map(|p| ("id__n".to_owned(), p.to_string()))
20479                    .collect::<Vec<(std::string::String, std::string::String)>>(),
20480            ),
20481            _ => local_var_req_builder.query(&[(
20482                "id__n",
20483                &local_var_str
20484                    .into_iter()
20485                    .map(|p| p.to_string())
20486                    .collect::<Vec<String>>()
20487                    .join(",")
20488                    .to_string(),
20489            )]),
20490        };
20491    }
20492    if let Some(ref local_var_str) = ipsec_profile {
20493        local_var_req_builder = match "multi" {
20494            "multi" => local_var_req_builder.query(
20495                &local_var_str
20496                    .into_iter()
20497                    .map(|p| ("ipsec_profile".to_owned(), p.to_string()))
20498                    .collect::<Vec<(std::string::String, std::string::String)>>(),
20499            ),
20500            _ => local_var_req_builder.query(&[(
20501                "ipsec_profile",
20502                &local_var_str
20503                    .into_iter()
20504                    .map(|p| p.to_string())
20505                    .collect::<Vec<String>>()
20506                    .join(",")
20507                    .to_string(),
20508            )]),
20509        };
20510    }
20511    if let Some(ref local_var_str) = ipsec_profile__n {
20512        local_var_req_builder = match "multi" {
20513            "multi" => local_var_req_builder.query(
20514                &local_var_str
20515                    .into_iter()
20516                    .map(|p| ("ipsec_profile__n".to_owned(), p.to_string()))
20517                    .collect::<Vec<(std::string::String, std::string::String)>>(),
20518            ),
20519            _ => local_var_req_builder.query(&[(
20520                "ipsec_profile__n",
20521                &local_var_str
20522                    .into_iter()
20523                    .map(|p| p.to_string())
20524                    .collect::<Vec<String>>()
20525                    .join(",")
20526                    .to_string(),
20527            )]),
20528        };
20529    }
20530    if let Some(ref local_var_str) = ipsec_profile_id {
20531        local_var_req_builder = match "multi" {
20532            "multi" => local_var_req_builder.query(
20533                &local_var_str
20534                    .into_iter()
20535                    .map(|p| ("ipsec_profile_id".to_owned(), p.to_string()))
20536                    .collect::<Vec<(std::string::String, std::string::String)>>(),
20537            ),
20538            _ => local_var_req_builder.query(&[(
20539                "ipsec_profile_id",
20540                &local_var_str
20541                    .into_iter()
20542                    .map(|p| p.to_string())
20543                    .collect::<Vec<String>>()
20544                    .join(",")
20545                    .to_string(),
20546            )]),
20547        };
20548    }
20549    if let Some(ref local_var_str) = ipsec_profile_id__n {
20550        local_var_req_builder = match "multi" {
20551            "multi" => local_var_req_builder.query(
20552                &local_var_str
20553                    .into_iter()
20554                    .map(|p| ("ipsec_profile_id__n".to_owned(), p.to_string()))
20555                    .collect::<Vec<(std::string::String, std::string::String)>>(),
20556            ),
20557            _ => local_var_req_builder.query(&[(
20558                "ipsec_profile_id__n",
20559                &local_var_str
20560                    .into_iter()
20561                    .map(|p| p.to_string())
20562                    .collect::<Vec<String>>()
20563                    .join(",")
20564                    .to_string(),
20565            )]),
20566        };
20567    }
20568    if let Some(ref local_var_str) = last_updated {
20569        local_var_req_builder = match "multi" {
20570            "multi" => local_var_req_builder.query(
20571                &local_var_str
20572                    .into_iter()
20573                    .map(|p| ("last_updated".to_owned(), p.to_string()))
20574                    .collect::<Vec<(std::string::String, std::string::String)>>(),
20575            ),
20576            _ => local_var_req_builder.query(&[(
20577                "last_updated",
20578                &local_var_str
20579                    .into_iter()
20580                    .map(|p| p.to_string())
20581                    .collect::<Vec<String>>()
20582                    .join(",")
20583                    .to_string(),
20584            )]),
20585        };
20586    }
20587    if let Some(ref local_var_str) = last_updated__empty {
20588        local_var_req_builder = match "multi" {
20589            "multi" => local_var_req_builder.query(
20590                &local_var_str
20591                    .into_iter()
20592                    .map(|p| ("last_updated__empty".to_owned(), p.to_string()))
20593                    .collect::<Vec<(std::string::String, std::string::String)>>(),
20594            ),
20595            _ => local_var_req_builder.query(&[(
20596                "last_updated__empty",
20597                &local_var_str
20598                    .into_iter()
20599                    .map(|p| p.to_string())
20600                    .collect::<Vec<String>>()
20601                    .join(",")
20602                    .to_string(),
20603            )]),
20604        };
20605    }
20606    if let Some(ref local_var_str) = last_updated__gt {
20607        local_var_req_builder = match "multi" {
20608            "multi" => local_var_req_builder.query(
20609                &local_var_str
20610                    .into_iter()
20611                    .map(|p| ("last_updated__gt".to_owned(), p.to_string()))
20612                    .collect::<Vec<(std::string::String, std::string::String)>>(),
20613            ),
20614            _ => local_var_req_builder.query(&[(
20615                "last_updated__gt",
20616                &local_var_str
20617                    .into_iter()
20618                    .map(|p| p.to_string())
20619                    .collect::<Vec<String>>()
20620                    .join(",")
20621                    .to_string(),
20622            )]),
20623        };
20624    }
20625    if let Some(ref local_var_str) = last_updated__gte {
20626        local_var_req_builder = match "multi" {
20627            "multi" => local_var_req_builder.query(
20628                &local_var_str
20629                    .into_iter()
20630                    .map(|p| ("last_updated__gte".to_owned(), p.to_string()))
20631                    .collect::<Vec<(std::string::String, std::string::String)>>(),
20632            ),
20633            _ => local_var_req_builder.query(&[(
20634                "last_updated__gte",
20635                &local_var_str
20636                    .into_iter()
20637                    .map(|p| p.to_string())
20638                    .collect::<Vec<String>>()
20639                    .join(",")
20640                    .to_string(),
20641            )]),
20642        };
20643    }
20644    if let Some(ref local_var_str) = last_updated__lt {
20645        local_var_req_builder = match "multi" {
20646            "multi" => local_var_req_builder.query(
20647                &local_var_str
20648                    .into_iter()
20649                    .map(|p| ("last_updated__lt".to_owned(), p.to_string()))
20650                    .collect::<Vec<(std::string::String, std::string::String)>>(),
20651            ),
20652            _ => local_var_req_builder.query(&[(
20653                "last_updated__lt",
20654                &local_var_str
20655                    .into_iter()
20656                    .map(|p| p.to_string())
20657                    .collect::<Vec<String>>()
20658                    .join(",")
20659                    .to_string(),
20660            )]),
20661        };
20662    }
20663    if let Some(ref local_var_str) = last_updated__lte {
20664        local_var_req_builder = match "multi" {
20665            "multi" => local_var_req_builder.query(
20666                &local_var_str
20667                    .into_iter()
20668                    .map(|p| ("last_updated__lte".to_owned(), p.to_string()))
20669                    .collect::<Vec<(std::string::String, std::string::String)>>(),
20670            ),
20671            _ => local_var_req_builder.query(&[(
20672                "last_updated__lte",
20673                &local_var_str
20674                    .into_iter()
20675                    .map(|p| p.to_string())
20676                    .collect::<Vec<String>>()
20677                    .join(",")
20678                    .to_string(),
20679            )]),
20680        };
20681    }
20682    if let Some(ref local_var_str) = last_updated__n {
20683        local_var_req_builder = match "multi" {
20684            "multi" => local_var_req_builder.query(
20685                &local_var_str
20686                    .into_iter()
20687                    .map(|p| ("last_updated__n".to_owned(), p.to_string()))
20688                    .collect::<Vec<(std::string::String, std::string::String)>>(),
20689            ),
20690            _ => local_var_req_builder.query(&[(
20691                "last_updated__n",
20692                &local_var_str
20693                    .into_iter()
20694                    .map(|p| p.to_string())
20695                    .collect::<Vec<String>>()
20696                    .join(",")
20697                    .to_string(),
20698            )]),
20699        };
20700    }
20701    if let Some(ref local_var_str) = limit {
20702        local_var_req_builder =
20703            local_var_req_builder.query(&[("limit", &local_var_str.to_string())]);
20704    }
20705    if let Some(ref local_var_str) = modified_by_request {
20706        local_var_req_builder =
20707            local_var_req_builder.query(&[("modified_by_request", &local_var_str.to_string())]);
20708    }
20709    if let Some(ref local_var_str) = name {
20710        local_var_req_builder = match "multi" {
20711            "multi" => local_var_req_builder.query(
20712                &local_var_str
20713                    .into_iter()
20714                    .map(|p| ("name".to_owned(), p.to_string()))
20715                    .collect::<Vec<(std::string::String, std::string::String)>>(),
20716            ),
20717            _ => local_var_req_builder.query(&[(
20718                "name",
20719                &local_var_str
20720                    .into_iter()
20721                    .map(|p| p.to_string())
20722                    .collect::<Vec<String>>()
20723                    .join(",")
20724                    .to_string(),
20725            )]),
20726        };
20727    }
20728    if let Some(ref local_var_str) = name__empty {
20729        local_var_req_builder =
20730            local_var_req_builder.query(&[("name__empty", &local_var_str.to_string())]);
20731    }
20732    if let Some(ref local_var_str) = name__ic {
20733        local_var_req_builder = match "multi" {
20734            "multi" => local_var_req_builder.query(
20735                &local_var_str
20736                    .into_iter()
20737                    .map(|p| ("name__ic".to_owned(), p.to_string()))
20738                    .collect::<Vec<(std::string::String, std::string::String)>>(),
20739            ),
20740            _ => local_var_req_builder.query(&[(
20741                "name__ic",
20742                &local_var_str
20743                    .into_iter()
20744                    .map(|p| p.to_string())
20745                    .collect::<Vec<String>>()
20746                    .join(",")
20747                    .to_string(),
20748            )]),
20749        };
20750    }
20751    if let Some(ref local_var_str) = name__ie {
20752        local_var_req_builder = match "multi" {
20753            "multi" => local_var_req_builder.query(
20754                &local_var_str
20755                    .into_iter()
20756                    .map(|p| ("name__ie".to_owned(), p.to_string()))
20757                    .collect::<Vec<(std::string::String, std::string::String)>>(),
20758            ),
20759            _ => local_var_req_builder.query(&[(
20760                "name__ie",
20761                &local_var_str
20762                    .into_iter()
20763                    .map(|p| p.to_string())
20764                    .collect::<Vec<String>>()
20765                    .join(",")
20766                    .to_string(),
20767            )]),
20768        };
20769    }
20770    if let Some(ref local_var_str) = name__iew {
20771        local_var_req_builder = match "multi" {
20772            "multi" => local_var_req_builder.query(
20773                &local_var_str
20774                    .into_iter()
20775                    .map(|p| ("name__iew".to_owned(), p.to_string()))
20776                    .collect::<Vec<(std::string::String, std::string::String)>>(),
20777            ),
20778            _ => local_var_req_builder.query(&[(
20779                "name__iew",
20780                &local_var_str
20781                    .into_iter()
20782                    .map(|p| p.to_string())
20783                    .collect::<Vec<String>>()
20784                    .join(",")
20785                    .to_string(),
20786            )]),
20787        };
20788    }
20789    if let Some(ref local_var_str) = name__iregex {
20790        local_var_req_builder = match "multi" {
20791            "multi" => local_var_req_builder.query(
20792                &local_var_str
20793                    .into_iter()
20794                    .map(|p| ("name__iregex".to_owned(), p.to_string()))
20795                    .collect::<Vec<(std::string::String, std::string::String)>>(),
20796            ),
20797            _ => local_var_req_builder.query(&[(
20798                "name__iregex",
20799                &local_var_str
20800                    .into_iter()
20801                    .map(|p| p.to_string())
20802                    .collect::<Vec<String>>()
20803                    .join(",")
20804                    .to_string(),
20805            )]),
20806        };
20807    }
20808    if let Some(ref local_var_str) = name__isw {
20809        local_var_req_builder = match "multi" {
20810            "multi" => local_var_req_builder.query(
20811                &local_var_str
20812                    .into_iter()
20813                    .map(|p| ("name__isw".to_owned(), p.to_string()))
20814                    .collect::<Vec<(std::string::String, std::string::String)>>(),
20815            ),
20816            _ => local_var_req_builder.query(&[(
20817                "name__isw",
20818                &local_var_str
20819                    .into_iter()
20820                    .map(|p| p.to_string())
20821                    .collect::<Vec<String>>()
20822                    .join(",")
20823                    .to_string(),
20824            )]),
20825        };
20826    }
20827    if let Some(ref local_var_str) = name__n {
20828        local_var_req_builder = match "multi" {
20829            "multi" => local_var_req_builder.query(
20830                &local_var_str
20831                    .into_iter()
20832                    .map(|p| ("name__n".to_owned(), p.to_string()))
20833                    .collect::<Vec<(std::string::String, std::string::String)>>(),
20834            ),
20835            _ => local_var_req_builder.query(&[(
20836                "name__n",
20837                &local_var_str
20838                    .into_iter()
20839                    .map(|p| p.to_string())
20840                    .collect::<Vec<String>>()
20841                    .join(",")
20842                    .to_string(),
20843            )]),
20844        };
20845    }
20846    if let Some(ref local_var_str) = name__nic {
20847        local_var_req_builder = match "multi" {
20848            "multi" => local_var_req_builder.query(
20849                &local_var_str
20850                    .into_iter()
20851                    .map(|p| ("name__nic".to_owned(), p.to_string()))
20852                    .collect::<Vec<(std::string::String, std::string::String)>>(),
20853            ),
20854            _ => local_var_req_builder.query(&[(
20855                "name__nic",
20856                &local_var_str
20857                    .into_iter()
20858                    .map(|p| p.to_string())
20859                    .collect::<Vec<String>>()
20860                    .join(",")
20861                    .to_string(),
20862            )]),
20863        };
20864    }
20865    if let Some(ref local_var_str) = name__nie {
20866        local_var_req_builder = match "multi" {
20867            "multi" => local_var_req_builder.query(
20868                &local_var_str
20869                    .into_iter()
20870                    .map(|p| ("name__nie".to_owned(), p.to_string()))
20871                    .collect::<Vec<(std::string::String, std::string::String)>>(),
20872            ),
20873            _ => local_var_req_builder.query(&[(
20874                "name__nie",
20875                &local_var_str
20876                    .into_iter()
20877                    .map(|p| p.to_string())
20878                    .collect::<Vec<String>>()
20879                    .join(",")
20880                    .to_string(),
20881            )]),
20882        };
20883    }
20884    if let Some(ref local_var_str) = name__niew {
20885        local_var_req_builder = match "multi" {
20886            "multi" => local_var_req_builder.query(
20887                &local_var_str
20888                    .into_iter()
20889                    .map(|p| ("name__niew".to_owned(), p.to_string()))
20890                    .collect::<Vec<(std::string::String, std::string::String)>>(),
20891            ),
20892            _ => local_var_req_builder.query(&[(
20893                "name__niew",
20894                &local_var_str
20895                    .into_iter()
20896                    .map(|p| p.to_string())
20897                    .collect::<Vec<String>>()
20898                    .join(",")
20899                    .to_string(),
20900            )]),
20901        };
20902    }
20903    if let Some(ref local_var_str) = name__nisw {
20904        local_var_req_builder = match "multi" {
20905            "multi" => local_var_req_builder.query(
20906                &local_var_str
20907                    .into_iter()
20908                    .map(|p| ("name__nisw".to_owned(), p.to_string()))
20909                    .collect::<Vec<(std::string::String, std::string::String)>>(),
20910            ),
20911            _ => local_var_req_builder.query(&[(
20912                "name__nisw",
20913                &local_var_str
20914                    .into_iter()
20915                    .map(|p| p.to_string())
20916                    .collect::<Vec<String>>()
20917                    .join(",")
20918                    .to_string(),
20919            )]),
20920        };
20921    }
20922    if let Some(ref local_var_str) = name__regex {
20923        local_var_req_builder = match "multi" {
20924            "multi" => local_var_req_builder.query(
20925                &local_var_str
20926                    .into_iter()
20927                    .map(|p| ("name__regex".to_owned(), p.to_string()))
20928                    .collect::<Vec<(std::string::String, std::string::String)>>(),
20929            ),
20930            _ => local_var_req_builder.query(&[(
20931                "name__regex",
20932                &local_var_str
20933                    .into_iter()
20934                    .map(|p| p.to_string())
20935                    .collect::<Vec<String>>()
20936                    .join(",")
20937                    .to_string(),
20938            )]),
20939        };
20940    }
20941    if let Some(ref local_var_str) = offset {
20942        local_var_req_builder =
20943            local_var_req_builder.query(&[("offset", &local_var_str.to_string())]);
20944    }
20945    if let Some(ref local_var_str) = ordering {
20946        local_var_req_builder =
20947            local_var_req_builder.query(&[("ordering", &local_var_str.to_string())]);
20948    }
20949    if let Some(ref local_var_str) = q {
20950        local_var_req_builder = local_var_req_builder.query(&[("q", &local_var_str.to_string())]);
20951    }
20952    if let Some(ref local_var_str) = status {
20953        local_var_req_builder = match "multi" {
20954            "multi" => local_var_req_builder.query(
20955                &local_var_str
20956                    .into_iter()
20957                    .map(|p| ("status".to_owned(), p.to_string()))
20958                    .collect::<Vec<(std::string::String, std::string::String)>>(),
20959            ),
20960            _ => local_var_req_builder.query(&[(
20961                "status",
20962                &local_var_str
20963                    .into_iter()
20964                    .map(|p| p.to_string())
20965                    .collect::<Vec<String>>()
20966                    .join(",")
20967                    .to_string(),
20968            )]),
20969        };
20970    }
20971    if let Some(ref local_var_str) = status__empty {
20972        local_var_req_builder =
20973            local_var_req_builder.query(&[("status__empty", &local_var_str.to_string())]);
20974    }
20975    if let Some(ref local_var_str) = status__ic {
20976        local_var_req_builder = match "multi" {
20977            "multi" => local_var_req_builder.query(
20978                &local_var_str
20979                    .into_iter()
20980                    .map(|p| ("status__ic".to_owned(), p.to_string()))
20981                    .collect::<Vec<(std::string::String, std::string::String)>>(),
20982            ),
20983            _ => local_var_req_builder.query(&[(
20984                "status__ic",
20985                &local_var_str
20986                    .into_iter()
20987                    .map(|p| p.to_string())
20988                    .collect::<Vec<String>>()
20989                    .join(",")
20990                    .to_string(),
20991            )]),
20992        };
20993    }
20994    if let Some(ref local_var_str) = status__ie {
20995        local_var_req_builder = match "multi" {
20996            "multi" => local_var_req_builder.query(
20997                &local_var_str
20998                    .into_iter()
20999                    .map(|p| ("status__ie".to_owned(), p.to_string()))
21000                    .collect::<Vec<(std::string::String, std::string::String)>>(),
21001            ),
21002            _ => local_var_req_builder.query(&[(
21003                "status__ie",
21004                &local_var_str
21005                    .into_iter()
21006                    .map(|p| p.to_string())
21007                    .collect::<Vec<String>>()
21008                    .join(",")
21009                    .to_string(),
21010            )]),
21011        };
21012    }
21013    if let Some(ref local_var_str) = status__iew {
21014        local_var_req_builder = match "multi" {
21015            "multi" => local_var_req_builder.query(
21016                &local_var_str
21017                    .into_iter()
21018                    .map(|p| ("status__iew".to_owned(), p.to_string()))
21019                    .collect::<Vec<(std::string::String, std::string::String)>>(),
21020            ),
21021            _ => local_var_req_builder.query(&[(
21022                "status__iew",
21023                &local_var_str
21024                    .into_iter()
21025                    .map(|p| p.to_string())
21026                    .collect::<Vec<String>>()
21027                    .join(",")
21028                    .to_string(),
21029            )]),
21030        };
21031    }
21032    if let Some(ref local_var_str) = status__iregex {
21033        local_var_req_builder = match "multi" {
21034            "multi" => local_var_req_builder.query(
21035                &local_var_str
21036                    .into_iter()
21037                    .map(|p| ("status__iregex".to_owned(), p.to_string()))
21038                    .collect::<Vec<(std::string::String, std::string::String)>>(),
21039            ),
21040            _ => local_var_req_builder.query(&[(
21041                "status__iregex",
21042                &local_var_str
21043                    .into_iter()
21044                    .map(|p| p.to_string())
21045                    .collect::<Vec<String>>()
21046                    .join(",")
21047                    .to_string(),
21048            )]),
21049        };
21050    }
21051    if let Some(ref local_var_str) = status__isw {
21052        local_var_req_builder = match "multi" {
21053            "multi" => local_var_req_builder.query(
21054                &local_var_str
21055                    .into_iter()
21056                    .map(|p| ("status__isw".to_owned(), p.to_string()))
21057                    .collect::<Vec<(std::string::String, std::string::String)>>(),
21058            ),
21059            _ => local_var_req_builder.query(&[(
21060                "status__isw",
21061                &local_var_str
21062                    .into_iter()
21063                    .map(|p| p.to_string())
21064                    .collect::<Vec<String>>()
21065                    .join(",")
21066                    .to_string(),
21067            )]),
21068        };
21069    }
21070    if let Some(ref local_var_str) = status__n {
21071        local_var_req_builder = match "multi" {
21072            "multi" => local_var_req_builder.query(
21073                &local_var_str
21074                    .into_iter()
21075                    .map(|p| ("status__n".to_owned(), p.to_string()))
21076                    .collect::<Vec<(std::string::String, std::string::String)>>(),
21077            ),
21078            _ => local_var_req_builder.query(&[(
21079                "status__n",
21080                &local_var_str
21081                    .into_iter()
21082                    .map(|p| p.to_string())
21083                    .collect::<Vec<String>>()
21084                    .join(",")
21085                    .to_string(),
21086            )]),
21087        };
21088    }
21089    if let Some(ref local_var_str) = status__nic {
21090        local_var_req_builder = match "multi" {
21091            "multi" => local_var_req_builder.query(
21092                &local_var_str
21093                    .into_iter()
21094                    .map(|p| ("status__nic".to_owned(), p.to_string()))
21095                    .collect::<Vec<(std::string::String, std::string::String)>>(),
21096            ),
21097            _ => local_var_req_builder.query(&[(
21098                "status__nic",
21099                &local_var_str
21100                    .into_iter()
21101                    .map(|p| p.to_string())
21102                    .collect::<Vec<String>>()
21103                    .join(",")
21104                    .to_string(),
21105            )]),
21106        };
21107    }
21108    if let Some(ref local_var_str) = status__nie {
21109        local_var_req_builder = match "multi" {
21110            "multi" => local_var_req_builder.query(
21111                &local_var_str
21112                    .into_iter()
21113                    .map(|p| ("status__nie".to_owned(), p.to_string()))
21114                    .collect::<Vec<(std::string::String, std::string::String)>>(),
21115            ),
21116            _ => local_var_req_builder.query(&[(
21117                "status__nie",
21118                &local_var_str
21119                    .into_iter()
21120                    .map(|p| p.to_string())
21121                    .collect::<Vec<String>>()
21122                    .join(",")
21123                    .to_string(),
21124            )]),
21125        };
21126    }
21127    if let Some(ref local_var_str) = status__niew {
21128        local_var_req_builder = match "multi" {
21129            "multi" => local_var_req_builder.query(
21130                &local_var_str
21131                    .into_iter()
21132                    .map(|p| ("status__niew".to_owned(), p.to_string()))
21133                    .collect::<Vec<(std::string::String, std::string::String)>>(),
21134            ),
21135            _ => local_var_req_builder.query(&[(
21136                "status__niew",
21137                &local_var_str
21138                    .into_iter()
21139                    .map(|p| p.to_string())
21140                    .collect::<Vec<String>>()
21141                    .join(",")
21142                    .to_string(),
21143            )]),
21144        };
21145    }
21146    if let Some(ref local_var_str) = status__nisw {
21147        local_var_req_builder = match "multi" {
21148            "multi" => local_var_req_builder.query(
21149                &local_var_str
21150                    .into_iter()
21151                    .map(|p| ("status__nisw".to_owned(), p.to_string()))
21152                    .collect::<Vec<(std::string::String, std::string::String)>>(),
21153            ),
21154            _ => local_var_req_builder.query(&[(
21155                "status__nisw",
21156                &local_var_str
21157                    .into_iter()
21158                    .map(|p| p.to_string())
21159                    .collect::<Vec<String>>()
21160                    .join(",")
21161                    .to_string(),
21162            )]),
21163        };
21164    }
21165    if let Some(ref local_var_str) = status__regex {
21166        local_var_req_builder = match "multi" {
21167            "multi" => local_var_req_builder.query(
21168                &local_var_str
21169                    .into_iter()
21170                    .map(|p| ("status__regex".to_owned(), p.to_string()))
21171                    .collect::<Vec<(std::string::String, std::string::String)>>(),
21172            ),
21173            _ => local_var_req_builder.query(&[(
21174                "status__regex",
21175                &local_var_str
21176                    .into_iter()
21177                    .map(|p| p.to_string())
21178                    .collect::<Vec<String>>()
21179                    .join(",")
21180                    .to_string(),
21181            )]),
21182        };
21183    }
21184    if let Some(ref local_var_str) = tag {
21185        local_var_req_builder = match "multi" {
21186            "multi" => local_var_req_builder.query(
21187                &local_var_str
21188                    .into_iter()
21189                    .map(|p| ("tag".to_owned(), p.to_string()))
21190                    .collect::<Vec<(std::string::String, std::string::String)>>(),
21191            ),
21192            _ => local_var_req_builder.query(&[(
21193                "tag",
21194                &local_var_str
21195                    .into_iter()
21196                    .map(|p| p.to_string())
21197                    .collect::<Vec<String>>()
21198                    .join(",")
21199                    .to_string(),
21200            )]),
21201        };
21202    }
21203    if let Some(ref local_var_str) = tag__n {
21204        local_var_req_builder = match "multi" {
21205            "multi" => local_var_req_builder.query(
21206                &local_var_str
21207                    .into_iter()
21208                    .map(|p| ("tag__n".to_owned(), p.to_string()))
21209                    .collect::<Vec<(std::string::String, std::string::String)>>(),
21210            ),
21211            _ => local_var_req_builder.query(&[(
21212                "tag__n",
21213                &local_var_str
21214                    .into_iter()
21215                    .map(|p| p.to_string())
21216                    .collect::<Vec<String>>()
21217                    .join(",")
21218                    .to_string(),
21219            )]),
21220        };
21221    }
21222    if let Some(ref local_var_str) = tag_id {
21223        local_var_req_builder = match "multi" {
21224            "multi" => local_var_req_builder.query(
21225                &local_var_str
21226                    .into_iter()
21227                    .map(|p| ("tag_id".to_owned(), p.to_string()))
21228                    .collect::<Vec<(std::string::String, std::string::String)>>(),
21229            ),
21230            _ => local_var_req_builder.query(&[(
21231                "tag_id",
21232                &local_var_str
21233                    .into_iter()
21234                    .map(|p| p.to_string())
21235                    .collect::<Vec<String>>()
21236                    .join(",")
21237                    .to_string(),
21238            )]),
21239        };
21240    }
21241    if let Some(ref local_var_str) = tag_id__n {
21242        local_var_req_builder = match "multi" {
21243            "multi" => local_var_req_builder.query(
21244                &local_var_str
21245                    .into_iter()
21246                    .map(|p| ("tag_id__n".to_owned(), p.to_string()))
21247                    .collect::<Vec<(std::string::String, std::string::String)>>(),
21248            ),
21249            _ => local_var_req_builder.query(&[(
21250                "tag_id__n",
21251                &local_var_str
21252                    .into_iter()
21253                    .map(|p| p.to_string())
21254                    .collect::<Vec<String>>()
21255                    .join(",")
21256                    .to_string(),
21257            )]),
21258        };
21259    }
21260    if let Some(ref local_var_str) = tenant {
21261        local_var_req_builder = match "multi" {
21262            "multi" => local_var_req_builder.query(
21263                &local_var_str
21264                    .into_iter()
21265                    .map(|p| ("tenant".to_owned(), p.to_string()))
21266                    .collect::<Vec<(std::string::String, std::string::String)>>(),
21267            ),
21268            _ => local_var_req_builder.query(&[(
21269                "tenant",
21270                &local_var_str
21271                    .into_iter()
21272                    .map(|p| p.to_string())
21273                    .collect::<Vec<String>>()
21274                    .join(",")
21275                    .to_string(),
21276            )]),
21277        };
21278    }
21279    if let Some(ref local_var_str) = tenant__n {
21280        local_var_req_builder = match "multi" {
21281            "multi" => local_var_req_builder.query(
21282                &local_var_str
21283                    .into_iter()
21284                    .map(|p| ("tenant__n".to_owned(), p.to_string()))
21285                    .collect::<Vec<(std::string::String, std::string::String)>>(),
21286            ),
21287            _ => local_var_req_builder.query(&[(
21288                "tenant__n",
21289                &local_var_str
21290                    .into_iter()
21291                    .map(|p| p.to_string())
21292                    .collect::<Vec<String>>()
21293                    .join(",")
21294                    .to_string(),
21295            )]),
21296        };
21297    }
21298    if let Some(ref local_var_str) = tenant_group {
21299        local_var_req_builder = match "multi" {
21300            "multi" => local_var_req_builder.query(
21301                &local_var_str
21302                    .into_iter()
21303                    .map(|p| ("tenant_group".to_owned(), p.to_string()))
21304                    .collect::<Vec<(std::string::String, std::string::String)>>(),
21305            ),
21306            _ => local_var_req_builder.query(&[(
21307                "tenant_group",
21308                &local_var_str
21309                    .into_iter()
21310                    .map(|p| p.to_string())
21311                    .collect::<Vec<String>>()
21312                    .join(",")
21313                    .to_string(),
21314            )]),
21315        };
21316    }
21317    if let Some(ref local_var_str) = tenant_group__n {
21318        local_var_req_builder = match "multi" {
21319            "multi" => local_var_req_builder.query(
21320                &local_var_str
21321                    .into_iter()
21322                    .map(|p| ("tenant_group__n".to_owned(), p.to_string()))
21323                    .collect::<Vec<(std::string::String, std::string::String)>>(),
21324            ),
21325            _ => local_var_req_builder.query(&[(
21326                "tenant_group__n",
21327                &local_var_str
21328                    .into_iter()
21329                    .map(|p| p.to_string())
21330                    .collect::<Vec<String>>()
21331                    .join(",")
21332                    .to_string(),
21333            )]),
21334        };
21335    }
21336    if let Some(ref local_var_str) = tenant_group_id {
21337        local_var_req_builder = match "multi" {
21338            "multi" => local_var_req_builder.query(
21339                &local_var_str
21340                    .into_iter()
21341                    .map(|p| ("tenant_group_id".to_owned(), p.to_string()))
21342                    .collect::<Vec<(std::string::String, std::string::String)>>(),
21343            ),
21344            _ => local_var_req_builder.query(&[(
21345                "tenant_group_id",
21346                &local_var_str
21347                    .into_iter()
21348                    .map(|p| p.to_string())
21349                    .collect::<Vec<String>>()
21350                    .join(",")
21351                    .to_string(),
21352            )]),
21353        };
21354    }
21355    if let Some(ref local_var_str) = tenant_group_id__n {
21356        local_var_req_builder = match "multi" {
21357            "multi" => local_var_req_builder.query(
21358                &local_var_str
21359                    .into_iter()
21360                    .map(|p| ("tenant_group_id__n".to_owned(), p.to_string()))
21361                    .collect::<Vec<(std::string::String, std::string::String)>>(),
21362            ),
21363            _ => local_var_req_builder.query(&[(
21364                "tenant_group_id__n",
21365                &local_var_str
21366                    .into_iter()
21367                    .map(|p| p.to_string())
21368                    .collect::<Vec<String>>()
21369                    .join(",")
21370                    .to_string(),
21371            )]),
21372        };
21373    }
21374    if let Some(ref local_var_str) = tenant_id {
21375        local_var_req_builder = match "multi" {
21376            "multi" => local_var_req_builder.query(
21377                &local_var_str
21378                    .into_iter()
21379                    .map(|p| ("tenant_id".to_owned(), p.to_string()))
21380                    .collect::<Vec<(std::string::String, std::string::String)>>(),
21381            ),
21382            _ => local_var_req_builder.query(&[(
21383                "tenant_id",
21384                &local_var_str
21385                    .into_iter()
21386                    .map(|p| p.to_string())
21387                    .collect::<Vec<String>>()
21388                    .join(",")
21389                    .to_string(),
21390            )]),
21391        };
21392    }
21393    if let Some(ref local_var_str) = tenant_id__n {
21394        local_var_req_builder = match "multi" {
21395            "multi" => local_var_req_builder.query(
21396                &local_var_str
21397                    .into_iter()
21398                    .map(|p| ("tenant_id__n".to_owned(), p.to_string()))
21399                    .collect::<Vec<(std::string::String, std::string::String)>>(),
21400            ),
21401            _ => local_var_req_builder.query(&[(
21402                "tenant_id__n",
21403                &local_var_str
21404                    .into_iter()
21405                    .map(|p| p.to_string())
21406                    .collect::<Vec<String>>()
21407                    .join(",")
21408                    .to_string(),
21409            )]),
21410        };
21411    }
21412    if let Some(ref local_var_str) = tunnel_id {
21413        local_var_req_builder = match "multi" {
21414            "multi" => local_var_req_builder.query(
21415                &local_var_str
21416                    .into_iter()
21417                    .map(|p| ("tunnel_id".to_owned(), p.to_string()))
21418                    .collect::<Vec<(std::string::String, std::string::String)>>(),
21419            ),
21420            _ => local_var_req_builder.query(&[(
21421                "tunnel_id",
21422                &local_var_str
21423                    .into_iter()
21424                    .map(|p| p.to_string())
21425                    .collect::<Vec<String>>()
21426                    .join(",")
21427                    .to_string(),
21428            )]),
21429        };
21430    }
21431    if let Some(ref local_var_str) = tunnel_id__empty {
21432        local_var_req_builder =
21433            local_var_req_builder.query(&[("tunnel_id__empty", &local_var_str.to_string())]);
21434    }
21435    if let Some(ref local_var_str) = tunnel_id__gt {
21436        local_var_req_builder = match "multi" {
21437            "multi" => local_var_req_builder.query(
21438                &local_var_str
21439                    .into_iter()
21440                    .map(|p| ("tunnel_id__gt".to_owned(), p.to_string()))
21441                    .collect::<Vec<(std::string::String, std::string::String)>>(),
21442            ),
21443            _ => local_var_req_builder.query(&[(
21444                "tunnel_id__gt",
21445                &local_var_str
21446                    .into_iter()
21447                    .map(|p| p.to_string())
21448                    .collect::<Vec<String>>()
21449                    .join(",")
21450                    .to_string(),
21451            )]),
21452        };
21453    }
21454    if let Some(ref local_var_str) = tunnel_id__gte {
21455        local_var_req_builder = match "multi" {
21456            "multi" => local_var_req_builder.query(
21457                &local_var_str
21458                    .into_iter()
21459                    .map(|p| ("tunnel_id__gte".to_owned(), p.to_string()))
21460                    .collect::<Vec<(std::string::String, std::string::String)>>(),
21461            ),
21462            _ => local_var_req_builder.query(&[(
21463                "tunnel_id__gte",
21464                &local_var_str
21465                    .into_iter()
21466                    .map(|p| p.to_string())
21467                    .collect::<Vec<String>>()
21468                    .join(",")
21469                    .to_string(),
21470            )]),
21471        };
21472    }
21473    if let Some(ref local_var_str) = tunnel_id__lt {
21474        local_var_req_builder = match "multi" {
21475            "multi" => local_var_req_builder.query(
21476                &local_var_str
21477                    .into_iter()
21478                    .map(|p| ("tunnel_id__lt".to_owned(), p.to_string()))
21479                    .collect::<Vec<(std::string::String, std::string::String)>>(),
21480            ),
21481            _ => local_var_req_builder.query(&[(
21482                "tunnel_id__lt",
21483                &local_var_str
21484                    .into_iter()
21485                    .map(|p| p.to_string())
21486                    .collect::<Vec<String>>()
21487                    .join(",")
21488                    .to_string(),
21489            )]),
21490        };
21491    }
21492    if let Some(ref local_var_str) = tunnel_id__lte {
21493        local_var_req_builder = match "multi" {
21494            "multi" => local_var_req_builder.query(
21495                &local_var_str
21496                    .into_iter()
21497                    .map(|p| ("tunnel_id__lte".to_owned(), p.to_string()))
21498                    .collect::<Vec<(std::string::String, std::string::String)>>(),
21499            ),
21500            _ => local_var_req_builder.query(&[(
21501                "tunnel_id__lte",
21502                &local_var_str
21503                    .into_iter()
21504                    .map(|p| p.to_string())
21505                    .collect::<Vec<String>>()
21506                    .join(",")
21507                    .to_string(),
21508            )]),
21509        };
21510    }
21511    if let Some(ref local_var_str) = tunnel_id__n {
21512        local_var_req_builder = match "multi" {
21513            "multi" => local_var_req_builder.query(
21514                &local_var_str
21515                    .into_iter()
21516                    .map(|p| ("tunnel_id__n".to_owned(), p.to_string()))
21517                    .collect::<Vec<(std::string::String, std::string::String)>>(),
21518            ),
21519            _ => local_var_req_builder.query(&[(
21520                "tunnel_id__n",
21521                &local_var_str
21522                    .into_iter()
21523                    .map(|p| p.to_string())
21524                    .collect::<Vec<String>>()
21525                    .join(",")
21526                    .to_string(),
21527            )]),
21528        };
21529    }
21530    if let Some(ref local_var_str) = updated_by_request {
21531        local_var_req_builder =
21532            local_var_req_builder.query(&[("updated_by_request", &local_var_str.to_string())]);
21533    }
21534    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
21535        local_var_req_builder =
21536            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
21537    }
21538    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
21539        let local_var_key = local_var_apikey.key.clone();
21540        let local_var_value = match local_var_apikey.prefix {
21541            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
21542            None => local_var_key,
21543        };
21544        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
21545    };
21546
21547    let local_var_req = local_var_req_builder.build()?;
21548    let local_var_resp = local_var_client.execute(local_var_req).await?;
21549
21550    let local_var_status = local_var_resp.status();
21551    let local_var_content = local_var_resp.text().await?;
21552
21553    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
21554        serde_json::from_str(&local_var_content).map_err(Error::from)
21555    } else {
21556        let local_var_entity: Option<VpnTunnelsListError> =
21557            serde_json::from_str(&local_var_content).ok();
21558        let local_var_error = ResponseContent {
21559            status: local_var_status,
21560            content: local_var_content,
21561            entity: local_var_entity,
21562        };
21563        Err(Error::ResponseError(local_var_error))
21564    }
21565}
21566
21567/// Patch a tunnel object.
21568pub async fn vpn_tunnels_partial_update(
21569    configuration: &configuration::Configuration,
21570    id: i32,
21571    patched_writable_tunnel_request: Option<crate::models::PatchedWritableTunnelRequest>,
21572) -> Result<crate::models::Tunnel, Error<VpnTunnelsPartialUpdateError>> {
21573    let local_var_configuration = configuration;
21574
21575    let local_var_client = &local_var_configuration.client;
21576
21577    let local_var_uri_str = format!(
21578        "{}/api/vpn/tunnels/{id}/",
21579        local_var_configuration.base_path,
21580        id = id
21581    );
21582    let mut local_var_req_builder =
21583        local_var_client.request(reqwest::Method::PATCH, local_var_uri_str.as_str());
21584
21585    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
21586        local_var_req_builder =
21587            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
21588    }
21589    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
21590        let local_var_key = local_var_apikey.key.clone();
21591        let local_var_value = match local_var_apikey.prefix {
21592            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
21593            None => local_var_key,
21594        };
21595        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
21596    };
21597    local_var_req_builder = local_var_req_builder.json(&patched_writable_tunnel_request);
21598
21599    let local_var_req = local_var_req_builder.build()?;
21600    let local_var_resp = local_var_client.execute(local_var_req).await?;
21601
21602    let local_var_status = local_var_resp.status();
21603    let local_var_content = local_var_resp.text().await?;
21604
21605    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
21606        serde_json::from_str(&local_var_content).map_err(Error::from)
21607    } else {
21608        let local_var_entity: Option<VpnTunnelsPartialUpdateError> =
21609            serde_json::from_str(&local_var_content).ok();
21610        let local_var_error = ResponseContent {
21611            status: local_var_status,
21612            content: local_var_content,
21613            entity: local_var_entity,
21614        };
21615        Err(Error::ResponseError(local_var_error))
21616    }
21617}
21618
21619/// Get a tunnel object.
21620pub async fn vpn_tunnels_retrieve(
21621    configuration: &configuration::Configuration,
21622    id: i32,
21623) -> Result<crate::models::Tunnel, Error<VpnTunnelsRetrieveError>> {
21624    let local_var_configuration = configuration;
21625
21626    let local_var_client = &local_var_configuration.client;
21627
21628    let local_var_uri_str = format!(
21629        "{}/api/vpn/tunnels/{id}/",
21630        local_var_configuration.base_path,
21631        id = id
21632    );
21633    let mut local_var_req_builder =
21634        local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
21635
21636    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
21637        local_var_req_builder =
21638            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
21639    }
21640    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
21641        let local_var_key = local_var_apikey.key.clone();
21642        let local_var_value = match local_var_apikey.prefix {
21643            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
21644            None => local_var_key,
21645        };
21646        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
21647    };
21648
21649    let local_var_req = local_var_req_builder.build()?;
21650    let local_var_resp = local_var_client.execute(local_var_req).await?;
21651
21652    let local_var_status = local_var_resp.status();
21653    let local_var_content = local_var_resp.text().await?;
21654
21655    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
21656        serde_json::from_str(&local_var_content).map_err(Error::from)
21657    } else {
21658        let local_var_entity: Option<VpnTunnelsRetrieveError> =
21659            serde_json::from_str(&local_var_content).ok();
21660        let local_var_error = ResponseContent {
21661            status: local_var_status,
21662            content: local_var_content,
21663            entity: local_var_entity,
21664        };
21665        Err(Error::ResponseError(local_var_error))
21666    }
21667}
21668
21669/// Put a tunnel object.
21670pub async fn vpn_tunnels_update(
21671    configuration: &configuration::Configuration,
21672    id: i32,
21673    writable_tunnel_request: crate::models::WritableTunnelRequest,
21674) -> Result<crate::models::Tunnel, Error<VpnTunnelsUpdateError>> {
21675    let local_var_configuration = configuration;
21676
21677    let local_var_client = &local_var_configuration.client;
21678
21679    let local_var_uri_str = format!(
21680        "{}/api/vpn/tunnels/{id}/",
21681        local_var_configuration.base_path,
21682        id = id
21683    );
21684    let mut local_var_req_builder =
21685        local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());
21686
21687    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
21688        local_var_req_builder =
21689            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
21690    }
21691    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
21692        let local_var_key = local_var_apikey.key.clone();
21693        let local_var_value = match local_var_apikey.prefix {
21694            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
21695            None => local_var_key,
21696        };
21697        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
21698    };
21699    local_var_req_builder = local_var_req_builder.json(&writable_tunnel_request);
21700
21701    let local_var_req = local_var_req_builder.build()?;
21702    let local_var_resp = local_var_client.execute(local_var_req).await?;
21703
21704    let local_var_status = local_var_resp.status();
21705    let local_var_content = local_var_resp.text().await?;
21706
21707    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
21708        serde_json::from_str(&local_var_content).map_err(Error::from)
21709    } else {
21710        let local_var_entity: Option<VpnTunnelsUpdateError> =
21711            serde_json::from_str(&local_var_content).ok();
21712        let local_var_error = ResponseContent {
21713            status: local_var_status,
21714            content: local_var_content,
21715            entity: local_var_entity,
21716        };
21717        Err(Error::ResponseError(local_var_error))
21718    }
21719}
netbox_openapi/apis/vpn_api.rs

netbox_openapi/apis/
vpn_api.rs
