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.6.0 (4.6)
7 *
8 * Generated by: https://openapi-generator.tech
9 */
10
11use reqwest;
12
13use super::{Error, configuration};
14use crate::apis::ResponseContent;
15
16/// struct for typed errors of method [`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    vpn_ike_policies_create_request: crate::models::VpnIkePoliciesCreateRequest,
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(&vpn_ike_policies_create_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    owner: Option<Vec<String>>,
969    owner__n: Option<Vec<String>>,
970    owner_group: Option<Vec<String>>,
971    owner_group__n: Option<Vec<String>>,
972    owner_group_id: Option<Vec<i32>>,
973    owner_group_id__n: Option<Vec<i32>>,
974    owner_id: Option<Vec<i32>>,
975    owner_id__n: Option<Vec<i32>>,
976    preshared_key: Option<&str>,
977    preshared_key__ic: Option<&str>,
978    preshared_key__ie: Option<&str>,
979    preshared_key__iew: Option<&str>,
980    preshared_key__iregex: Option<&str>,
981    preshared_key__isw: Option<&str>,
982    preshared_key__n: Option<&str>,
983    preshared_key__nic: Option<&str>,
984    preshared_key__nie: Option<&str>,
985    preshared_key__niew: Option<&str>,
986    preshared_key__nisw: Option<&str>,
987    preshared_key__regex: Option<&str>,
988    q: Option<&str>,
989    start: Option<i32>,
990    tag: Option<Vec<String>>,
991    tag__n: Option<Vec<String>>,
992    tag_id: Option<Vec<i32>>,
993    tag_id__n: Option<Vec<i32>>,
994    updated_by_request: Option<&str>,
995    version: Option<Vec<i32>>,
996    version__ic: Option<Vec<i32>>,
997    version__ie: Option<Vec<i32>>,
998    version__iew: Option<Vec<i32>>,
999    version__iregex: Option<Vec<i32>>,
1000    version__isw: Option<Vec<i32>>,
1001    version__n: Option<Vec<i32>>,
1002    version__nic: Option<Vec<i32>>,
1003    version__nie: Option<Vec<i32>>,
1004    version__niew: Option<Vec<i32>>,
1005    version__nisw: Option<Vec<i32>>,
1006    version__regex: Option<Vec<i32>>,
1007) -> Result<crate::models::PaginatedIkePolicyList, Error<VpnIkePoliciesListError>> {
1008    let local_var_configuration = configuration;
1009
1010    let local_var_client = &local_var_configuration.client;
1011
1012    let local_var_uri_str = format!(
1013        "{}/api/vpn/ike-policies/",
1014        local_var_configuration.base_path
1015    );
1016    let mut local_var_req_builder =
1017        local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
1018
1019    if let Some(ref local_var_str) = created {
1020        local_var_req_builder = match "multi" {
1021            "multi" => local_var_req_builder.query(
1022                &local_var_str
1023                    .into_iter()
1024                    .map(|p| ("created".to_owned(), p.to_string()))
1025                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1026            ),
1027            _ => local_var_req_builder.query(&[(
1028                "created",
1029                &local_var_str
1030                    .into_iter()
1031                    .map(|p| p.to_string())
1032                    .collect::<Vec<String>>()
1033                    .join(",")
1034                    .to_string(),
1035            )]),
1036        };
1037    }
1038    if let Some(ref local_var_str) = created__empty {
1039        local_var_req_builder = match "multi" {
1040            "multi" => local_var_req_builder.query(
1041                &local_var_str
1042                    .into_iter()
1043                    .map(|p| ("created__empty".to_owned(), p.to_string()))
1044                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1045            ),
1046            _ => local_var_req_builder.query(&[(
1047                "created__empty",
1048                &local_var_str
1049                    .into_iter()
1050                    .map(|p| p.to_string())
1051                    .collect::<Vec<String>>()
1052                    .join(",")
1053                    .to_string(),
1054            )]),
1055        };
1056    }
1057    if let Some(ref local_var_str) = created__gt {
1058        local_var_req_builder = match "multi" {
1059            "multi" => local_var_req_builder.query(
1060                &local_var_str
1061                    .into_iter()
1062                    .map(|p| ("created__gt".to_owned(), p.to_string()))
1063                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1064            ),
1065            _ => local_var_req_builder.query(&[(
1066                "created__gt",
1067                &local_var_str
1068                    .into_iter()
1069                    .map(|p| p.to_string())
1070                    .collect::<Vec<String>>()
1071                    .join(",")
1072                    .to_string(),
1073            )]),
1074        };
1075    }
1076    if let Some(ref local_var_str) = created__gte {
1077        local_var_req_builder = match "multi" {
1078            "multi" => local_var_req_builder.query(
1079                &local_var_str
1080                    .into_iter()
1081                    .map(|p| ("created__gte".to_owned(), p.to_string()))
1082                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1083            ),
1084            _ => local_var_req_builder.query(&[(
1085                "created__gte",
1086                &local_var_str
1087                    .into_iter()
1088                    .map(|p| p.to_string())
1089                    .collect::<Vec<String>>()
1090                    .join(",")
1091                    .to_string(),
1092            )]),
1093        };
1094    }
1095    if let Some(ref local_var_str) = created__lt {
1096        local_var_req_builder = match "multi" {
1097            "multi" => local_var_req_builder.query(
1098                &local_var_str
1099                    .into_iter()
1100                    .map(|p| ("created__lt".to_owned(), p.to_string()))
1101                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1102            ),
1103            _ => local_var_req_builder.query(&[(
1104                "created__lt",
1105                &local_var_str
1106                    .into_iter()
1107                    .map(|p| p.to_string())
1108                    .collect::<Vec<String>>()
1109                    .join(",")
1110                    .to_string(),
1111            )]),
1112        };
1113    }
1114    if let Some(ref local_var_str) = created__lte {
1115        local_var_req_builder = match "multi" {
1116            "multi" => local_var_req_builder.query(
1117                &local_var_str
1118                    .into_iter()
1119                    .map(|p| ("created__lte".to_owned(), p.to_string()))
1120                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1121            ),
1122            _ => local_var_req_builder.query(&[(
1123                "created__lte",
1124                &local_var_str
1125                    .into_iter()
1126                    .map(|p| p.to_string())
1127                    .collect::<Vec<String>>()
1128                    .join(",")
1129                    .to_string(),
1130            )]),
1131        };
1132    }
1133    if let Some(ref local_var_str) = created__n {
1134        local_var_req_builder = match "multi" {
1135            "multi" => local_var_req_builder.query(
1136                &local_var_str
1137                    .into_iter()
1138                    .map(|p| ("created__n".to_owned(), p.to_string()))
1139                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1140            ),
1141            _ => local_var_req_builder.query(&[(
1142                "created__n",
1143                &local_var_str
1144                    .into_iter()
1145                    .map(|p| p.to_string())
1146                    .collect::<Vec<String>>()
1147                    .join(",")
1148                    .to_string(),
1149            )]),
1150        };
1151    }
1152    if let Some(ref local_var_str) = created_by_request {
1153        local_var_req_builder =
1154            local_var_req_builder.query(&[("created_by_request", &local_var_str.to_string())]);
1155    }
1156    if let Some(ref local_var_str) = description {
1157        local_var_req_builder = match "multi" {
1158            "multi" => local_var_req_builder.query(
1159                &local_var_str
1160                    .into_iter()
1161                    .map(|p| ("description".to_owned(), p.to_string()))
1162                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1163            ),
1164            _ => local_var_req_builder.query(&[(
1165                "description",
1166                &local_var_str
1167                    .into_iter()
1168                    .map(|p| p.to_string())
1169                    .collect::<Vec<String>>()
1170                    .join(",")
1171                    .to_string(),
1172            )]),
1173        };
1174    }
1175    if let Some(ref local_var_str) = description__empty {
1176        local_var_req_builder =
1177            local_var_req_builder.query(&[("description__empty", &local_var_str.to_string())]);
1178    }
1179    if let Some(ref local_var_str) = description__ic {
1180        local_var_req_builder = match "multi" {
1181            "multi" => local_var_req_builder.query(
1182                &local_var_str
1183                    .into_iter()
1184                    .map(|p| ("description__ic".to_owned(), p.to_string()))
1185                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1186            ),
1187            _ => local_var_req_builder.query(&[(
1188                "description__ic",
1189                &local_var_str
1190                    .into_iter()
1191                    .map(|p| p.to_string())
1192                    .collect::<Vec<String>>()
1193                    .join(",")
1194                    .to_string(),
1195            )]),
1196        };
1197    }
1198    if let Some(ref local_var_str) = description__ie {
1199        local_var_req_builder = match "multi" {
1200            "multi" => local_var_req_builder.query(
1201                &local_var_str
1202                    .into_iter()
1203                    .map(|p| ("description__ie".to_owned(), p.to_string()))
1204                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1205            ),
1206            _ => local_var_req_builder.query(&[(
1207                "description__ie",
1208                &local_var_str
1209                    .into_iter()
1210                    .map(|p| p.to_string())
1211                    .collect::<Vec<String>>()
1212                    .join(",")
1213                    .to_string(),
1214            )]),
1215        };
1216    }
1217    if let Some(ref local_var_str) = description__iew {
1218        local_var_req_builder = match "multi" {
1219            "multi" => local_var_req_builder.query(
1220                &local_var_str
1221                    .into_iter()
1222                    .map(|p| ("description__iew".to_owned(), p.to_string()))
1223                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1224            ),
1225            _ => local_var_req_builder.query(&[(
1226                "description__iew",
1227                &local_var_str
1228                    .into_iter()
1229                    .map(|p| p.to_string())
1230                    .collect::<Vec<String>>()
1231                    .join(",")
1232                    .to_string(),
1233            )]),
1234        };
1235    }
1236    if let Some(ref local_var_str) = description__iregex {
1237        local_var_req_builder = match "multi" {
1238            "multi" => local_var_req_builder.query(
1239                &local_var_str
1240                    .into_iter()
1241                    .map(|p| ("description__iregex".to_owned(), p.to_string()))
1242                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1243            ),
1244            _ => local_var_req_builder.query(&[(
1245                "description__iregex",
1246                &local_var_str
1247                    .into_iter()
1248                    .map(|p| p.to_string())
1249                    .collect::<Vec<String>>()
1250                    .join(",")
1251                    .to_string(),
1252            )]),
1253        };
1254    }
1255    if let Some(ref local_var_str) = description__isw {
1256        local_var_req_builder = match "multi" {
1257            "multi" => local_var_req_builder.query(
1258                &local_var_str
1259                    .into_iter()
1260                    .map(|p| ("description__isw".to_owned(), p.to_string()))
1261                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1262            ),
1263            _ => local_var_req_builder.query(&[(
1264                "description__isw",
1265                &local_var_str
1266                    .into_iter()
1267                    .map(|p| p.to_string())
1268                    .collect::<Vec<String>>()
1269                    .join(",")
1270                    .to_string(),
1271            )]),
1272        };
1273    }
1274    if let Some(ref local_var_str) = description__n {
1275        local_var_req_builder = match "multi" {
1276            "multi" => local_var_req_builder.query(
1277                &local_var_str
1278                    .into_iter()
1279                    .map(|p| ("description__n".to_owned(), p.to_string()))
1280                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1281            ),
1282            _ => local_var_req_builder.query(&[(
1283                "description__n",
1284                &local_var_str
1285                    .into_iter()
1286                    .map(|p| p.to_string())
1287                    .collect::<Vec<String>>()
1288                    .join(",")
1289                    .to_string(),
1290            )]),
1291        };
1292    }
1293    if let Some(ref local_var_str) = description__nic {
1294        local_var_req_builder = match "multi" {
1295            "multi" => local_var_req_builder.query(
1296                &local_var_str
1297                    .into_iter()
1298                    .map(|p| ("description__nic".to_owned(), p.to_string()))
1299                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1300            ),
1301            _ => local_var_req_builder.query(&[(
1302                "description__nic",
1303                &local_var_str
1304                    .into_iter()
1305                    .map(|p| p.to_string())
1306                    .collect::<Vec<String>>()
1307                    .join(",")
1308                    .to_string(),
1309            )]),
1310        };
1311    }
1312    if let Some(ref local_var_str) = description__nie {
1313        local_var_req_builder = match "multi" {
1314            "multi" => local_var_req_builder.query(
1315                &local_var_str
1316                    .into_iter()
1317                    .map(|p| ("description__nie".to_owned(), p.to_string()))
1318                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1319            ),
1320            _ => local_var_req_builder.query(&[(
1321                "description__nie",
1322                &local_var_str
1323                    .into_iter()
1324                    .map(|p| p.to_string())
1325                    .collect::<Vec<String>>()
1326                    .join(",")
1327                    .to_string(),
1328            )]),
1329        };
1330    }
1331    if let Some(ref local_var_str) = description__niew {
1332        local_var_req_builder = match "multi" {
1333            "multi" => local_var_req_builder.query(
1334                &local_var_str
1335                    .into_iter()
1336                    .map(|p| ("description__niew".to_owned(), p.to_string()))
1337                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1338            ),
1339            _ => local_var_req_builder.query(&[(
1340                "description__niew",
1341                &local_var_str
1342                    .into_iter()
1343                    .map(|p| p.to_string())
1344                    .collect::<Vec<String>>()
1345                    .join(",")
1346                    .to_string(),
1347            )]),
1348        };
1349    }
1350    if let Some(ref local_var_str) = description__nisw {
1351        local_var_req_builder = match "multi" {
1352            "multi" => local_var_req_builder.query(
1353                &local_var_str
1354                    .into_iter()
1355                    .map(|p| ("description__nisw".to_owned(), p.to_string()))
1356                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1357            ),
1358            _ => local_var_req_builder.query(&[(
1359                "description__nisw",
1360                &local_var_str
1361                    .into_iter()
1362                    .map(|p| p.to_string())
1363                    .collect::<Vec<String>>()
1364                    .join(",")
1365                    .to_string(),
1366            )]),
1367        };
1368    }
1369    if let Some(ref local_var_str) = description__regex {
1370        local_var_req_builder = match "multi" {
1371            "multi" => local_var_req_builder.query(
1372                &local_var_str
1373                    .into_iter()
1374                    .map(|p| ("description__regex".to_owned(), p.to_string()))
1375                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1376            ),
1377            _ => local_var_req_builder.query(&[(
1378                "description__regex",
1379                &local_var_str
1380                    .into_iter()
1381                    .map(|p| p.to_string())
1382                    .collect::<Vec<String>>()
1383                    .join(",")
1384                    .to_string(),
1385            )]),
1386        };
1387    }
1388    if let Some(ref local_var_str) = id {
1389        local_var_req_builder = match "multi" {
1390            "multi" => local_var_req_builder.query(
1391                &local_var_str
1392                    .into_iter()
1393                    .map(|p| ("id".to_owned(), p.to_string()))
1394                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1395            ),
1396            _ => local_var_req_builder.query(&[(
1397                "id",
1398                &local_var_str
1399                    .into_iter()
1400                    .map(|p| p.to_string())
1401                    .collect::<Vec<String>>()
1402                    .join(",")
1403                    .to_string(),
1404            )]),
1405        };
1406    }
1407    if let Some(ref local_var_str) = id__empty {
1408        local_var_req_builder =
1409            local_var_req_builder.query(&[("id__empty", &local_var_str.to_string())]);
1410    }
1411    if let Some(ref local_var_str) = id__gt {
1412        local_var_req_builder = match "multi" {
1413            "multi" => local_var_req_builder.query(
1414                &local_var_str
1415                    .into_iter()
1416                    .map(|p| ("id__gt".to_owned(), p.to_string()))
1417                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1418            ),
1419            _ => local_var_req_builder.query(&[(
1420                "id__gt",
1421                &local_var_str
1422                    .into_iter()
1423                    .map(|p| p.to_string())
1424                    .collect::<Vec<String>>()
1425                    .join(",")
1426                    .to_string(),
1427            )]),
1428        };
1429    }
1430    if let Some(ref local_var_str) = id__gte {
1431        local_var_req_builder = match "multi" {
1432            "multi" => local_var_req_builder.query(
1433                &local_var_str
1434                    .into_iter()
1435                    .map(|p| ("id__gte".to_owned(), p.to_string()))
1436                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1437            ),
1438            _ => local_var_req_builder.query(&[(
1439                "id__gte",
1440                &local_var_str
1441                    .into_iter()
1442                    .map(|p| p.to_string())
1443                    .collect::<Vec<String>>()
1444                    .join(",")
1445                    .to_string(),
1446            )]),
1447        };
1448    }
1449    if let Some(ref local_var_str) = id__lt {
1450        local_var_req_builder = match "multi" {
1451            "multi" => local_var_req_builder.query(
1452                &local_var_str
1453                    .into_iter()
1454                    .map(|p| ("id__lt".to_owned(), p.to_string()))
1455                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1456            ),
1457            _ => local_var_req_builder.query(&[(
1458                "id__lt",
1459                &local_var_str
1460                    .into_iter()
1461                    .map(|p| p.to_string())
1462                    .collect::<Vec<String>>()
1463                    .join(",")
1464                    .to_string(),
1465            )]),
1466        };
1467    }
1468    if let Some(ref local_var_str) = id__lte {
1469        local_var_req_builder = match "multi" {
1470            "multi" => local_var_req_builder.query(
1471                &local_var_str
1472                    .into_iter()
1473                    .map(|p| ("id__lte".to_owned(), p.to_string()))
1474                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1475            ),
1476            _ => local_var_req_builder.query(&[(
1477                "id__lte",
1478                &local_var_str
1479                    .into_iter()
1480                    .map(|p| p.to_string())
1481                    .collect::<Vec<String>>()
1482                    .join(",")
1483                    .to_string(),
1484            )]),
1485        };
1486    }
1487    if let Some(ref local_var_str) = id__n {
1488        local_var_req_builder = match "multi" {
1489            "multi" => local_var_req_builder.query(
1490                &local_var_str
1491                    .into_iter()
1492                    .map(|p| ("id__n".to_owned(), p.to_string()))
1493                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1494            ),
1495            _ => local_var_req_builder.query(&[(
1496                "id__n",
1497                &local_var_str
1498                    .into_iter()
1499                    .map(|p| p.to_string())
1500                    .collect::<Vec<String>>()
1501                    .join(",")
1502                    .to_string(),
1503            )]),
1504        };
1505    }
1506    if let Some(ref local_var_str) = ike_proposal {
1507        local_var_req_builder = match "multi" {
1508            "multi" => local_var_req_builder.query(
1509                &local_var_str
1510                    .into_iter()
1511                    .map(|p| ("ike_proposal".to_owned(), p.to_string()))
1512                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1513            ),
1514            _ => local_var_req_builder.query(&[(
1515                "ike_proposal",
1516                &local_var_str
1517                    .into_iter()
1518                    .map(|p| p.to_string())
1519                    .collect::<Vec<String>>()
1520                    .join(",")
1521                    .to_string(),
1522            )]),
1523        };
1524    }
1525    if let Some(ref local_var_str) = ike_proposal__n {
1526        local_var_req_builder = match "multi" {
1527            "multi" => local_var_req_builder.query(
1528                &local_var_str
1529                    .into_iter()
1530                    .map(|p| ("ike_proposal__n".to_owned(), p.to_string()))
1531                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1532            ),
1533            _ => local_var_req_builder.query(&[(
1534                "ike_proposal__n",
1535                &local_var_str
1536                    .into_iter()
1537                    .map(|p| p.to_string())
1538                    .collect::<Vec<String>>()
1539                    .join(",")
1540                    .to_string(),
1541            )]),
1542        };
1543    }
1544    if let Some(ref local_var_str) = ike_proposal_id {
1545        local_var_req_builder = match "multi" {
1546            "multi" => local_var_req_builder.query(
1547                &local_var_str
1548                    .into_iter()
1549                    .map(|p| ("ike_proposal_id".to_owned(), p.to_string()))
1550                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1551            ),
1552            _ => local_var_req_builder.query(&[(
1553                "ike_proposal_id",
1554                &local_var_str
1555                    .into_iter()
1556                    .map(|p| p.to_string())
1557                    .collect::<Vec<String>>()
1558                    .join(",")
1559                    .to_string(),
1560            )]),
1561        };
1562    }
1563    if let Some(ref local_var_str) = ike_proposal_id__n {
1564        local_var_req_builder = match "multi" {
1565            "multi" => local_var_req_builder.query(
1566                &local_var_str
1567                    .into_iter()
1568                    .map(|p| ("ike_proposal_id__n".to_owned(), p.to_string()))
1569                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1570            ),
1571            _ => local_var_req_builder.query(&[(
1572                "ike_proposal_id__n",
1573                &local_var_str
1574                    .into_iter()
1575                    .map(|p| p.to_string())
1576                    .collect::<Vec<String>>()
1577                    .join(",")
1578                    .to_string(),
1579            )]),
1580        };
1581    }
1582    if let Some(ref local_var_str) = last_updated {
1583        local_var_req_builder = match "multi" {
1584            "multi" => local_var_req_builder.query(
1585                &local_var_str
1586                    .into_iter()
1587                    .map(|p| ("last_updated".to_owned(), p.to_string()))
1588                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1589            ),
1590            _ => local_var_req_builder.query(&[(
1591                "last_updated",
1592                &local_var_str
1593                    .into_iter()
1594                    .map(|p| p.to_string())
1595                    .collect::<Vec<String>>()
1596                    .join(",")
1597                    .to_string(),
1598            )]),
1599        };
1600    }
1601    if let Some(ref local_var_str) = last_updated__empty {
1602        local_var_req_builder = match "multi" {
1603            "multi" => local_var_req_builder.query(
1604                &local_var_str
1605                    .into_iter()
1606                    .map(|p| ("last_updated__empty".to_owned(), p.to_string()))
1607                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1608            ),
1609            _ => local_var_req_builder.query(&[(
1610                "last_updated__empty",
1611                &local_var_str
1612                    .into_iter()
1613                    .map(|p| p.to_string())
1614                    .collect::<Vec<String>>()
1615                    .join(",")
1616                    .to_string(),
1617            )]),
1618        };
1619    }
1620    if let Some(ref local_var_str) = last_updated__gt {
1621        local_var_req_builder = match "multi" {
1622            "multi" => local_var_req_builder.query(
1623                &local_var_str
1624                    .into_iter()
1625                    .map(|p| ("last_updated__gt".to_owned(), p.to_string()))
1626                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1627            ),
1628            _ => local_var_req_builder.query(&[(
1629                "last_updated__gt",
1630                &local_var_str
1631                    .into_iter()
1632                    .map(|p| p.to_string())
1633                    .collect::<Vec<String>>()
1634                    .join(",")
1635                    .to_string(),
1636            )]),
1637        };
1638    }
1639    if let Some(ref local_var_str) = last_updated__gte {
1640        local_var_req_builder = match "multi" {
1641            "multi" => local_var_req_builder.query(
1642                &local_var_str
1643                    .into_iter()
1644                    .map(|p| ("last_updated__gte".to_owned(), p.to_string()))
1645                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1646            ),
1647            _ => local_var_req_builder.query(&[(
1648                "last_updated__gte",
1649                &local_var_str
1650                    .into_iter()
1651                    .map(|p| p.to_string())
1652                    .collect::<Vec<String>>()
1653                    .join(",")
1654                    .to_string(),
1655            )]),
1656        };
1657    }
1658    if let Some(ref local_var_str) = last_updated__lt {
1659        local_var_req_builder = match "multi" {
1660            "multi" => local_var_req_builder.query(
1661                &local_var_str
1662                    .into_iter()
1663                    .map(|p| ("last_updated__lt".to_owned(), p.to_string()))
1664                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1665            ),
1666            _ => local_var_req_builder.query(&[(
1667                "last_updated__lt",
1668                &local_var_str
1669                    .into_iter()
1670                    .map(|p| p.to_string())
1671                    .collect::<Vec<String>>()
1672                    .join(",")
1673                    .to_string(),
1674            )]),
1675        };
1676    }
1677    if let Some(ref local_var_str) = last_updated__lte {
1678        local_var_req_builder = match "multi" {
1679            "multi" => local_var_req_builder.query(
1680                &local_var_str
1681                    .into_iter()
1682                    .map(|p| ("last_updated__lte".to_owned(), p.to_string()))
1683                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1684            ),
1685            _ => local_var_req_builder.query(&[(
1686                "last_updated__lte",
1687                &local_var_str
1688                    .into_iter()
1689                    .map(|p| p.to_string())
1690                    .collect::<Vec<String>>()
1691                    .join(",")
1692                    .to_string(),
1693            )]),
1694        };
1695    }
1696    if let Some(ref local_var_str) = last_updated__n {
1697        local_var_req_builder = match "multi" {
1698            "multi" => local_var_req_builder.query(
1699                &local_var_str
1700                    .into_iter()
1701                    .map(|p| ("last_updated__n".to_owned(), p.to_string()))
1702                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1703            ),
1704            _ => local_var_req_builder.query(&[(
1705                "last_updated__n",
1706                &local_var_str
1707                    .into_iter()
1708                    .map(|p| p.to_string())
1709                    .collect::<Vec<String>>()
1710                    .join(",")
1711                    .to_string(),
1712            )]),
1713        };
1714    }
1715    if let Some(ref local_var_str) = limit {
1716        local_var_req_builder =
1717            local_var_req_builder.query(&[("limit", &local_var_str.to_string())]);
1718    }
1719    if let Some(ref local_var_str) = mode {
1720        local_var_req_builder = match "multi" {
1721            "multi" => local_var_req_builder.query(
1722                &local_var_str
1723                    .into_iter()
1724                    .map(|p| ("mode".to_owned(), p.to_string()))
1725                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1726            ),
1727            _ => local_var_req_builder.query(&[(
1728                "mode",
1729                &local_var_str
1730                    .into_iter()
1731                    .map(|p| p.to_string())
1732                    .collect::<Vec<String>>()
1733                    .join(",")
1734                    .to_string(),
1735            )]),
1736        };
1737    }
1738    if let Some(ref local_var_str) = mode__empty {
1739        local_var_req_builder =
1740            local_var_req_builder.query(&[("mode__empty", &local_var_str.to_string())]);
1741    }
1742    if let Some(ref local_var_str) = mode__ic {
1743        local_var_req_builder = match "multi" {
1744            "multi" => local_var_req_builder.query(
1745                &local_var_str
1746                    .into_iter()
1747                    .map(|p| ("mode__ic".to_owned(), p.to_string()))
1748                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1749            ),
1750            _ => local_var_req_builder.query(&[(
1751                "mode__ic",
1752                &local_var_str
1753                    .into_iter()
1754                    .map(|p| p.to_string())
1755                    .collect::<Vec<String>>()
1756                    .join(",")
1757                    .to_string(),
1758            )]),
1759        };
1760    }
1761    if let Some(ref local_var_str) = mode__ie {
1762        local_var_req_builder = match "multi" {
1763            "multi" => local_var_req_builder.query(
1764                &local_var_str
1765                    .into_iter()
1766                    .map(|p| ("mode__ie".to_owned(), p.to_string()))
1767                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1768            ),
1769            _ => local_var_req_builder.query(&[(
1770                "mode__ie",
1771                &local_var_str
1772                    .into_iter()
1773                    .map(|p| p.to_string())
1774                    .collect::<Vec<String>>()
1775                    .join(",")
1776                    .to_string(),
1777            )]),
1778        };
1779    }
1780    if let Some(ref local_var_str) = mode__iew {
1781        local_var_req_builder = match "multi" {
1782            "multi" => local_var_req_builder.query(
1783                &local_var_str
1784                    .into_iter()
1785                    .map(|p| ("mode__iew".to_owned(), p.to_string()))
1786                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1787            ),
1788            _ => local_var_req_builder.query(&[(
1789                "mode__iew",
1790                &local_var_str
1791                    .into_iter()
1792                    .map(|p| p.to_string())
1793                    .collect::<Vec<String>>()
1794                    .join(",")
1795                    .to_string(),
1796            )]),
1797        };
1798    }
1799    if let Some(ref local_var_str) = mode__iregex {
1800        local_var_req_builder = match "multi" {
1801            "multi" => local_var_req_builder.query(
1802                &local_var_str
1803                    .into_iter()
1804                    .map(|p| ("mode__iregex".to_owned(), p.to_string()))
1805                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1806            ),
1807            _ => local_var_req_builder.query(&[(
1808                "mode__iregex",
1809                &local_var_str
1810                    .into_iter()
1811                    .map(|p| p.to_string())
1812                    .collect::<Vec<String>>()
1813                    .join(",")
1814                    .to_string(),
1815            )]),
1816        };
1817    }
1818    if let Some(ref local_var_str) = mode__isw {
1819        local_var_req_builder = match "multi" {
1820            "multi" => local_var_req_builder.query(
1821                &local_var_str
1822                    .into_iter()
1823                    .map(|p| ("mode__isw".to_owned(), p.to_string()))
1824                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1825            ),
1826            _ => local_var_req_builder.query(&[(
1827                "mode__isw",
1828                &local_var_str
1829                    .into_iter()
1830                    .map(|p| p.to_string())
1831                    .collect::<Vec<String>>()
1832                    .join(",")
1833                    .to_string(),
1834            )]),
1835        };
1836    }
1837    if let Some(ref local_var_str) = mode__n {
1838        local_var_req_builder = match "multi" {
1839            "multi" => local_var_req_builder.query(
1840                &local_var_str
1841                    .into_iter()
1842                    .map(|p| ("mode__n".to_owned(), p.to_string()))
1843                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1844            ),
1845            _ => local_var_req_builder.query(&[(
1846                "mode__n",
1847                &local_var_str
1848                    .into_iter()
1849                    .map(|p| p.to_string())
1850                    .collect::<Vec<String>>()
1851                    .join(",")
1852                    .to_string(),
1853            )]),
1854        };
1855    }
1856    if let Some(ref local_var_str) = mode__nic {
1857        local_var_req_builder = match "multi" {
1858            "multi" => local_var_req_builder.query(
1859                &local_var_str
1860                    .into_iter()
1861                    .map(|p| ("mode__nic".to_owned(), p.to_string()))
1862                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1863            ),
1864            _ => local_var_req_builder.query(&[(
1865                "mode__nic",
1866                &local_var_str
1867                    .into_iter()
1868                    .map(|p| p.to_string())
1869                    .collect::<Vec<String>>()
1870                    .join(",")
1871                    .to_string(),
1872            )]),
1873        };
1874    }
1875    if let Some(ref local_var_str) = mode__nie {
1876        local_var_req_builder = match "multi" {
1877            "multi" => local_var_req_builder.query(
1878                &local_var_str
1879                    .into_iter()
1880                    .map(|p| ("mode__nie".to_owned(), p.to_string()))
1881                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1882            ),
1883            _ => local_var_req_builder.query(&[(
1884                "mode__nie",
1885                &local_var_str
1886                    .into_iter()
1887                    .map(|p| p.to_string())
1888                    .collect::<Vec<String>>()
1889                    .join(",")
1890                    .to_string(),
1891            )]),
1892        };
1893    }
1894    if let Some(ref local_var_str) = mode__niew {
1895        local_var_req_builder = match "multi" {
1896            "multi" => local_var_req_builder.query(
1897                &local_var_str
1898                    .into_iter()
1899                    .map(|p| ("mode__niew".to_owned(), p.to_string()))
1900                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1901            ),
1902            _ => local_var_req_builder.query(&[(
1903                "mode__niew",
1904                &local_var_str
1905                    .into_iter()
1906                    .map(|p| p.to_string())
1907                    .collect::<Vec<String>>()
1908                    .join(",")
1909                    .to_string(),
1910            )]),
1911        };
1912    }
1913    if let Some(ref local_var_str) = mode__nisw {
1914        local_var_req_builder = match "multi" {
1915            "multi" => local_var_req_builder.query(
1916                &local_var_str
1917                    .into_iter()
1918                    .map(|p| ("mode__nisw".to_owned(), p.to_string()))
1919                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1920            ),
1921            _ => local_var_req_builder.query(&[(
1922                "mode__nisw",
1923                &local_var_str
1924                    .into_iter()
1925                    .map(|p| p.to_string())
1926                    .collect::<Vec<String>>()
1927                    .join(",")
1928                    .to_string(),
1929            )]),
1930        };
1931    }
1932    if let Some(ref local_var_str) = mode__regex {
1933        local_var_req_builder = match "multi" {
1934            "multi" => local_var_req_builder.query(
1935                &local_var_str
1936                    .into_iter()
1937                    .map(|p| ("mode__regex".to_owned(), p.to_string()))
1938                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1939            ),
1940            _ => local_var_req_builder.query(&[(
1941                "mode__regex",
1942                &local_var_str
1943                    .into_iter()
1944                    .map(|p| p.to_string())
1945                    .collect::<Vec<String>>()
1946                    .join(",")
1947                    .to_string(),
1948            )]),
1949        };
1950    }
1951    if let Some(ref local_var_str) = modified_by_request {
1952        local_var_req_builder =
1953            local_var_req_builder.query(&[("modified_by_request", &local_var_str.to_string())]);
1954    }
1955    if let Some(ref local_var_str) = name {
1956        local_var_req_builder = match "multi" {
1957            "multi" => local_var_req_builder.query(
1958                &local_var_str
1959                    .into_iter()
1960                    .map(|p| ("name".to_owned(), p.to_string()))
1961                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1962            ),
1963            _ => local_var_req_builder.query(&[(
1964                "name",
1965                &local_var_str
1966                    .into_iter()
1967                    .map(|p| p.to_string())
1968                    .collect::<Vec<String>>()
1969                    .join(",")
1970                    .to_string(),
1971            )]),
1972        };
1973    }
1974    if let Some(ref local_var_str) = name__empty {
1975        local_var_req_builder =
1976            local_var_req_builder.query(&[("name__empty", &local_var_str.to_string())]);
1977    }
1978    if let Some(ref local_var_str) = name__ic {
1979        local_var_req_builder = match "multi" {
1980            "multi" => local_var_req_builder.query(
1981                &local_var_str
1982                    .into_iter()
1983                    .map(|p| ("name__ic".to_owned(), p.to_string()))
1984                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1985            ),
1986            _ => local_var_req_builder.query(&[(
1987                "name__ic",
1988                &local_var_str
1989                    .into_iter()
1990                    .map(|p| p.to_string())
1991                    .collect::<Vec<String>>()
1992                    .join(",")
1993                    .to_string(),
1994            )]),
1995        };
1996    }
1997    if let Some(ref local_var_str) = name__ie {
1998        local_var_req_builder = match "multi" {
1999            "multi" => local_var_req_builder.query(
2000                &local_var_str
2001                    .into_iter()
2002                    .map(|p| ("name__ie".to_owned(), p.to_string()))
2003                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2004            ),
2005            _ => local_var_req_builder.query(&[(
2006                "name__ie",
2007                &local_var_str
2008                    .into_iter()
2009                    .map(|p| p.to_string())
2010                    .collect::<Vec<String>>()
2011                    .join(",")
2012                    .to_string(),
2013            )]),
2014        };
2015    }
2016    if let Some(ref local_var_str) = name__iew {
2017        local_var_req_builder = match "multi" {
2018            "multi" => local_var_req_builder.query(
2019                &local_var_str
2020                    .into_iter()
2021                    .map(|p| ("name__iew".to_owned(), p.to_string()))
2022                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2023            ),
2024            _ => local_var_req_builder.query(&[(
2025                "name__iew",
2026                &local_var_str
2027                    .into_iter()
2028                    .map(|p| p.to_string())
2029                    .collect::<Vec<String>>()
2030                    .join(",")
2031                    .to_string(),
2032            )]),
2033        };
2034    }
2035    if let Some(ref local_var_str) = name__iregex {
2036        local_var_req_builder = match "multi" {
2037            "multi" => local_var_req_builder.query(
2038                &local_var_str
2039                    .into_iter()
2040                    .map(|p| ("name__iregex".to_owned(), p.to_string()))
2041                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2042            ),
2043            _ => local_var_req_builder.query(&[(
2044                "name__iregex",
2045                &local_var_str
2046                    .into_iter()
2047                    .map(|p| p.to_string())
2048                    .collect::<Vec<String>>()
2049                    .join(",")
2050                    .to_string(),
2051            )]),
2052        };
2053    }
2054    if let Some(ref local_var_str) = name__isw {
2055        local_var_req_builder = match "multi" {
2056            "multi" => local_var_req_builder.query(
2057                &local_var_str
2058                    .into_iter()
2059                    .map(|p| ("name__isw".to_owned(), p.to_string()))
2060                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2061            ),
2062            _ => local_var_req_builder.query(&[(
2063                "name__isw",
2064                &local_var_str
2065                    .into_iter()
2066                    .map(|p| p.to_string())
2067                    .collect::<Vec<String>>()
2068                    .join(",")
2069                    .to_string(),
2070            )]),
2071        };
2072    }
2073    if let Some(ref local_var_str) = name__n {
2074        local_var_req_builder = match "multi" {
2075            "multi" => local_var_req_builder.query(
2076                &local_var_str
2077                    .into_iter()
2078                    .map(|p| ("name__n".to_owned(), p.to_string()))
2079                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2080            ),
2081            _ => local_var_req_builder.query(&[(
2082                "name__n",
2083                &local_var_str
2084                    .into_iter()
2085                    .map(|p| p.to_string())
2086                    .collect::<Vec<String>>()
2087                    .join(",")
2088                    .to_string(),
2089            )]),
2090        };
2091    }
2092    if let Some(ref local_var_str) = name__nic {
2093        local_var_req_builder = match "multi" {
2094            "multi" => local_var_req_builder.query(
2095                &local_var_str
2096                    .into_iter()
2097                    .map(|p| ("name__nic".to_owned(), p.to_string()))
2098                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2099            ),
2100            _ => local_var_req_builder.query(&[(
2101                "name__nic",
2102                &local_var_str
2103                    .into_iter()
2104                    .map(|p| p.to_string())
2105                    .collect::<Vec<String>>()
2106                    .join(",")
2107                    .to_string(),
2108            )]),
2109        };
2110    }
2111    if let Some(ref local_var_str) = name__nie {
2112        local_var_req_builder = match "multi" {
2113            "multi" => local_var_req_builder.query(
2114                &local_var_str
2115                    .into_iter()
2116                    .map(|p| ("name__nie".to_owned(), p.to_string()))
2117                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2118            ),
2119            _ => local_var_req_builder.query(&[(
2120                "name__nie",
2121                &local_var_str
2122                    .into_iter()
2123                    .map(|p| p.to_string())
2124                    .collect::<Vec<String>>()
2125                    .join(",")
2126                    .to_string(),
2127            )]),
2128        };
2129    }
2130    if let Some(ref local_var_str) = name__niew {
2131        local_var_req_builder = match "multi" {
2132            "multi" => local_var_req_builder.query(
2133                &local_var_str
2134                    .into_iter()
2135                    .map(|p| ("name__niew".to_owned(), p.to_string()))
2136                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2137            ),
2138            _ => local_var_req_builder.query(&[(
2139                "name__niew",
2140                &local_var_str
2141                    .into_iter()
2142                    .map(|p| p.to_string())
2143                    .collect::<Vec<String>>()
2144                    .join(",")
2145                    .to_string(),
2146            )]),
2147        };
2148    }
2149    if let Some(ref local_var_str) = name__nisw {
2150        local_var_req_builder = match "multi" {
2151            "multi" => local_var_req_builder.query(
2152                &local_var_str
2153                    .into_iter()
2154                    .map(|p| ("name__nisw".to_owned(), p.to_string()))
2155                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2156            ),
2157            _ => local_var_req_builder.query(&[(
2158                "name__nisw",
2159                &local_var_str
2160                    .into_iter()
2161                    .map(|p| p.to_string())
2162                    .collect::<Vec<String>>()
2163                    .join(",")
2164                    .to_string(),
2165            )]),
2166        };
2167    }
2168    if let Some(ref local_var_str) = name__regex {
2169        local_var_req_builder = match "multi" {
2170            "multi" => local_var_req_builder.query(
2171                &local_var_str
2172                    .into_iter()
2173                    .map(|p| ("name__regex".to_owned(), p.to_string()))
2174                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2175            ),
2176            _ => local_var_req_builder.query(&[(
2177                "name__regex",
2178                &local_var_str
2179                    .into_iter()
2180                    .map(|p| p.to_string())
2181                    .collect::<Vec<String>>()
2182                    .join(",")
2183                    .to_string(),
2184            )]),
2185        };
2186    }
2187    if let Some(ref local_var_str) = offset {
2188        local_var_req_builder =
2189            local_var_req_builder.query(&[("offset", &local_var_str.to_string())]);
2190    }
2191    if let Some(ref local_var_str) = ordering {
2192        local_var_req_builder =
2193            local_var_req_builder.query(&[("ordering", &local_var_str.to_string())]);
2194    }
2195    if let Some(ref local_var_str) = owner {
2196        local_var_req_builder = match "multi" {
2197            "multi" => local_var_req_builder.query(
2198                &local_var_str
2199                    .into_iter()
2200                    .map(|p| ("owner".to_owned(), p.to_string()))
2201                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2202            ),
2203            _ => local_var_req_builder.query(&[(
2204                "owner",
2205                &local_var_str
2206                    .into_iter()
2207                    .map(|p| p.to_string())
2208                    .collect::<Vec<String>>()
2209                    .join(",")
2210                    .to_string(),
2211            )]),
2212        };
2213    }
2214    if let Some(ref local_var_str) = owner__n {
2215        local_var_req_builder = match "multi" {
2216            "multi" => local_var_req_builder.query(
2217                &local_var_str
2218                    .into_iter()
2219                    .map(|p| ("owner__n".to_owned(), p.to_string()))
2220                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2221            ),
2222            _ => local_var_req_builder.query(&[(
2223                "owner__n",
2224                &local_var_str
2225                    .into_iter()
2226                    .map(|p| p.to_string())
2227                    .collect::<Vec<String>>()
2228                    .join(",")
2229                    .to_string(),
2230            )]),
2231        };
2232    }
2233    if let Some(ref local_var_str) = owner_group {
2234        local_var_req_builder = match "multi" {
2235            "multi" => local_var_req_builder.query(
2236                &local_var_str
2237                    .into_iter()
2238                    .map(|p| ("owner_group".to_owned(), p.to_string()))
2239                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2240            ),
2241            _ => local_var_req_builder.query(&[(
2242                "owner_group",
2243                &local_var_str
2244                    .into_iter()
2245                    .map(|p| p.to_string())
2246                    .collect::<Vec<String>>()
2247                    .join(",")
2248                    .to_string(),
2249            )]),
2250        };
2251    }
2252    if let Some(ref local_var_str) = owner_group__n {
2253        local_var_req_builder = match "multi" {
2254            "multi" => local_var_req_builder.query(
2255                &local_var_str
2256                    .into_iter()
2257                    .map(|p| ("owner_group__n".to_owned(), p.to_string()))
2258                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2259            ),
2260            _ => local_var_req_builder.query(&[(
2261                "owner_group__n",
2262                &local_var_str
2263                    .into_iter()
2264                    .map(|p| p.to_string())
2265                    .collect::<Vec<String>>()
2266                    .join(",")
2267                    .to_string(),
2268            )]),
2269        };
2270    }
2271    if let Some(ref local_var_str) = owner_group_id {
2272        local_var_req_builder = match "multi" {
2273            "multi" => local_var_req_builder.query(
2274                &local_var_str
2275                    .into_iter()
2276                    .map(|p| ("owner_group_id".to_owned(), p.to_string()))
2277                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2278            ),
2279            _ => local_var_req_builder.query(&[(
2280                "owner_group_id",
2281                &local_var_str
2282                    .into_iter()
2283                    .map(|p| p.to_string())
2284                    .collect::<Vec<String>>()
2285                    .join(",")
2286                    .to_string(),
2287            )]),
2288        };
2289    }
2290    if let Some(ref local_var_str) = owner_group_id__n {
2291        local_var_req_builder = match "multi" {
2292            "multi" => local_var_req_builder.query(
2293                &local_var_str
2294                    .into_iter()
2295                    .map(|p| ("owner_group_id__n".to_owned(), p.to_string()))
2296                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2297            ),
2298            _ => local_var_req_builder.query(&[(
2299                "owner_group_id__n",
2300                &local_var_str
2301                    .into_iter()
2302                    .map(|p| p.to_string())
2303                    .collect::<Vec<String>>()
2304                    .join(",")
2305                    .to_string(),
2306            )]),
2307        };
2308    }
2309    if let Some(ref local_var_str) = owner_id {
2310        local_var_req_builder = match "multi" {
2311            "multi" => local_var_req_builder.query(
2312                &local_var_str
2313                    .into_iter()
2314                    .map(|p| ("owner_id".to_owned(), p.to_string()))
2315                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2316            ),
2317            _ => local_var_req_builder.query(&[(
2318                "owner_id",
2319                &local_var_str
2320                    .into_iter()
2321                    .map(|p| p.to_string())
2322                    .collect::<Vec<String>>()
2323                    .join(",")
2324                    .to_string(),
2325            )]),
2326        };
2327    }
2328    if let Some(ref local_var_str) = owner_id__n {
2329        local_var_req_builder = match "multi" {
2330            "multi" => local_var_req_builder.query(
2331                &local_var_str
2332                    .into_iter()
2333                    .map(|p| ("owner_id__n".to_owned(), p.to_string()))
2334                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2335            ),
2336            _ => local_var_req_builder.query(&[(
2337                "owner_id__n",
2338                &local_var_str
2339                    .into_iter()
2340                    .map(|p| p.to_string())
2341                    .collect::<Vec<String>>()
2342                    .join(",")
2343                    .to_string(),
2344            )]),
2345        };
2346    }
2347    if let Some(ref local_var_str) = preshared_key {
2348        local_var_req_builder =
2349            local_var_req_builder.query(&[("preshared_key", &local_var_str.to_string())]);
2350    }
2351    if let Some(ref local_var_str) = preshared_key__ic {
2352        local_var_req_builder =
2353            local_var_req_builder.query(&[("preshared_key__ic", &local_var_str.to_string())]);
2354    }
2355    if let Some(ref local_var_str) = preshared_key__ie {
2356        local_var_req_builder =
2357            local_var_req_builder.query(&[("preshared_key__ie", &local_var_str.to_string())]);
2358    }
2359    if let Some(ref local_var_str) = preshared_key__iew {
2360        local_var_req_builder =
2361            local_var_req_builder.query(&[("preshared_key__iew", &local_var_str.to_string())]);
2362    }
2363    if let Some(ref local_var_str) = preshared_key__iregex {
2364        local_var_req_builder =
2365            local_var_req_builder.query(&[("preshared_key__iregex", &local_var_str.to_string())]);
2366    }
2367    if let Some(ref local_var_str) = preshared_key__isw {
2368        local_var_req_builder =
2369            local_var_req_builder.query(&[("preshared_key__isw", &local_var_str.to_string())]);
2370    }
2371    if let Some(ref local_var_str) = preshared_key__n {
2372        local_var_req_builder =
2373            local_var_req_builder.query(&[("preshared_key__n", &local_var_str.to_string())]);
2374    }
2375    if let Some(ref local_var_str) = preshared_key__nic {
2376        local_var_req_builder =
2377            local_var_req_builder.query(&[("preshared_key__nic", &local_var_str.to_string())]);
2378    }
2379    if let Some(ref local_var_str) = preshared_key__nie {
2380        local_var_req_builder =
2381            local_var_req_builder.query(&[("preshared_key__nie", &local_var_str.to_string())]);
2382    }
2383    if let Some(ref local_var_str) = preshared_key__niew {
2384        local_var_req_builder =
2385            local_var_req_builder.query(&[("preshared_key__niew", &local_var_str.to_string())]);
2386    }
2387    if let Some(ref local_var_str) = preshared_key__nisw {
2388        local_var_req_builder =
2389            local_var_req_builder.query(&[("preshared_key__nisw", &local_var_str.to_string())]);
2390    }
2391    if let Some(ref local_var_str) = preshared_key__regex {
2392        local_var_req_builder =
2393            local_var_req_builder.query(&[("preshared_key__regex", &local_var_str.to_string())]);
2394    }
2395    if let Some(ref local_var_str) = q {
2396        local_var_req_builder = local_var_req_builder.query(&[("q", &local_var_str.to_string())]);
2397    }
2398    if let Some(ref local_var_str) = start {
2399        local_var_req_builder =
2400            local_var_req_builder.query(&[("start", &local_var_str.to_string())]);
2401    }
2402    if let Some(ref local_var_str) = tag {
2403        local_var_req_builder = match "multi" {
2404            "multi" => local_var_req_builder.query(
2405                &local_var_str
2406                    .into_iter()
2407                    .map(|p| ("tag".to_owned(), p.to_string()))
2408                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2409            ),
2410            _ => local_var_req_builder.query(&[(
2411                "tag",
2412                &local_var_str
2413                    .into_iter()
2414                    .map(|p| p.to_string())
2415                    .collect::<Vec<String>>()
2416                    .join(",")
2417                    .to_string(),
2418            )]),
2419        };
2420    }
2421    if let Some(ref local_var_str) = tag__n {
2422        local_var_req_builder = match "multi" {
2423            "multi" => local_var_req_builder.query(
2424                &local_var_str
2425                    .into_iter()
2426                    .map(|p| ("tag__n".to_owned(), p.to_string()))
2427                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2428            ),
2429            _ => local_var_req_builder.query(&[(
2430                "tag__n",
2431                &local_var_str
2432                    .into_iter()
2433                    .map(|p| p.to_string())
2434                    .collect::<Vec<String>>()
2435                    .join(",")
2436                    .to_string(),
2437            )]),
2438        };
2439    }
2440    if let Some(ref local_var_str) = tag_id {
2441        local_var_req_builder = match "multi" {
2442            "multi" => local_var_req_builder.query(
2443                &local_var_str
2444                    .into_iter()
2445                    .map(|p| ("tag_id".to_owned(), p.to_string()))
2446                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2447            ),
2448            _ => local_var_req_builder.query(&[(
2449                "tag_id",
2450                &local_var_str
2451                    .into_iter()
2452                    .map(|p| p.to_string())
2453                    .collect::<Vec<String>>()
2454                    .join(",")
2455                    .to_string(),
2456            )]),
2457        };
2458    }
2459    if let Some(ref local_var_str) = tag_id__n {
2460        local_var_req_builder = match "multi" {
2461            "multi" => local_var_req_builder.query(
2462                &local_var_str
2463                    .into_iter()
2464                    .map(|p| ("tag_id__n".to_owned(), p.to_string()))
2465                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2466            ),
2467            _ => local_var_req_builder.query(&[(
2468                "tag_id__n",
2469                &local_var_str
2470                    .into_iter()
2471                    .map(|p| p.to_string())
2472                    .collect::<Vec<String>>()
2473                    .join(",")
2474                    .to_string(),
2475            )]),
2476        };
2477    }
2478    if let Some(ref local_var_str) = updated_by_request {
2479        local_var_req_builder =
2480            local_var_req_builder.query(&[("updated_by_request", &local_var_str.to_string())]);
2481    }
2482    if let Some(ref local_var_str) = version {
2483        local_var_req_builder = match "multi" {
2484            "multi" => local_var_req_builder.query(
2485                &local_var_str
2486                    .into_iter()
2487                    .map(|p| ("version".to_owned(), p.to_string()))
2488                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2489            ),
2490            _ => local_var_req_builder.query(&[(
2491                "version",
2492                &local_var_str
2493                    .into_iter()
2494                    .map(|p| p.to_string())
2495                    .collect::<Vec<String>>()
2496                    .join(",")
2497                    .to_string(),
2498            )]),
2499        };
2500    }
2501    if let Some(ref local_var_str) = version__ic {
2502        local_var_req_builder = match "multi" {
2503            "multi" => local_var_req_builder.query(
2504                &local_var_str
2505                    .into_iter()
2506                    .map(|p| ("version__ic".to_owned(), p.to_string()))
2507                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2508            ),
2509            _ => local_var_req_builder.query(&[(
2510                "version__ic",
2511                &local_var_str
2512                    .into_iter()
2513                    .map(|p| p.to_string())
2514                    .collect::<Vec<String>>()
2515                    .join(",")
2516                    .to_string(),
2517            )]),
2518        };
2519    }
2520    if let Some(ref local_var_str) = version__ie {
2521        local_var_req_builder = match "multi" {
2522            "multi" => local_var_req_builder.query(
2523                &local_var_str
2524                    .into_iter()
2525                    .map(|p| ("version__ie".to_owned(), p.to_string()))
2526                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2527            ),
2528            _ => local_var_req_builder.query(&[(
2529                "version__ie",
2530                &local_var_str
2531                    .into_iter()
2532                    .map(|p| p.to_string())
2533                    .collect::<Vec<String>>()
2534                    .join(",")
2535                    .to_string(),
2536            )]),
2537        };
2538    }
2539    if let Some(ref local_var_str) = version__iew {
2540        local_var_req_builder = match "multi" {
2541            "multi" => local_var_req_builder.query(
2542                &local_var_str
2543                    .into_iter()
2544                    .map(|p| ("version__iew".to_owned(), p.to_string()))
2545                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2546            ),
2547            _ => local_var_req_builder.query(&[(
2548                "version__iew",
2549                &local_var_str
2550                    .into_iter()
2551                    .map(|p| p.to_string())
2552                    .collect::<Vec<String>>()
2553                    .join(",")
2554                    .to_string(),
2555            )]),
2556        };
2557    }
2558    if let Some(ref local_var_str) = version__iregex {
2559        local_var_req_builder = match "multi" {
2560            "multi" => local_var_req_builder.query(
2561                &local_var_str
2562                    .into_iter()
2563                    .map(|p| ("version__iregex".to_owned(), p.to_string()))
2564                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2565            ),
2566            _ => local_var_req_builder.query(&[(
2567                "version__iregex",
2568                &local_var_str
2569                    .into_iter()
2570                    .map(|p| p.to_string())
2571                    .collect::<Vec<String>>()
2572                    .join(",")
2573                    .to_string(),
2574            )]),
2575        };
2576    }
2577    if let Some(ref local_var_str) = version__isw {
2578        local_var_req_builder = match "multi" {
2579            "multi" => local_var_req_builder.query(
2580                &local_var_str
2581                    .into_iter()
2582                    .map(|p| ("version__isw".to_owned(), p.to_string()))
2583                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2584            ),
2585            _ => local_var_req_builder.query(&[(
2586                "version__isw",
2587                &local_var_str
2588                    .into_iter()
2589                    .map(|p| p.to_string())
2590                    .collect::<Vec<String>>()
2591                    .join(",")
2592                    .to_string(),
2593            )]),
2594        };
2595    }
2596    if let Some(ref local_var_str) = version__n {
2597        local_var_req_builder = match "multi" {
2598            "multi" => local_var_req_builder.query(
2599                &local_var_str
2600                    .into_iter()
2601                    .map(|p| ("version__n".to_owned(), p.to_string()))
2602                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2603            ),
2604            _ => local_var_req_builder.query(&[(
2605                "version__n",
2606                &local_var_str
2607                    .into_iter()
2608                    .map(|p| p.to_string())
2609                    .collect::<Vec<String>>()
2610                    .join(",")
2611                    .to_string(),
2612            )]),
2613        };
2614    }
2615    if let Some(ref local_var_str) = version__nic {
2616        local_var_req_builder = match "multi" {
2617            "multi" => local_var_req_builder.query(
2618                &local_var_str
2619                    .into_iter()
2620                    .map(|p| ("version__nic".to_owned(), p.to_string()))
2621                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2622            ),
2623            _ => local_var_req_builder.query(&[(
2624                "version__nic",
2625                &local_var_str
2626                    .into_iter()
2627                    .map(|p| p.to_string())
2628                    .collect::<Vec<String>>()
2629                    .join(",")
2630                    .to_string(),
2631            )]),
2632        };
2633    }
2634    if let Some(ref local_var_str) = version__nie {
2635        local_var_req_builder = match "multi" {
2636            "multi" => local_var_req_builder.query(
2637                &local_var_str
2638                    .into_iter()
2639                    .map(|p| ("version__nie".to_owned(), p.to_string()))
2640                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2641            ),
2642            _ => local_var_req_builder.query(&[(
2643                "version__nie",
2644                &local_var_str
2645                    .into_iter()
2646                    .map(|p| p.to_string())
2647                    .collect::<Vec<String>>()
2648                    .join(",")
2649                    .to_string(),
2650            )]),
2651        };
2652    }
2653    if let Some(ref local_var_str) = version__niew {
2654        local_var_req_builder = match "multi" {
2655            "multi" => local_var_req_builder.query(
2656                &local_var_str
2657                    .into_iter()
2658                    .map(|p| ("version__niew".to_owned(), p.to_string()))
2659                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2660            ),
2661            _ => local_var_req_builder.query(&[(
2662                "version__niew",
2663                &local_var_str
2664                    .into_iter()
2665                    .map(|p| p.to_string())
2666                    .collect::<Vec<String>>()
2667                    .join(",")
2668                    .to_string(),
2669            )]),
2670        };
2671    }
2672    if let Some(ref local_var_str) = version__nisw {
2673        local_var_req_builder = match "multi" {
2674            "multi" => local_var_req_builder.query(
2675                &local_var_str
2676                    .into_iter()
2677                    .map(|p| ("version__nisw".to_owned(), p.to_string()))
2678                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2679            ),
2680            _ => local_var_req_builder.query(&[(
2681                "version__nisw",
2682                &local_var_str
2683                    .into_iter()
2684                    .map(|p| p.to_string())
2685                    .collect::<Vec<String>>()
2686                    .join(",")
2687                    .to_string(),
2688            )]),
2689        };
2690    }
2691    if let Some(ref local_var_str) = version__regex {
2692        local_var_req_builder = match "multi" {
2693            "multi" => local_var_req_builder.query(
2694                &local_var_str
2695                    .into_iter()
2696                    .map(|p| ("version__regex".to_owned(), p.to_string()))
2697                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2698            ),
2699            _ => local_var_req_builder.query(&[(
2700                "version__regex",
2701                &local_var_str
2702                    .into_iter()
2703                    .map(|p| p.to_string())
2704                    .collect::<Vec<String>>()
2705                    .join(",")
2706                    .to_string(),
2707            )]),
2708        };
2709    }
2710    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
2711        local_var_req_builder =
2712            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
2713    }
2714    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
2715        let local_var_key = local_var_apikey.key.clone();
2716        let local_var_value = match local_var_apikey.prefix {
2717            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
2718            None => local_var_key,
2719        };
2720        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
2721    };
2722
2723    let local_var_req = local_var_req_builder.build()?;
2724    let local_var_resp = local_var_client.execute(local_var_req).await?;
2725
2726    let local_var_status = local_var_resp.status();
2727    let local_var_content = local_var_resp.text().await?;
2728
2729    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
2730        serde_json::from_str(&local_var_content).map_err(Error::from)
2731    } else {
2732        let local_var_entity: Option<VpnIkePoliciesListError> =
2733            serde_json::from_str(&local_var_content).ok();
2734        let local_var_error = ResponseContent {
2735            status: local_var_status,
2736            content: local_var_content,
2737            entity: local_var_entity,
2738        };
2739        Err(Error::ResponseError(local_var_error))
2740    }
2741}
2742
2743/// Patch a IKE policy object.
2744pub async fn vpn_ike_policies_partial_update(
2745    configuration: &configuration::Configuration,
2746    id: i32,
2747    patched_writable_ike_policy_request: Option<crate::models::PatchedWritableIkePolicyRequest>,
2748) -> Result<crate::models::IkePolicy, Error<VpnIkePoliciesPartialUpdateError>> {
2749    let local_var_configuration = configuration;
2750
2751    let local_var_client = &local_var_configuration.client;
2752
2753    let local_var_uri_str = format!(
2754        "{}/api/vpn/ike-policies/{id}/",
2755        local_var_configuration.base_path,
2756        id = id
2757    );
2758    let mut local_var_req_builder =
2759        local_var_client.request(reqwest::Method::PATCH, local_var_uri_str.as_str());
2760
2761    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
2762        local_var_req_builder =
2763            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
2764    }
2765    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
2766        let local_var_key = local_var_apikey.key.clone();
2767        let local_var_value = match local_var_apikey.prefix {
2768            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
2769            None => local_var_key,
2770        };
2771        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
2772    };
2773    local_var_req_builder = local_var_req_builder.json(&patched_writable_ike_policy_request);
2774
2775    let local_var_req = local_var_req_builder.build()?;
2776    let local_var_resp = local_var_client.execute(local_var_req).await?;
2777
2778    let local_var_status = local_var_resp.status();
2779    let local_var_content = local_var_resp.text().await?;
2780
2781    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
2782        serde_json::from_str(&local_var_content).map_err(Error::from)
2783    } else {
2784        let local_var_entity: Option<VpnIkePoliciesPartialUpdateError> =
2785            serde_json::from_str(&local_var_content).ok();
2786        let local_var_error = ResponseContent {
2787            status: local_var_status,
2788            content: local_var_content,
2789            entity: local_var_entity,
2790        };
2791        Err(Error::ResponseError(local_var_error))
2792    }
2793}
2794
2795/// Get a IKE policy object.
2796pub async fn vpn_ike_policies_retrieve(
2797    configuration: &configuration::Configuration,
2798    id: i32,
2799) -> Result<crate::models::IkePolicy, Error<VpnIkePoliciesRetrieveError>> {
2800    let local_var_configuration = configuration;
2801
2802    let local_var_client = &local_var_configuration.client;
2803
2804    let local_var_uri_str = format!(
2805        "{}/api/vpn/ike-policies/{id}/",
2806        local_var_configuration.base_path,
2807        id = id
2808    );
2809    let mut local_var_req_builder =
2810        local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
2811
2812    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
2813        local_var_req_builder =
2814            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
2815    }
2816    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
2817        let local_var_key = local_var_apikey.key.clone();
2818        let local_var_value = match local_var_apikey.prefix {
2819            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
2820            None => local_var_key,
2821        };
2822        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
2823    };
2824
2825    let local_var_req = local_var_req_builder.build()?;
2826    let local_var_resp = local_var_client.execute(local_var_req).await?;
2827
2828    let local_var_status = local_var_resp.status();
2829    let local_var_content = local_var_resp.text().await?;
2830
2831    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
2832        serde_json::from_str(&local_var_content).map_err(Error::from)
2833    } else {
2834        let local_var_entity: Option<VpnIkePoliciesRetrieveError> =
2835            serde_json::from_str(&local_var_content).ok();
2836        let local_var_error = ResponseContent {
2837            status: local_var_status,
2838            content: local_var_content,
2839            entity: local_var_entity,
2840        };
2841        Err(Error::ResponseError(local_var_error))
2842    }
2843}
2844
2845/// Put a IKE policy object.
2846pub async fn vpn_ike_policies_update(
2847    configuration: &configuration::Configuration,
2848    id: i32,
2849    writable_ike_policy_request: crate::models::WritableIkePolicyRequest,
2850) -> Result<crate::models::IkePolicy, Error<VpnIkePoliciesUpdateError>> {
2851    let local_var_configuration = configuration;
2852
2853    let local_var_client = &local_var_configuration.client;
2854
2855    let local_var_uri_str = format!(
2856        "{}/api/vpn/ike-policies/{id}/",
2857        local_var_configuration.base_path,
2858        id = id
2859    );
2860    let mut local_var_req_builder =
2861        local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());
2862
2863    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
2864        local_var_req_builder =
2865            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
2866    }
2867    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
2868        let local_var_key = local_var_apikey.key.clone();
2869        let local_var_value = match local_var_apikey.prefix {
2870            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
2871            None => local_var_key,
2872        };
2873        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
2874    };
2875    local_var_req_builder = local_var_req_builder.json(&writable_ike_policy_request);
2876
2877    let local_var_req = local_var_req_builder.build()?;
2878    let local_var_resp = local_var_client.execute(local_var_req).await?;
2879
2880    let local_var_status = local_var_resp.status();
2881    let local_var_content = local_var_resp.text().await?;
2882
2883    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
2884        serde_json::from_str(&local_var_content).map_err(Error::from)
2885    } else {
2886        let local_var_entity: Option<VpnIkePoliciesUpdateError> =
2887            serde_json::from_str(&local_var_content).ok();
2888        let local_var_error = ResponseContent {
2889            status: local_var_status,
2890            content: local_var_content,
2891            entity: local_var_entity,
2892        };
2893        Err(Error::ResponseError(local_var_error))
2894    }
2895}
2896
2897/// Delete a list of IKE proposal objects.
2898pub async fn vpn_ike_proposals_bulk_destroy(
2899    configuration: &configuration::Configuration,
2900    ike_proposal_request: Vec<crate::models::IkeProposalRequest>,
2901) -> Result<(), Error<VpnIkeProposalsBulkDestroyError>> {
2902    let local_var_configuration = configuration;
2903
2904    let local_var_client = &local_var_configuration.client;
2905
2906    let local_var_uri_str = format!(
2907        "{}/api/vpn/ike-proposals/",
2908        local_var_configuration.base_path
2909    );
2910    let mut local_var_req_builder =
2911        local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());
2912
2913    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
2914        local_var_req_builder =
2915            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
2916    }
2917    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
2918        let local_var_key = local_var_apikey.key.clone();
2919        let local_var_value = match local_var_apikey.prefix {
2920            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
2921            None => local_var_key,
2922        };
2923        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
2924    };
2925    local_var_req_builder = local_var_req_builder.json(&ike_proposal_request);
2926
2927    let local_var_req = local_var_req_builder.build()?;
2928    let local_var_resp = local_var_client.execute(local_var_req).await?;
2929
2930    let local_var_status = local_var_resp.status();
2931    let local_var_content = local_var_resp.text().await?;
2932
2933    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
2934        Ok(())
2935    } else {
2936        let local_var_entity: Option<VpnIkeProposalsBulkDestroyError> =
2937            serde_json::from_str(&local_var_content).ok();
2938        let local_var_error = ResponseContent {
2939            status: local_var_status,
2940            content: local_var_content,
2941            entity: local_var_entity,
2942        };
2943        Err(Error::ResponseError(local_var_error))
2944    }
2945}
2946
2947/// Patch a list of IKE proposal objects.
2948pub async fn vpn_ike_proposals_bulk_partial_update(
2949    configuration: &configuration::Configuration,
2950    ike_proposal_request: Vec<crate::models::IkeProposalRequest>,
2951) -> Result<Vec<crate::models::IkeProposal>, Error<VpnIkeProposalsBulkPartialUpdateError>> {
2952    let local_var_configuration = configuration;
2953
2954    let local_var_client = &local_var_configuration.client;
2955
2956    let local_var_uri_str = format!(
2957        "{}/api/vpn/ike-proposals/",
2958        local_var_configuration.base_path
2959    );
2960    let mut local_var_req_builder =
2961        local_var_client.request(reqwest::Method::PATCH, local_var_uri_str.as_str());
2962
2963    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
2964        local_var_req_builder =
2965            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
2966    }
2967    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
2968        let local_var_key = local_var_apikey.key.clone();
2969        let local_var_value = match local_var_apikey.prefix {
2970            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
2971            None => local_var_key,
2972        };
2973        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
2974    };
2975    local_var_req_builder = local_var_req_builder.json(&ike_proposal_request);
2976
2977    let local_var_req = local_var_req_builder.build()?;
2978    let local_var_resp = local_var_client.execute(local_var_req).await?;
2979
2980    let local_var_status = local_var_resp.status();
2981    let local_var_content = local_var_resp.text().await?;
2982
2983    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
2984        serde_json::from_str(&local_var_content).map_err(Error::from)
2985    } else {
2986        let local_var_entity: Option<VpnIkeProposalsBulkPartialUpdateError> =
2987            serde_json::from_str(&local_var_content).ok();
2988        let local_var_error = ResponseContent {
2989            status: local_var_status,
2990            content: local_var_content,
2991            entity: local_var_entity,
2992        };
2993        Err(Error::ResponseError(local_var_error))
2994    }
2995}
2996
2997/// Put a list of IKE proposal objects.
2998pub async fn vpn_ike_proposals_bulk_update(
2999    configuration: &configuration::Configuration,
3000    ike_proposal_request: Vec<crate::models::IkeProposalRequest>,
3001) -> Result<Vec<crate::models::IkeProposal>, Error<VpnIkeProposalsBulkUpdateError>> {
3002    let local_var_configuration = configuration;
3003
3004    let local_var_client = &local_var_configuration.client;
3005
3006    let local_var_uri_str = format!(
3007        "{}/api/vpn/ike-proposals/",
3008        local_var_configuration.base_path
3009    );
3010    let mut local_var_req_builder =
3011        local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());
3012
3013    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
3014        local_var_req_builder =
3015            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
3016    }
3017    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
3018        let local_var_key = local_var_apikey.key.clone();
3019        let local_var_value = match local_var_apikey.prefix {
3020            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
3021            None => local_var_key,
3022        };
3023        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
3024    };
3025    local_var_req_builder = local_var_req_builder.json(&ike_proposal_request);
3026
3027    let local_var_req = local_var_req_builder.build()?;
3028    let local_var_resp = local_var_client.execute(local_var_req).await?;
3029
3030    let local_var_status = local_var_resp.status();
3031    let local_var_content = local_var_resp.text().await?;
3032
3033    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
3034        serde_json::from_str(&local_var_content).map_err(Error::from)
3035    } else {
3036        let local_var_entity: Option<VpnIkeProposalsBulkUpdateError> =
3037            serde_json::from_str(&local_var_content).ok();
3038        let local_var_error = ResponseContent {
3039            status: local_var_status,
3040            content: local_var_content,
3041            entity: local_var_entity,
3042        };
3043        Err(Error::ResponseError(local_var_error))
3044    }
3045}
3046
3047/// Post a list of IKE proposal objects.
3048pub async fn vpn_ike_proposals_create(
3049    configuration: &configuration::Configuration,
3050    vpn_ike_proposals_create_request: crate::models::VpnIkeProposalsCreateRequest,
3051) -> Result<crate::models::IkeProposal, Error<VpnIkeProposalsCreateError>> {
3052    let local_var_configuration = configuration;
3053
3054    let local_var_client = &local_var_configuration.client;
3055
3056    let local_var_uri_str = format!(
3057        "{}/api/vpn/ike-proposals/",
3058        local_var_configuration.base_path
3059    );
3060    let mut local_var_req_builder =
3061        local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
3062
3063    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
3064        local_var_req_builder =
3065            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
3066    }
3067    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
3068        let local_var_key = local_var_apikey.key.clone();
3069        let local_var_value = match local_var_apikey.prefix {
3070            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
3071            None => local_var_key,
3072        };
3073        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
3074    };
3075    local_var_req_builder = local_var_req_builder.json(&vpn_ike_proposals_create_request);
3076
3077    let local_var_req = local_var_req_builder.build()?;
3078    let local_var_resp = local_var_client.execute(local_var_req).await?;
3079
3080    let local_var_status = local_var_resp.status();
3081    let local_var_content = local_var_resp.text().await?;
3082
3083    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
3084        serde_json::from_str(&local_var_content).map_err(Error::from)
3085    } else {
3086        let local_var_entity: Option<VpnIkeProposalsCreateError> =
3087            serde_json::from_str(&local_var_content).ok();
3088        let local_var_error = ResponseContent {
3089            status: local_var_status,
3090            content: local_var_content,
3091            entity: local_var_entity,
3092        };
3093        Err(Error::ResponseError(local_var_error))
3094    }
3095}
3096
3097/// Delete a IKE proposal object.
3098pub async fn vpn_ike_proposals_destroy(
3099    configuration: &configuration::Configuration,
3100    id: i32,
3101) -> Result<(), Error<VpnIkeProposalsDestroyError>> {
3102    let local_var_configuration = configuration;
3103
3104    let local_var_client = &local_var_configuration.client;
3105
3106    let local_var_uri_str = format!(
3107        "{}/api/vpn/ike-proposals/{id}/",
3108        local_var_configuration.base_path,
3109        id = id
3110    );
3111    let mut local_var_req_builder =
3112        local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());
3113
3114    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
3115        local_var_req_builder =
3116            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
3117    }
3118    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
3119        let local_var_key = local_var_apikey.key.clone();
3120        let local_var_value = match local_var_apikey.prefix {
3121            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
3122            None => local_var_key,
3123        };
3124        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
3125    };
3126
3127    let local_var_req = local_var_req_builder.build()?;
3128    let local_var_resp = local_var_client.execute(local_var_req).await?;
3129
3130    let local_var_status = local_var_resp.status();
3131    let local_var_content = local_var_resp.text().await?;
3132
3133    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
3134        Ok(())
3135    } else {
3136        let local_var_entity: Option<VpnIkeProposalsDestroyError> =
3137            serde_json::from_str(&local_var_content).ok();
3138        let local_var_error = ResponseContent {
3139            status: local_var_status,
3140            content: local_var_content,
3141            entity: local_var_entity,
3142        };
3143        Err(Error::ResponseError(local_var_error))
3144    }
3145}
3146
3147/// Get a list of IKE proposal objects.
3148pub async fn vpn_ike_proposals_list(
3149    configuration: &configuration::Configuration,
3150    authentication_algorithm: Option<Vec<String>>,
3151    authentication_algorithm__empty: Option<bool>,
3152    authentication_algorithm__ic: Option<Vec<String>>,
3153    authentication_algorithm__ie: Option<Vec<String>>,
3154    authentication_algorithm__iew: Option<Vec<String>>,
3155    authentication_algorithm__iregex: Option<Vec<String>>,
3156    authentication_algorithm__isw: Option<Vec<String>>,
3157    authentication_algorithm__n: Option<Vec<String>>,
3158    authentication_algorithm__nic: Option<Vec<String>>,
3159    authentication_algorithm__nie: Option<Vec<String>>,
3160    authentication_algorithm__niew: Option<Vec<String>>,
3161    authentication_algorithm__nisw: Option<Vec<String>>,
3162    authentication_algorithm__regex: Option<Vec<String>>,
3163    authentication_method: Option<Vec<String>>,
3164    authentication_method__empty: Option<bool>,
3165    authentication_method__ic: Option<Vec<String>>,
3166    authentication_method__ie: Option<Vec<String>>,
3167    authentication_method__iew: Option<Vec<String>>,
3168    authentication_method__iregex: Option<Vec<String>>,
3169    authentication_method__isw: Option<Vec<String>>,
3170    authentication_method__n: Option<Vec<String>>,
3171    authentication_method__nic: Option<Vec<String>>,
3172    authentication_method__nie: Option<Vec<String>>,
3173    authentication_method__niew: Option<Vec<String>>,
3174    authentication_method__nisw: Option<Vec<String>>,
3175    authentication_method__regex: Option<Vec<String>>,
3176    created: Option<Vec<String>>,
3177    created__empty: Option<Vec<String>>,
3178    created__gt: Option<Vec<String>>,
3179    created__gte: Option<Vec<String>>,
3180    created__lt: Option<Vec<String>>,
3181    created__lte: Option<Vec<String>>,
3182    created__n: Option<Vec<String>>,
3183    created_by_request: Option<&str>,
3184    description: Option<Vec<String>>,
3185    description__empty: Option<bool>,
3186    description__ic: Option<Vec<String>>,
3187    description__ie: Option<Vec<String>>,
3188    description__iew: Option<Vec<String>>,
3189    description__iregex: Option<Vec<String>>,
3190    description__isw: Option<Vec<String>>,
3191    description__n: Option<Vec<String>>,
3192    description__nic: Option<Vec<String>>,
3193    description__nie: Option<Vec<String>>,
3194    description__niew: Option<Vec<String>>,
3195    description__nisw: Option<Vec<String>>,
3196    description__regex: Option<Vec<String>>,
3197    encryption_algorithm: Option<Vec<String>>,
3198    encryption_algorithm__empty: Option<bool>,
3199    encryption_algorithm__ic: Option<Vec<String>>,
3200    encryption_algorithm__ie: Option<Vec<String>>,
3201    encryption_algorithm__iew: Option<Vec<String>>,
3202    encryption_algorithm__iregex: Option<Vec<String>>,
3203    encryption_algorithm__isw: Option<Vec<String>>,
3204    encryption_algorithm__n: Option<Vec<String>>,
3205    encryption_algorithm__nic: Option<Vec<String>>,
3206    encryption_algorithm__nie: Option<Vec<String>>,
3207    encryption_algorithm__niew: Option<Vec<String>>,
3208    encryption_algorithm__nisw: Option<Vec<String>>,
3209    encryption_algorithm__regex: Option<Vec<String>>,
3210    group: Option<Vec<i32>>,
3211    group__ic: Option<Vec<i32>>,
3212    group__ie: Option<Vec<i32>>,
3213    group__iew: Option<Vec<i32>>,
3214    group__iregex: Option<Vec<i32>>,
3215    group__isw: Option<Vec<i32>>,
3216    group__n: Option<Vec<i32>>,
3217    group__nic: Option<Vec<i32>>,
3218    group__nie: Option<Vec<i32>>,
3219    group__niew: Option<Vec<i32>>,
3220    group__nisw: Option<Vec<i32>>,
3221    group__regex: Option<Vec<i32>>,
3222    id: Option<Vec<i32>>,
3223    id__empty: Option<bool>,
3224    id__gt: Option<Vec<i32>>,
3225    id__gte: Option<Vec<i32>>,
3226    id__lt: Option<Vec<i32>>,
3227    id__lte: Option<Vec<i32>>,
3228    id__n: Option<Vec<i32>>,
3229    ike_policy: Option<Vec<String>>,
3230    ike_policy__n: Option<Vec<String>>,
3231    ike_policy_id: Option<Vec<i32>>,
3232    ike_policy_id__n: Option<Vec<i32>>,
3233    last_updated: Option<Vec<String>>,
3234    last_updated__empty: Option<Vec<String>>,
3235    last_updated__gt: Option<Vec<String>>,
3236    last_updated__gte: Option<Vec<String>>,
3237    last_updated__lt: Option<Vec<String>>,
3238    last_updated__lte: Option<Vec<String>>,
3239    last_updated__n: Option<Vec<String>>,
3240    limit: Option<i32>,
3241    modified_by_request: Option<&str>,
3242    name: Option<Vec<String>>,
3243    name__empty: Option<bool>,
3244    name__ic: Option<Vec<String>>,
3245    name__ie: Option<Vec<String>>,
3246    name__iew: Option<Vec<String>>,
3247    name__iregex: Option<Vec<String>>,
3248    name__isw: Option<Vec<String>>,
3249    name__n: Option<Vec<String>>,
3250    name__nic: Option<Vec<String>>,
3251    name__nie: Option<Vec<String>>,
3252    name__niew: Option<Vec<String>>,
3253    name__nisw: Option<Vec<String>>,
3254    name__regex: Option<Vec<String>>,
3255    offset: Option<i32>,
3256    ordering: Option<&str>,
3257    owner: Option<Vec<String>>,
3258    owner__n: Option<Vec<String>>,
3259    owner_group: Option<Vec<String>>,
3260    owner_group__n: Option<Vec<String>>,
3261    owner_group_id: Option<Vec<i32>>,
3262    owner_group_id__n: Option<Vec<i32>>,
3263    owner_id: Option<Vec<i32>>,
3264    owner_id__n: Option<Vec<i32>>,
3265    q: Option<&str>,
3266    sa_lifetime: Option<Vec<i32>>,
3267    sa_lifetime__empty: Option<bool>,
3268    sa_lifetime__gt: Option<Vec<i32>>,
3269    sa_lifetime__gte: Option<Vec<i32>>,
3270    sa_lifetime__lt: Option<Vec<i32>>,
3271    sa_lifetime__lte: Option<Vec<i32>>,
3272    sa_lifetime__n: Option<Vec<i32>>,
3273    start: Option<i32>,
3274    tag: Option<Vec<String>>,
3275    tag__n: Option<Vec<String>>,
3276    tag_id: Option<Vec<i32>>,
3277    tag_id__n: Option<Vec<i32>>,
3278    updated_by_request: Option<&str>,
3279) -> Result<crate::models::PaginatedIkeProposalList, Error<VpnIkeProposalsListError>> {
3280    let local_var_configuration = configuration;
3281
3282    let local_var_client = &local_var_configuration.client;
3283
3284    let local_var_uri_str = format!(
3285        "{}/api/vpn/ike-proposals/",
3286        local_var_configuration.base_path
3287    );
3288    let mut local_var_req_builder =
3289        local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
3290
3291    if let Some(ref local_var_str) = authentication_algorithm {
3292        local_var_req_builder = match "multi" {
3293            "multi" => local_var_req_builder.query(
3294                &local_var_str
3295                    .into_iter()
3296                    .map(|p| ("authentication_algorithm".to_owned(), p.to_string()))
3297                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3298            ),
3299            _ => local_var_req_builder.query(&[(
3300                "authentication_algorithm",
3301                &local_var_str
3302                    .into_iter()
3303                    .map(|p| p.to_string())
3304                    .collect::<Vec<String>>()
3305                    .join(",")
3306                    .to_string(),
3307            )]),
3308        };
3309    }
3310    if let Some(ref local_var_str) = authentication_algorithm__empty {
3311        local_var_req_builder = local_var_req_builder.query(&[(
3312            "authentication_algorithm__empty",
3313            &local_var_str.to_string(),
3314        )]);
3315    }
3316    if let Some(ref local_var_str) = authentication_algorithm__ic {
3317        local_var_req_builder = match "multi" {
3318            "multi" => local_var_req_builder.query(
3319                &local_var_str
3320                    .into_iter()
3321                    .map(|p| ("authentication_algorithm__ic".to_owned(), p.to_string()))
3322                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3323            ),
3324            _ => local_var_req_builder.query(&[(
3325                "authentication_algorithm__ic",
3326                &local_var_str
3327                    .into_iter()
3328                    .map(|p| p.to_string())
3329                    .collect::<Vec<String>>()
3330                    .join(",")
3331                    .to_string(),
3332            )]),
3333        };
3334    }
3335    if let Some(ref local_var_str) = authentication_algorithm__ie {
3336        local_var_req_builder = match "multi" {
3337            "multi" => local_var_req_builder.query(
3338                &local_var_str
3339                    .into_iter()
3340                    .map(|p| ("authentication_algorithm__ie".to_owned(), p.to_string()))
3341                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3342            ),
3343            _ => local_var_req_builder.query(&[(
3344                "authentication_algorithm__ie",
3345                &local_var_str
3346                    .into_iter()
3347                    .map(|p| p.to_string())
3348                    .collect::<Vec<String>>()
3349                    .join(",")
3350                    .to_string(),
3351            )]),
3352        };
3353    }
3354    if let Some(ref local_var_str) = authentication_algorithm__iew {
3355        local_var_req_builder = match "multi" {
3356            "multi" => local_var_req_builder.query(
3357                &local_var_str
3358                    .into_iter()
3359                    .map(|p| ("authentication_algorithm__iew".to_owned(), p.to_string()))
3360                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3361            ),
3362            _ => local_var_req_builder.query(&[(
3363                "authentication_algorithm__iew",
3364                &local_var_str
3365                    .into_iter()
3366                    .map(|p| p.to_string())
3367                    .collect::<Vec<String>>()
3368                    .join(",")
3369                    .to_string(),
3370            )]),
3371        };
3372    }
3373    if let Some(ref local_var_str) = authentication_algorithm__iregex {
3374        local_var_req_builder = match "multi" {
3375            "multi" => local_var_req_builder.query(
3376                &local_var_str
3377                    .into_iter()
3378                    .map(|p| ("authentication_algorithm__iregex".to_owned(), p.to_string()))
3379                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3380            ),
3381            _ => local_var_req_builder.query(&[(
3382                "authentication_algorithm__iregex",
3383                &local_var_str
3384                    .into_iter()
3385                    .map(|p| p.to_string())
3386                    .collect::<Vec<String>>()
3387                    .join(",")
3388                    .to_string(),
3389            )]),
3390        };
3391    }
3392    if let Some(ref local_var_str) = authentication_algorithm__isw {
3393        local_var_req_builder = match "multi" {
3394            "multi" => local_var_req_builder.query(
3395                &local_var_str
3396                    .into_iter()
3397                    .map(|p| ("authentication_algorithm__isw".to_owned(), p.to_string()))
3398                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3399            ),
3400            _ => local_var_req_builder.query(&[(
3401                "authentication_algorithm__isw",
3402                &local_var_str
3403                    .into_iter()
3404                    .map(|p| p.to_string())
3405                    .collect::<Vec<String>>()
3406                    .join(",")
3407                    .to_string(),
3408            )]),
3409        };
3410    }
3411    if let Some(ref local_var_str) = authentication_algorithm__n {
3412        local_var_req_builder = match "multi" {
3413            "multi" => local_var_req_builder.query(
3414                &local_var_str
3415                    .into_iter()
3416                    .map(|p| ("authentication_algorithm__n".to_owned(), p.to_string()))
3417                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3418            ),
3419            _ => local_var_req_builder.query(&[(
3420                "authentication_algorithm__n",
3421                &local_var_str
3422                    .into_iter()
3423                    .map(|p| p.to_string())
3424                    .collect::<Vec<String>>()
3425                    .join(",")
3426                    .to_string(),
3427            )]),
3428        };
3429    }
3430    if let Some(ref local_var_str) = authentication_algorithm__nic {
3431        local_var_req_builder = match "multi" {
3432            "multi" => local_var_req_builder.query(
3433                &local_var_str
3434                    .into_iter()
3435                    .map(|p| ("authentication_algorithm__nic".to_owned(), p.to_string()))
3436                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3437            ),
3438            _ => local_var_req_builder.query(&[(
3439                "authentication_algorithm__nic",
3440                &local_var_str
3441                    .into_iter()
3442                    .map(|p| p.to_string())
3443                    .collect::<Vec<String>>()
3444                    .join(",")
3445                    .to_string(),
3446            )]),
3447        };
3448    }
3449    if let Some(ref local_var_str) = authentication_algorithm__nie {
3450        local_var_req_builder = match "multi" {
3451            "multi" => local_var_req_builder.query(
3452                &local_var_str
3453                    .into_iter()
3454                    .map(|p| ("authentication_algorithm__nie".to_owned(), p.to_string()))
3455                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3456            ),
3457            _ => local_var_req_builder.query(&[(
3458                "authentication_algorithm__nie",
3459                &local_var_str
3460                    .into_iter()
3461                    .map(|p| p.to_string())
3462                    .collect::<Vec<String>>()
3463                    .join(",")
3464                    .to_string(),
3465            )]),
3466        };
3467    }
3468    if let Some(ref local_var_str) = authentication_algorithm__niew {
3469        local_var_req_builder = match "multi" {
3470            "multi" => local_var_req_builder.query(
3471                &local_var_str
3472                    .into_iter()
3473                    .map(|p| ("authentication_algorithm__niew".to_owned(), p.to_string()))
3474                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3475            ),
3476            _ => local_var_req_builder.query(&[(
3477                "authentication_algorithm__niew",
3478                &local_var_str
3479                    .into_iter()
3480                    .map(|p| p.to_string())
3481                    .collect::<Vec<String>>()
3482                    .join(",")
3483                    .to_string(),
3484            )]),
3485        };
3486    }
3487    if let Some(ref local_var_str) = authentication_algorithm__nisw {
3488        local_var_req_builder = match "multi" {
3489            "multi" => local_var_req_builder.query(
3490                &local_var_str
3491                    .into_iter()
3492                    .map(|p| ("authentication_algorithm__nisw".to_owned(), p.to_string()))
3493                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3494            ),
3495            _ => local_var_req_builder.query(&[(
3496                "authentication_algorithm__nisw",
3497                &local_var_str
3498                    .into_iter()
3499                    .map(|p| p.to_string())
3500                    .collect::<Vec<String>>()
3501                    .join(",")
3502                    .to_string(),
3503            )]),
3504        };
3505    }
3506    if let Some(ref local_var_str) = authentication_algorithm__regex {
3507        local_var_req_builder = match "multi" {
3508            "multi" => local_var_req_builder.query(
3509                &local_var_str
3510                    .into_iter()
3511                    .map(|p| ("authentication_algorithm__regex".to_owned(), p.to_string()))
3512                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3513            ),
3514            _ => local_var_req_builder.query(&[(
3515                "authentication_algorithm__regex",
3516                &local_var_str
3517                    .into_iter()
3518                    .map(|p| p.to_string())
3519                    .collect::<Vec<String>>()
3520                    .join(",")
3521                    .to_string(),
3522            )]),
3523        };
3524    }
3525    if let Some(ref local_var_str) = authentication_method {
3526        local_var_req_builder = match "multi" {
3527            "multi" => local_var_req_builder.query(
3528                &local_var_str
3529                    .into_iter()
3530                    .map(|p| ("authentication_method".to_owned(), p.to_string()))
3531                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3532            ),
3533            _ => local_var_req_builder.query(&[(
3534                "authentication_method",
3535                &local_var_str
3536                    .into_iter()
3537                    .map(|p| p.to_string())
3538                    .collect::<Vec<String>>()
3539                    .join(",")
3540                    .to_string(),
3541            )]),
3542        };
3543    }
3544    if let Some(ref local_var_str) = authentication_method__empty {
3545        local_var_req_builder = local_var_req_builder
3546            .query(&[("authentication_method__empty", &local_var_str.to_string())]);
3547    }
3548    if let Some(ref local_var_str) = authentication_method__ic {
3549        local_var_req_builder = match "multi" {
3550            "multi" => local_var_req_builder.query(
3551                &local_var_str
3552                    .into_iter()
3553                    .map(|p| ("authentication_method__ic".to_owned(), p.to_string()))
3554                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3555            ),
3556            _ => local_var_req_builder.query(&[(
3557                "authentication_method__ic",
3558                &local_var_str
3559                    .into_iter()
3560                    .map(|p| p.to_string())
3561                    .collect::<Vec<String>>()
3562                    .join(",")
3563                    .to_string(),
3564            )]),
3565        };
3566    }
3567    if let Some(ref local_var_str) = authentication_method__ie {
3568        local_var_req_builder = match "multi" {
3569            "multi" => local_var_req_builder.query(
3570                &local_var_str
3571                    .into_iter()
3572                    .map(|p| ("authentication_method__ie".to_owned(), p.to_string()))
3573                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3574            ),
3575            _ => local_var_req_builder.query(&[(
3576                "authentication_method__ie",
3577                &local_var_str
3578                    .into_iter()
3579                    .map(|p| p.to_string())
3580                    .collect::<Vec<String>>()
3581                    .join(",")
3582                    .to_string(),
3583            )]),
3584        };
3585    }
3586    if let Some(ref local_var_str) = authentication_method__iew {
3587        local_var_req_builder = match "multi" {
3588            "multi" => local_var_req_builder.query(
3589                &local_var_str
3590                    .into_iter()
3591                    .map(|p| ("authentication_method__iew".to_owned(), p.to_string()))
3592                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3593            ),
3594            _ => local_var_req_builder.query(&[(
3595                "authentication_method__iew",
3596                &local_var_str
3597                    .into_iter()
3598                    .map(|p| p.to_string())
3599                    .collect::<Vec<String>>()
3600                    .join(",")
3601                    .to_string(),
3602            )]),
3603        };
3604    }
3605    if let Some(ref local_var_str) = authentication_method__iregex {
3606        local_var_req_builder = match "multi" {
3607            "multi" => local_var_req_builder.query(
3608                &local_var_str
3609                    .into_iter()
3610                    .map(|p| ("authentication_method__iregex".to_owned(), p.to_string()))
3611                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3612            ),
3613            _ => local_var_req_builder.query(&[(
3614                "authentication_method__iregex",
3615                &local_var_str
3616                    .into_iter()
3617                    .map(|p| p.to_string())
3618                    .collect::<Vec<String>>()
3619                    .join(",")
3620                    .to_string(),
3621            )]),
3622        };
3623    }
3624    if let Some(ref local_var_str) = authentication_method__isw {
3625        local_var_req_builder = match "multi" {
3626            "multi" => local_var_req_builder.query(
3627                &local_var_str
3628                    .into_iter()
3629                    .map(|p| ("authentication_method__isw".to_owned(), p.to_string()))
3630                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3631            ),
3632            _ => local_var_req_builder.query(&[(
3633                "authentication_method__isw",
3634                &local_var_str
3635                    .into_iter()
3636                    .map(|p| p.to_string())
3637                    .collect::<Vec<String>>()
3638                    .join(",")
3639                    .to_string(),
3640            )]),
3641        };
3642    }
3643    if let Some(ref local_var_str) = authentication_method__n {
3644        local_var_req_builder = match "multi" {
3645            "multi" => local_var_req_builder.query(
3646                &local_var_str
3647                    .into_iter()
3648                    .map(|p| ("authentication_method__n".to_owned(), p.to_string()))
3649                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3650            ),
3651            _ => local_var_req_builder.query(&[(
3652                "authentication_method__n",
3653                &local_var_str
3654                    .into_iter()
3655                    .map(|p| p.to_string())
3656                    .collect::<Vec<String>>()
3657                    .join(",")
3658                    .to_string(),
3659            )]),
3660        };
3661    }
3662    if let Some(ref local_var_str) = authentication_method__nic {
3663        local_var_req_builder = match "multi" {
3664            "multi" => local_var_req_builder.query(
3665                &local_var_str
3666                    .into_iter()
3667                    .map(|p| ("authentication_method__nic".to_owned(), p.to_string()))
3668                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3669            ),
3670            _ => local_var_req_builder.query(&[(
3671                "authentication_method__nic",
3672                &local_var_str
3673                    .into_iter()
3674                    .map(|p| p.to_string())
3675                    .collect::<Vec<String>>()
3676                    .join(",")
3677                    .to_string(),
3678            )]),
3679        };
3680    }
3681    if let Some(ref local_var_str) = authentication_method__nie {
3682        local_var_req_builder = match "multi" {
3683            "multi" => local_var_req_builder.query(
3684                &local_var_str
3685                    .into_iter()
3686                    .map(|p| ("authentication_method__nie".to_owned(), p.to_string()))
3687                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3688            ),
3689            _ => local_var_req_builder.query(&[(
3690                "authentication_method__nie",
3691                &local_var_str
3692                    .into_iter()
3693                    .map(|p| p.to_string())
3694                    .collect::<Vec<String>>()
3695                    .join(",")
3696                    .to_string(),
3697            )]),
3698        };
3699    }
3700    if let Some(ref local_var_str) = authentication_method__niew {
3701        local_var_req_builder = match "multi" {
3702            "multi" => local_var_req_builder.query(
3703                &local_var_str
3704                    .into_iter()
3705                    .map(|p| ("authentication_method__niew".to_owned(), p.to_string()))
3706                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3707            ),
3708            _ => local_var_req_builder.query(&[(
3709                "authentication_method__niew",
3710                &local_var_str
3711                    .into_iter()
3712                    .map(|p| p.to_string())
3713                    .collect::<Vec<String>>()
3714                    .join(",")
3715                    .to_string(),
3716            )]),
3717        };
3718    }
3719    if let Some(ref local_var_str) = authentication_method__nisw {
3720        local_var_req_builder = match "multi" {
3721            "multi" => local_var_req_builder.query(
3722                &local_var_str
3723                    .into_iter()
3724                    .map(|p| ("authentication_method__nisw".to_owned(), p.to_string()))
3725                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3726            ),
3727            _ => local_var_req_builder.query(&[(
3728                "authentication_method__nisw",
3729                &local_var_str
3730                    .into_iter()
3731                    .map(|p| p.to_string())
3732                    .collect::<Vec<String>>()
3733                    .join(",")
3734                    .to_string(),
3735            )]),
3736        };
3737    }
3738    if let Some(ref local_var_str) = authentication_method__regex {
3739        local_var_req_builder = match "multi" {
3740            "multi" => local_var_req_builder.query(
3741                &local_var_str
3742                    .into_iter()
3743                    .map(|p| ("authentication_method__regex".to_owned(), p.to_string()))
3744                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3745            ),
3746            _ => local_var_req_builder.query(&[(
3747                "authentication_method__regex",
3748                &local_var_str
3749                    .into_iter()
3750                    .map(|p| p.to_string())
3751                    .collect::<Vec<String>>()
3752                    .join(",")
3753                    .to_string(),
3754            )]),
3755        };
3756    }
3757    if let Some(ref local_var_str) = created {
3758        local_var_req_builder = match "multi" {
3759            "multi" => local_var_req_builder.query(
3760                &local_var_str
3761                    .into_iter()
3762                    .map(|p| ("created".to_owned(), p.to_string()))
3763                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3764            ),
3765            _ => local_var_req_builder.query(&[(
3766                "created",
3767                &local_var_str
3768                    .into_iter()
3769                    .map(|p| p.to_string())
3770                    .collect::<Vec<String>>()
3771                    .join(",")
3772                    .to_string(),
3773            )]),
3774        };
3775    }
3776    if let Some(ref local_var_str) = created__empty {
3777        local_var_req_builder = match "multi" {
3778            "multi" => local_var_req_builder.query(
3779                &local_var_str
3780                    .into_iter()
3781                    .map(|p| ("created__empty".to_owned(), p.to_string()))
3782                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3783            ),
3784            _ => local_var_req_builder.query(&[(
3785                "created__empty",
3786                &local_var_str
3787                    .into_iter()
3788                    .map(|p| p.to_string())
3789                    .collect::<Vec<String>>()
3790                    .join(",")
3791                    .to_string(),
3792            )]),
3793        };
3794    }
3795    if let Some(ref local_var_str) = created__gt {
3796        local_var_req_builder = match "multi" {
3797            "multi" => local_var_req_builder.query(
3798                &local_var_str
3799                    .into_iter()
3800                    .map(|p| ("created__gt".to_owned(), p.to_string()))
3801                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3802            ),
3803            _ => local_var_req_builder.query(&[(
3804                "created__gt",
3805                &local_var_str
3806                    .into_iter()
3807                    .map(|p| p.to_string())
3808                    .collect::<Vec<String>>()
3809                    .join(",")
3810                    .to_string(),
3811            )]),
3812        };
3813    }
3814    if let Some(ref local_var_str) = created__gte {
3815        local_var_req_builder = match "multi" {
3816            "multi" => local_var_req_builder.query(
3817                &local_var_str
3818                    .into_iter()
3819                    .map(|p| ("created__gte".to_owned(), p.to_string()))
3820                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3821            ),
3822            _ => local_var_req_builder.query(&[(
3823                "created__gte",
3824                &local_var_str
3825                    .into_iter()
3826                    .map(|p| p.to_string())
3827                    .collect::<Vec<String>>()
3828                    .join(",")
3829                    .to_string(),
3830            )]),
3831        };
3832    }
3833    if let Some(ref local_var_str) = created__lt {
3834        local_var_req_builder = match "multi" {
3835            "multi" => local_var_req_builder.query(
3836                &local_var_str
3837                    .into_iter()
3838                    .map(|p| ("created__lt".to_owned(), p.to_string()))
3839                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3840            ),
3841            _ => local_var_req_builder.query(&[(
3842                "created__lt",
3843                &local_var_str
3844                    .into_iter()
3845                    .map(|p| p.to_string())
3846                    .collect::<Vec<String>>()
3847                    .join(",")
3848                    .to_string(),
3849            )]),
3850        };
3851    }
3852    if let Some(ref local_var_str) = created__lte {
3853        local_var_req_builder = match "multi" {
3854            "multi" => local_var_req_builder.query(
3855                &local_var_str
3856                    .into_iter()
3857                    .map(|p| ("created__lte".to_owned(), p.to_string()))
3858                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3859            ),
3860            _ => local_var_req_builder.query(&[(
3861                "created__lte",
3862                &local_var_str
3863                    .into_iter()
3864                    .map(|p| p.to_string())
3865                    .collect::<Vec<String>>()
3866                    .join(",")
3867                    .to_string(),
3868            )]),
3869        };
3870    }
3871    if let Some(ref local_var_str) = created__n {
3872        local_var_req_builder = match "multi" {
3873            "multi" => local_var_req_builder.query(
3874                &local_var_str
3875                    .into_iter()
3876                    .map(|p| ("created__n".to_owned(), p.to_string()))
3877                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3878            ),
3879            _ => local_var_req_builder.query(&[(
3880                "created__n",
3881                &local_var_str
3882                    .into_iter()
3883                    .map(|p| p.to_string())
3884                    .collect::<Vec<String>>()
3885                    .join(",")
3886                    .to_string(),
3887            )]),
3888        };
3889    }
3890    if let Some(ref local_var_str) = created_by_request {
3891        local_var_req_builder =
3892            local_var_req_builder.query(&[("created_by_request", &local_var_str.to_string())]);
3893    }
3894    if let Some(ref local_var_str) = description {
3895        local_var_req_builder = match "multi" {
3896            "multi" => local_var_req_builder.query(
3897                &local_var_str
3898                    .into_iter()
3899                    .map(|p| ("description".to_owned(), p.to_string()))
3900                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3901            ),
3902            _ => local_var_req_builder.query(&[(
3903                "description",
3904                &local_var_str
3905                    .into_iter()
3906                    .map(|p| p.to_string())
3907                    .collect::<Vec<String>>()
3908                    .join(",")
3909                    .to_string(),
3910            )]),
3911        };
3912    }
3913    if let Some(ref local_var_str) = description__empty {
3914        local_var_req_builder =
3915            local_var_req_builder.query(&[("description__empty", &local_var_str.to_string())]);
3916    }
3917    if let Some(ref local_var_str) = description__ic {
3918        local_var_req_builder = match "multi" {
3919            "multi" => local_var_req_builder.query(
3920                &local_var_str
3921                    .into_iter()
3922                    .map(|p| ("description__ic".to_owned(), p.to_string()))
3923                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3924            ),
3925            _ => local_var_req_builder.query(&[(
3926                "description__ic",
3927                &local_var_str
3928                    .into_iter()
3929                    .map(|p| p.to_string())
3930                    .collect::<Vec<String>>()
3931                    .join(",")
3932                    .to_string(),
3933            )]),
3934        };
3935    }
3936    if let Some(ref local_var_str) = description__ie {
3937        local_var_req_builder = match "multi" {
3938            "multi" => local_var_req_builder.query(
3939                &local_var_str
3940                    .into_iter()
3941                    .map(|p| ("description__ie".to_owned(), p.to_string()))
3942                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3943            ),
3944            _ => local_var_req_builder.query(&[(
3945                "description__ie",
3946                &local_var_str
3947                    .into_iter()
3948                    .map(|p| p.to_string())
3949                    .collect::<Vec<String>>()
3950                    .join(",")
3951                    .to_string(),
3952            )]),
3953        };
3954    }
3955    if let Some(ref local_var_str) = description__iew {
3956        local_var_req_builder = match "multi" {
3957            "multi" => local_var_req_builder.query(
3958                &local_var_str
3959                    .into_iter()
3960                    .map(|p| ("description__iew".to_owned(), p.to_string()))
3961                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3962            ),
3963            _ => local_var_req_builder.query(&[(
3964                "description__iew",
3965                &local_var_str
3966                    .into_iter()
3967                    .map(|p| p.to_string())
3968                    .collect::<Vec<String>>()
3969                    .join(",")
3970                    .to_string(),
3971            )]),
3972        };
3973    }
3974    if let Some(ref local_var_str) = description__iregex {
3975        local_var_req_builder = match "multi" {
3976            "multi" => local_var_req_builder.query(
3977                &local_var_str
3978                    .into_iter()
3979                    .map(|p| ("description__iregex".to_owned(), p.to_string()))
3980                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3981            ),
3982            _ => local_var_req_builder.query(&[(
3983                "description__iregex",
3984                &local_var_str
3985                    .into_iter()
3986                    .map(|p| p.to_string())
3987                    .collect::<Vec<String>>()
3988                    .join(",")
3989                    .to_string(),
3990            )]),
3991        };
3992    }
3993    if let Some(ref local_var_str) = description__isw {
3994        local_var_req_builder = match "multi" {
3995            "multi" => local_var_req_builder.query(
3996                &local_var_str
3997                    .into_iter()
3998                    .map(|p| ("description__isw".to_owned(), p.to_string()))
3999                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4000            ),
4001            _ => local_var_req_builder.query(&[(
4002                "description__isw",
4003                &local_var_str
4004                    .into_iter()
4005                    .map(|p| p.to_string())
4006                    .collect::<Vec<String>>()
4007                    .join(",")
4008                    .to_string(),
4009            )]),
4010        };
4011    }
4012    if let Some(ref local_var_str) = description__n {
4013        local_var_req_builder = match "multi" {
4014            "multi" => local_var_req_builder.query(
4015                &local_var_str
4016                    .into_iter()
4017                    .map(|p| ("description__n".to_owned(), p.to_string()))
4018                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4019            ),
4020            _ => local_var_req_builder.query(&[(
4021                "description__n",
4022                &local_var_str
4023                    .into_iter()
4024                    .map(|p| p.to_string())
4025                    .collect::<Vec<String>>()
4026                    .join(",")
4027                    .to_string(),
4028            )]),
4029        };
4030    }
4031    if let Some(ref local_var_str) = description__nic {
4032        local_var_req_builder = match "multi" {
4033            "multi" => local_var_req_builder.query(
4034                &local_var_str
4035                    .into_iter()
4036                    .map(|p| ("description__nic".to_owned(), p.to_string()))
4037                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4038            ),
4039            _ => local_var_req_builder.query(&[(
4040                "description__nic",
4041                &local_var_str
4042                    .into_iter()
4043                    .map(|p| p.to_string())
4044                    .collect::<Vec<String>>()
4045                    .join(",")
4046                    .to_string(),
4047            )]),
4048        };
4049    }
4050    if let Some(ref local_var_str) = description__nie {
4051        local_var_req_builder = match "multi" {
4052            "multi" => local_var_req_builder.query(
4053                &local_var_str
4054                    .into_iter()
4055                    .map(|p| ("description__nie".to_owned(), p.to_string()))
4056                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4057            ),
4058            _ => local_var_req_builder.query(&[(
4059                "description__nie",
4060                &local_var_str
4061                    .into_iter()
4062                    .map(|p| p.to_string())
4063                    .collect::<Vec<String>>()
4064                    .join(",")
4065                    .to_string(),
4066            )]),
4067        };
4068    }
4069    if let Some(ref local_var_str) = description__niew {
4070        local_var_req_builder = match "multi" {
4071            "multi" => local_var_req_builder.query(
4072                &local_var_str
4073                    .into_iter()
4074                    .map(|p| ("description__niew".to_owned(), p.to_string()))
4075                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4076            ),
4077            _ => local_var_req_builder.query(&[(
4078                "description__niew",
4079                &local_var_str
4080                    .into_iter()
4081                    .map(|p| p.to_string())
4082                    .collect::<Vec<String>>()
4083                    .join(",")
4084                    .to_string(),
4085            )]),
4086        };
4087    }
4088    if let Some(ref local_var_str) = description__nisw {
4089        local_var_req_builder = match "multi" {
4090            "multi" => local_var_req_builder.query(
4091                &local_var_str
4092                    .into_iter()
4093                    .map(|p| ("description__nisw".to_owned(), p.to_string()))
4094                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4095            ),
4096            _ => local_var_req_builder.query(&[(
4097                "description__nisw",
4098                &local_var_str
4099                    .into_iter()
4100                    .map(|p| p.to_string())
4101                    .collect::<Vec<String>>()
4102                    .join(",")
4103                    .to_string(),
4104            )]),
4105        };
4106    }
4107    if let Some(ref local_var_str) = description__regex {
4108        local_var_req_builder = match "multi" {
4109            "multi" => local_var_req_builder.query(
4110                &local_var_str
4111                    .into_iter()
4112                    .map(|p| ("description__regex".to_owned(), p.to_string()))
4113                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4114            ),
4115            _ => local_var_req_builder.query(&[(
4116                "description__regex",
4117                &local_var_str
4118                    .into_iter()
4119                    .map(|p| p.to_string())
4120                    .collect::<Vec<String>>()
4121                    .join(",")
4122                    .to_string(),
4123            )]),
4124        };
4125    }
4126    if let Some(ref local_var_str) = encryption_algorithm {
4127        local_var_req_builder = match "multi" {
4128            "multi" => local_var_req_builder.query(
4129                &local_var_str
4130                    .into_iter()
4131                    .map(|p| ("encryption_algorithm".to_owned(), p.to_string()))
4132                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4133            ),
4134            _ => local_var_req_builder.query(&[(
4135                "encryption_algorithm",
4136                &local_var_str
4137                    .into_iter()
4138                    .map(|p| p.to_string())
4139                    .collect::<Vec<String>>()
4140                    .join(",")
4141                    .to_string(),
4142            )]),
4143        };
4144    }
4145    if let Some(ref local_var_str) = encryption_algorithm__empty {
4146        local_var_req_builder = local_var_req_builder
4147            .query(&[("encryption_algorithm__empty", &local_var_str.to_string())]);
4148    }
4149    if let Some(ref local_var_str) = encryption_algorithm__ic {
4150        local_var_req_builder = match "multi" {
4151            "multi" => local_var_req_builder.query(
4152                &local_var_str
4153                    .into_iter()
4154                    .map(|p| ("encryption_algorithm__ic".to_owned(), p.to_string()))
4155                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4156            ),
4157            _ => local_var_req_builder.query(&[(
4158                "encryption_algorithm__ic",
4159                &local_var_str
4160                    .into_iter()
4161                    .map(|p| p.to_string())
4162                    .collect::<Vec<String>>()
4163                    .join(",")
4164                    .to_string(),
4165            )]),
4166        };
4167    }
4168    if let Some(ref local_var_str) = encryption_algorithm__ie {
4169        local_var_req_builder = match "multi" {
4170            "multi" => local_var_req_builder.query(
4171                &local_var_str
4172                    .into_iter()
4173                    .map(|p| ("encryption_algorithm__ie".to_owned(), p.to_string()))
4174                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4175            ),
4176            _ => local_var_req_builder.query(&[(
4177                "encryption_algorithm__ie",
4178                &local_var_str
4179                    .into_iter()
4180                    .map(|p| p.to_string())
4181                    .collect::<Vec<String>>()
4182                    .join(",")
4183                    .to_string(),
4184            )]),
4185        };
4186    }
4187    if let Some(ref local_var_str) = encryption_algorithm__iew {
4188        local_var_req_builder = match "multi" {
4189            "multi" => local_var_req_builder.query(
4190                &local_var_str
4191                    .into_iter()
4192                    .map(|p| ("encryption_algorithm__iew".to_owned(), p.to_string()))
4193                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4194            ),
4195            _ => local_var_req_builder.query(&[(
4196                "encryption_algorithm__iew",
4197                &local_var_str
4198                    .into_iter()
4199                    .map(|p| p.to_string())
4200                    .collect::<Vec<String>>()
4201                    .join(",")
4202                    .to_string(),
4203            )]),
4204        };
4205    }
4206    if let Some(ref local_var_str) = encryption_algorithm__iregex {
4207        local_var_req_builder = match "multi" {
4208            "multi" => local_var_req_builder.query(
4209                &local_var_str
4210                    .into_iter()
4211                    .map(|p| ("encryption_algorithm__iregex".to_owned(), p.to_string()))
4212                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4213            ),
4214            _ => local_var_req_builder.query(&[(
4215                "encryption_algorithm__iregex",
4216                &local_var_str
4217                    .into_iter()
4218                    .map(|p| p.to_string())
4219                    .collect::<Vec<String>>()
4220                    .join(",")
4221                    .to_string(),
4222            )]),
4223        };
4224    }
4225    if let Some(ref local_var_str) = encryption_algorithm__isw {
4226        local_var_req_builder = match "multi" {
4227            "multi" => local_var_req_builder.query(
4228                &local_var_str
4229                    .into_iter()
4230                    .map(|p| ("encryption_algorithm__isw".to_owned(), p.to_string()))
4231                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4232            ),
4233            _ => local_var_req_builder.query(&[(
4234                "encryption_algorithm__isw",
4235                &local_var_str
4236                    .into_iter()
4237                    .map(|p| p.to_string())
4238                    .collect::<Vec<String>>()
4239                    .join(",")
4240                    .to_string(),
4241            )]),
4242        };
4243    }
4244    if let Some(ref local_var_str) = encryption_algorithm__n {
4245        local_var_req_builder = match "multi" {
4246            "multi" => local_var_req_builder.query(
4247                &local_var_str
4248                    .into_iter()
4249                    .map(|p| ("encryption_algorithm__n".to_owned(), p.to_string()))
4250                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4251            ),
4252            _ => local_var_req_builder.query(&[(
4253                "encryption_algorithm__n",
4254                &local_var_str
4255                    .into_iter()
4256                    .map(|p| p.to_string())
4257                    .collect::<Vec<String>>()
4258                    .join(",")
4259                    .to_string(),
4260            )]),
4261        };
4262    }
4263    if let Some(ref local_var_str) = encryption_algorithm__nic {
4264        local_var_req_builder = match "multi" {
4265            "multi" => local_var_req_builder.query(
4266                &local_var_str
4267                    .into_iter()
4268                    .map(|p| ("encryption_algorithm__nic".to_owned(), p.to_string()))
4269                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4270            ),
4271            _ => local_var_req_builder.query(&[(
4272                "encryption_algorithm__nic",
4273                &local_var_str
4274                    .into_iter()
4275                    .map(|p| p.to_string())
4276                    .collect::<Vec<String>>()
4277                    .join(",")
4278                    .to_string(),
4279            )]),
4280        };
4281    }
4282    if let Some(ref local_var_str) = encryption_algorithm__nie {
4283        local_var_req_builder = match "multi" {
4284            "multi" => local_var_req_builder.query(
4285                &local_var_str
4286                    .into_iter()
4287                    .map(|p| ("encryption_algorithm__nie".to_owned(), p.to_string()))
4288                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4289            ),
4290            _ => local_var_req_builder.query(&[(
4291                "encryption_algorithm__nie",
4292                &local_var_str
4293                    .into_iter()
4294                    .map(|p| p.to_string())
4295                    .collect::<Vec<String>>()
4296                    .join(",")
4297                    .to_string(),
4298            )]),
4299        };
4300    }
4301    if let Some(ref local_var_str) = encryption_algorithm__niew {
4302        local_var_req_builder = match "multi" {
4303            "multi" => local_var_req_builder.query(
4304                &local_var_str
4305                    .into_iter()
4306                    .map(|p| ("encryption_algorithm__niew".to_owned(), p.to_string()))
4307                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4308            ),
4309            _ => local_var_req_builder.query(&[(
4310                "encryption_algorithm__niew",
4311                &local_var_str
4312                    .into_iter()
4313                    .map(|p| p.to_string())
4314                    .collect::<Vec<String>>()
4315                    .join(",")
4316                    .to_string(),
4317            )]),
4318        };
4319    }
4320    if let Some(ref local_var_str) = encryption_algorithm__nisw {
4321        local_var_req_builder = match "multi" {
4322            "multi" => local_var_req_builder.query(
4323                &local_var_str
4324                    .into_iter()
4325                    .map(|p| ("encryption_algorithm__nisw".to_owned(), p.to_string()))
4326                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4327            ),
4328            _ => local_var_req_builder.query(&[(
4329                "encryption_algorithm__nisw",
4330                &local_var_str
4331                    .into_iter()
4332                    .map(|p| p.to_string())
4333                    .collect::<Vec<String>>()
4334                    .join(",")
4335                    .to_string(),
4336            )]),
4337        };
4338    }
4339    if let Some(ref local_var_str) = encryption_algorithm__regex {
4340        local_var_req_builder = match "multi" {
4341            "multi" => local_var_req_builder.query(
4342                &local_var_str
4343                    .into_iter()
4344                    .map(|p| ("encryption_algorithm__regex".to_owned(), p.to_string()))
4345                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4346            ),
4347            _ => local_var_req_builder.query(&[(
4348                "encryption_algorithm__regex",
4349                &local_var_str
4350                    .into_iter()
4351                    .map(|p| p.to_string())
4352                    .collect::<Vec<String>>()
4353                    .join(",")
4354                    .to_string(),
4355            )]),
4356        };
4357    }
4358    if let Some(ref local_var_str) = group {
4359        local_var_req_builder = match "multi" {
4360            "multi" => local_var_req_builder.query(
4361                &local_var_str
4362                    .into_iter()
4363                    .map(|p| ("group".to_owned(), p.to_string()))
4364                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4365            ),
4366            _ => local_var_req_builder.query(&[(
4367                "group",
4368                &local_var_str
4369                    .into_iter()
4370                    .map(|p| p.to_string())
4371                    .collect::<Vec<String>>()
4372                    .join(",")
4373                    .to_string(),
4374            )]),
4375        };
4376    }
4377    if let Some(ref local_var_str) = group__ic {
4378        local_var_req_builder = match "multi" {
4379            "multi" => local_var_req_builder.query(
4380                &local_var_str
4381                    .into_iter()
4382                    .map(|p| ("group__ic".to_owned(), p.to_string()))
4383                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4384            ),
4385            _ => local_var_req_builder.query(&[(
4386                "group__ic",
4387                &local_var_str
4388                    .into_iter()
4389                    .map(|p| p.to_string())
4390                    .collect::<Vec<String>>()
4391                    .join(",")
4392                    .to_string(),
4393            )]),
4394        };
4395    }
4396    if let Some(ref local_var_str) = group__ie {
4397        local_var_req_builder = match "multi" {
4398            "multi" => local_var_req_builder.query(
4399                &local_var_str
4400                    .into_iter()
4401                    .map(|p| ("group__ie".to_owned(), p.to_string()))
4402                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4403            ),
4404            _ => local_var_req_builder.query(&[(
4405                "group__ie",
4406                &local_var_str
4407                    .into_iter()
4408                    .map(|p| p.to_string())
4409                    .collect::<Vec<String>>()
4410                    .join(",")
4411                    .to_string(),
4412            )]),
4413        };
4414    }
4415    if let Some(ref local_var_str) = group__iew {
4416        local_var_req_builder = match "multi" {
4417            "multi" => local_var_req_builder.query(
4418                &local_var_str
4419                    .into_iter()
4420                    .map(|p| ("group__iew".to_owned(), p.to_string()))
4421                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4422            ),
4423            _ => local_var_req_builder.query(&[(
4424                "group__iew",
4425                &local_var_str
4426                    .into_iter()
4427                    .map(|p| p.to_string())
4428                    .collect::<Vec<String>>()
4429                    .join(",")
4430                    .to_string(),
4431            )]),
4432        };
4433    }
4434    if let Some(ref local_var_str) = group__iregex {
4435        local_var_req_builder = match "multi" {
4436            "multi" => local_var_req_builder.query(
4437                &local_var_str
4438                    .into_iter()
4439                    .map(|p| ("group__iregex".to_owned(), p.to_string()))
4440                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4441            ),
4442            _ => local_var_req_builder.query(&[(
4443                "group__iregex",
4444                &local_var_str
4445                    .into_iter()
4446                    .map(|p| p.to_string())
4447                    .collect::<Vec<String>>()
4448                    .join(",")
4449                    .to_string(),
4450            )]),
4451        };
4452    }
4453    if let Some(ref local_var_str) = group__isw {
4454        local_var_req_builder = match "multi" {
4455            "multi" => local_var_req_builder.query(
4456                &local_var_str
4457                    .into_iter()
4458                    .map(|p| ("group__isw".to_owned(), p.to_string()))
4459                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4460            ),
4461            _ => local_var_req_builder.query(&[(
4462                "group__isw",
4463                &local_var_str
4464                    .into_iter()
4465                    .map(|p| p.to_string())
4466                    .collect::<Vec<String>>()
4467                    .join(",")
4468                    .to_string(),
4469            )]),
4470        };
4471    }
4472    if let Some(ref local_var_str) = group__n {
4473        local_var_req_builder = match "multi" {
4474            "multi" => local_var_req_builder.query(
4475                &local_var_str
4476                    .into_iter()
4477                    .map(|p| ("group__n".to_owned(), p.to_string()))
4478                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4479            ),
4480            _ => local_var_req_builder.query(&[(
4481                "group__n",
4482                &local_var_str
4483                    .into_iter()
4484                    .map(|p| p.to_string())
4485                    .collect::<Vec<String>>()
4486                    .join(",")
4487                    .to_string(),
4488            )]),
4489        };
4490    }
4491    if let Some(ref local_var_str) = group__nic {
4492        local_var_req_builder = match "multi" {
4493            "multi" => local_var_req_builder.query(
4494                &local_var_str
4495                    .into_iter()
4496                    .map(|p| ("group__nic".to_owned(), p.to_string()))
4497                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4498            ),
4499            _ => local_var_req_builder.query(&[(
4500                "group__nic",
4501                &local_var_str
4502                    .into_iter()
4503                    .map(|p| p.to_string())
4504                    .collect::<Vec<String>>()
4505                    .join(",")
4506                    .to_string(),
4507            )]),
4508        };
4509    }
4510    if let Some(ref local_var_str) = group__nie {
4511        local_var_req_builder = match "multi" {
4512            "multi" => local_var_req_builder.query(
4513                &local_var_str
4514                    .into_iter()
4515                    .map(|p| ("group__nie".to_owned(), p.to_string()))
4516                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4517            ),
4518            _ => local_var_req_builder.query(&[(
4519                "group__nie",
4520                &local_var_str
4521                    .into_iter()
4522                    .map(|p| p.to_string())
4523                    .collect::<Vec<String>>()
4524                    .join(",")
4525                    .to_string(),
4526            )]),
4527        };
4528    }
4529    if let Some(ref local_var_str) = group__niew {
4530        local_var_req_builder = match "multi" {
4531            "multi" => local_var_req_builder.query(
4532                &local_var_str
4533                    .into_iter()
4534                    .map(|p| ("group__niew".to_owned(), p.to_string()))
4535                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4536            ),
4537            _ => local_var_req_builder.query(&[(
4538                "group__niew",
4539                &local_var_str
4540                    .into_iter()
4541                    .map(|p| p.to_string())
4542                    .collect::<Vec<String>>()
4543                    .join(",")
4544                    .to_string(),
4545            )]),
4546        };
4547    }
4548    if let Some(ref local_var_str) = group__nisw {
4549        local_var_req_builder = match "multi" {
4550            "multi" => local_var_req_builder.query(
4551                &local_var_str
4552                    .into_iter()
4553                    .map(|p| ("group__nisw".to_owned(), p.to_string()))
4554                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4555            ),
4556            _ => local_var_req_builder.query(&[(
4557                "group__nisw",
4558                &local_var_str
4559                    .into_iter()
4560                    .map(|p| p.to_string())
4561                    .collect::<Vec<String>>()
4562                    .join(",")
4563                    .to_string(),
4564            )]),
4565        };
4566    }
4567    if let Some(ref local_var_str) = group__regex {
4568        local_var_req_builder = match "multi" {
4569            "multi" => local_var_req_builder.query(
4570                &local_var_str
4571                    .into_iter()
4572                    .map(|p| ("group__regex".to_owned(), p.to_string()))
4573                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4574            ),
4575            _ => local_var_req_builder.query(&[(
4576                "group__regex",
4577                &local_var_str
4578                    .into_iter()
4579                    .map(|p| p.to_string())
4580                    .collect::<Vec<String>>()
4581                    .join(",")
4582                    .to_string(),
4583            )]),
4584        };
4585    }
4586    if let Some(ref local_var_str) = id {
4587        local_var_req_builder = match "multi" {
4588            "multi" => local_var_req_builder.query(
4589                &local_var_str
4590                    .into_iter()
4591                    .map(|p| ("id".to_owned(), p.to_string()))
4592                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4593            ),
4594            _ => local_var_req_builder.query(&[(
4595                "id",
4596                &local_var_str
4597                    .into_iter()
4598                    .map(|p| p.to_string())
4599                    .collect::<Vec<String>>()
4600                    .join(",")
4601                    .to_string(),
4602            )]),
4603        };
4604    }
4605    if let Some(ref local_var_str) = id__empty {
4606        local_var_req_builder =
4607            local_var_req_builder.query(&[("id__empty", &local_var_str.to_string())]);
4608    }
4609    if let Some(ref local_var_str) = id__gt {
4610        local_var_req_builder = match "multi" {
4611            "multi" => local_var_req_builder.query(
4612                &local_var_str
4613                    .into_iter()
4614                    .map(|p| ("id__gt".to_owned(), p.to_string()))
4615                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4616            ),
4617            _ => local_var_req_builder.query(&[(
4618                "id__gt",
4619                &local_var_str
4620                    .into_iter()
4621                    .map(|p| p.to_string())
4622                    .collect::<Vec<String>>()
4623                    .join(",")
4624                    .to_string(),
4625            )]),
4626        };
4627    }
4628    if let Some(ref local_var_str) = id__gte {
4629        local_var_req_builder = match "multi" {
4630            "multi" => local_var_req_builder.query(
4631                &local_var_str
4632                    .into_iter()
4633                    .map(|p| ("id__gte".to_owned(), p.to_string()))
4634                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4635            ),
4636            _ => local_var_req_builder.query(&[(
4637                "id__gte",
4638                &local_var_str
4639                    .into_iter()
4640                    .map(|p| p.to_string())
4641                    .collect::<Vec<String>>()
4642                    .join(",")
4643                    .to_string(),
4644            )]),
4645        };
4646    }
4647    if let Some(ref local_var_str) = id__lt {
4648        local_var_req_builder = match "multi" {
4649            "multi" => local_var_req_builder.query(
4650                &local_var_str
4651                    .into_iter()
4652                    .map(|p| ("id__lt".to_owned(), p.to_string()))
4653                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4654            ),
4655            _ => local_var_req_builder.query(&[(
4656                "id__lt",
4657                &local_var_str
4658                    .into_iter()
4659                    .map(|p| p.to_string())
4660                    .collect::<Vec<String>>()
4661                    .join(",")
4662                    .to_string(),
4663            )]),
4664        };
4665    }
4666    if let Some(ref local_var_str) = id__lte {
4667        local_var_req_builder = match "multi" {
4668            "multi" => local_var_req_builder.query(
4669                &local_var_str
4670                    .into_iter()
4671                    .map(|p| ("id__lte".to_owned(), p.to_string()))
4672                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4673            ),
4674            _ => local_var_req_builder.query(&[(
4675                "id__lte",
4676                &local_var_str
4677                    .into_iter()
4678                    .map(|p| p.to_string())
4679                    .collect::<Vec<String>>()
4680                    .join(",")
4681                    .to_string(),
4682            )]),
4683        };
4684    }
4685    if let Some(ref local_var_str) = id__n {
4686        local_var_req_builder = match "multi" {
4687            "multi" => local_var_req_builder.query(
4688                &local_var_str
4689                    .into_iter()
4690                    .map(|p| ("id__n".to_owned(), p.to_string()))
4691                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4692            ),
4693            _ => local_var_req_builder.query(&[(
4694                "id__n",
4695                &local_var_str
4696                    .into_iter()
4697                    .map(|p| p.to_string())
4698                    .collect::<Vec<String>>()
4699                    .join(",")
4700                    .to_string(),
4701            )]),
4702        };
4703    }
4704    if let Some(ref local_var_str) = ike_policy {
4705        local_var_req_builder = match "multi" {
4706            "multi" => local_var_req_builder.query(
4707                &local_var_str
4708                    .into_iter()
4709                    .map(|p| ("ike_policy".to_owned(), p.to_string()))
4710                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4711            ),
4712            _ => local_var_req_builder.query(&[(
4713                "ike_policy",
4714                &local_var_str
4715                    .into_iter()
4716                    .map(|p| p.to_string())
4717                    .collect::<Vec<String>>()
4718                    .join(",")
4719                    .to_string(),
4720            )]),
4721        };
4722    }
4723    if let Some(ref local_var_str) = ike_policy__n {
4724        local_var_req_builder = match "multi" {
4725            "multi" => local_var_req_builder.query(
4726                &local_var_str
4727                    .into_iter()
4728                    .map(|p| ("ike_policy__n".to_owned(), p.to_string()))
4729                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4730            ),
4731            _ => local_var_req_builder.query(&[(
4732                "ike_policy__n",
4733                &local_var_str
4734                    .into_iter()
4735                    .map(|p| p.to_string())
4736                    .collect::<Vec<String>>()
4737                    .join(",")
4738                    .to_string(),
4739            )]),
4740        };
4741    }
4742    if let Some(ref local_var_str) = ike_policy_id {
4743        local_var_req_builder = match "multi" {
4744            "multi" => local_var_req_builder.query(
4745                &local_var_str
4746                    .into_iter()
4747                    .map(|p| ("ike_policy_id".to_owned(), p.to_string()))
4748                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4749            ),
4750            _ => local_var_req_builder.query(&[(
4751                "ike_policy_id",
4752                &local_var_str
4753                    .into_iter()
4754                    .map(|p| p.to_string())
4755                    .collect::<Vec<String>>()
4756                    .join(",")
4757                    .to_string(),
4758            )]),
4759        };
4760    }
4761    if let Some(ref local_var_str) = ike_policy_id__n {
4762        local_var_req_builder = match "multi" {
4763            "multi" => local_var_req_builder.query(
4764                &local_var_str
4765                    .into_iter()
4766                    .map(|p| ("ike_policy_id__n".to_owned(), p.to_string()))
4767                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4768            ),
4769            _ => local_var_req_builder.query(&[(
4770                "ike_policy_id__n",
4771                &local_var_str
4772                    .into_iter()
4773                    .map(|p| p.to_string())
4774                    .collect::<Vec<String>>()
4775                    .join(",")
4776                    .to_string(),
4777            )]),
4778        };
4779    }
4780    if let Some(ref local_var_str) = last_updated {
4781        local_var_req_builder = match "multi" {
4782            "multi" => local_var_req_builder.query(
4783                &local_var_str
4784                    .into_iter()
4785                    .map(|p| ("last_updated".to_owned(), p.to_string()))
4786                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4787            ),
4788            _ => local_var_req_builder.query(&[(
4789                "last_updated",
4790                &local_var_str
4791                    .into_iter()
4792                    .map(|p| p.to_string())
4793                    .collect::<Vec<String>>()
4794                    .join(",")
4795                    .to_string(),
4796            )]),
4797        };
4798    }
4799    if let Some(ref local_var_str) = last_updated__empty {
4800        local_var_req_builder = match "multi" {
4801            "multi" => local_var_req_builder.query(
4802                &local_var_str
4803                    .into_iter()
4804                    .map(|p| ("last_updated__empty".to_owned(), p.to_string()))
4805                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4806            ),
4807            _ => local_var_req_builder.query(&[(
4808                "last_updated__empty",
4809                &local_var_str
4810                    .into_iter()
4811                    .map(|p| p.to_string())
4812                    .collect::<Vec<String>>()
4813                    .join(",")
4814                    .to_string(),
4815            )]),
4816        };
4817    }
4818    if let Some(ref local_var_str) = last_updated__gt {
4819        local_var_req_builder = match "multi" {
4820            "multi" => local_var_req_builder.query(
4821                &local_var_str
4822                    .into_iter()
4823                    .map(|p| ("last_updated__gt".to_owned(), p.to_string()))
4824                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4825            ),
4826            _ => local_var_req_builder.query(&[(
4827                "last_updated__gt",
4828                &local_var_str
4829                    .into_iter()
4830                    .map(|p| p.to_string())
4831                    .collect::<Vec<String>>()
4832                    .join(",")
4833                    .to_string(),
4834            )]),
4835        };
4836    }
4837    if let Some(ref local_var_str) = last_updated__gte {
4838        local_var_req_builder = match "multi" {
4839            "multi" => local_var_req_builder.query(
4840                &local_var_str
4841                    .into_iter()
4842                    .map(|p| ("last_updated__gte".to_owned(), p.to_string()))
4843                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4844            ),
4845            _ => local_var_req_builder.query(&[(
4846                "last_updated__gte",
4847                &local_var_str
4848                    .into_iter()
4849                    .map(|p| p.to_string())
4850                    .collect::<Vec<String>>()
4851                    .join(",")
4852                    .to_string(),
4853            )]),
4854        };
4855    }
4856    if let Some(ref local_var_str) = last_updated__lt {
4857        local_var_req_builder = match "multi" {
4858            "multi" => local_var_req_builder.query(
4859                &local_var_str
4860                    .into_iter()
4861                    .map(|p| ("last_updated__lt".to_owned(), p.to_string()))
4862                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4863            ),
4864            _ => local_var_req_builder.query(&[(
4865                "last_updated__lt",
4866                &local_var_str
4867                    .into_iter()
4868                    .map(|p| p.to_string())
4869                    .collect::<Vec<String>>()
4870                    .join(",")
4871                    .to_string(),
4872            )]),
4873        };
4874    }
4875    if let Some(ref local_var_str) = last_updated__lte {
4876        local_var_req_builder = match "multi" {
4877            "multi" => local_var_req_builder.query(
4878                &local_var_str
4879                    .into_iter()
4880                    .map(|p| ("last_updated__lte".to_owned(), p.to_string()))
4881                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4882            ),
4883            _ => local_var_req_builder.query(&[(
4884                "last_updated__lte",
4885                &local_var_str
4886                    .into_iter()
4887                    .map(|p| p.to_string())
4888                    .collect::<Vec<String>>()
4889                    .join(",")
4890                    .to_string(),
4891            )]),
4892        };
4893    }
4894    if let Some(ref local_var_str) = last_updated__n {
4895        local_var_req_builder = match "multi" {
4896            "multi" => local_var_req_builder.query(
4897                &local_var_str
4898                    .into_iter()
4899                    .map(|p| ("last_updated__n".to_owned(), p.to_string()))
4900                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4901            ),
4902            _ => local_var_req_builder.query(&[(
4903                "last_updated__n",
4904                &local_var_str
4905                    .into_iter()
4906                    .map(|p| p.to_string())
4907                    .collect::<Vec<String>>()
4908                    .join(",")
4909                    .to_string(),
4910            )]),
4911        };
4912    }
4913    if let Some(ref local_var_str) = limit {
4914        local_var_req_builder =
4915            local_var_req_builder.query(&[("limit", &local_var_str.to_string())]);
4916    }
4917    if let Some(ref local_var_str) = modified_by_request {
4918        local_var_req_builder =
4919            local_var_req_builder.query(&[("modified_by_request", &local_var_str.to_string())]);
4920    }
4921    if let Some(ref local_var_str) = name {
4922        local_var_req_builder = match "multi" {
4923            "multi" => local_var_req_builder.query(
4924                &local_var_str
4925                    .into_iter()
4926                    .map(|p| ("name".to_owned(), p.to_string()))
4927                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4928            ),
4929            _ => local_var_req_builder.query(&[(
4930                "name",
4931                &local_var_str
4932                    .into_iter()
4933                    .map(|p| p.to_string())
4934                    .collect::<Vec<String>>()
4935                    .join(",")
4936                    .to_string(),
4937            )]),
4938        };
4939    }
4940    if let Some(ref local_var_str) = name__empty {
4941        local_var_req_builder =
4942            local_var_req_builder.query(&[("name__empty", &local_var_str.to_string())]);
4943    }
4944    if let Some(ref local_var_str) = name__ic {
4945        local_var_req_builder = match "multi" {
4946            "multi" => local_var_req_builder.query(
4947                &local_var_str
4948                    .into_iter()
4949                    .map(|p| ("name__ic".to_owned(), p.to_string()))
4950                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4951            ),
4952            _ => local_var_req_builder.query(&[(
4953                "name__ic",
4954                &local_var_str
4955                    .into_iter()
4956                    .map(|p| p.to_string())
4957                    .collect::<Vec<String>>()
4958                    .join(",")
4959                    .to_string(),
4960            )]),
4961        };
4962    }
4963    if let Some(ref local_var_str) = name__ie {
4964        local_var_req_builder = match "multi" {
4965            "multi" => local_var_req_builder.query(
4966                &local_var_str
4967                    .into_iter()
4968                    .map(|p| ("name__ie".to_owned(), p.to_string()))
4969                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4970            ),
4971            _ => local_var_req_builder.query(&[(
4972                "name__ie",
4973                &local_var_str
4974                    .into_iter()
4975                    .map(|p| p.to_string())
4976                    .collect::<Vec<String>>()
4977                    .join(",")
4978                    .to_string(),
4979            )]),
4980        };
4981    }
4982    if let Some(ref local_var_str) = name__iew {
4983        local_var_req_builder = match "multi" {
4984            "multi" => local_var_req_builder.query(
4985                &local_var_str
4986                    .into_iter()
4987                    .map(|p| ("name__iew".to_owned(), p.to_string()))
4988                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4989            ),
4990            _ => local_var_req_builder.query(&[(
4991                "name__iew",
4992                &local_var_str
4993                    .into_iter()
4994                    .map(|p| p.to_string())
4995                    .collect::<Vec<String>>()
4996                    .join(",")
4997                    .to_string(),
4998            )]),
4999        };
5000    }
5001    if let Some(ref local_var_str) = name__iregex {
5002        local_var_req_builder = match "multi" {
5003            "multi" => local_var_req_builder.query(
5004                &local_var_str
5005                    .into_iter()
5006                    .map(|p| ("name__iregex".to_owned(), p.to_string()))
5007                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5008            ),
5009            _ => local_var_req_builder.query(&[(
5010                "name__iregex",
5011                &local_var_str
5012                    .into_iter()
5013                    .map(|p| p.to_string())
5014                    .collect::<Vec<String>>()
5015                    .join(",")
5016                    .to_string(),
5017            )]),
5018        };
5019    }
5020    if let Some(ref local_var_str) = name__isw {
5021        local_var_req_builder = match "multi" {
5022            "multi" => local_var_req_builder.query(
5023                &local_var_str
5024                    .into_iter()
5025                    .map(|p| ("name__isw".to_owned(), p.to_string()))
5026                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5027            ),
5028            _ => local_var_req_builder.query(&[(
5029                "name__isw",
5030                &local_var_str
5031                    .into_iter()
5032                    .map(|p| p.to_string())
5033                    .collect::<Vec<String>>()
5034                    .join(",")
5035                    .to_string(),
5036            )]),
5037        };
5038    }
5039    if let Some(ref local_var_str) = name__n {
5040        local_var_req_builder = match "multi" {
5041            "multi" => local_var_req_builder.query(
5042                &local_var_str
5043                    .into_iter()
5044                    .map(|p| ("name__n".to_owned(), p.to_string()))
5045                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5046            ),
5047            _ => local_var_req_builder.query(&[(
5048                "name__n",
5049                &local_var_str
5050                    .into_iter()
5051                    .map(|p| p.to_string())
5052                    .collect::<Vec<String>>()
5053                    .join(",")
5054                    .to_string(),
5055            )]),
5056        };
5057    }
5058    if let Some(ref local_var_str) = name__nic {
5059        local_var_req_builder = match "multi" {
5060            "multi" => local_var_req_builder.query(
5061                &local_var_str
5062                    .into_iter()
5063                    .map(|p| ("name__nic".to_owned(), p.to_string()))
5064                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5065            ),
5066            _ => local_var_req_builder.query(&[(
5067                "name__nic",
5068                &local_var_str
5069                    .into_iter()
5070                    .map(|p| p.to_string())
5071                    .collect::<Vec<String>>()
5072                    .join(",")
5073                    .to_string(),
5074            )]),
5075        };
5076    }
5077    if let Some(ref local_var_str) = name__nie {
5078        local_var_req_builder = match "multi" {
5079            "multi" => local_var_req_builder.query(
5080                &local_var_str
5081                    .into_iter()
5082                    .map(|p| ("name__nie".to_owned(), p.to_string()))
5083                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5084            ),
5085            _ => local_var_req_builder.query(&[(
5086                "name__nie",
5087                &local_var_str
5088                    .into_iter()
5089                    .map(|p| p.to_string())
5090                    .collect::<Vec<String>>()
5091                    .join(",")
5092                    .to_string(),
5093            )]),
5094        };
5095    }
5096    if let Some(ref local_var_str) = name__niew {
5097        local_var_req_builder = match "multi" {
5098            "multi" => local_var_req_builder.query(
5099                &local_var_str
5100                    .into_iter()
5101                    .map(|p| ("name__niew".to_owned(), p.to_string()))
5102                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5103            ),
5104            _ => local_var_req_builder.query(&[(
5105                "name__niew",
5106                &local_var_str
5107                    .into_iter()
5108                    .map(|p| p.to_string())
5109                    .collect::<Vec<String>>()
5110                    .join(",")
5111                    .to_string(),
5112            )]),
5113        };
5114    }
5115    if let Some(ref local_var_str) = name__nisw {
5116        local_var_req_builder = match "multi" {
5117            "multi" => local_var_req_builder.query(
5118                &local_var_str
5119                    .into_iter()
5120                    .map(|p| ("name__nisw".to_owned(), p.to_string()))
5121                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5122            ),
5123            _ => local_var_req_builder.query(&[(
5124                "name__nisw",
5125                &local_var_str
5126                    .into_iter()
5127                    .map(|p| p.to_string())
5128                    .collect::<Vec<String>>()
5129                    .join(",")
5130                    .to_string(),
5131            )]),
5132        };
5133    }
5134    if let Some(ref local_var_str) = name__regex {
5135        local_var_req_builder = match "multi" {
5136            "multi" => local_var_req_builder.query(
5137                &local_var_str
5138                    .into_iter()
5139                    .map(|p| ("name__regex".to_owned(), p.to_string()))
5140                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5141            ),
5142            _ => local_var_req_builder.query(&[(
5143                "name__regex",
5144                &local_var_str
5145                    .into_iter()
5146                    .map(|p| p.to_string())
5147                    .collect::<Vec<String>>()
5148                    .join(",")
5149                    .to_string(),
5150            )]),
5151        };
5152    }
5153    if let Some(ref local_var_str) = offset {
5154        local_var_req_builder =
5155            local_var_req_builder.query(&[("offset", &local_var_str.to_string())]);
5156    }
5157    if let Some(ref local_var_str) = ordering {
5158        local_var_req_builder =
5159            local_var_req_builder.query(&[("ordering", &local_var_str.to_string())]);
5160    }
5161    if let Some(ref local_var_str) = owner {
5162        local_var_req_builder = match "multi" {
5163            "multi" => local_var_req_builder.query(
5164                &local_var_str
5165                    .into_iter()
5166                    .map(|p| ("owner".to_owned(), p.to_string()))
5167                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5168            ),
5169            _ => local_var_req_builder.query(&[(
5170                "owner",
5171                &local_var_str
5172                    .into_iter()
5173                    .map(|p| p.to_string())
5174                    .collect::<Vec<String>>()
5175                    .join(",")
5176                    .to_string(),
5177            )]),
5178        };
5179    }
5180    if let Some(ref local_var_str) = owner__n {
5181        local_var_req_builder = match "multi" {
5182            "multi" => local_var_req_builder.query(
5183                &local_var_str
5184                    .into_iter()
5185                    .map(|p| ("owner__n".to_owned(), p.to_string()))
5186                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5187            ),
5188            _ => local_var_req_builder.query(&[(
5189                "owner__n",
5190                &local_var_str
5191                    .into_iter()
5192                    .map(|p| p.to_string())
5193                    .collect::<Vec<String>>()
5194                    .join(",")
5195                    .to_string(),
5196            )]),
5197        };
5198    }
5199    if let Some(ref local_var_str) = owner_group {
5200        local_var_req_builder = match "multi" {
5201            "multi" => local_var_req_builder.query(
5202                &local_var_str
5203                    .into_iter()
5204                    .map(|p| ("owner_group".to_owned(), p.to_string()))
5205                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5206            ),
5207            _ => local_var_req_builder.query(&[(
5208                "owner_group",
5209                &local_var_str
5210                    .into_iter()
5211                    .map(|p| p.to_string())
5212                    .collect::<Vec<String>>()
5213                    .join(",")
5214                    .to_string(),
5215            )]),
5216        };
5217    }
5218    if let Some(ref local_var_str) = owner_group__n {
5219        local_var_req_builder = match "multi" {
5220            "multi" => local_var_req_builder.query(
5221                &local_var_str
5222                    .into_iter()
5223                    .map(|p| ("owner_group__n".to_owned(), p.to_string()))
5224                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5225            ),
5226            _ => local_var_req_builder.query(&[(
5227                "owner_group__n",
5228                &local_var_str
5229                    .into_iter()
5230                    .map(|p| p.to_string())
5231                    .collect::<Vec<String>>()
5232                    .join(",")
5233                    .to_string(),
5234            )]),
5235        };
5236    }
5237    if let Some(ref local_var_str) = owner_group_id {
5238        local_var_req_builder = match "multi" {
5239            "multi" => local_var_req_builder.query(
5240                &local_var_str
5241                    .into_iter()
5242                    .map(|p| ("owner_group_id".to_owned(), p.to_string()))
5243                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5244            ),
5245            _ => local_var_req_builder.query(&[(
5246                "owner_group_id",
5247                &local_var_str
5248                    .into_iter()
5249                    .map(|p| p.to_string())
5250                    .collect::<Vec<String>>()
5251                    .join(",")
5252                    .to_string(),
5253            )]),
5254        };
5255    }
5256    if let Some(ref local_var_str) = owner_group_id__n {
5257        local_var_req_builder = match "multi" {
5258            "multi" => local_var_req_builder.query(
5259                &local_var_str
5260                    .into_iter()
5261                    .map(|p| ("owner_group_id__n".to_owned(), p.to_string()))
5262                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5263            ),
5264            _ => local_var_req_builder.query(&[(
5265                "owner_group_id__n",
5266                &local_var_str
5267                    .into_iter()
5268                    .map(|p| p.to_string())
5269                    .collect::<Vec<String>>()
5270                    .join(",")
5271                    .to_string(),
5272            )]),
5273        };
5274    }
5275    if let Some(ref local_var_str) = owner_id {
5276        local_var_req_builder = match "multi" {
5277            "multi" => local_var_req_builder.query(
5278                &local_var_str
5279                    .into_iter()
5280                    .map(|p| ("owner_id".to_owned(), p.to_string()))
5281                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5282            ),
5283            _ => local_var_req_builder.query(&[(
5284                "owner_id",
5285                &local_var_str
5286                    .into_iter()
5287                    .map(|p| p.to_string())
5288                    .collect::<Vec<String>>()
5289                    .join(",")
5290                    .to_string(),
5291            )]),
5292        };
5293    }
5294    if let Some(ref local_var_str) = owner_id__n {
5295        local_var_req_builder = match "multi" {
5296            "multi" => local_var_req_builder.query(
5297                &local_var_str
5298                    .into_iter()
5299                    .map(|p| ("owner_id__n".to_owned(), p.to_string()))
5300                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5301            ),
5302            _ => local_var_req_builder.query(&[(
5303                "owner_id__n",
5304                &local_var_str
5305                    .into_iter()
5306                    .map(|p| p.to_string())
5307                    .collect::<Vec<String>>()
5308                    .join(",")
5309                    .to_string(),
5310            )]),
5311        };
5312    }
5313    if let Some(ref local_var_str) = q {
5314        local_var_req_builder = local_var_req_builder.query(&[("q", &local_var_str.to_string())]);
5315    }
5316    if let Some(ref local_var_str) = sa_lifetime {
5317        local_var_req_builder = match "multi" {
5318            "multi" => local_var_req_builder.query(
5319                &local_var_str
5320                    .into_iter()
5321                    .map(|p| ("sa_lifetime".to_owned(), p.to_string()))
5322                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5323            ),
5324            _ => local_var_req_builder.query(&[(
5325                "sa_lifetime",
5326                &local_var_str
5327                    .into_iter()
5328                    .map(|p| p.to_string())
5329                    .collect::<Vec<String>>()
5330                    .join(",")
5331                    .to_string(),
5332            )]),
5333        };
5334    }
5335    if let Some(ref local_var_str) = sa_lifetime__empty {
5336        local_var_req_builder =
5337            local_var_req_builder.query(&[("sa_lifetime__empty", &local_var_str.to_string())]);
5338    }
5339    if let Some(ref local_var_str) = sa_lifetime__gt {
5340        local_var_req_builder = match "multi" {
5341            "multi" => local_var_req_builder.query(
5342                &local_var_str
5343                    .into_iter()
5344                    .map(|p| ("sa_lifetime__gt".to_owned(), p.to_string()))
5345                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5346            ),
5347            _ => local_var_req_builder.query(&[(
5348                "sa_lifetime__gt",
5349                &local_var_str
5350                    .into_iter()
5351                    .map(|p| p.to_string())
5352                    .collect::<Vec<String>>()
5353                    .join(",")
5354                    .to_string(),
5355            )]),
5356        };
5357    }
5358    if let Some(ref local_var_str) = sa_lifetime__gte {
5359        local_var_req_builder = match "multi" {
5360            "multi" => local_var_req_builder.query(
5361                &local_var_str
5362                    .into_iter()
5363                    .map(|p| ("sa_lifetime__gte".to_owned(), p.to_string()))
5364                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5365            ),
5366            _ => local_var_req_builder.query(&[(
5367                "sa_lifetime__gte",
5368                &local_var_str
5369                    .into_iter()
5370                    .map(|p| p.to_string())
5371                    .collect::<Vec<String>>()
5372                    .join(",")
5373                    .to_string(),
5374            )]),
5375        };
5376    }
5377    if let Some(ref local_var_str) = sa_lifetime__lt {
5378        local_var_req_builder = match "multi" {
5379            "multi" => local_var_req_builder.query(
5380                &local_var_str
5381                    .into_iter()
5382                    .map(|p| ("sa_lifetime__lt".to_owned(), p.to_string()))
5383                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5384            ),
5385            _ => local_var_req_builder.query(&[(
5386                "sa_lifetime__lt",
5387                &local_var_str
5388                    .into_iter()
5389                    .map(|p| p.to_string())
5390                    .collect::<Vec<String>>()
5391                    .join(",")
5392                    .to_string(),
5393            )]),
5394        };
5395    }
5396    if let Some(ref local_var_str) = sa_lifetime__lte {
5397        local_var_req_builder = match "multi" {
5398            "multi" => local_var_req_builder.query(
5399                &local_var_str
5400                    .into_iter()
5401                    .map(|p| ("sa_lifetime__lte".to_owned(), p.to_string()))
5402                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5403            ),
5404            _ => local_var_req_builder.query(&[(
5405                "sa_lifetime__lte",
5406                &local_var_str
5407                    .into_iter()
5408                    .map(|p| p.to_string())
5409                    .collect::<Vec<String>>()
5410                    .join(",")
5411                    .to_string(),
5412            )]),
5413        };
5414    }
5415    if let Some(ref local_var_str) = sa_lifetime__n {
5416        local_var_req_builder = match "multi" {
5417            "multi" => local_var_req_builder.query(
5418                &local_var_str
5419                    .into_iter()
5420                    .map(|p| ("sa_lifetime__n".to_owned(), p.to_string()))
5421                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5422            ),
5423            _ => local_var_req_builder.query(&[(
5424                "sa_lifetime__n",
5425                &local_var_str
5426                    .into_iter()
5427                    .map(|p| p.to_string())
5428                    .collect::<Vec<String>>()
5429                    .join(",")
5430                    .to_string(),
5431            )]),
5432        };
5433    }
5434    if let Some(ref local_var_str) = start {
5435        local_var_req_builder =
5436            local_var_req_builder.query(&[("start", &local_var_str.to_string())]);
5437    }
5438    if let Some(ref local_var_str) = tag {
5439        local_var_req_builder = match "multi" {
5440            "multi" => local_var_req_builder.query(
5441                &local_var_str
5442                    .into_iter()
5443                    .map(|p| ("tag".to_owned(), p.to_string()))
5444                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5445            ),
5446            _ => local_var_req_builder.query(&[(
5447                "tag",
5448                &local_var_str
5449                    .into_iter()
5450                    .map(|p| p.to_string())
5451                    .collect::<Vec<String>>()
5452                    .join(",")
5453                    .to_string(),
5454            )]),
5455        };
5456    }
5457    if let Some(ref local_var_str) = tag__n {
5458        local_var_req_builder = match "multi" {
5459            "multi" => local_var_req_builder.query(
5460                &local_var_str
5461                    .into_iter()
5462                    .map(|p| ("tag__n".to_owned(), p.to_string()))
5463                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5464            ),
5465            _ => local_var_req_builder.query(&[(
5466                "tag__n",
5467                &local_var_str
5468                    .into_iter()
5469                    .map(|p| p.to_string())
5470                    .collect::<Vec<String>>()
5471                    .join(",")
5472                    .to_string(),
5473            )]),
5474        };
5475    }
5476    if let Some(ref local_var_str) = tag_id {
5477        local_var_req_builder = match "multi" {
5478            "multi" => local_var_req_builder.query(
5479                &local_var_str
5480                    .into_iter()
5481                    .map(|p| ("tag_id".to_owned(), p.to_string()))
5482                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5483            ),
5484            _ => local_var_req_builder.query(&[(
5485                "tag_id",
5486                &local_var_str
5487                    .into_iter()
5488                    .map(|p| p.to_string())
5489                    .collect::<Vec<String>>()
5490                    .join(",")
5491                    .to_string(),
5492            )]),
5493        };
5494    }
5495    if let Some(ref local_var_str) = tag_id__n {
5496        local_var_req_builder = match "multi" {
5497            "multi" => local_var_req_builder.query(
5498                &local_var_str
5499                    .into_iter()
5500                    .map(|p| ("tag_id__n".to_owned(), p.to_string()))
5501                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5502            ),
5503            _ => local_var_req_builder.query(&[(
5504                "tag_id__n",
5505                &local_var_str
5506                    .into_iter()
5507                    .map(|p| p.to_string())
5508                    .collect::<Vec<String>>()
5509                    .join(",")
5510                    .to_string(),
5511            )]),
5512        };
5513    }
5514    if let Some(ref local_var_str) = updated_by_request {
5515        local_var_req_builder =
5516            local_var_req_builder.query(&[("updated_by_request", &local_var_str.to_string())]);
5517    }
5518    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
5519        local_var_req_builder =
5520            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
5521    }
5522    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
5523        let local_var_key = local_var_apikey.key.clone();
5524        let local_var_value = match local_var_apikey.prefix {
5525            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
5526            None => local_var_key,
5527        };
5528        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
5529    };
5530
5531    let local_var_req = local_var_req_builder.build()?;
5532    let local_var_resp = local_var_client.execute(local_var_req).await?;
5533
5534    let local_var_status = local_var_resp.status();
5535    let local_var_content = local_var_resp.text().await?;
5536
5537    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
5538        serde_json::from_str(&local_var_content).map_err(Error::from)
5539    } else {
5540        let local_var_entity: Option<VpnIkeProposalsListError> =
5541            serde_json::from_str(&local_var_content).ok();
5542        let local_var_error = ResponseContent {
5543            status: local_var_status,
5544            content: local_var_content,
5545            entity: local_var_entity,
5546        };
5547        Err(Error::ResponseError(local_var_error))
5548    }
5549}
5550
5551/// Patch a IKE proposal object.
5552pub async fn vpn_ike_proposals_partial_update(
5553    configuration: &configuration::Configuration,
5554    id: i32,
5555    patched_writable_ike_proposal_request: Option<crate::models::PatchedWritableIkeProposalRequest>,
5556) -> Result<crate::models::IkeProposal, Error<VpnIkeProposalsPartialUpdateError>> {
5557    let local_var_configuration = configuration;
5558
5559    let local_var_client = &local_var_configuration.client;
5560
5561    let local_var_uri_str = format!(
5562        "{}/api/vpn/ike-proposals/{id}/",
5563        local_var_configuration.base_path,
5564        id = id
5565    );
5566    let mut local_var_req_builder =
5567        local_var_client.request(reqwest::Method::PATCH, local_var_uri_str.as_str());
5568
5569    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
5570        local_var_req_builder =
5571            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
5572    }
5573    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
5574        let local_var_key = local_var_apikey.key.clone();
5575        let local_var_value = match local_var_apikey.prefix {
5576            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
5577            None => local_var_key,
5578        };
5579        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
5580    };
5581    local_var_req_builder = local_var_req_builder.json(&patched_writable_ike_proposal_request);
5582
5583    let local_var_req = local_var_req_builder.build()?;
5584    let local_var_resp = local_var_client.execute(local_var_req).await?;
5585
5586    let local_var_status = local_var_resp.status();
5587    let local_var_content = local_var_resp.text().await?;
5588
5589    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
5590        serde_json::from_str(&local_var_content).map_err(Error::from)
5591    } else {
5592        let local_var_entity: Option<VpnIkeProposalsPartialUpdateError> =
5593            serde_json::from_str(&local_var_content).ok();
5594        let local_var_error = ResponseContent {
5595            status: local_var_status,
5596            content: local_var_content,
5597            entity: local_var_entity,
5598        };
5599        Err(Error::ResponseError(local_var_error))
5600    }
5601}
5602
5603/// Get a IKE proposal object.
5604pub async fn vpn_ike_proposals_retrieve(
5605    configuration: &configuration::Configuration,
5606    id: i32,
5607) -> Result<crate::models::IkeProposal, Error<VpnIkeProposalsRetrieveError>> {
5608    let local_var_configuration = configuration;
5609
5610    let local_var_client = &local_var_configuration.client;
5611
5612    let local_var_uri_str = format!(
5613        "{}/api/vpn/ike-proposals/{id}/",
5614        local_var_configuration.base_path,
5615        id = id
5616    );
5617    let mut local_var_req_builder =
5618        local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
5619
5620    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
5621        local_var_req_builder =
5622            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
5623    }
5624    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
5625        let local_var_key = local_var_apikey.key.clone();
5626        let local_var_value = match local_var_apikey.prefix {
5627            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
5628            None => local_var_key,
5629        };
5630        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
5631    };
5632
5633    let local_var_req = local_var_req_builder.build()?;
5634    let local_var_resp = local_var_client.execute(local_var_req).await?;
5635
5636    let local_var_status = local_var_resp.status();
5637    let local_var_content = local_var_resp.text().await?;
5638
5639    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
5640        serde_json::from_str(&local_var_content).map_err(Error::from)
5641    } else {
5642        let local_var_entity: Option<VpnIkeProposalsRetrieveError> =
5643            serde_json::from_str(&local_var_content).ok();
5644        let local_var_error = ResponseContent {
5645            status: local_var_status,
5646            content: local_var_content,
5647            entity: local_var_entity,
5648        };
5649        Err(Error::ResponseError(local_var_error))
5650    }
5651}
5652
5653/// Put a IKE proposal object.
5654pub async fn vpn_ike_proposals_update(
5655    configuration: &configuration::Configuration,
5656    id: i32,
5657    writable_ike_proposal_request: crate::models::WritableIkeProposalRequest,
5658) -> Result<crate::models::IkeProposal, Error<VpnIkeProposalsUpdateError>> {
5659    let local_var_configuration = configuration;
5660
5661    let local_var_client = &local_var_configuration.client;
5662
5663    let local_var_uri_str = format!(
5664        "{}/api/vpn/ike-proposals/{id}/",
5665        local_var_configuration.base_path,
5666        id = id
5667    );
5668    let mut local_var_req_builder =
5669        local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());
5670
5671    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
5672        local_var_req_builder =
5673            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
5674    }
5675    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
5676        let local_var_key = local_var_apikey.key.clone();
5677        let local_var_value = match local_var_apikey.prefix {
5678            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
5679            None => local_var_key,
5680        };
5681        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
5682    };
5683    local_var_req_builder = local_var_req_builder.json(&writable_ike_proposal_request);
5684
5685    let local_var_req = local_var_req_builder.build()?;
5686    let local_var_resp = local_var_client.execute(local_var_req).await?;
5687
5688    let local_var_status = local_var_resp.status();
5689    let local_var_content = local_var_resp.text().await?;
5690
5691    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
5692        serde_json::from_str(&local_var_content).map_err(Error::from)
5693    } else {
5694        let local_var_entity: Option<VpnIkeProposalsUpdateError> =
5695            serde_json::from_str(&local_var_content).ok();
5696        let local_var_error = ResponseContent {
5697            status: local_var_status,
5698            content: local_var_content,
5699            entity: local_var_entity,
5700        };
5701        Err(Error::ResponseError(local_var_error))
5702    }
5703}
5704
5705/// Delete a list of IPSec policy objects.
5706pub async fn vpn_ipsec_policies_bulk_destroy(
5707    configuration: &configuration::Configuration,
5708    ip_sec_policy_request: Vec<crate::models::IpSecPolicyRequest>,
5709) -> Result<(), Error<VpnIpsecPoliciesBulkDestroyError>> {
5710    let local_var_configuration = configuration;
5711
5712    let local_var_client = &local_var_configuration.client;
5713
5714    let local_var_uri_str = format!(
5715        "{}/api/vpn/ipsec-policies/",
5716        local_var_configuration.base_path
5717    );
5718    let mut local_var_req_builder =
5719        local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());
5720
5721    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
5722        local_var_req_builder =
5723            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
5724    }
5725    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
5726        let local_var_key = local_var_apikey.key.clone();
5727        let local_var_value = match local_var_apikey.prefix {
5728            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
5729            None => local_var_key,
5730        };
5731        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
5732    };
5733    local_var_req_builder = local_var_req_builder.json(&ip_sec_policy_request);
5734
5735    let local_var_req = local_var_req_builder.build()?;
5736    let local_var_resp = local_var_client.execute(local_var_req).await?;
5737
5738    let local_var_status = local_var_resp.status();
5739    let local_var_content = local_var_resp.text().await?;
5740
5741    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
5742        Ok(())
5743    } else {
5744        let local_var_entity: Option<VpnIpsecPoliciesBulkDestroyError> =
5745            serde_json::from_str(&local_var_content).ok();
5746        let local_var_error = ResponseContent {
5747            status: local_var_status,
5748            content: local_var_content,
5749            entity: local_var_entity,
5750        };
5751        Err(Error::ResponseError(local_var_error))
5752    }
5753}
5754
5755/// Patch a list of IPSec policy objects.
5756pub async fn vpn_ipsec_policies_bulk_partial_update(
5757    configuration: &configuration::Configuration,
5758    ip_sec_policy_request: Vec<crate::models::IpSecPolicyRequest>,
5759) -> Result<Vec<crate::models::IpSecPolicy>, Error<VpnIpsecPoliciesBulkPartialUpdateError>> {
5760    let local_var_configuration = configuration;
5761
5762    let local_var_client = &local_var_configuration.client;
5763
5764    let local_var_uri_str = format!(
5765        "{}/api/vpn/ipsec-policies/",
5766        local_var_configuration.base_path
5767    );
5768    let mut local_var_req_builder =
5769        local_var_client.request(reqwest::Method::PATCH, local_var_uri_str.as_str());
5770
5771    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
5772        local_var_req_builder =
5773            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
5774    }
5775    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
5776        let local_var_key = local_var_apikey.key.clone();
5777        let local_var_value = match local_var_apikey.prefix {
5778            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
5779            None => local_var_key,
5780        };
5781        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
5782    };
5783    local_var_req_builder = local_var_req_builder.json(&ip_sec_policy_request);
5784
5785    let local_var_req = local_var_req_builder.build()?;
5786    let local_var_resp = local_var_client.execute(local_var_req).await?;
5787
5788    let local_var_status = local_var_resp.status();
5789    let local_var_content = local_var_resp.text().await?;
5790
5791    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
5792        serde_json::from_str(&local_var_content).map_err(Error::from)
5793    } else {
5794        let local_var_entity: Option<VpnIpsecPoliciesBulkPartialUpdateError> =
5795            serde_json::from_str(&local_var_content).ok();
5796        let local_var_error = ResponseContent {
5797            status: local_var_status,
5798            content: local_var_content,
5799            entity: local_var_entity,
5800        };
5801        Err(Error::ResponseError(local_var_error))
5802    }
5803}
5804
5805/// Put a list of IPSec policy objects.
5806pub async fn vpn_ipsec_policies_bulk_update(
5807    configuration: &configuration::Configuration,
5808    ip_sec_policy_request: Vec<crate::models::IpSecPolicyRequest>,
5809) -> Result<Vec<crate::models::IpSecPolicy>, Error<VpnIpsecPoliciesBulkUpdateError>> {
5810    let local_var_configuration = configuration;
5811
5812    let local_var_client = &local_var_configuration.client;
5813
5814    let local_var_uri_str = format!(
5815        "{}/api/vpn/ipsec-policies/",
5816        local_var_configuration.base_path
5817    );
5818    let mut local_var_req_builder =
5819        local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());
5820
5821    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
5822        local_var_req_builder =
5823            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
5824    }
5825    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
5826        let local_var_key = local_var_apikey.key.clone();
5827        let local_var_value = match local_var_apikey.prefix {
5828            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
5829            None => local_var_key,
5830        };
5831        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
5832    };
5833    local_var_req_builder = local_var_req_builder.json(&ip_sec_policy_request);
5834
5835    let local_var_req = local_var_req_builder.build()?;
5836    let local_var_resp = local_var_client.execute(local_var_req).await?;
5837
5838    let local_var_status = local_var_resp.status();
5839    let local_var_content = local_var_resp.text().await?;
5840
5841    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
5842        serde_json::from_str(&local_var_content).map_err(Error::from)
5843    } else {
5844        let local_var_entity: Option<VpnIpsecPoliciesBulkUpdateError> =
5845            serde_json::from_str(&local_var_content).ok();
5846        let local_var_error = ResponseContent {
5847            status: local_var_status,
5848            content: local_var_content,
5849            entity: local_var_entity,
5850        };
5851        Err(Error::ResponseError(local_var_error))
5852    }
5853}
5854
5855/// Post a list of IPSec policy objects.
5856pub async fn vpn_ipsec_policies_create(
5857    configuration: &configuration::Configuration,
5858    vpn_ipsec_policies_create_request: crate::models::VpnIpsecPoliciesCreateRequest,
5859) -> Result<crate::models::IpSecPolicy, Error<VpnIpsecPoliciesCreateError>> {
5860    let local_var_configuration = configuration;
5861
5862    let local_var_client = &local_var_configuration.client;
5863
5864    let local_var_uri_str = format!(
5865        "{}/api/vpn/ipsec-policies/",
5866        local_var_configuration.base_path
5867    );
5868    let mut local_var_req_builder =
5869        local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
5870
5871    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
5872        local_var_req_builder =
5873            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
5874    }
5875    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
5876        let local_var_key = local_var_apikey.key.clone();
5877        let local_var_value = match local_var_apikey.prefix {
5878            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
5879            None => local_var_key,
5880        };
5881        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
5882    };
5883    local_var_req_builder = local_var_req_builder.json(&vpn_ipsec_policies_create_request);
5884
5885    let local_var_req = local_var_req_builder.build()?;
5886    let local_var_resp = local_var_client.execute(local_var_req).await?;
5887
5888    let local_var_status = local_var_resp.status();
5889    let local_var_content = local_var_resp.text().await?;
5890
5891    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
5892        serde_json::from_str(&local_var_content).map_err(Error::from)
5893    } else {
5894        let local_var_entity: Option<VpnIpsecPoliciesCreateError> =
5895            serde_json::from_str(&local_var_content).ok();
5896        let local_var_error = ResponseContent {
5897            status: local_var_status,
5898            content: local_var_content,
5899            entity: local_var_entity,
5900        };
5901        Err(Error::ResponseError(local_var_error))
5902    }
5903}
5904
5905/// Delete a IPSec policy object.
5906pub async fn vpn_ipsec_policies_destroy(
5907    configuration: &configuration::Configuration,
5908    id: i32,
5909) -> Result<(), Error<VpnIpsecPoliciesDestroyError>> {
5910    let local_var_configuration = configuration;
5911
5912    let local_var_client = &local_var_configuration.client;
5913
5914    let local_var_uri_str = format!(
5915        "{}/api/vpn/ipsec-policies/{id}/",
5916        local_var_configuration.base_path,
5917        id = id
5918    );
5919    let mut local_var_req_builder =
5920        local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());
5921
5922    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
5923        local_var_req_builder =
5924            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
5925    }
5926    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
5927        let local_var_key = local_var_apikey.key.clone();
5928        let local_var_value = match local_var_apikey.prefix {
5929            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
5930            None => local_var_key,
5931        };
5932        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
5933    };
5934
5935    let local_var_req = local_var_req_builder.build()?;
5936    let local_var_resp = local_var_client.execute(local_var_req).await?;
5937
5938    let local_var_status = local_var_resp.status();
5939    let local_var_content = local_var_resp.text().await?;
5940
5941    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
5942        Ok(())
5943    } else {
5944        let local_var_entity: Option<VpnIpsecPoliciesDestroyError> =
5945            serde_json::from_str(&local_var_content).ok();
5946        let local_var_error = ResponseContent {
5947            status: local_var_status,
5948            content: local_var_content,
5949            entity: local_var_entity,
5950        };
5951        Err(Error::ResponseError(local_var_error))
5952    }
5953}
5954
5955/// Get a list of IPSec policy objects.
5956pub async fn vpn_ipsec_policies_list(
5957    configuration: &configuration::Configuration,
5958    created: Option<Vec<String>>,
5959    created__empty: Option<Vec<String>>,
5960    created__gt: Option<Vec<String>>,
5961    created__gte: Option<Vec<String>>,
5962    created__lt: Option<Vec<String>>,
5963    created__lte: Option<Vec<String>>,
5964    created__n: Option<Vec<String>>,
5965    created_by_request: Option<&str>,
5966    description: Option<Vec<String>>,
5967    description__empty: Option<bool>,
5968    description__ic: Option<Vec<String>>,
5969    description__ie: Option<Vec<String>>,
5970    description__iew: Option<Vec<String>>,
5971    description__iregex: Option<Vec<String>>,
5972    description__isw: Option<Vec<String>>,
5973    description__n: Option<Vec<String>>,
5974    description__nic: Option<Vec<String>>,
5975    description__nie: Option<Vec<String>>,
5976    description__niew: Option<Vec<String>>,
5977    description__nisw: Option<Vec<String>>,
5978    description__regex: Option<Vec<String>>,
5979    id: Option<Vec<i32>>,
5980    id__empty: Option<bool>,
5981    id__gt: Option<Vec<i32>>,
5982    id__gte: Option<Vec<i32>>,
5983    id__lt: Option<Vec<i32>>,
5984    id__lte: Option<Vec<i32>>,
5985    id__n: Option<Vec<i32>>,
5986    ipsec_proposal: Option<Vec<String>>,
5987    ipsec_proposal__n: Option<Vec<String>>,
5988    ipsec_proposal_id: Option<Vec<i32>>,
5989    ipsec_proposal_id__n: Option<Vec<i32>>,
5990    last_updated: Option<Vec<String>>,
5991    last_updated__empty: Option<Vec<String>>,
5992    last_updated__gt: Option<Vec<String>>,
5993    last_updated__gte: Option<Vec<String>>,
5994    last_updated__lt: Option<Vec<String>>,
5995    last_updated__lte: Option<Vec<String>>,
5996    last_updated__n: Option<Vec<String>>,
5997    limit: Option<i32>,
5998    modified_by_request: Option<&str>,
5999    name: Option<Vec<String>>,
6000    name__empty: Option<bool>,
6001    name__ic: Option<Vec<String>>,
6002    name__ie: Option<Vec<String>>,
6003    name__iew: Option<Vec<String>>,
6004    name__iregex: Option<Vec<String>>,
6005    name__isw: Option<Vec<String>>,
6006    name__n: Option<Vec<String>>,
6007    name__nic: Option<Vec<String>>,
6008    name__nie: Option<Vec<String>>,
6009    name__niew: Option<Vec<String>>,
6010    name__nisw: Option<Vec<String>>,
6011    name__regex: Option<Vec<String>>,
6012    offset: Option<i32>,
6013    ordering: Option<&str>,
6014    owner: Option<Vec<String>>,
6015    owner__n: Option<Vec<String>>,
6016    owner_group: Option<Vec<String>>,
6017    owner_group__n: Option<Vec<String>>,
6018    owner_group_id: Option<Vec<i32>>,
6019    owner_group_id__n: Option<Vec<i32>>,
6020    owner_id: Option<Vec<i32>>,
6021    owner_id__n: Option<Vec<i32>>,
6022    pfs_group: Option<Vec<i32>>,
6023    pfs_group__ic: Option<Vec<i32>>,
6024    pfs_group__ie: Option<Vec<i32>>,
6025    pfs_group__iew: Option<Vec<i32>>,
6026    pfs_group__iregex: Option<Vec<i32>>,
6027    pfs_group__isw: Option<Vec<i32>>,
6028    pfs_group__n: Option<Vec<i32>>,
6029    pfs_group__nic: Option<Vec<i32>>,
6030    pfs_group__nie: Option<Vec<i32>>,
6031    pfs_group__niew: Option<Vec<i32>>,
6032    pfs_group__nisw: Option<Vec<i32>>,
6033    pfs_group__regex: Option<Vec<i32>>,
6034    q: Option<&str>,
6035    start: Option<i32>,
6036    tag: Option<Vec<String>>,
6037    tag__n: Option<Vec<String>>,
6038    tag_id: Option<Vec<i32>>,
6039    tag_id__n: Option<Vec<i32>>,
6040    updated_by_request: Option<&str>,
6041) -> Result<crate::models::PaginatedIpSecPolicyList, Error<VpnIpsecPoliciesListError>> {
6042    let local_var_configuration = configuration;
6043
6044    let local_var_client = &local_var_configuration.client;
6045
6046    let local_var_uri_str = format!(
6047        "{}/api/vpn/ipsec-policies/",
6048        local_var_configuration.base_path
6049    );
6050    let mut local_var_req_builder =
6051        local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
6052
6053    if let Some(ref local_var_str) = created {
6054        local_var_req_builder = match "multi" {
6055            "multi" => local_var_req_builder.query(
6056                &local_var_str
6057                    .into_iter()
6058                    .map(|p| ("created".to_owned(), p.to_string()))
6059                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6060            ),
6061            _ => local_var_req_builder.query(&[(
6062                "created",
6063                &local_var_str
6064                    .into_iter()
6065                    .map(|p| p.to_string())
6066                    .collect::<Vec<String>>()
6067                    .join(",")
6068                    .to_string(),
6069            )]),
6070        };
6071    }
6072    if let Some(ref local_var_str) = created__empty {
6073        local_var_req_builder = match "multi" {
6074            "multi" => local_var_req_builder.query(
6075                &local_var_str
6076                    .into_iter()
6077                    .map(|p| ("created__empty".to_owned(), p.to_string()))
6078                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6079            ),
6080            _ => local_var_req_builder.query(&[(
6081                "created__empty",
6082                &local_var_str
6083                    .into_iter()
6084                    .map(|p| p.to_string())
6085                    .collect::<Vec<String>>()
6086                    .join(",")
6087                    .to_string(),
6088            )]),
6089        };
6090    }
6091    if let Some(ref local_var_str) = created__gt {
6092        local_var_req_builder = match "multi" {
6093            "multi" => local_var_req_builder.query(
6094                &local_var_str
6095                    .into_iter()
6096                    .map(|p| ("created__gt".to_owned(), p.to_string()))
6097                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6098            ),
6099            _ => local_var_req_builder.query(&[(
6100                "created__gt",
6101                &local_var_str
6102                    .into_iter()
6103                    .map(|p| p.to_string())
6104                    .collect::<Vec<String>>()
6105                    .join(",")
6106                    .to_string(),
6107            )]),
6108        };
6109    }
6110    if let Some(ref local_var_str) = created__gte {
6111        local_var_req_builder = match "multi" {
6112            "multi" => local_var_req_builder.query(
6113                &local_var_str
6114                    .into_iter()
6115                    .map(|p| ("created__gte".to_owned(), p.to_string()))
6116                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6117            ),
6118            _ => local_var_req_builder.query(&[(
6119                "created__gte",
6120                &local_var_str
6121                    .into_iter()
6122                    .map(|p| p.to_string())
6123                    .collect::<Vec<String>>()
6124                    .join(",")
6125                    .to_string(),
6126            )]),
6127        };
6128    }
6129    if let Some(ref local_var_str) = created__lt {
6130        local_var_req_builder = match "multi" {
6131            "multi" => local_var_req_builder.query(
6132                &local_var_str
6133                    .into_iter()
6134                    .map(|p| ("created__lt".to_owned(), p.to_string()))
6135                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6136            ),
6137            _ => local_var_req_builder.query(&[(
6138                "created__lt",
6139                &local_var_str
6140                    .into_iter()
6141                    .map(|p| p.to_string())
6142                    .collect::<Vec<String>>()
6143                    .join(",")
6144                    .to_string(),
6145            )]),
6146        };
6147    }
6148    if let Some(ref local_var_str) = created__lte {
6149        local_var_req_builder = match "multi" {
6150            "multi" => local_var_req_builder.query(
6151                &local_var_str
6152                    .into_iter()
6153                    .map(|p| ("created__lte".to_owned(), p.to_string()))
6154                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6155            ),
6156            _ => local_var_req_builder.query(&[(
6157                "created__lte",
6158                &local_var_str
6159                    .into_iter()
6160                    .map(|p| p.to_string())
6161                    .collect::<Vec<String>>()
6162                    .join(",")
6163                    .to_string(),
6164            )]),
6165        };
6166    }
6167    if let Some(ref local_var_str) = created__n {
6168        local_var_req_builder = match "multi" {
6169            "multi" => local_var_req_builder.query(
6170                &local_var_str
6171                    .into_iter()
6172                    .map(|p| ("created__n".to_owned(), p.to_string()))
6173                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6174            ),
6175            _ => local_var_req_builder.query(&[(
6176                "created__n",
6177                &local_var_str
6178                    .into_iter()
6179                    .map(|p| p.to_string())
6180                    .collect::<Vec<String>>()
6181                    .join(",")
6182                    .to_string(),
6183            )]),
6184        };
6185    }
6186    if let Some(ref local_var_str) = created_by_request {
6187        local_var_req_builder =
6188            local_var_req_builder.query(&[("created_by_request", &local_var_str.to_string())]);
6189    }
6190    if let Some(ref local_var_str) = description {
6191        local_var_req_builder = match "multi" {
6192            "multi" => local_var_req_builder.query(
6193                &local_var_str
6194                    .into_iter()
6195                    .map(|p| ("description".to_owned(), p.to_string()))
6196                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6197            ),
6198            _ => local_var_req_builder.query(&[(
6199                "description",
6200                &local_var_str
6201                    .into_iter()
6202                    .map(|p| p.to_string())
6203                    .collect::<Vec<String>>()
6204                    .join(",")
6205                    .to_string(),
6206            )]),
6207        };
6208    }
6209    if let Some(ref local_var_str) = description__empty {
6210        local_var_req_builder =
6211            local_var_req_builder.query(&[("description__empty", &local_var_str.to_string())]);
6212    }
6213    if let Some(ref local_var_str) = description__ic {
6214        local_var_req_builder = match "multi" {
6215            "multi" => local_var_req_builder.query(
6216                &local_var_str
6217                    .into_iter()
6218                    .map(|p| ("description__ic".to_owned(), p.to_string()))
6219                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6220            ),
6221            _ => local_var_req_builder.query(&[(
6222                "description__ic",
6223                &local_var_str
6224                    .into_iter()
6225                    .map(|p| p.to_string())
6226                    .collect::<Vec<String>>()
6227                    .join(",")
6228                    .to_string(),
6229            )]),
6230        };
6231    }
6232    if let Some(ref local_var_str) = description__ie {
6233        local_var_req_builder = match "multi" {
6234            "multi" => local_var_req_builder.query(
6235                &local_var_str
6236                    .into_iter()
6237                    .map(|p| ("description__ie".to_owned(), p.to_string()))
6238                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6239            ),
6240            _ => local_var_req_builder.query(&[(
6241                "description__ie",
6242                &local_var_str
6243                    .into_iter()
6244                    .map(|p| p.to_string())
6245                    .collect::<Vec<String>>()
6246                    .join(",")
6247                    .to_string(),
6248            )]),
6249        };
6250    }
6251    if let Some(ref local_var_str) = description__iew {
6252        local_var_req_builder = match "multi" {
6253            "multi" => local_var_req_builder.query(
6254                &local_var_str
6255                    .into_iter()
6256                    .map(|p| ("description__iew".to_owned(), p.to_string()))
6257                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6258            ),
6259            _ => local_var_req_builder.query(&[(
6260                "description__iew",
6261                &local_var_str
6262                    .into_iter()
6263                    .map(|p| p.to_string())
6264                    .collect::<Vec<String>>()
6265                    .join(",")
6266                    .to_string(),
6267            )]),
6268        };
6269    }
6270    if let Some(ref local_var_str) = description__iregex {
6271        local_var_req_builder = match "multi" {
6272            "multi" => local_var_req_builder.query(
6273                &local_var_str
6274                    .into_iter()
6275                    .map(|p| ("description__iregex".to_owned(), p.to_string()))
6276                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6277            ),
6278            _ => local_var_req_builder.query(&[(
6279                "description__iregex",
6280                &local_var_str
6281                    .into_iter()
6282                    .map(|p| p.to_string())
6283                    .collect::<Vec<String>>()
6284                    .join(",")
6285                    .to_string(),
6286            )]),
6287        };
6288    }
6289    if let Some(ref local_var_str) = description__isw {
6290        local_var_req_builder = match "multi" {
6291            "multi" => local_var_req_builder.query(
6292                &local_var_str
6293                    .into_iter()
6294                    .map(|p| ("description__isw".to_owned(), p.to_string()))
6295                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6296            ),
6297            _ => local_var_req_builder.query(&[(
6298                "description__isw",
6299                &local_var_str
6300                    .into_iter()
6301                    .map(|p| p.to_string())
6302                    .collect::<Vec<String>>()
6303                    .join(",")
6304                    .to_string(),
6305            )]),
6306        };
6307    }
6308    if let Some(ref local_var_str) = description__n {
6309        local_var_req_builder = match "multi" {
6310            "multi" => local_var_req_builder.query(
6311                &local_var_str
6312                    .into_iter()
6313                    .map(|p| ("description__n".to_owned(), p.to_string()))
6314                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6315            ),
6316            _ => local_var_req_builder.query(&[(
6317                "description__n",
6318                &local_var_str
6319                    .into_iter()
6320                    .map(|p| p.to_string())
6321                    .collect::<Vec<String>>()
6322                    .join(",")
6323                    .to_string(),
6324            )]),
6325        };
6326    }
6327    if let Some(ref local_var_str) = description__nic {
6328        local_var_req_builder = match "multi" {
6329            "multi" => local_var_req_builder.query(
6330                &local_var_str
6331                    .into_iter()
6332                    .map(|p| ("description__nic".to_owned(), p.to_string()))
6333                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6334            ),
6335            _ => local_var_req_builder.query(&[(
6336                "description__nic",
6337                &local_var_str
6338                    .into_iter()
6339                    .map(|p| p.to_string())
6340                    .collect::<Vec<String>>()
6341                    .join(",")
6342                    .to_string(),
6343            )]),
6344        };
6345    }
6346    if let Some(ref local_var_str) = description__nie {
6347        local_var_req_builder = match "multi" {
6348            "multi" => local_var_req_builder.query(
6349                &local_var_str
6350                    .into_iter()
6351                    .map(|p| ("description__nie".to_owned(), p.to_string()))
6352                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6353            ),
6354            _ => local_var_req_builder.query(&[(
6355                "description__nie",
6356                &local_var_str
6357                    .into_iter()
6358                    .map(|p| p.to_string())
6359                    .collect::<Vec<String>>()
6360                    .join(",")
6361                    .to_string(),
6362            )]),
6363        };
6364    }
6365    if let Some(ref local_var_str) = description__niew {
6366        local_var_req_builder = match "multi" {
6367            "multi" => local_var_req_builder.query(
6368                &local_var_str
6369                    .into_iter()
6370                    .map(|p| ("description__niew".to_owned(), p.to_string()))
6371                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6372            ),
6373            _ => local_var_req_builder.query(&[(
6374                "description__niew",
6375                &local_var_str
6376                    .into_iter()
6377                    .map(|p| p.to_string())
6378                    .collect::<Vec<String>>()
6379                    .join(",")
6380                    .to_string(),
6381            )]),
6382        };
6383    }
6384    if let Some(ref local_var_str) = description__nisw {
6385        local_var_req_builder = match "multi" {
6386            "multi" => local_var_req_builder.query(
6387                &local_var_str
6388                    .into_iter()
6389                    .map(|p| ("description__nisw".to_owned(), p.to_string()))
6390                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6391            ),
6392            _ => local_var_req_builder.query(&[(
6393                "description__nisw",
6394                &local_var_str
6395                    .into_iter()
6396                    .map(|p| p.to_string())
6397                    .collect::<Vec<String>>()
6398                    .join(",")
6399                    .to_string(),
6400            )]),
6401        };
6402    }
6403    if let Some(ref local_var_str) = description__regex {
6404        local_var_req_builder = match "multi" {
6405            "multi" => local_var_req_builder.query(
6406                &local_var_str
6407                    .into_iter()
6408                    .map(|p| ("description__regex".to_owned(), p.to_string()))
6409                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6410            ),
6411            _ => local_var_req_builder.query(&[(
6412                "description__regex",
6413                &local_var_str
6414                    .into_iter()
6415                    .map(|p| p.to_string())
6416                    .collect::<Vec<String>>()
6417                    .join(",")
6418                    .to_string(),
6419            )]),
6420        };
6421    }
6422    if let Some(ref local_var_str) = id {
6423        local_var_req_builder = match "multi" {
6424            "multi" => local_var_req_builder.query(
6425                &local_var_str
6426                    .into_iter()
6427                    .map(|p| ("id".to_owned(), p.to_string()))
6428                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6429            ),
6430            _ => local_var_req_builder.query(&[(
6431                "id",
6432                &local_var_str
6433                    .into_iter()
6434                    .map(|p| p.to_string())
6435                    .collect::<Vec<String>>()
6436                    .join(",")
6437                    .to_string(),
6438            )]),
6439        };
6440    }
6441    if let Some(ref local_var_str) = id__empty {
6442        local_var_req_builder =
6443            local_var_req_builder.query(&[("id__empty", &local_var_str.to_string())]);
6444    }
6445    if let Some(ref local_var_str) = id__gt {
6446        local_var_req_builder = match "multi" {
6447            "multi" => local_var_req_builder.query(
6448                &local_var_str
6449                    .into_iter()
6450                    .map(|p| ("id__gt".to_owned(), p.to_string()))
6451                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6452            ),
6453            _ => local_var_req_builder.query(&[(
6454                "id__gt",
6455                &local_var_str
6456                    .into_iter()
6457                    .map(|p| p.to_string())
6458                    .collect::<Vec<String>>()
6459                    .join(",")
6460                    .to_string(),
6461            )]),
6462        };
6463    }
6464    if let Some(ref local_var_str) = id__gte {
6465        local_var_req_builder = match "multi" {
6466            "multi" => local_var_req_builder.query(
6467                &local_var_str
6468                    .into_iter()
6469                    .map(|p| ("id__gte".to_owned(), p.to_string()))
6470                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6471            ),
6472            _ => local_var_req_builder.query(&[(
6473                "id__gte",
6474                &local_var_str
6475                    .into_iter()
6476                    .map(|p| p.to_string())
6477                    .collect::<Vec<String>>()
6478                    .join(",")
6479                    .to_string(),
6480            )]),
6481        };
6482    }
6483    if let Some(ref local_var_str) = id__lt {
6484        local_var_req_builder = match "multi" {
6485            "multi" => local_var_req_builder.query(
6486                &local_var_str
6487                    .into_iter()
6488                    .map(|p| ("id__lt".to_owned(), p.to_string()))
6489                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6490            ),
6491            _ => local_var_req_builder.query(&[(
6492                "id__lt",
6493                &local_var_str
6494                    .into_iter()
6495                    .map(|p| p.to_string())
6496                    .collect::<Vec<String>>()
6497                    .join(",")
6498                    .to_string(),
6499            )]),
6500        };
6501    }
6502    if let Some(ref local_var_str) = id__lte {
6503        local_var_req_builder = match "multi" {
6504            "multi" => local_var_req_builder.query(
6505                &local_var_str
6506                    .into_iter()
6507                    .map(|p| ("id__lte".to_owned(), p.to_string()))
6508                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6509            ),
6510            _ => local_var_req_builder.query(&[(
6511                "id__lte",
6512                &local_var_str
6513                    .into_iter()
6514                    .map(|p| p.to_string())
6515                    .collect::<Vec<String>>()
6516                    .join(",")
6517                    .to_string(),
6518            )]),
6519        };
6520    }
6521    if let Some(ref local_var_str) = id__n {
6522        local_var_req_builder = match "multi" {
6523            "multi" => local_var_req_builder.query(
6524                &local_var_str
6525                    .into_iter()
6526                    .map(|p| ("id__n".to_owned(), p.to_string()))
6527                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6528            ),
6529            _ => local_var_req_builder.query(&[(
6530                "id__n",
6531                &local_var_str
6532                    .into_iter()
6533                    .map(|p| p.to_string())
6534                    .collect::<Vec<String>>()
6535                    .join(",")
6536                    .to_string(),
6537            )]),
6538        };
6539    }
6540    if let Some(ref local_var_str) = ipsec_proposal {
6541        local_var_req_builder = match "multi" {
6542            "multi" => local_var_req_builder.query(
6543                &local_var_str
6544                    .into_iter()
6545                    .map(|p| ("ipsec_proposal".to_owned(), p.to_string()))
6546                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6547            ),
6548            _ => local_var_req_builder.query(&[(
6549                "ipsec_proposal",
6550                &local_var_str
6551                    .into_iter()
6552                    .map(|p| p.to_string())
6553                    .collect::<Vec<String>>()
6554                    .join(",")
6555                    .to_string(),
6556            )]),
6557        };
6558    }
6559    if let Some(ref local_var_str) = ipsec_proposal__n {
6560        local_var_req_builder = match "multi" {
6561            "multi" => local_var_req_builder.query(
6562                &local_var_str
6563                    .into_iter()
6564                    .map(|p| ("ipsec_proposal__n".to_owned(), p.to_string()))
6565                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6566            ),
6567            _ => local_var_req_builder.query(&[(
6568                "ipsec_proposal__n",
6569                &local_var_str
6570                    .into_iter()
6571                    .map(|p| p.to_string())
6572                    .collect::<Vec<String>>()
6573                    .join(",")
6574                    .to_string(),
6575            )]),
6576        };
6577    }
6578    if let Some(ref local_var_str) = ipsec_proposal_id {
6579        local_var_req_builder = match "multi" {
6580            "multi" => local_var_req_builder.query(
6581                &local_var_str
6582                    .into_iter()
6583                    .map(|p| ("ipsec_proposal_id".to_owned(), p.to_string()))
6584                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6585            ),
6586            _ => local_var_req_builder.query(&[(
6587                "ipsec_proposal_id",
6588                &local_var_str
6589                    .into_iter()
6590                    .map(|p| p.to_string())
6591                    .collect::<Vec<String>>()
6592                    .join(",")
6593                    .to_string(),
6594            )]),
6595        };
6596    }
6597    if let Some(ref local_var_str) = ipsec_proposal_id__n {
6598        local_var_req_builder = match "multi" {
6599            "multi" => local_var_req_builder.query(
6600                &local_var_str
6601                    .into_iter()
6602                    .map(|p| ("ipsec_proposal_id__n".to_owned(), p.to_string()))
6603                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6604            ),
6605            _ => local_var_req_builder.query(&[(
6606                "ipsec_proposal_id__n",
6607                &local_var_str
6608                    .into_iter()
6609                    .map(|p| p.to_string())
6610                    .collect::<Vec<String>>()
6611                    .join(",")
6612                    .to_string(),
6613            )]),
6614        };
6615    }
6616    if let Some(ref local_var_str) = last_updated {
6617        local_var_req_builder = match "multi" {
6618            "multi" => local_var_req_builder.query(
6619                &local_var_str
6620                    .into_iter()
6621                    .map(|p| ("last_updated".to_owned(), p.to_string()))
6622                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6623            ),
6624            _ => local_var_req_builder.query(&[(
6625                "last_updated",
6626                &local_var_str
6627                    .into_iter()
6628                    .map(|p| p.to_string())
6629                    .collect::<Vec<String>>()
6630                    .join(",")
6631                    .to_string(),
6632            )]),
6633        };
6634    }
6635    if let Some(ref local_var_str) = last_updated__empty {
6636        local_var_req_builder = match "multi" {
6637            "multi" => local_var_req_builder.query(
6638                &local_var_str
6639                    .into_iter()
6640                    .map(|p| ("last_updated__empty".to_owned(), p.to_string()))
6641                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6642            ),
6643            _ => local_var_req_builder.query(&[(
6644                "last_updated__empty",
6645                &local_var_str
6646                    .into_iter()
6647                    .map(|p| p.to_string())
6648                    .collect::<Vec<String>>()
6649                    .join(",")
6650                    .to_string(),
6651            )]),
6652        };
6653    }
6654    if let Some(ref local_var_str) = last_updated__gt {
6655        local_var_req_builder = match "multi" {
6656            "multi" => local_var_req_builder.query(
6657                &local_var_str
6658                    .into_iter()
6659                    .map(|p| ("last_updated__gt".to_owned(), p.to_string()))
6660                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6661            ),
6662            _ => local_var_req_builder.query(&[(
6663                "last_updated__gt",
6664                &local_var_str
6665                    .into_iter()
6666                    .map(|p| p.to_string())
6667                    .collect::<Vec<String>>()
6668                    .join(",")
6669                    .to_string(),
6670            )]),
6671        };
6672    }
6673    if let Some(ref local_var_str) = last_updated__gte {
6674        local_var_req_builder = match "multi" {
6675            "multi" => local_var_req_builder.query(
6676                &local_var_str
6677                    .into_iter()
6678                    .map(|p| ("last_updated__gte".to_owned(), p.to_string()))
6679                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6680            ),
6681            _ => local_var_req_builder.query(&[(
6682                "last_updated__gte",
6683                &local_var_str
6684                    .into_iter()
6685                    .map(|p| p.to_string())
6686                    .collect::<Vec<String>>()
6687                    .join(",")
6688                    .to_string(),
6689            )]),
6690        };
6691    }
6692    if let Some(ref local_var_str) = last_updated__lt {
6693        local_var_req_builder = match "multi" {
6694            "multi" => local_var_req_builder.query(
6695                &local_var_str
6696                    .into_iter()
6697                    .map(|p| ("last_updated__lt".to_owned(), p.to_string()))
6698                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6699            ),
6700            _ => local_var_req_builder.query(&[(
6701                "last_updated__lt",
6702                &local_var_str
6703                    .into_iter()
6704                    .map(|p| p.to_string())
6705                    .collect::<Vec<String>>()
6706                    .join(",")
6707                    .to_string(),
6708            )]),
6709        };
6710    }
6711    if let Some(ref local_var_str) = last_updated__lte {
6712        local_var_req_builder = match "multi" {
6713            "multi" => local_var_req_builder.query(
6714                &local_var_str
6715                    .into_iter()
6716                    .map(|p| ("last_updated__lte".to_owned(), p.to_string()))
6717                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6718            ),
6719            _ => local_var_req_builder.query(&[(
6720                "last_updated__lte",
6721                &local_var_str
6722                    .into_iter()
6723                    .map(|p| p.to_string())
6724                    .collect::<Vec<String>>()
6725                    .join(",")
6726                    .to_string(),
6727            )]),
6728        };
6729    }
6730    if let Some(ref local_var_str) = last_updated__n {
6731        local_var_req_builder = match "multi" {
6732            "multi" => local_var_req_builder.query(
6733                &local_var_str
6734                    .into_iter()
6735                    .map(|p| ("last_updated__n".to_owned(), p.to_string()))
6736                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6737            ),
6738            _ => local_var_req_builder.query(&[(
6739                "last_updated__n",
6740                &local_var_str
6741                    .into_iter()
6742                    .map(|p| p.to_string())
6743                    .collect::<Vec<String>>()
6744                    .join(",")
6745                    .to_string(),
6746            )]),
6747        };
6748    }
6749    if let Some(ref local_var_str) = limit {
6750        local_var_req_builder =
6751            local_var_req_builder.query(&[("limit", &local_var_str.to_string())]);
6752    }
6753    if let Some(ref local_var_str) = modified_by_request {
6754        local_var_req_builder =
6755            local_var_req_builder.query(&[("modified_by_request", &local_var_str.to_string())]);
6756    }
6757    if let Some(ref local_var_str) = name {
6758        local_var_req_builder = match "multi" {
6759            "multi" => local_var_req_builder.query(
6760                &local_var_str
6761                    .into_iter()
6762                    .map(|p| ("name".to_owned(), p.to_string()))
6763                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6764            ),
6765            _ => local_var_req_builder.query(&[(
6766                "name",
6767                &local_var_str
6768                    .into_iter()
6769                    .map(|p| p.to_string())
6770                    .collect::<Vec<String>>()
6771                    .join(",")
6772                    .to_string(),
6773            )]),
6774        };
6775    }
6776    if let Some(ref local_var_str) = name__empty {
6777        local_var_req_builder =
6778            local_var_req_builder.query(&[("name__empty", &local_var_str.to_string())]);
6779    }
6780    if let Some(ref local_var_str) = name__ic {
6781        local_var_req_builder = match "multi" {
6782            "multi" => local_var_req_builder.query(
6783                &local_var_str
6784                    .into_iter()
6785                    .map(|p| ("name__ic".to_owned(), p.to_string()))
6786                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6787            ),
6788            _ => local_var_req_builder.query(&[(
6789                "name__ic",
6790                &local_var_str
6791                    .into_iter()
6792                    .map(|p| p.to_string())
6793                    .collect::<Vec<String>>()
6794                    .join(",")
6795                    .to_string(),
6796            )]),
6797        };
6798    }
6799    if let Some(ref local_var_str) = name__ie {
6800        local_var_req_builder = match "multi" {
6801            "multi" => local_var_req_builder.query(
6802                &local_var_str
6803                    .into_iter()
6804                    .map(|p| ("name__ie".to_owned(), p.to_string()))
6805                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6806            ),
6807            _ => local_var_req_builder.query(&[(
6808                "name__ie",
6809                &local_var_str
6810                    .into_iter()
6811                    .map(|p| p.to_string())
6812                    .collect::<Vec<String>>()
6813                    .join(",")
6814                    .to_string(),
6815            )]),
6816        };
6817    }
6818    if let Some(ref local_var_str) = name__iew {
6819        local_var_req_builder = match "multi" {
6820            "multi" => local_var_req_builder.query(
6821                &local_var_str
6822                    .into_iter()
6823                    .map(|p| ("name__iew".to_owned(), p.to_string()))
6824                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6825            ),
6826            _ => local_var_req_builder.query(&[(
6827                "name__iew",
6828                &local_var_str
6829                    .into_iter()
6830                    .map(|p| p.to_string())
6831                    .collect::<Vec<String>>()
6832                    .join(",")
6833                    .to_string(),
6834            )]),
6835        };
6836    }
6837    if let Some(ref local_var_str) = name__iregex {
6838        local_var_req_builder = match "multi" {
6839            "multi" => local_var_req_builder.query(
6840                &local_var_str
6841                    .into_iter()
6842                    .map(|p| ("name__iregex".to_owned(), p.to_string()))
6843                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6844            ),
6845            _ => local_var_req_builder.query(&[(
6846                "name__iregex",
6847                &local_var_str
6848                    .into_iter()
6849                    .map(|p| p.to_string())
6850                    .collect::<Vec<String>>()
6851                    .join(",")
6852                    .to_string(),
6853            )]),
6854        };
6855    }
6856    if let Some(ref local_var_str) = name__isw {
6857        local_var_req_builder = match "multi" {
6858            "multi" => local_var_req_builder.query(
6859                &local_var_str
6860                    .into_iter()
6861                    .map(|p| ("name__isw".to_owned(), p.to_string()))
6862                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6863            ),
6864            _ => local_var_req_builder.query(&[(
6865                "name__isw",
6866                &local_var_str
6867                    .into_iter()
6868                    .map(|p| p.to_string())
6869                    .collect::<Vec<String>>()
6870                    .join(",")
6871                    .to_string(),
6872            )]),
6873        };
6874    }
6875    if let Some(ref local_var_str) = name__n {
6876        local_var_req_builder = match "multi" {
6877            "multi" => local_var_req_builder.query(
6878                &local_var_str
6879                    .into_iter()
6880                    .map(|p| ("name__n".to_owned(), p.to_string()))
6881                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6882            ),
6883            _ => local_var_req_builder.query(&[(
6884                "name__n",
6885                &local_var_str
6886                    .into_iter()
6887                    .map(|p| p.to_string())
6888                    .collect::<Vec<String>>()
6889                    .join(",")
6890                    .to_string(),
6891            )]),
6892        };
6893    }
6894    if let Some(ref local_var_str) = name__nic {
6895        local_var_req_builder = match "multi" {
6896            "multi" => local_var_req_builder.query(
6897                &local_var_str
6898                    .into_iter()
6899                    .map(|p| ("name__nic".to_owned(), p.to_string()))
6900                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6901            ),
6902            _ => local_var_req_builder.query(&[(
6903                "name__nic",
6904                &local_var_str
6905                    .into_iter()
6906                    .map(|p| p.to_string())
6907                    .collect::<Vec<String>>()
6908                    .join(",")
6909                    .to_string(),
6910            )]),
6911        };
6912    }
6913    if let Some(ref local_var_str) = name__nie {
6914        local_var_req_builder = match "multi" {
6915            "multi" => local_var_req_builder.query(
6916                &local_var_str
6917                    .into_iter()
6918                    .map(|p| ("name__nie".to_owned(), p.to_string()))
6919                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6920            ),
6921            _ => local_var_req_builder.query(&[(
6922                "name__nie",
6923                &local_var_str
6924                    .into_iter()
6925                    .map(|p| p.to_string())
6926                    .collect::<Vec<String>>()
6927                    .join(",")
6928                    .to_string(),
6929            )]),
6930        };
6931    }
6932    if let Some(ref local_var_str) = name__niew {
6933        local_var_req_builder = match "multi" {
6934            "multi" => local_var_req_builder.query(
6935                &local_var_str
6936                    .into_iter()
6937                    .map(|p| ("name__niew".to_owned(), p.to_string()))
6938                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6939            ),
6940            _ => local_var_req_builder.query(&[(
6941                "name__niew",
6942                &local_var_str
6943                    .into_iter()
6944                    .map(|p| p.to_string())
6945                    .collect::<Vec<String>>()
6946                    .join(",")
6947                    .to_string(),
6948            )]),
6949        };
6950    }
6951    if let Some(ref local_var_str) = name__nisw {
6952        local_var_req_builder = match "multi" {
6953            "multi" => local_var_req_builder.query(
6954                &local_var_str
6955                    .into_iter()
6956                    .map(|p| ("name__nisw".to_owned(), p.to_string()))
6957                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6958            ),
6959            _ => local_var_req_builder.query(&[(
6960                "name__nisw",
6961                &local_var_str
6962                    .into_iter()
6963                    .map(|p| p.to_string())
6964                    .collect::<Vec<String>>()
6965                    .join(",")
6966                    .to_string(),
6967            )]),
6968        };
6969    }
6970    if let Some(ref local_var_str) = name__regex {
6971        local_var_req_builder = match "multi" {
6972            "multi" => local_var_req_builder.query(
6973                &local_var_str
6974                    .into_iter()
6975                    .map(|p| ("name__regex".to_owned(), p.to_string()))
6976                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6977            ),
6978            _ => local_var_req_builder.query(&[(
6979                "name__regex",
6980                &local_var_str
6981                    .into_iter()
6982                    .map(|p| p.to_string())
6983                    .collect::<Vec<String>>()
6984                    .join(",")
6985                    .to_string(),
6986            )]),
6987        };
6988    }
6989    if let Some(ref local_var_str) = offset {
6990        local_var_req_builder =
6991            local_var_req_builder.query(&[("offset", &local_var_str.to_string())]);
6992    }
6993    if let Some(ref local_var_str) = ordering {
6994        local_var_req_builder =
6995            local_var_req_builder.query(&[("ordering", &local_var_str.to_string())]);
6996    }
6997    if let Some(ref local_var_str) = owner {
6998        local_var_req_builder = match "multi" {
6999            "multi" => local_var_req_builder.query(
7000                &local_var_str
7001                    .into_iter()
7002                    .map(|p| ("owner".to_owned(), p.to_string()))
7003                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7004            ),
7005            _ => local_var_req_builder.query(&[(
7006                "owner",
7007                &local_var_str
7008                    .into_iter()
7009                    .map(|p| p.to_string())
7010                    .collect::<Vec<String>>()
7011                    .join(",")
7012                    .to_string(),
7013            )]),
7014        };
7015    }
7016    if let Some(ref local_var_str) = owner__n {
7017        local_var_req_builder = match "multi" {
7018            "multi" => local_var_req_builder.query(
7019                &local_var_str
7020                    .into_iter()
7021                    .map(|p| ("owner__n".to_owned(), p.to_string()))
7022                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7023            ),
7024            _ => local_var_req_builder.query(&[(
7025                "owner__n",
7026                &local_var_str
7027                    .into_iter()
7028                    .map(|p| p.to_string())
7029                    .collect::<Vec<String>>()
7030                    .join(",")
7031                    .to_string(),
7032            )]),
7033        };
7034    }
7035    if let Some(ref local_var_str) = owner_group {
7036        local_var_req_builder = match "multi" {
7037            "multi" => local_var_req_builder.query(
7038                &local_var_str
7039                    .into_iter()
7040                    .map(|p| ("owner_group".to_owned(), p.to_string()))
7041                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7042            ),
7043            _ => local_var_req_builder.query(&[(
7044                "owner_group",
7045                &local_var_str
7046                    .into_iter()
7047                    .map(|p| p.to_string())
7048                    .collect::<Vec<String>>()
7049                    .join(",")
7050                    .to_string(),
7051            )]),
7052        };
7053    }
7054    if let Some(ref local_var_str) = owner_group__n {
7055        local_var_req_builder = match "multi" {
7056            "multi" => local_var_req_builder.query(
7057                &local_var_str
7058                    .into_iter()
7059                    .map(|p| ("owner_group__n".to_owned(), p.to_string()))
7060                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7061            ),
7062            _ => local_var_req_builder.query(&[(
7063                "owner_group__n",
7064                &local_var_str
7065                    .into_iter()
7066                    .map(|p| p.to_string())
7067                    .collect::<Vec<String>>()
7068                    .join(",")
7069                    .to_string(),
7070            )]),
7071        };
7072    }
7073    if let Some(ref local_var_str) = owner_group_id {
7074        local_var_req_builder = match "multi" {
7075            "multi" => local_var_req_builder.query(
7076                &local_var_str
7077                    .into_iter()
7078                    .map(|p| ("owner_group_id".to_owned(), p.to_string()))
7079                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7080            ),
7081            _ => local_var_req_builder.query(&[(
7082                "owner_group_id",
7083                &local_var_str
7084                    .into_iter()
7085                    .map(|p| p.to_string())
7086                    .collect::<Vec<String>>()
7087                    .join(",")
7088                    .to_string(),
7089            )]),
7090        };
7091    }
7092    if let Some(ref local_var_str) = owner_group_id__n {
7093        local_var_req_builder = match "multi" {
7094            "multi" => local_var_req_builder.query(
7095                &local_var_str
7096                    .into_iter()
7097                    .map(|p| ("owner_group_id__n".to_owned(), p.to_string()))
7098                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7099            ),
7100            _ => local_var_req_builder.query(&[(
7101                "owner_group_id__n",
7102                &local_var_str
7103                    .into_iter()
7104                    .map(|p| p.to_string())
7105                    .collect::<Vec<String>>()
7106                    .join(",")
7107                    .to_string(),
7108            )]),
7109        };
7110    }
7111    if let Some(ref local_var_str) = owner_id {
7112        local_var_req_builder = match "multi" {
7113            "multi" => local_var_req_builder.query(
7114                &local_var_str
7115                    .into_iter()
7116                    .map(|p| ("owner_id".to_owned(), p.to_string()))
7117                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7118            ),
7119            _ => local_var_req_builder.query(&[(
7120                "owner_id",
7121                &local_var_str
7122                    .into_iter()
7123                    .map(|p| p.to_string())
7124                    .collect::<Vec<String>>()
7125                    .join(",")
7126                    .to_string(),
7127            )]),
7128        };
7129    }
7130    if let Some(ref local_var_str) = owner_id__n {
7131        local_var_req_builder = match "multi" {
7132            "multi" => local_var_req_builder.query(
7133                &local_var_str
7134                    .into_iter()
7135                    .map(|p| ("owner_id__n".to_owned(), p.to_string()))
7136                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7137            ),
7138            _ => local_var_req_builder.query(&[(
7139                "owner_id__n",
7140                &local_var_str
7141                    .into_iter()
7142                    .map(|p| p.to_string())
7143                    .collect::<Vec<String>>()
7144                    .join(",")
7145                    .to_string(),
7146            )]),
7147        };
7148    }
7149    if let Some(ref local_var_str) = pfs_group {
7150        local_var_req_builder = match "multi" {
7151            "multi" => local_var_req_builder.query(
7152                &local_var_str
7153                    .into_iter()
7154                    .map(|p| ("pfs_group".to_owned(), p.to_string()))
7155                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7156            ),
7157            _ => local_var_req_builder.query(&[(
7158                "pfs_group",
7159                &local_var_str
7160                    .into_iter()
7161                    .map(|p| p.to_string())
7162                    .collect::<Vec<String>>()
7163                    .join(",")
7164                    .to_string(),
7165            )]),
7166        };
7167    }
7168    if let Some(ref local_var_str) = pfs_group__ic {
7169        local_var_req_builder = match "multi" {
7170            "multi" => local_var_req_builder.query(
7171                &local_var_str
7172                    .into_iter()
7173                    .map(|p| ("pfs_group__ic".to_owned(), p.to_string()))
7174                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7175            ),
7176            _ => local_var_req_builder.query(&[(
7177                "pfs_group__ic",
7178                &local_var_str
7179                    .into_iter()
7180                    .map(|p| p.to_string())
7181                    .collect::<Vec<String>>()
7182                    .join(",")
7183                    .to_string(),
7184            )]),
7185        };
7186    }
7187    if let Some(ref local_var_str) = pfs_group__ie {
7188        local_var_req_builder = match "multi" {
7189            "multi" => local_var_req_builder.query(
7190                &local_var_str
7191                    .into_iter()
7192                    .map(|p| ("pfs_group__ie".to_owned(), p.to_string()))
7193                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7194            ),
7195            _ => local_var_req_builder.query(&[(
7196                "pfs_group__ie",
7197                &local_var_str
7198                    .into_iter()
7199                    .map(|p| p.to_string())
7200                    .collect::<Vec<String>>()
7201                    .join(",")
7202                    .to_string(),
7203            )]),
7204        };
7205    }
7206    if let Some(ref local_var_str) = pfs_group__iew {
7207        local_var_req_builder = match "multi" {
7208            "multi" => local_var_req_builder.query(
7209                &local_var_str
7210                    .into_iter()
7211                    .map(|p| ("pfs_group__iew".to_owned(), p.to_string()))
7212                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7213            ),
7214            _ => local_var_req_builder.query(&[(
7215                "pfs_group__iew",
7216                &local_var_str
7217                    .into_iter()
7218                    .map(|p| p.to_string())
7219                    .collect::<Vec<String>>()
7220                    .join(",")
7221                    .to_string(),
7222            )]),
7223        };
7224    }
7225    if let Some(ref local_var_str) = pfs_group__iregex {
7226        local_var_req_builder = match "multi" {
7227            "multi" => local_var_req_builder.query(
7228                &local_var_str
7229                    .into_iter()
7230                    .map(|p| ("pfs_group__iregex".to_owned(), p.to_string()))
7231                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7232            ),
7233            _ => local_var_req_builder.query(&[(
7234                "pfs_group__iregex",
7235                &local_var_str
7236                    .into_iter()
7237                    .map(|p| p.to_string())
7238                    .collect::<Vec<String>>()
7239                    .join(",")
7240                    .to_string(),
7241            )]),
7242        };
7243    }
7244    if let Some(ref local_var_str) = pfs_group__isw {
7245        local_var_req_builder = match "multi" {
7246            "multi" => local_var_req_builder.query(
7247                &local_var_str
7248                    .into_iter()
7249                    .map(|p| ("pfs_group__isw".to_owned(), p.to_string()))
7250                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7251            ),
7252            _ => local_var_req_builder.query(&[(
7253                "pfs_group__isw",
7254                &local_var_str
7255                    .into_iter()
7256                    .map(|p| p.to_string())
7257                    .collect::<Vec<String>>()
7258                    .join(",")
7259                    .to_string(),
7260            )]),
7261        };
7262    }
7263    if let Some(ref local_var_str) = pfs_group__n {
7264        local_var_req_builder = match "multi" {
7265            "multi" => local_var_req_builder.query(
7266                &local_var_str
7267                    .into_iter()
7268                    .map(|p| ("pfs_group__n".to_owned(), p.to_string()))
7269                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7270            ),
7271            _ => local_var_req_builder.query(&[(
7272                "pfs_group__n",
7273                &local_var_str
7274                    .into_iter()
7275                    .map(|p| p.to_string())
7276                    .collect::<Vec<String>>()
7277                    .join(",")
7278                    .to_string(),
7279            )]),
7280        };
7281    }
7282    if let Some(ref local_var_str) = pfs_group__nic {
7283        local_var_req_builder = match "multi" {
7284            "multi" => local_var_req_builder.query(
7285                &local_var_str
7286                    .into_iter()
7287                    .map(|p| ("pfs_group__nic".to_owned(), p.to_string()))
7288                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7289            ),
7290            _ => local_var_req_builder.query(&[(
7291                "pfs_group__nic",
7292                &local_var_str
7293                    .into_iter()
7294                    .map(|p| p.to_string())
7295                    .collect::<Vec<String>>()
7296                    .join(",")
7297                    .to_string(),
7298            )]),
7299        };
7300    }
7301    if let Some(ref local_var_str) = pfs_group__nie {
7302        local_var_req_builder = match "multi" {
7303            "multi" => local_var_req_builder.query(
7304                &local_var_str
7305                    .into_iter()
7306                    .map(|p| ("pfs_group__nie".to_owned(), p.to_string()))
7307                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7308            ),
7309            _ => local_var_req_builder.query(&[(
7310                "pfs_group__nie",
7311                &local_var_str
7312                    .into_iter()
7313                    .map(|p| p.to_string())
7314                    .collect::<Vec<String>>()
7315                    .join(",")
7316                    .to_string(),
7317            )]),
7318        };
7319    }
7320    if let Some(ref local_var_str) = pfs_group__niew {
7321        local_var_req_builder = match "multi" {
7322            "multi" => local_var_req_builder.query(
7323                &local_var_str
7324                    .into_iter()
7325                    .map(|p| ("pfs_group__niew".to_owned(), p.to_string()))
7326                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7327            ),
7328            _ => local_var_req_builder.query(&[(
7329                "pfs_group__niew",
7330                &local_var_str
7331                    .into_iter()
7332                    .map(|p| p.to_string())
7333                    .collect::<Vec<String>>()
7334                    .join(",")
7335                    .to_string(),
7336            )]),
7337        };
7338    }
7339    if let Some(ref local_var_str) = pfs_group__nisw {
7340        local_var_req_builder = match "multi" {
7341            "multi" => local_var_req_builder.query(
7342                &local_var_str
7343                    .into_iter()
7344                    .map(|p| ("pfs_group__nisw".to_owned(), p.to_string()))
7345                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7346            ),
7347            _ => local_var_req_builder.query(&[(
7348                "pfs_group__nisw",
7349                &local_var_str
7350                    .into_iter()
7351                    .map(|p| p.to_string())
7352                    .collect::<Vec<String>>()
7353                    .join(",")
7354                    .to_string(),
7355            )]),
7356        };
7357    }
7358    if let Some(ref local_var_str) = pfs_group__regex {
7359        local_var_req_builder = match "multi" {
7360            "multi" => local_var_req_builder.query(
7361                &local_var_str
7362                    .into_iter()
7363                    .map(|p| ("pfs_group__regex".to_owned(), p.to_string()))
7364                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7365            ),
7366            _ => local_var_req_builder.query(&[(
7367                "pfs_group__regex",
7368                &local_var_str
7369                    .into_iter()
7370                    .map(|p| p.to_string())
7371                    .collect::<Vec<String>>()
7372                    .join(",")
7373                    .to_string(),
7374            )]),
7375        };
7376    }
7377    if let Some(ref local_var_str) = q {
7378        local_var_req_builder = local_var_req_builder.query(&[("q", &local_var_str.to_string())]);
7379    }
7380    if let Some(ref local_var_str) = start {
7381        local_var_req_builder =
7382            local_var_req_builder.query(&[("start", &local_var_str.to_string())]);
7383    }
7384    if let Some(ref local_var_str) = tag {
7385        local_var_req_builder = match "multi" {
7386            "multi" => local_var_req_builder.query(
7387                &local_var_str
7388                    .into_iter()
7389                    .map(|p| ("tag".to_owned(), p.to_string()))
7390                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7391            ),
7392            _ => local_var_req_builder.query(&[(
7393                "tag",
7394                &local_var_str
7395                    .into_iter()
7396                    .map(|p| p.to_string())
7397                    .collect::<Vec<String>>()
7398                    .join(",")
7399                    .to_string(),
7400            )]),
7401        };
7402    }
7403    if let Some(ref local_var_str) = tag__n {
7404        local_var_req_builder = match "multi" {
7405            "multi" => local_var_req_builder.query(
7406                &local_var_str
7407                    .into_iter()
7408                    .map(|p| ("tag__n".to_owned(), p.to_string()))
7409                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7410            ),
7411            _ => local_var_req_builder.query(&[(
7412                "tag__n",
7413                &local_var_str
7414                    .into_iter()
7415                    .map(|p| p.to_string())
7416                    .collect::<Vec<String>>()
7417                    .join(",")
7418                    .to_string(),
7419            )]),
7420        };
7421    }
7422    if let Some(ref local_var_str) = tag_id {
7423        local_var_req_builder = match "multi" {
7424            "multi" => local_var_req_builder.query(
7425                &local_var_str
7426                    .into_iter()
7427                    .map(|p| ("tag_id".to_owned(), p.to_string()))
7428                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7429            ),
7430            _ => local_var_req_builder.query(&[(
7431                "tag_id",
7432                &local_var_str
7433                    .into_iter()
7434                    .map(|p| p.to_string())
7435                    .collect::<Vec<String>>()
7436                    .join(",")
7437                    .to_string(),
7438            )]),
7439        };
7440    }
7441    if let Some(ref local_var_str) = tag_id__n {
7442        local_var_req_builder = match "multi" {
7443            "multi" => local_var_req_builder.query(
7444                &local_var_str
7445                    .into_iter()
7446                    .map(|p| ("tag_id__n".to_owned(), p.to_string()))
7447                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7448            ),
7449            _ => local_var_req_builder.query(&[(
7450                "tag_id__n",
7451                &local_var_str
7452                    .into_iter()
7453                    .map(|p| p.to_string())
7454                    .collect::<Vec<String>>()
7455                    .join(",")
7456                    .to_string(),
7457            )]),
7458        };
7459    }
7460    if let Some(ref local_var_str) = updated_by_request {
7461        local_var_req_builder =
7462            local_var_req_builder.query(&[("updated_by_request", &local_var_str.to_string())]);
7463    }
7464    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
7465        local_var_req_builder =
7466            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
7467    }
7468    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
7469        let local_var_key = local_var_apikey.key.clone();
7470        let local_var_value = match local_var_apikey.prefix {
7471            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
7472            None => local_var_key,
7473        };
7474        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
7475    };
7476
7477    let local_var_req = local_var_req_builder.build()?;
7478    let local_var_resp = local_var_client.execute(local_var_req).await?;
7479
7480    let local_var_status = local_var_resp.status();
7481    let local_var_content = local_var_resp.text().await?;
7482
7483    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
7484        serde_json::from_str(&local_var_content).map_err(Error::from)
7485    } else {
7486        let local_var_entity: Option<VpnIpsecPoliciesListError> =
7487            serde_json::from_str(&local_var_content).ok();
7488        let local_var_error = ResponseContent {
7489            status: local_var_status,
7490            content: local_var_content,
7491            entity: local_var_entity,
7492        };
7493        Err(Error::ResponseError(local_var_error))
7494    }
7495}
7496
7497/// Patch a IPSec policy object.
7498pub async fn vpn_ipsec_policies_partial_update(
7499    configuration: &configuration::Configuration,
7500    id: i32,
7501    patched_writable_ip_sec_policy_request: Option<
7502        crate::models::PatchedWritableIpSecPolicyRequest,
7503    >,
7504) -> Result<crate::models::IpSecPolicy, Error<VpnIpsecPoliciesPartialUpdateError>> {
7505    let local_var_configuration = configuration;
7506
7507    let local_var_client = &local_var_configuration.client;
7508
7509    let local_var_uri_str = format!(
7510        "{}/api/vpn/ipsec-policies/{id}/",
7511        local_var_configuration.base_path,
7512        id = id
7513    );
7514    let mut local_var_req_builder =
7515        local_var_client.request(reqwest::Method::PATCH, local_var_uri_str.as_str());
7516
7517    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
7518        local_var_req_builder =
7519            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
7520    }
7521    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
7522        let local_var_key = local_var_apikey.key.clone();
7523        let local_var_value = match local_var_apikey.prefix {
7524            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
7525            None => local_var_key,
7526        };
7527        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
7528    };
7529    local_var_req_builder = local_var_req_builder.json(&patched_writable_ip_sec_policy_request);
7530
7531    let local_var_req = local_var_req_builder.build()?;
7532    let local_var_resp = local_var_client.execute(local_var_req).await?;
7533
7534    let local_var_status = local_var_resp.status();
7535    let local_var_content = local_var_resp.text().await?;
7536
7537    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
7538        serde_json::from_str(&local_var_content).map_err(Error::from)
7539    } else {
7540        let local_var_entity: Option<VpnIpsecPoliciesPartialUpdateError> =
7541            serde_json::from_str(&local_var_content).ok();
7542        let local_var_error = ResponseContent {
7543            status: local_var_status,
7544            content: local_var_content,
7545            entity: local_var_entity,
7546        };
7547        Err(Error::ResponseError(local_var_error))
7548    }
7549}
7550
7551/// Get a IPSec policy object.
7552pub async fn vpn_ipsec_policies_retrieve(
7553    configuration: &configuration::Configuration,
7554    id: i32,
7555) -> Result<crate::models::IpSecPolicy, Error<VpnIpsecPoliciesRetrieveError>> {
7556    let local_var_configuration = configuration;
7557
7558    let local_var_client = &local_var_configuration.client;
7559
7560    let local_var_uri_str = format!(
7561        "{}/api/vpn/ipsec-policies/{id}/",
7562        local_var_configuration.base_path,
7563        id = id
7564    );
7565    let mut local_var_req_builder =
7566        local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
7567
7568    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
7569        local_var_req_builder =
7570            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
7571    }
7572    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
7573        let local_var_key = local_var_apikey.key.clone();
7574        let local_var_value = match local_var_apikey.prefix {
7575            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
7576            None => local_var_key,
7577        };
7578        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
7579    };
7580
7581    let local_var_req = local_var_req_builder.build()?;
7582    let local_var_resp = local_var_client.execute(local_var_req).await?;
7583
7584    let local_var_status = local_var_resp.status();
7585    let local_var_content = local_var_resp.text().await?;
7586
7587    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
7588        serde_json::from_str(&local_var_content).map_err(Error::from)
7589    } else {
7590        let local_var_entity: Option<VpnIpsecPoliciesRetrieveError> =
7591            serde_json::from_str(&local_var_content).ok();
7592        let local_var_error = ResponseContent {
7593            status: local_var_status,
7594            content: local_var_content,
7595            entity: local_var_entity,
7596        };
7597        Err(Error::ResponseError(local_var_error))
7598    }
7599}
7600
7601/// Put a IPSec policy object.
7602pub async fn vpn_ipsec_policies_update(
7603    configuration: &configuration::Configuration,
7604    id: i32,
7605    writable_ip_sec_policy_request: crate::models::WritableIpSecPolicyRequest,
7606) -> Result<crate::models::IpSecPolicy, Error<VpnIpsecPoliciesUpdateError>> {
7607    let local_var_configuration = configuration;
7608
7609    let local_var_client = &local_var_configuration.client;
7610
7611    let local_var_uri_str = format!(
7612        "{}/api/vpn/ipsec-policies/{id}/",
7613        local_var_configuration.base_path,
7614        id = id
7615    );
7616    let mut local_var_req_builder =
7617        local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());
7618
7619    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
7620        local_var_req_builder =
7621            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
7622    }
7623    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
7624        let local_var_key = local_var_apikey.key.clone();
7625        let local_var_value = match local_var_apikey.prefix {
7626            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
7627            None => local_var_key,
7628        };
7629        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
7630    };
7631    local_var_req_builder = local_var_req_builder.json(&writable_ip_sec_policy_request);
7632
7633    let local_var_req = local_var_req_builder.build()?;
7634    let local_var_resp = local_var_client.execute(local_var_req).await?;
7635
7636    let local_var_status = local_var_resp.status();
7637    let local_var_content = local_var_resp.text().await?;
7638
7639    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
7640        serde_json::from_str(&local_var_content).map_err(Error::from)
7641    } else {
7642        let local_var_entity: Option<VpnIpsecPoliciesUpdateError> =
7643            serde_json::from_str(&local_var_content).ok();
7644        let local_var_error = ResponseContent {
7645            status: local_var_status,
7646            content: local_var_content,
7647            entity: local_var_entity,
7648        };
7649        Err(Error::ResponseError(local_var_error))
7650    }
7651}
7652
7653/// Delete a list of IPSec profile objects.
7654pub async fn vpn_ipsec_profiles_bulk_destroy(
7655    configuration: &configuration::Configuration,
7656    ip_sec_profile_request: Vec<crate::models::IpSecProfileRequest>,
7657) -> Result<(), Error<VpnIpsecProfilesBulkDestroyError>> {
7658    let local_var_configuration = configuration;
7659
7660    let local_var_client = &local_var_configuration.client;
7661
7662    let local_var_uri_str = format!(
7663        "{}/api/vpn/ipsec-profiles/",
7664        local_var_configuration.base_path
7665    );
7666    let mut local_var_req_builder =
7667        local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());
7668
7669    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
7670        local_var_req_builder =
7671            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
7672    }
7673    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
7674        let local_var_key = local_var_apikey.key.clone();
7675        let local_var_value = match local_var_apikey.prefix {
7676            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
7677            None => local_var_key,
7678        };
7679        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
7680    };
7681    local_var_req_builder = local_var_req_builder.json(&ip_sec_profile_request);
7682
7683    let local_var_req = local_var_req_builder.build()?;
7684    let local_var_resp = local_var_client.execute(local_var_req).await?;
7685
7686    let local_var_status = local_var_resp.status();
7687    let local_var_content = local_var_resp.text().await?;
7688
7689    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
7690        Ok(())
7691    } else {
7692        let local_var_entity: Option<VpnIpsecProfilesBulkDestroyError> =
7693            serde_json::from_str(&local_var_content).ok();
7694        let local_var_error = ResponseContent {
7695            status: local_var_status,
7696            content: local_var_content,
7697            entity: local_var_entity,
7698        };
7699        Err(Error::ResponseError(local_var_error))
7700    }
7701}
7702
7703/// Patch a list of IPSec profile objects.
7704pub async fn vpn_ipsec_profiles_bulk_partial_update(
7705    configuration: &configuration::Configuration,
7706    ip_sec_profile_request: Vec<crate::models::IpSecProfileRequest>,
7707) -> Result<Vec<crate::models::IpSecProfile>, Error<VpnIpsecProfilesBulkPartialUpdateError>> {
7708    let local_var_configuration = configuration;
7709
7710    let local_var_client = &local_var_configuration.client;
7711
7712    let local_var_uri_str = format!(
7713        "{}/api/vpn/ipsec-profiles/",
7714        local_var_configuration.base_path
7715    );
7716    let mut local_var_req_builder =
7717        local_var_client.request(reqwest::Method::PATCH, local_var_uri_str.as_str());
7718
7719    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
7720        local_var_req_builder =
7721            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
7722    }
7723    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
7724        let local_var_key = local_var_apikey.key.clone();
7725        let local_var_value = match local_var_apikey.prefix {
7726            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
7727            None => local_var_key,
7728        };
7729        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
7730    };
7731    local_var_req_builder = local_var_req_builder.json(&ip_sec_profile_request);
7732
7733    let local_var_req = local_var_req_builder.build()?;
7734    let local_var_resp = local_var_client.execute(local_var_req).await?;
7735
7736    let local_var_status = local_var_resp.status();
7737    let local_var_content = local_var_resp.text().await?;
7738
7739    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
7740        serde_json::from_str(&local_var_content).map_err(Error::from)
7741    } else {
7742        let local_var_entity: Option<VpnIpsecProfilesBulkPartialUpdateError> =
7743            serde_json::from_str(&local_var_content).ok();
7744        let local_var_error = ResponseContent {
7745            status: local_var_status,
7746            content: local_var_content,
7747            entity: local_var_entity,
7748        };
7749        Err(Error::ResponseError(local_var_error))
7750    }
7751}
7752
7753/// Put a list of IPSec profile objects.
7754pub async fn vpn_ipsec_profiles_bulk_update(
7755    configuration: &configuration::Configuration,
7756    ip_sec_profile_request: Vec<crate::models::IpSecProfileRequest>,
7757) -> Result<Vec<crate::models::IpSecProfile>, Error<VpnIpsecProfilesBulkUpdateError>> {
7758    let local_var_configuration = configuration;
7759
7760    let local_var_client = &local_var_configuration.client;
7761
7762    let local_var_uri_str = format!(
7763        "{}/api/vpn/ipsec-profiles/",
7764        local_var_configuration.base_path
7765    );
7766    let mut local_var_req_builder =
7767        local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());
7768
7769    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
7770        local_var_req_builder =
7771            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
7772    }
7773    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
7774        let local_var_key = local_var_apikey.key.clone();
7775        let local_var_value = match local_var_apikey.prefix {
7776            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
7777            None => local_var_key,
7778        };
7779        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
7780    };
7781    local_var_req_builder = local_var_req_builder.json(&ip_sec_profile_request);
7782
7783    let local_var_req = local_var_req_builder.build()?;
7784    let local_var_resp = local_var_client.execute(local_var_req).await?;
7785
7786    let local_var_status = local_var_resp.status();
7787    let local_var_content = local_var_resp.text().await?;
7788
7789    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
7790        serde_json::from_str(&local_var_content).map_err(Error::from)
7791    } else {
7792        let local_var_entity: Option<VpnIpsecProfilesBulkUpdateError> =
7793            serde_json::from_str(&local_var_content).ok();
7794        let local_var_error = ResponseContent {
7795            status: local_var_status,
7796            content: local_var_content,
7797            entity: local_var_entity,
7798        };
7799        Err(Error::ResponseError(local_var_error))
7800    }
7801}
7802
7803/// Post a list of IPSec profile objects.
7804pub async fn vpn_ipsec_profiles_create(
7805    configuration: &configuration::Configuration,
7806    vpn_ipsec_profiles_create_request: crate::models::VpnIpsecProfilesCreateRequest,
7807) -> Result<crate::models::IpSecProfile, Error<VpnIpsecProfilesCreateError>> {
7808    let local_var_configuration = configuration;
7809
7810    let local_var_client = &local_var_configuration.client;
7811
7812    let local_var_uri_str = format!(
7813        "{}/api/vpn/ipsec-profiles/",
7814        local_var_configuration.base_path
7815    );
7816    let mut local_var_req_builder =
7817        local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
7818
7819    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
7820        local_var_req_builder =
7821            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
7822    }
7823    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
7824        let local_var_key = local_var_apikey.key.clone();
7825        let local_var_value = match local_var_apikey.prefix {
7826            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
7827            None => local_var_key,
7828        };
7829        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
7830    };
7831    local_var_req_builder = local_var_req_builder.json(&vpn_ipsec_profiles_create_request);
7832
7833    let local_var_req = local_var_req_builder.build()?;
7834    let local_var_resp = local_var_client.execute(local_var_req).await?;
7835
7836    let local_var_status = local_var_resp.status();
7837    let local_var_content = local_var_resp.text().await?;
7838
7839    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
7840        serde_json::from_str(&local_var_content).map_err(Error::from)
7841    } else {
7842        let local_var_entity: Option<VpnIpsecProfilesCreateError> =
7843            serde_json::from_str(&local_var_content).ok();
7844        let local_var_error = ResponseContent {
7845            status: local_var_status,
7846            content: local_var_content,
7847            entity: local_var_entity,
7848        };
7849        Err(Error::ResponseError(local_var_error))
7850    }
7851}
7852
7853/// Delete a IPSec profile object.
7854pub async fn vpn_ipsec_profiles_destroy(
7855    configuration: &configuration::Configuration,
7856    id: i32,
7857) -> Result<(), Error<VpnIpsecProfilesDestroyError>> {
7858    let local_var_configuration = configuration;
7859
7860    let local_var_client = &local_var_configuration.client;
7861
7862    let local_var_uri_str = format!(
7863        "{}/api/vpn/ipsec-profiles/{id}/",
7864        local_var_configuration.base_path,
7865        id = id
7866    );
7867    let mut local_var_req_builder =
7868        local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());
7869
7870    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
7871        local_var_req_builder =
7872            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
7873    }
7874    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
7875        let local_var_key = local_var_apikey.key.clone();
7876        let local_var_value = match local_var_apikey.prefix {
7877            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
7878            None => local_var_key,
7879        };
7880        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
7881    };
7882
7883    let local_var_req = local_var_req_builder.build()?;
7884    let local_var_resp = local_var_client.execute(local_var_req).await?;
7885
7886    let local_var_status = local_var_resp.status();
7887    let local_var_content = local_var_resp.text().await?;
7888
7889    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
7890        Ok(())
7891    } else {
7892        let local_var_entity: Option<VpnIpsecProfilesDestroyError> =
7893            serde_json::from_str(&local_var_content).ok();
7894        let local_var_error = ResponseContent {
7895            status: local_var_status,
7896            content: local_var_content,
7897            entity: local_var_entity,
7898        };
7899        Err(Error::ResponseError(local_var_error))
7900    }
7901}
7902
7903/// Get a list of IPSec profile objects.
7904pub async fn vpn_ipsec_profiles_list(
7905    configuration: &configuration::Configuration,
7906    created: Option<Vec<String>>,
7907    created__empty: Option<Vec<String>>,
7908    created__gt: Option<Vec<String>>,
7909    created__gte: Option<Vec<String>>,
7910    created__lt: Option<Vec<String>>,
7911    created__lte: Option<Vec<String>>,
7912    created__n: Option<Vec<String>>,
7913    created_by_request: Option<&str>,
7914    description: Option<Vec<String>>,
7915    description__empty: Option<bool>,
7916    description__ic: Option<Vec<String>>,
7917    description__ie: Option<Vec<String>>,
7918    description__iew: Option<Vec<String>>,
7919    description__iregex: Option<Vec<String>>,
7920    description__isw: Option<Vec<String>>,
7921    description__n: Option<Vec<String>>,
7922    description__nic: Option<Vec<String>>,
7923    description__nie: Option<Vec<String>>,
7924    description__niew: Option<Vec<String>>,
7925    description__nisw: Option<Vec<String>>,
7926    description__regex: Option<Vec<String>>,
7927    id: Option<Vec<i32>>,
7928    id__empty: Option<bool>,
7929    id__gt: Option<Vec<i32>>,
7930    id__gte: Option<Vec<i32>>,
7931    id__lt: Option<Vec<i32>>,
7932    id__lte: Option<Vec<i32>>,
7933    id__n: Option<Vec<i32>>,
7934    ike_policy: Option<Vec<String>>,
7935    ike_policy__n: Option<Vec<String>>,
7936    ike_policy_id: Option<Vec<i32>>,
7937    ike_policy_id__n: Option<Vec<i32>>,
7938    ipsec_policy: Option<Vec<String>>,
7939    ipsec_policy__n: Option<Vec<String>>,
7940    ipsec_policy_id: Option<Vec<i32>>,
7941    ipsec_policy_id__n: Option<Vec<i32>>,
7942    last_updated: Option<Vec<String>>,
7943    last_updated__empty: Option<Vec<String>>,
7944    last_updated__gt: Option<Vec<String>>,
7945    last_updated__gte: Option<Vec<String>>,
7946    last_updated__lt: Option<Vec<String>>,
7947    last_updated__lte: Option<Vec<String>>,
7948    last_updated__n: Option<Vec<String>>,
7949    limit: Option<i32>,
7950    mode: Option<Vec<String>>,
7951    mode__empty: Option<bool>,
7952    mode__ic: Option<Vec<String>>,
7953    mode__ie: Option<Vec<String>>,
7954    mode__iew: Option<Vec<String>>,
7955    mode__iregex: Option<Vec<String>>,
7956    mode__isw: Option<Vec<String>>,
7957    mode__n: Option<Vec<String>>,
7958    mode__nic: Option<Vec<String>>,
7959    mode__nie: Option<Vec<String>>,
7960    mode__niew: Option<Vec<String>>,
7961    mode__nisw: Option<Vec<String>>,
7962    mode__regex: Option<Vec<String>>,
7963    modified_by_request: Option<&str>,
7964    name: Option<Vec<String>>,
7965    name__empty: Option<bool>,
7966    name__ic: Option<Vec<String>>,
7967    name__ie: Option<Vec<String>>,
7968    name__iew: Option<Vec<String>>,
7969    name__iregex: Option<Vec<String>>,
7970    name__isw: Option<Vec<String>>,
7971    name__n: Option<Vec<String>>,
7972    name__nic: Option<Vec<String>>,
7973    name__nie: Option<Vec<String>>,
7974    name__niew: Option<Vec<String>>,
7975    name__nisw: Option<Vec<String>>,
7976    name__regex: Option<Vec<String>>,
7977    offset: Option<i32>,
7978    ordering: Option<&str>,
7979    owner: Option<Vec<String>>,
7980    owner__n: Option<Vec<String>>,
7981    owner_group: Option<Vec<String>>,
7982    owner_group__n: Option<Vec<String>>,
7983    owner_group_id: Option<Vec<i32>>,
7984    owner_group_id__n: Option<Vec<i32>>,
7985    owner_id: Option<Vec<i32>>,
7986    owner_id__n: Option<Vec<i32>>,
7987    q: Option<&str>,
7988    start: Option<i32>,
7989    tag: Option<Vec<String>>,
7990    tag__n: Option<Vec<String>>,
7991    tag_id: Option<Vec<i32>>,
7992    tag_id__n: Option<Vec<i32>>,
7993    updated_by_request: Option<&str>,
7994) -> Result<crate::models::PaginatedIpSecProfileList, Error<VpnIpsecProfilesListError>> {
7995    let local_var_configuration = configuration;
7996
7997    let local_var_client = &local_var_configuration.client;
7998
7999    let local_var_uri_str = format!(
8000        "{}/api/vpn/ipsec-profiles/",
8001        local_var_configuration.base_path
8002    );
8003    let mut local_var_req_builder =
8004        local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
8005
8006    if let Some(ref local_var_str) = created {
8007        local_var_req_builder = match "multi" {
8008            "multi" => local_var_req_builder.query(
8009                &local_var_str
8010                    .into_iter()
8011                    .map(|p| ("created".to_owned(), p.to_string()))
8012                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8013            ),
8014            _ => local_var_req_builder.query(&[(
8015                "created",
8016                &local_var_str
8017                    .into_iter()
8018                    .map(|p| p.to_string())
8019                    .collect::<Vec<String>>()
8020                    .join(",")
8021                    .to_string(),
8022            )]),
8023        };
8024    }
8025    if let Some(ref local_var_str) = created__empty {
8026        local_var_req_builder = match "multi" {
8027            "multi" => local_var_req_builder.query(
8028                &local_var_str
8029                    .into_iter()
8030                    .map(|p| ("created__empty".to_owned(), p.to_string()))
8031                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8032            ),
8033            _ => local_var_req_builder.query(&[(
8034                "created__empty",
8035                &local_var_str
8036                    .into_iter()
8037                    .map(|p| p.to_string())
8038                    .collect::<Vec<String>>()
8039                    .join(",")
8040                    .to_string(),
8041            )]),
8042        };
8043    }
8044    if let Some(ref local_var_str) = created__gt {
8045        local_var_req_builder = match "multi" {
8046            "multi" => local_var_req_builder.query(
8047                &local_var_str
8048                    .into_iter()
8049                    .map(|p| ("created__gt".to_owned(), p.to_string()))
8050                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8051            ),
8052            _ => local_var_req_builder.query(&[(
8053                "created__gt",
8054                &local_var_str
8055                    .into_iter()
8056                    .map(|p| p.to_string())
8057                    .collect::<Vec<String>>()
8058                    .join(",")
8059                    .to_string(),
8060            )]),
8061        };
8062    }
8063    if let Some(ref local_var_str) = created__gte {
8064        local_var_req_builder = match "multi" {
8065            "multi" => local_var_req_builder.query(
8066                &local_var_str
8067                    .into_iter()
8068                    .map(|p| ("created__gte".to_owned(), p.to_string()))
8069                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8070            ),
8071            _ => local_var_req_builder.query(&[(
8072                "created__gte",
8073                &local_var_str
8074                    .into_iter()
8075                    .map(|p| p.to_string())
8076                    .collect::<Vec<String>>()
8077                    .join(",")
8078                    .to_string(),
8079            )]),
8080        };
8081    }
8082    if let Some(ref local_var_str) = created__lt {
8083        local_var_req_builder = match "multi" {
8084            "multi" => local_var_req_builder.query(
8085                &local_var_str
8086                    .into_iter()
8087                    .map(|p| ("created__lt".to_owned(), p.to_string()))
8088                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8089            ),
8090            _ => local_var_req_builder.query(&[(
8091                "created__lt",
8092                &local_var_str
8093                    .into_iter()
8094                    .map(|p| p.to_string())
8095                    .collect::<Vec<String>>()
8096                    .join(",")
8097                    .to_string(),
8098            )]),
8099        };
8100    }
8101    if let Some(ref local_var_str) = created__lte {
8102        local_var_req_builder = match "multi" {
8103            "multi" => local_var_req_builder.query(
8104                &local_var_str
8105                    .into_iter()
8106                    .map(|p| ("created__lte".to_owned(), p.to_string()))
8107                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8108            ),
8109            _ => local_var_req_builder.query(&[(
8110                "created__lte",
8111                &local_var_str
8112                    .into_iter()
8113                    .map(|p| p.to_string())
8114                    .collect::<Vec<String>>()
8115                    .join(",")
8116                    .to_string(),
8117            )]),
8118        };
8119    }
8120    if let Some(ref local_var_str) = created__n {
8121        local_var_req_builder = match "multi" {
8122            "multi" => local_var_req_builder.query(
8123                &local_var_str
8124                    .into_iter()
8125                    .map(|p| ("created__n".to_owned(), p.to_string()))
8126                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8127            ),
8128            _ => local_var_req_builder.query(&[(
8129                "created__n",
8130                &local_var_str
8131                    .into_iter()
8132                    .map(|p| p.to_string())
8133                    .collect::<Vec<String>>()
8134                    .join(",")
8135                    .to_string(),
8136            )]),
8137        };
8138    }
8139    if let Some(ref local_var_str) = created_by_request {
8140        local_var_req_builder =
8141            local_var_req_builder.query(&[("created_by_request", &local_var_str.to_string())]);
8142    }
8143    if let Some(ref local_var_str) = description {
8144        local_var_req_builder = match "multi" {
8145            "multi" => local_var_req_builder.query(
8146                &local_var_str
8147                    .into_iter()
8148                    .map(|p| ("description".to_owned(), p.to_string()))
8149                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8150            ),
8151            _ => local_var_req_builder.query(&[(
8152                "description",
8153                &local_var_str
8154                    .into_iter()
8155                    .map(|p| p.to_string())
8156                    .collect::<Vec<String>>()
8157                    .join(",")
8158                    .to_string(),
8159            )]),
8160        };
8161    }
8162    if let Some(ref local_var_str) = description__empty {
8163        local_var_req_builder =
8164            local_var_req_builder.query(&[("description__empty", &local_var_str.to_string())]);
8165    }
8166    if let Some(ref local_var_str) = description__ic {
8167        local_var_req_builder = match "multi" {
8168            "multi" => local_var_req_builder.query(
8169                &local_var_str
8170                    .into_iter()
8171                    .map(|p| ("description__ic".to_owned(), p.to_string()))
8172                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8173            ),
8174            _ => local_var_req_builder.query(&[(
8175                "description__ic",
8176                &local_var_str
8177                    .into_iter()
8178                    .map(|p| p.to_string())
8179                    .collect::<Vec<String>>()
8180                    .join(",")
8181                    .to_string(),
8182            )]),
8183        };
8184    }
8185    if let Some(ref local_var_str) = description__ie {
8186        local_var_req_builder = match "multi" {
8187            "multi" => local_var_req_builder.query(
8188                &local_var_str
8189                    .into_iter()
8190                    .map(|p| ("description__ie".to_owned(), p.to_string()))
8191                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8192            ),
8193            _ => local_var_req_builder.query(&[(
8194                "description__ie",
8195                &local_var_str
8196                    .into_iter()
8197                    .map(|p| p.to_string())
8198                    .collect::<Vec<String>>()
8199                    .join(",")
8200                    .to_string(),
8201            )]),
8202        };
8203    }
8204    if let Some(ref local_var_str) = description__iew {
8205        local_var_req_builder = match "multi" {
8206            "multi" => local_var_req_builder.query(
8207                &local_var_str
8208                    .into_iter()
8209                    .map(|p| ("description__iew".to_owned(), p.to_string()))
8210                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8211            ),
8212            _ => local_var_req_builder.query(&[(
8213                "description__iew",
8214                &local_var_str
8215                    .into_iter()
8216                    .map(|p| p.to_string())
8217                    .collect::<Vec<String>>()
8218                    .join(",")
8219                    .to_string(),
8220            )]),
8221        };
8222    }
8223    if let Some(ref local_var_str) = description__iregex {
8224        local_var_req_builder = match "multi" {
8225            "multi" => local_var_req_builder.query(
8226                &local_var_str
8227                    .into_iter()
8228                    .map(|p| ("description__iregex".to_owned(), p.to_string()))
8229                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8230            ),
8231            _ => local_var_req_builder.query(&[(
8232                "description__iregex",
8233                &local_var_str
8234                    .into_iter()
8235                    .map(|p| p.to_string())
8236                    .collect::<Vec<String>>()
8237                    .join(",")
8238                    .to_string(),
8239            )]),
8240        };
8241    }
8242    if let Some(ref local_var_str) = description__isw {
8243        local_var_req_builder = match "multi" {
8244            "multi" => local_var_req_builder.query(
8245                &local_var_str
8246                    .into_iter()
8247                    .map(|p| ("description__isw".to_owned(), p.to_string()))
8248                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8249            ),
8250            _ => local_var_req_builder.query(&[(
8251                "description__isw",
8252                &local_var_str
8253                    .into_iter()
8254                    .map(|p| p.to_string())
8255                    .collect::<Vec<String>>()
8256                    .join(",")
8257                    .to_string(),
8258            )]),
8259        };
8260    }
8261    if let Some(ref local_var_str) = description__n {
8262        local_var_req_builder = match "multi" {
8263            "multi" => local_var_req_builder.query(
8264                &local_var_str
8265                    .into_iter()
8266                    .map(|p| ("description__n".to_owned(), p.to_string()))
8267                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8268            ),
8269            _ => local_var_req_builder.query(&[(
8270                "description__n",
8271                &local_var_str
8272                    .into_iter()
8273                    .map(|p| p.to_string())
8274                    .collect::<Vec<String>>()
8275                    .join(",")
8276                    .to_string(),
8277            )]),
8278        };
8279    }
8280    if let Some(ref local_var_str) = description__nic {
8281        local_var_req_builder = match "multi" {
8282            "multi" => local_var_req_builder.query(
8283                &local_var_str
8284                    .into_iter()
8285                    .map(|p| ("description__nic".to_owned(), p.to_string()))
8286                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8287            ),
8288            _ => local_var_req_builder.query(&[(
8289                "description__nic",
8290                &local_var_str
8291                    .into_iter()
8292                    .map(|p| p.to_string())
8293                    .collect::<Vec<String>>()
8294                    .join(",")
8295                    .to_string(),
8296            )]),
8297        };
8298    }
8299    if let Some(ref local_var_str) = description__nie {
8300        local_var_req_builder = match "multi" {
8301            "multi" => local_var_req_builder.query(
8302                &local_var_str
8303                    .into_iter()
8304                    .map(|p| ("description__nie".to_owned(), p.to_string()))
8305                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8306            ),
8307            _ => local_var_req_builder.query(&[(
8308                "description__nie",
8309                &local_var_str
8310                    .into_iter()
8311                    .map(|p| p.to_string())
8312                    .collect::<Vec<String>>()
8313                    .join(",")
8314                    .to_string(),
8315            )]),
8316        };
8317    }
8318    if let Some(ref local_var_str) = description__niew {
8319        local_var_req_builder = match "multi" {
8320            "multi" => local_var_req_builder.query(
8321                &local_var_str
8322                    .into_iter()
8323                    .map(|p| ("description__niew".to_owned(), p.to_string()))
8324                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8325            ),
8326            _ => local_var_req_builder.query(&[(
8327                "description__niew",
8328                &local_var_str
8329                    .into_iter()
8330                    .map(|p| p.to_string())
8331                    .collect::<Vec<String>>()
8332                    .join(",")
8333                    .to_string(),
8334            )]),
8335        };
8336    }
8337    if let Some(ref local_var_str) = description__nisw {
8338        local_var_req_builder = match "multi" {
8339            "multi" => local_var_req_builder.query(
8340                &local_var_str
8341                    .into_iter()
8342                    .map(|p| ("description__nisw".to_owned(), p.to_string()))
8343                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8344            ),
8345            _ => local_var_req_builder.query(&[(
8346                "description__nisw",
8347                &local_var_str
8348                    .into_iter()
8349                    .map(|p| p.to_string())
8350                    .collect::<Vec<String>>()
8351                    .join(",")
8352                    .to_string(),
8353            )]),
8354        };
8355    }
8356    if let Some(ref local_var_str) = description__regex {
8357        local_var_req_builder = match "multi" {
8358            "multi" => local_var_req_builder.query(
8359                &local_var_str
8360                    .into_iter()
8361                    .map(|p| ("description__regex".to_owned(), p.to_string()))
8362                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8363            ),
8364            _ => local_var_req_builder.query(&[(
8365                "description__regex",
8366                &local_var_str
8367                    .into_iter()
8368                    .map(|p| p.to_string())
8369                    .collect::<Vec<String>>()
8370                    .join(",")
8371                    .to_string(),
8372            )]),
8373        };
8374    }
8375    if let Some(ref local_var_str) = id {
8376        local_var_req_builder = match "multi" {
8377            "multi" => local_var_req_builder.query(
8378                &local_var_str
8379                    .into_iter()
8380                    .map(|p| ("id".to_owned(), p.to_string()))
8381                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8382            ),
8383            _ => local_var_req_builder.query(&[(
8384                "id",
8385                &local_var_str
8386                    .into_iter()
8387                    .map(|p| p.to_string())
8388                    .collect::<Vec<String>>()
8389                    .join(",")
8390                    .to_string(),
8391            )]),
8392        };
8393    }
8394    if let Some(ref local_var_str) = id__empty {
8395        local_var_req_builder =
8396            local_var_req_builder.query(&[("id__empty", &local_var_str.to_string())]);
8397    }
8398    if let Some(ref local_var_str) = id__gt {
8399        local_var_req_builder = match "multi" {
8400            "multi" => local_var_req_builder.query(
8401                &local_var_str
8402                    .into_iter()
8403                    .map(|p| ("id__gt".to_owned(), p.to_string()))
8404                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8405            ),
8406            _ => local_var_req_builder.query(&[(
8407                "id__gt",
8408                &local_var_str
8409                    .into_iter()
8410                    .map(|p| p.to_string())
8411                    .collect::<Vec<String>>()
8412                    .join(",")
8413                    .to_string(),
8414            )]),
8415        };
8416    }
8417    if let Some(ref local_var_str) = id__gte {
8418        local_var_req_builder = match "multi" {
8419            "multi" => local_var_req_builder.query(
8420                &local_var_str
8421                    .into_iter()
8422                    .map(|p| ("id__gte".to_owned(), p.to_string()))
8423                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8424            ),
8425            _ => local_var_req_builder.query(&[(
8426                "id__gte",
8427                &local_var_str
8428                    .into_iter()
8429                    .map(|p| p.to_string())
8430                    .collect::<Vec<String>>()
8431                    .join(",")
8432                    .to_string(),
8433            )]),
8434        };
8435    }
8436    if let Some(ref local_var_str) = id__lt {
8437        local_var_req_builder = match "multi" {
8438            "multi" => local_var_req_builder.query(
8439                &local_var_str
8440                    .into_iter()
8441                    .map(|p| ("id__lt".to_owned(), p.to_string()))
8442                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8443            ),
8444            _ => local_var_req_builder.query(&[(
8445                "id__lt",
8446                &local_var_str
8447                    .into_iter()
8448                    .map(|p| p.to_string())
8449                    .collect::<Vec<String>>()
8450                    .join(",")
8451                    .to_string(),
8452            )]),
8453        };
8454    }
8455    if let Some(ref local_var_str) = id__lte {
8456        local_var_req_builder = match "multi" {
8457            "multi" => local_var_req_builder.query(
8458                &local_var_str
8459                    .into_iter()
8460                    .map(|p| ("id__lte".to_owned(), p.to_string()))
8461                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8462            ),
8463            _ => local_var_req_builder.query(&[(
8464                "id__lte",
8465                &local_var_str
8466                    .into_iter()
8467                    .map(|p| p.to_string())
8468                    .collect::<Vec<String>>()
8469                    .join(",")
8470                    .to_string(),
8471            )]),
8472        };
8473    }
8474    if let Some(ref local_var_str) = id__n {
8475        local_var_req_builder = match "multi" {
8476            "multi" => local_var_req_builder.query(
8477                &local_var_str
8478                    .into_iter()
8479                    .map(|p| ("id__n".to_owned(), p.to_string()))
8480                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8481            ),
8482            _ => local_var_req_builder.query(&[(
8483                "id__n",
8484                &local_var_str
8485                    .into_iter()
8486                    .map(|p| p.to_string())
8487                    .collect::<Vec<String>>()
8488                    .join(",")
8489                    .to_string(),
8490            )]),
8491        };
8492    }
8493    if let Some(ref local_var_str) = ike_policy {
8494        local_var_req_builder = match "multi" {
8495            "multi" => local_var_req_builder.query(
8496                &local_var_str
8497                    .into_iter()
8498                    .map(|p| ("ike_policy".to_owned(), p.to_string()))
8499                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8500            ),
8501            _ => local_var_req_builder.query(&[(
8502                "ike_policy",
8503                &local_var_str
8504                    .into_iter()
8505                    .map(|p| p.to_string())
8506                    .collect::<Vec<String>>()
8507                    .join(",")
8508                    .to_string(),
8509            )]),
8510        };
8511    }
8512    if let Some(ref local_var_str) = ike_policy__n {
8513        local_var_req_builder = match "multi" {
8514            "multi" => local_var_req_builder.query(
8515                &local_var_str
8516                    .into_iter()
8517                    .map(|p| ("ike_policy__n".to_owned(), p.to_string()))
8518                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8519            ),
8520            _ => local_var_req_builder.query(&[(
8521                "ike_policy__n",
8522                &local_var_str
8523                    .into_iter()
8524                    .map(|p| p.to_string())
8525                    .collect::<Vec<String>>()
8526                    .join(",")
8527                    .to_string(),
8528            )]),
8529        };
8530    }
8531    if let Some(ref local_var_str) = ike_policy_id {
8532        local_var_req_builder = match "multi" {
8533            "multi" => local_var_req_builder.query(
8534                &local_var_str
8535                    .into_iter()
8536                    .map(|p| ("ike_policy_id".to_owned(), p.to_string()))
8537                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8538            ),
8539            _ => local_var_req_builder.query(&[(
8540                "ike_policy_id",
8541                &local_var_str
8542                    .into_iter()
8543                    .map(|p| p.to_string())
8544                    .collect::<Vec<String>>()
8545                    .join(",")
8546                    .to_string(),
8547            )]),
8548        };
8549    }
8550    if let Some(ref local_var_str) = ike_policy_id__n {
8551        local_var_req_builder = match "multi" {
8552            "multi" => local_var_req_builder.query(
8553                &local_var_str
8554                    .into_iter()
8555                    .map(|p| ("ike_policy_id__n".to_owned(), p.to_string()))
8556                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8557            ),
8558            _ => local_var_req_builder.query(&[(
8559                "ike_policy_id__n",
8560                &local_var_str
8561                    .into_iter()
8562                    .map(|p| p.to_string())
8563                    .collect::<Vec<String>>()
8564                    .join(",")
8565                    .to_string(),
8566            )]),
8567        };
8568    }
8569    if let Some(ref local_var_str) = ipsec_policy {
8570        local_var_req_builder = match "multi" {
8571            "multi" => local_var_req_builder.query(
8572                &local_var_str
8573                    .into_iter()
8574                    .map(|p| ("ipsec_policy".to_owned(), p.to_string()))
8575                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8576            ),
8577            _ => local_var_req_builder.query(&[(
8578                "ipsec_policy",
8579                &local_var_str
8580                    .into_iter()
8581                    .map(|p| p.to_string())
8582                    .collect::<Vec<String>>()
8583                    .join(",")
8584                    .to_string(),
8585            )]),
8586        };
8587    }
8588    if let Some(ref local_var_str) = ipsec_policy__n {
8589        local_var_req_builder = match "multi" {
8590            "multi" => local_var_req_builder.query(
8591                &local_var_str
8592                    .into_iter()
8593                    .map(|p| ("ipsec_policy__n".to_owned(), p.to_string()))
8594                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8595            ),
8596            _ => local_var_req_builder.query(&[(
8597                "ipsec_policy__n",
8598                &local_var_str
8599                    .into_iter()
8600                    .map(|p| p.to_string())
8601                    .collect::<Vec<String>>()
8602                    .join(",")
8603                    .to_string(),
8604            )]),
8605        };
8606    }
8607    if let Some(ref local_var_str) = ipsec_policy_id {
8608        local_var_req_builder = match "multi" {
8609            "multi" => local_var_req_builder.query(
8610                &local_var_str
8611                    .into_iter()
8612                    .map(|p| ("ipsec_policy_id".to_owned(), p.to_string()))
8613                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8614            ),
8615            _ => local_var_req_builder.query(&[(
8616                "ipsec_policy_id",
8617                &local_var_str
8618                    .into_iter()
8619                    .map(|p| p.to_string())
8620                    .collect::<Vec<String>>()
8621                    .join(",")
8622                    .to_string(),
8623            )]),
8624        };
8625    }
8626    if let Some(ref local_var_str) = ipsec_policy_id__n {
8627        local_var_req_builder = match "multi" {
8628            "multi" => local_var_req_builder.query(
8629                &local_var_str
8630                    .into_iter()
8631                    .map(|p| ("ipsec_policy_id__n".to_owned(), p.to_string()))
8632                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8633            ),
8634            _ => local_var_req_builder.query(&[(
8635                "ipsec_policy_id__n",
8636                &local_var_str
8637                    .into_iter()
8638                    .map(|p| p.to_string())
8639                    .collect::<Vec<String>>()
8640                    .join(",")
8641                    .to_string(),
8642            )]),
8643        };
8644    }
8645    if let Some(ref local_var_str) = last_updated {
8646        local_var_req_builder = match "multi" {
8647            "multi" => local_var_req_builder.query(
8648                &local_var_str
8649                    .into_iter()
8650                    .map(|p| ("last_updated".to_owned(), p.to_string()))
8651                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8652            ),
8653            _ => local_var_req_builder.query(&[(
8654                "last_updated",
8655                &local_var_str
8656                    .into_iter()
8657                    .map(|p| p.to_string())
8658                    .collect::<Vec<String>>()
8659                    .join(",")
8660                    .to_string(),
8661            )]),
8662        };
8663    }
8664    if let Some(ref local_var_str) = last_updated__empty {
8665        local_var_req_builder = match "multi" {
8666            "multi" => local_var_req_builder.query(
8667                &local_var_str
8668                    .into_iter()
8669                    .map(|p| ("last_updated__empty".to_owned(), p.to_string()))
8670                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8671            ),
8672            _ => local_var_req_builder.query(&[(
8673                "last_updated__empty",
8674                &local_var_str
8675                    .into_iter()
8676                    .map(|p| p.to_string())
8677                    .collect::<Vec<String>>()
8678                    .join(",")
8679                    .to_string(),
8680            )]),
8681        };
8682    }
8683    if let Some(ref local_var_str) = last_updated__gt {
8684        local_var_req_builder = match "multi" {
8685            "multi" => local_var_req_builder.query(
8686                &local_var_str
8687                    .into_iter()
8688                    .map(|p| ("last_updated__gt".to_owned(), p.to_string()))
8689                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8690            ),
8691            _ => local_var_req_builder.query(&[(
8692                "last_updated__gt",
8693                &local_var_str
8694                    .into_iter()
8695                    .map(|p| p.to_string())
8696                    .collect::<Vec<String>>()
8697                    .join(",")
8698                    .to_string(),
8699            )]),
8700        };
8701    }
8702    if let Some(ref local_var_str) = last_updated__gte {
8703        local_var_req_builder = match "multi" {
8704            "multi" => local_var_req_builder.query(
8705                &local_var_str
8706                    .into_iter()
8707                    .map(|p| ("last_updated__gte".to_owned(), p.to_string()))
8708                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8709            ),
8710            _ => local_var_req_builder.query(&[(
8711                "last_updated__gte",
8712                &local_var_str
8713                    .into_iter()
8714                    .map(|p| p.to_string())
8715                    .collect::<Vec<String>>()
8716                    .join(",")
8717                    .to_string(),
8718            )]),
8719        };
8720    }
8721    if let Some(ref local_var_str) = last_updated__lt {
8722        local_var_req_builder = match "multi" {
8723            "multi" => local_var_req_builder.query(
8724                &local_var_str
8725                    .into_iter()
8726                    .map(|p| ("last_updated__lt".to_owned(), p.to_string()))
8727                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8728            ),
8729            _ => local_var_req_builder.query(&[(
8730                "last_updated__lt",
8731                &local_var_str
8732                    .into_iter()
8733                    .map(|p| p.to_string())
8734                    .collect::<Vec<String>>()
8735                    .join(",")
8736                    .to_string(),
8737            )]),
8738        };
8739    }
8740    if let Some(ref local_var_str) = last_updated__lte {
8741        local_var_req_builder = match "multi" {
8742            "multi" => local_var_req_builder.query(
8743                &local_var_str
8744                    .into_iter()
8745                    .map(|p| ("last_updated__lte".to_owned(), p.to_string()))
8746                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8747            ),
8748            _ => local_var_req_builder.query(&[(
8749                "last_updated__lte",
8750                &local_var_str
8751                    .into_iter()
8752                    .map(|p| p.to_string())
8753                    .collect::<Vec<String>>()
8754                    .join(",")
8755                    .to_string(),
8756            )]),
8757        };
8758    }
8759    if let Some(ref local_var_str) = last_updated__n {
8760        local_var_req_builder = match "multi" {
8761            "multi" => local_var_req_builder.query(
8762                &local_var_str
8763                    .into_iter()
8764                    .map(|p| ("last_updated__n".to_owned(), p.to_string()))
8765                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8766            ),
8767            _ => local_var_req_builder.query(&[(
8768                "last_updated__n",
8769                &local_var_str
8770                    .into_iter()
8771                    .map(|p| p.to_string())
8772                    .collect::<Vec<String>>()
8773                    .join(",")
8774                    .to_string(),
8775            )]),
8776        };
8777    }
8778    if let Some(ref local_var_str) = limit {
8779        local_var_req_builder =
8780            local_var_req_builder.query(&[("limit", &local_var_str.to_string())]);
8781    }
8782    if let Some(ref local_var_str) = mode {
8783        local_var_req_builder = match "multi" {
8784            "multi" => local_var_req_builder.query(
8785                &local_var_str
8786                    .into_iter()
8787                    .map(|p| ("mode".to_owned(), p.to_string()))
8788                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8789            ),
8790            _ => local_var_req_builder.query(&[(
8791                "mode",
8792                &local_var_str
8793                    .into_iter()
8794                    .map(|p| p.to_string())
8795                    .collect::<Vec<String>>()
8796                    .join(",")
8797                    .to_string(),
8798            )]),
8799        };
8800    }
8801    if let Some(ref local_var_str) = mode__empty {
8802        local_var_req_builder =
8803            local_var_req_builder.query(&[("mode__empty", &local_var_str.to_string())]);
8804    }
8805    if let Some(ref local_var_str) = mode__ic {
8806        local_var_req_builder = match "multi" {
8807            "multi" => local_var_req_builder.query(
8808                &local_var_str
8809                    .into_iter()
8810                    .map(|p| ("mode__ic".to_owned(), p.to_string()))
8811                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8812            ),
8813            _ => local_var_req_builder.query(&[(
8814                "mode__ic",
8815                &local_var_str
8816                    .into_iter()
8817                    .map(|p| p.to_string())
8818                    .collect::<Vec<String>>()
8819                    .join(",")
8820                    .to_string(),
8821            )]),
8822        };
8823    }
8824    if let Some(ref local_var_str) = mode__ie {
8825        local_var_req_builder = match "multi" {
8826            "multi" => local_var_req_builder.query(
8827                &local_var_str
8828                    .into_iter()
8829                    .map(|p| ("mode__ie".to_owned(), p.to_string()))
8830                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8831            ),
8832            _ => local_var_req_builder.query(&[(
8833                "mode__ie",
8834                &local_var_str
8835                    .into_iter()
8836                    .map(|p| p.to_string())
8837                    .collect::<Vec<String>>()
8838                    .join(",")
8839                    .to_string(),
8840            )]),
8841        };
8842    }
8843    if let Some(ref local_var_str) = mode__iew {
8844        local_var_req_builder = match "multi" {
8845            "multi" => local_var_req_builder.query(
8846                &local_var_str
8847                    .into_iter()
8848                    .map(|p| ("mode__iew".to_owned(), p.to_string()))
8849                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8850            ),
8851            _ => local_var_req_builder.query(&[(
8852                "mode__iew",
8853                &local_var_str
8854                    .into_iter()
8855                    .map(|p| p.to_string())
8856                    .collect::<Vec<String>>()
8857                    .join(",")
8858                    .to_string(),
8859            )]),
8860        };
8861    }
8862    if let Some(ref local_var_str) = mode__iregex {
8863        local_var_req_builder = match "multi" {
8864            "multi" => local_var_req_builder.query(
8865                &local_var_str
8866                    .into_iter()
8867                    .map(|p| ("mode__iregex".to_owned(), p.to_string()))
8868                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8869            ),
8870            _ => local_var_req_builder.query(&[(
8871                "mode__iregex",
8872                &local_var_str
8873                    .into_iter()
8874                    .map(|p| p.to_string())
8875                    .collect::<Vec<String>>()
8876                    .join(",")
8877                    .to_string(),
8878            )]),
8879        };
8880    }
8881    if let Some(ref local_var_str) = mode__isw {
8882        local_var_req_builder = match "multi" {
8883            "multi" => local_var_req_builder.query(
8884                &local_var_str
8885                    .into_iter()
8886                    .map(|p| ("mode__isw".to_owned(), p.to_string()))
8887                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8888            ),
8889            _ => local_var_req_builder.query(&[(
8890                "mode__isw",
8891                &local_var_str
8892                    .into_iter()
8893                    .map(|p| p.to_string())
8894                    .collect::<Vec<String>>()
8895                    .join(",")
8896                    .to_string(),
8897            )]),
8898        };
8899    }
8900    if let Some(ref local_var_str) = mode__n {
8901        local_var_req_builder = match "multi" {
8902            "multi" => local_var_req_builder.query(
8903                &local_var_str
8904                    .into_iter()
8905                    .map(|p| ("mode__n".to_owned(), p.to_string()))
8906                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8907            ),
8908            _ => local_var_req_builder.query(&[(
8909                "mode__n",
8910                &local_var_str
8911                    .into_iter()
8912                    .map(|p| p.to_string())
8913                    .collect::<Vec<String>>()
8914                    .join(",")
8915                    .to_string(),
8916            )]),
8917        };
8918    }
8919    if let Some(ref local_var_str) = mode__nic {
8920        local_var_req_builder = match "multi" {
8921            "multi" => local_var_req_builder.query(
8922                &local_var_str
8923                    .into_iter()
8924                    .map(|p| ("mode__nic".to_owned(), p.to_string()))
8925                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8926            ),
8927            _ => local_var_req_builder.query(&[(
8928                "mode__nic",
8929                &local_var_str
8930                    .into_iter()
8931                    .map(|p| p.to_string())
8932                    .collect::<Vec<String>>()
8933                    .join(",")
8934                    .to_string(),
8935            )]),
8936        };
8937    }
8938    if let Some(ref local_var_str) = mode__nie {
8939        local_var_req_builder = match "multi" {
8940            "multi" => local_var_req_builder.query(
8941                &local_var_str
8942                    .into_iter()
8943                    .map(|p| ("mode__nie".to_owned(), p.to_string()))
8944                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8945            ),
8946            _ => local_var_req_builder.query(&[(
8947                "mode__nie",
8948                &local_var_str
8949                    .into_iter()
8950                    .map(|p| p.to_string())
8951                    .collect::<Vec<String>>()
8952                    .join(",")
8953                    .to_string(),
8954            )]),
8955        };
8956    }
8957    if let Some(ref local_var_str) = mode__niew {
8958        local_var_req_builder = match "multi" {
8959            "multi" => local_var_req_builder.query(
8960                &local_var_str
8961                    .into_iter()
8962                    .map(|p| ("mode__niew".to_owned(), p.to_string()))
8963                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8964            ),
8965            _ => local_var_req_builder.query(&[(
8966                "mode__niew",
8967                &local_var_str
8968                    .into_iter()
8969                    .map(|p| p.to_string())
8970                    .collect::<Vec<String>>()
8971                    .join(",")
8972                    .to_string(),
8973            )]),
8974        };
8975    }
8976    if let Some(ref local_var_str) = mode__nisw {
8977        local_var_req_builder = match "multi" {
8978            "multi" => local_var_req_builder.query(
8979                &local_var_str
8980                    .into_iter()
8981                    .map(|p| ("mode__nisw".to_owned(), p.to_string()))
8982                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8983            ),
8984            _ => local_var_req_builder.query(&[(
8985                "mode__nisw",
8986                &local_var_str
8987                    .into_iter()
8988                    .map(|p| p.to_string())
8989                    .collect::<Vec<String>>()
8990                    .join(",")
8991                    .to_string(),
8992            )]),
8993        };
8994    }
8995    if let Some(ref local_var_str) = mode__regex {
8996        local_var_req_builder = match "multi" {
8997            "multi" => local_var_req_builder.query(
8998                &local_var_str
8999                    .into_iter()
9000                    .map(|p| ("mode__regex".to_owned(), p.to_string()))
9001                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9002            ),
9003            _ => local_var_req_builder.query(&[(
9004                "mode__regex",
9005                &local_var_str
9006                    .into_iter()
9007                    .map(|p| p.to_string())
9008                    .collect::<Vec<String>>()
9009                    .join(",")
9010                    .to_string(),
9011            )]),
9012        };
9013    }
9014    if let Some(ref local_var_str) = modified_by_request {
9015        local_var_req_builder =
9016            local_var_req_builder.query(&[("modified_by_request", &local_var_str.to_string())]);
9017    }
9018    if let Some(ref local_var_str) = name {
9019        local_var_req_builder = match "multi" {
9020            "multi" => local_var_req_builder.query(
9021                &local_var_str
9022                    .into_iter()
9023                    .map(|p| ("name".to_owned(), p.to_string()))
9024                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9025            ),
9026            _ => local_var_req_builder.query(&[(
9027                "name",
9028                &local_var_str
9029                    .into_iter()
9030                    .map(|p| p.to_string())
9031                    .collect::<Vec<String>>()
9032                    .join(",")
9033                    .to_string(),
9034            )]),
9035        };
9036    }
9037    if let Some(ref local_var_str) = name__empty {
9038        local_var_req_builder =
9039            local_var_req_builder.query(&[("name__empty", &local_var_str.to_string())]);
9040    }
9041    if let Some(ref local_var_str) = name__ic {
9042        local_var_req_builder = match "multi" {
9043            "multi" => local_var_req_builder.query(
9044                &local_var_str
9045                    .into_iter()
9046                    .map(|p| ("name__ic".to_owned(), p.to_string()))
9047                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9048            ),
9049            _ => local_var_req_builder.query(&[(
9050                "name__ic",
9051                &local_var_str
9052                    .into_iter()
9053                    .map(|p| p.to_string())
9054                    .collect::<Vec<String>>()
9055                    .join(",")
9056                    .to_string(),
9057            )]),
9058        };
9059    }
9060    if let Some(ref local_var_str) = name__ie {
9061        local_var_req_builder = match "multi" {
9062            "multi" => local_var_req_builder.query(
9063                &local_var_str
9064                    .into_iter()
9065                    .map(|p| ("name__ie".to_owned(), p.to_string()))
9066                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9067            ),
9068            _ => local_var_req_builder.query(&[(
9069                "name__ie",
9070                &local_var_str
9071                    .into_iter()
9072                    .map(|p| p.to_string())
9073                    .collect::<Vec<String>>()
9074                    .join(",")
9075                    .to_string(),
9076            )]),
9077        };
9078    }
9079    if let Some(ref local_var_str) = name__iew {
9080        local_var_req_builder = match "multi" {
9081            "multi" => local_var_req_builder.query(
9082                &local_var_str
9083                    .into_iter()
9084                    .map(|p| ("name__iew".to_owned(), p.to_string()))
9085                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9086            ),
9087            _ => local_var_req_builder.query(&[(
9088                "name__iew",
9089                &local_var_str
9090                    .into_iter()
9091                    .map(|p| p.to_string())
9092                    .collect::<Vec<String>>()
9093                    .join(",")
9094                    .to_string(),
9095            )]),
9096        };
9097    }
9098    if let Some(ref local_var_str) = name__iregex {
9099        local_var_req_builder = match "multi" {
9100            "multi" => local_var_req_builder.query(
9101                &local_var_str
9102                    .into_iter()
9103                    .map(|p| ("name__iregex".to_owned(), p.to_string()))
9104                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9105            ),
9106            _ => local_var_req_builder.query(&[(
9107                "name__iregex",
9108                &local_var_str
9109                    .into_iter()
9110                    .map(|p| p.to_string())
9111                    .collect::<Vec<String>>()
9112                    .join(",")
9113                    .to_string(),
9114            )]),
9115        };
9116    }
9117    if let Some(ref local_var_str) = name__isw {
9118        local_var_req_builder = match "multi" {
9119            "multi" => local_var_req_builder.query(
9120                &local_var_str
9121                    .into_iter()
9122                    .map(|p| ("name__isw".to_owned(), p.to_string()))
9123                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9124            ),
9125            _ => local_var_req_builder.query(&[(
9126                "name__isw",
9127                &local_var_str
9128                    .into_iter()
9129                    .map(|p| p.to_string())
9130                    .collect::<Vec<String>>()
9131                    .join(",")
9132                    .to_string(),
9133            )]),
9134        };
9135    }
9136    if let Some(ref local_var_str) = name__n {
9137        local_var_req_builder = match "multi" {
9138            "multi" => local_var_req_builder.query(
9139                &local_var_str
9140                    .into_iter()
9141                    .map(|p| ("name__n".to_owned(), p.to_string()))
9142                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9143            ),
9144            _ => local_var_req_builder.query(&[(
9145                "name__n",
9146                &local_var_str
9147                    .into_iter()
9148                    .map(|p| p.to_string())
9149                    .collect::<Vec<String>>()
9150                    .join(",")
9151                    .to_string(),
9152            )]),
9153        };
9154    }
9155    if let Some(ref local_var_str) = name__nic {
9156        local_var_req_builder = match "multi" {
9157            "multi" => local_var_req_builder.query(
9158                &local_var_str
9159                    .into_iter()
9160                    .map(|p| ("name__nic".to_owned(), p.to_string()))
9161                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9162            ),
9163            _ => local_var_req_builder.query(&[(
9164                "name__nic",
9165                &local_var_str
9166                    .into_iter()
9167                    .map(|p| p.to_string())
9168                    .collect::<Vec<String>>()
9169                    .join(",")
9170                    .to_string(),
9171            )]),
9172        };
9173    }
9174    if let Some(ref local_var_str) = name__nie {
9175        local_var_req_builder = match "multi" {
9176            "multi" => local_var_req_builder.query(
9177                &local_var_str
9178                    .into_iter()
9179                    .map(|p| ("name__nie".to_owned(), p.to_string()))
9180                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9181            ),
9182            _ => local_var_req_builder.query(&[(
9183                "name__nie",
9184                &local_var_str
9185                    .into_iter()
9186                    .map(|p| p.to_string())
9187                    .collect::<Vec<String>>()
9188                    .join(",")
9189                    .to_string(),
9190            )]),
9191        };
9192    }
9193    if let Some(ref local_var_str) = name__niew {
9194        local_var_req_builder = match "multi" {
9195            "multi" => local_var_req_builder.query(
9196                &local_var_str
9197                    .into_iter()
9198                    .map(|p| ("name__niew".to_owned(), p.to_string()))
9199                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9200            ),
9201            _ => local_var_req_builder.query(&[(
9202                "name__niew",
9203                &local_var_str
9204                    .into_iter()
9205                    .map(|p| p.to_string())
9206                    .collect::<Vec<String>>()
9207                    .join(",")
9208                    .to_string(),
9209            )]),
9210        };
9211    }
9212    if let Some(ref local_var_str) = name__nisw {
9213        local_var_req_builder = match "multi" {
9214            "multi" => local_var_req_builder.query(
9215                &local_var_str
9216                    .into_iter()
9217                    .map(|p| ("name__nisw".to_owned(), p.to_string()))
9218                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9219            ),
9220            _ => local_var_req_builder.query(&[(
9221                "name__nisw",
9222                &local_var_str
9223                    .into_iter()
9224                    .map(|p| p.to_string())
9225                    .collect::<Vec<String>>()
9226                    .join(",")
9227                    .to_string(),
9228            )]),
9229        };
9230    }
9231    if let Some(ref local_var_str) = name__regex {
9232        local_var_req_builder = match "multi" {
9233            "multi" => local_var_req_builder.query(
9234                &local_var_str
9235                    .into_iter()
9236                    .map(|p| ("name__regex".to_owned(), p.to_string()))
9237                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9238            ),
9239            _ => local_var_req_builder.query(&[(
9240                "name__regex",
9241                &local_var_str
9242                    .into_iter()
9243                    .map(|p| p.to_string())
9244                    .collect::<Vec<String>>()
9245                    .join(",")
9246                    .to_string(),
9247            )]),
9248        };
9249    }
9250    if let Some(ref local_var_str) = offset {
9251        local_var_req_builder =
9252            local_var_req_builder.query(&[("offset", &local_var_str.to_string())]);
9253    }
9254    if let Some(ref local_var_str) = ordering {
9255        local_var_req_builder =
9256            local_var_req_builder.query(&[("ordering", &local_var_str.to_string())]);
9257    }
9258    if let Some(ref local_var_str) = owner {
9259        local_var_req_builder = match "multi" {
9260            "multi" => local_var_req_builder.query(
9261                &local_var_str
9262                    .into_iter()
9263                    .map(|p| ("owner".to_owned(), p.to_string()))
9264                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9265            ),
9266            _ => local_var_req_builder.query(&[(
9267                "owner",
9268                &local_var_str
9269                    .into_iter()
9270                    .map(|p| p.to_string())
9271                    .collect::<Vec<String>>()
9272                    .join(",")
9273                    .to_string(),
9274            )]),
9275        };
9276    }
9277    if let Some(ref local_var_str) = owner__n {
9278        local_var_req_builder = match "multi" {
9279            "multi" => local_var_req_builder.query(
9280                &local_var_str
9281                    .into_iter()
9282                    .map(|p| ("owner__n".to_owned(), p.to_string()))
9283                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9284            ),
9285            _ => local_var_req_builder.query(&[(
9286                "owner__n",
9287                &local_var_str
9288                    .into_iter()
9289                    .map(|p| p.to_string())
9290                    .collect::<Vec<String>>()
9291                    .join(",")
9292                    .to_string(),
9293            )]),
9294        };
9295    }
9296    if let Some(ref local_var_str) = owner_group {
9297        local_var_req_builder = match "multi" {
9298            "multi" => local_var_req_builder.query(
9299                &local_var_str
9300                    .into_iter()
9301                    .map(|p| ("owner_group".to_owned(), p.to_string()))
9302                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9303            ),
9304            _ => local_var_req_builder.query(&[(
9305                "owner_group",
9306                &local_var_str
9307                    .into_iter()
9308                    .map(|p| p.to_string())
9309                    .collect::<Vec<String>>()
9310                    .join(",")
9311                    .to_string(),
9312            )]),
9313        };
9314    }
9315    if let Some(ref local_var_str) = owner_group__n {
9316        local_var_req_builder = match "multi" {
9317            "multi" => local_var_req_builder.query(
9318                &local_var_str
9319                    .into_iter()
9320                    .map(|p| ("owner_group__n".to_owned(), p.to_string()))
9321                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9322            ),
9323            _ => local_var_req_builder.query(&[(
9324                "owner_group__n",
9325                &local_var_str
9326                    .into_iter()
9327                    .map(|p| p.to_string())
9328                    .collect::<Vec<String>>()
9329                    .join(",")
9330                    .to_string(),
9331            )]),
9332        };
9333    }
9334    if let Some(ref local_var_str) = owner_group_id {
9335        local_var_req_builder = match "multi" {
9336            "multi" => local_var_req_builder.query(
9337                &local_var_str
9338                    .into_iter()
9339                    .map(|p| ("owner_group_id".to_owned(), p.to_string()))
9340                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9341            ),
9342            _ => local_var_req_builder.query(&[(
9343                "owner_group_id",
9344                &local_var_str
9345                    .into_iter()
9346                    .map(|p| p.to_string())
9347                    .collect::<Vec<String>>()
9348                    .join(",")
9349                    .to_string(),
9350            )]),
9351        };
9352    }
9353    if let Some(ref local_var_str) = owner_group_id__n {
9354        local_var_req_builder = match "multi" {
9355            "multi" => local_var_req_builder.query(
9356                &local_var_str
9357                    .into_iter()
9358                    .map(|p| ("owner_group_id__n".to_owned(), p.to_string()))
9359                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9360            ),
9361            _ => local_var_req_builder.query(&[(
9362                "owner_group_id__n",
9363                &local_var_str
9364                    .into_iter()
9365                    .map(|p| p.to_string())
9366                    .collect::<Vec<String>>()
9367                    .join(",")
9368                    .to_string(),
9369            )]),
9370        };
9371    }
9372    if let Some(ref local_var_str) = owner_id {
9373        local_var_req_builder = match "multi" {
9374            "multi" => local_var_req_builder.query(
9375                &local_var_str
9376                    .into_iter()
9377                    .map(|p| ("owner_id".to_owned(), p.to_string()))
9378                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9379            ),
9380            _ => local_var_req_builder.query(&[(
9381                "owner_id",
9382                &local_var_str
9383                    .into_iter()
9384                    .map(|p| p.to_string())
9385                    .collect::<Vec<String>>()
9386                    .join(",")
9387                    .to_string(),
9388            )]),
9389        };
9390    }
9391    if let Some(ref local_var_str) = owner_id__n {
9392        local_var_req_builder = match "multi" {
9393            "multi" => local_var_req_builder.query(
9394                &local_var_str
9395                    .into_iter()
9396                    .map(|p| ("owner_id__n".to_owned(), p.to_string()))
9397                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9398            ),
9399            _ => local_var_req_builder.query(&[(
9400                "owner_id__n",
9401                &local_var_str
9402                    .into_iter()
9403                    .map(|p| p.to_string())
9404                    .collect::<Vec<String>>()
9405                    .join(",")
9406                    .to_string(),
9407            )]),
9408        };
9409    }
9410    if let Some(ref local_var_str) = q {
9411        local_var_req_builder = local_var_req_builder.query(&[("q", &local_var_str.to_string())]);
9412    }
9413    if let Some(ref local_var_str) = start {
9414        local_var_req_builder =
9415            local_var_req_builder.query(&[("start", &local_var_str.to_string())]);
9416    }
9417    if let Some(ref local_var_str) = tag {
9418        local_var_req_builder = match "multi" {
9419            "multi" => local_var_req_builder.query(
9420                &local_var_str
9421                    .into_iter()
9422                    .map(|p| ("tag".to_owned(), p.to_string()))
9423                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9424            ),
9425            _ => local_var_req_builder.query(&[(
9426                "tag",
9427                &local_var_str
9428                    .into_iter()
9429                    .map(|p| p.to_string())
9430                    .collect::<Vec<String>>()
9431                    .join(",")
9432                    .to_string(),
9433            )]),
9434        };
9435    }
9436    if let Some(ref local_var_str) = tag__n {
9437        local_var_req_builder = match "multi" {
9438            "multi" => local_var_req_builder.query(
9439                &local_var_str
9440                    .into_iter()
9441                    .map(|p| ("tag__n".to_owned(), p.to_string()))
9442                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9443            ),
9444            _ => local_var_req_builder.query(&[(
9445                "tag__n",
9446                &local_var_str
9447                    .into_iter()
9448                    .map(|p| p.to_string())
9449                    .collect::<Vec<String>>()
9450                    .join(",")
9451                    .to_string(),
9452            )]),
9453        };
9454    }
9455    if let Some(ref local_var_str) = tag_id {
9456        local_var_req_builder = match "multi" {
9457            "multi" => local_var_req_builder.query(
9458                &local_var_str
9459                    .into_iter()
9460                    .map(|p| ("tag_id".to_owned(), p.to_string()))
9461                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9462            ),
9463            _ => local_var_req_builder.query(&[(
9464                "tag_id",
9465                &local_var_str
9466                    .into_iter()
9467                    .map(|p| p.to_string())
9468                    .collect::<Vec<String>>()
9469                    .join(",")
9470                    .to_string(),
9471            )]),
9472        };
9473    }
9474    if let Some(ref local_var_str) = tag_id__n {
9475        local_var_req_builder = match "multi" {
9476            "multi" => local_var_req_builder.query(
9477                &local_var_str
9478                    .into_iter()
9479                    .map(|p| ("tag_id__n".to_owned(), p.to_string()))
9480                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9481            ),
9482            _ => local_var_req_builder.query(&[(
9483                "tag_id__n",
9484                &local_var_str
9485                    .into_iter()
9486                    .map(|p| p.to_string())
9487                    .collect::<Vec<String>>()
9488                    .join(",")
9489                    .to_string(),
9490            )]),
9491        };
9492    }
9493    if let Some(ref local_var_str) = updated_by_request {
9494        local_var_req_builder =
9495            local_var_req_builder.query(&[("updated_by_request", &local_var_str.to_string())]);
9496    }
9497    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
9498        local_var_req_builder =
9499            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
9500    }
9501    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
9502        let local_var_key = local_var_apikey.key.clone();
9503        let local_var_value = match local_var_apikey.prefix {
9504            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
9505            None => local_var_key,
9506        };
9507        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
9508    };
9509
9510    let local_var_req = local_var_req_builder.build()?;
9511    let local_var_resp = local_var_client.execute(local_var_req).await?;
9512
9513    let local_var_status = local_var_resp.status();
9514    let local_var_content = local_var_resp.text().await?;
9515
9516    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
9517        serde_json::from_str(&local_var_content).map_err(Error::from)
9518    } else {
9519        let local_var_entity: Option<VpnIpsecProfilesListError> =
9520            serde_json::from_str(&local_var_content).ok();
9521        let local_var_error = ResponseContent {
9522            status: local_var_status,
9523            content: local_var_content,
9524            entity: local_var_entity,
9525        };
9526        Err(Error::ResponseError(local_var_error))
9527    }
9528}
9529
9530/// Patch a IPSec profile object.
9531pub async fn vpn_ipsec_profiles_partial_update(
9532    configuration: &configuration::Configuration,
9533    id: i32,
9534    patched_writable_ip_sec_profile_request: Option<
9535        crate::models::PatchedWritableIpSecProfileRequest,
9536    >,
9537) -> Result<crate::models::IpSecProfile, Error<VpnIpsecProfilesPartialUpdateError>> {
9538    let local_var_configuration = configuration;
9539
9540    let local_var_client = &local_var_configuration.client;
9541
9542    let local_var_uri_str = format!(
9543        "{}/api/vpn/ipsec-profiles/{id}/",
9544        local_var_configuration.base_path,
9545        id = id
9546    );
9547    let mut local_var_req_builder =
9548        local_var_client.request(reqwest::Method::PATCH, local_var_uri_str.as_str());
9549
9550    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
9551        local_var_req_builder =
9552            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
9553    }
9554    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
9555        let local_var_key = local_var_apikey.key.clone();
9556        let local_var_value = match local_var_apikey.prefix {
9557            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
9558            None => local_var_key,
9559        };
9560        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
9561    };
9562    local_var_req_builder = local_var_req_builder.json(&patched_writable_ip_sec_profile_request);
9563
9564    let local_var_req = local_var_req_builder.build()?;
9565    let local_var_resp = local_var_client.execute(local_var_req).await?;
9566
9567    let local_var_status = local_var_resp.status();
9568    let local_var_content = local_var_resp.text().await?;
9569
9570    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
9571        serde_json::from_str(&local_var_content).map_err(Error::from)
9572    } else {
9573        let local_var_entity: Option<VpnIpsecProfilesPartialUpdateError> =
9574            serde_json::from_str(&local_var_content).ok();
9575        let local_var_error = ResponseContent {
9576            status: local_var_status,
9577            content: local_var_content,
9578            entity: local_var_entity,
9579        };
9580        Err(Error::ResponseError(local_var_error))
9581    }
9582}
9583
9584/// Get a IPSec profile object.
9585pub async fn vpn_ipsec_profiles_retrieve(
9586    configuration: &configuration::Configuration,
9587    id: i32,
9588) -> Result<crate::models::IpSecProfile, Error<VpnIpsecProfilesRetrieveError>> {
9589    let local_var_configuration = configuration;
9590
9591    let local_var_client = &local_var_configuration.client;
9592
9593    let local_var_uri_str = format!(
9594        "{}/api/vpn/ipsec-profiles/{id}/",
9595        local_var_configuration.base_path,
9596        id = id
9597    );
9598    let mut local_var_req_builder =
9599        local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
9600
9601    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
9602        local_var_req_builder =
9603            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
9604    }
9605    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
9606        let local_var_key = local_var_apikey.key.clone();
9607        let local_var_value = match local_var_apikey.prefix {
9608            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
9609            None => local_var_key,
9610        };
9611        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
9612    };
9613
9614    let local_var_req = local_var_req_builder.build()?;
9615    let local_var_resp = local_var_client.execute(local_var_req).await?;
9616
9617    let local_var_status = local_var_resp.status();
9618    let local_var_content = local_var_resp.text().await?;
9619
9620    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
9621        serde_json::from_str(&local_var_content).map_err(Error::from)
9622    } else {
9623        let local_var_entity: Option<VpnIpsecProfilesRetrieveError> =
9624            serde_json::from_str(&local_var_content).ok();
9625        let local_var_error = ResponseContent {
9626            status: local_var_status,
9627            content: local_var_content,
9628            entity: local_var_entity,
9629        };
9630        Err(Error::ResponseError(local_var_error))
9631    }
9632}
9633
9634/// Put a IPSec profile object.
9635pub async fn vpn_ipsec_profiles_update(
9636    configuration: &configuration::Configuration,
9637    id: i32,
9638    writable_ip_sec_profile_request: crate::models::WritableIpSecProfileRequest,
9639) -> Result<crate::models::IpSecProfile, Error<VpnIpsecProfilesUpdateError>> {
9640    let local_var_configuration = configuration;
9641
9642    let local_var_client = &local_var_configuration.client;
9643
9644    let local_var_uri_str = format!(
9645        "{}/api/vpn/ipsec-profiles/{id}/",
9646        local_var_configuration.base_path,
9647        id = id
9648    );
9649    let mut local_var_req_builder =
9650        local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());
9651
9652    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
9653        local_var_req_builder =
9654            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
9655    }
9656    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
9657        let local_var_key = local_var_apikey.key.clone();
9658        let local_var_value = match local_var_apikey.prefix {
9659            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
9660            None => local_var_key,
9661        };
9662        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
9663    };
9664    local_var_req_builder = local_var_req_builder.json(&writable_ip_sec_profile_request);
9665
9666    let local_var_req = local_var_req_builder.build()?;
9667    let local_var_resp = local_var_client.execute(local_var_req).await?;
9668
9669    let local_var_status = local_var_resp.status();
9670    let local_var_content = local_var_resp.text().await?;
9671
9672    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
9673        serde_json::from_str(&local_var_content).map_err(Error::from)
9674    } else {
9675        let local_var_entity: Option<VpnIpsecProfilesUpdateError> =
9676            serde_json::from_str(&local_var_content).ok();
9677        let local_var_error = ResponseContent {
9678            status: local_var_status,
9679            content: local_var_content,
9680            entity: local_var_entity,
9681        };
9682        Err(Error::ResponseError(local_var_error))
9683    }
9684}
9685
9686/// Delete a list of IPSec proposal objects.
9687pub async fn vpn_ipsec_proposals_bulk_destroy(
9688    configuration: &configuration::Configuration,
9689    ip_sec_proposal_request: Vec<crate::models::IpSecProposalRequest>,
9690) -> Result<(), Error<VpnIpsecProposalsBulkDestroyError>> {
9691    let local_var_configuration = configuration;
9692
9693    let local_var_client = &local_var_configuration.client;
9694
9695    let local_var_uri_str = format!(
9696        "{}/api/vpn/ipsec-proposals/",
9697        local_var_configuration.base_path
9698    );
9699    let mut local_var_req_builder =
9700        local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());
9701
9702    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
9703        local_var_req_builder =
9704            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
9705    }
9706    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
9707        let local_var_key = local_var_apikey.key.clone();
9708        let local_var_value = match local_var_apikey.prefix {
9709            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
9710            None => local_var_key,
9711        };
9712        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
9713    };
9714    local_var_req_builder = local_var_req_builder.json(&ip_sec_proposal_request);
9715
9716    let local_var_req = local_var_req_builder.build()?;
9717    let local_var_resp = local_var_client.execute(local_var_req).await?;
9718
9719    let local_var_status = local_var_resp.status();
9720    let local_var_content = local_var_resp.text().await?;
9721
9722    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
9723        Ok(())
9724    } else {
9725        let local_var_entity: Option<VpnIpsecProposalsBulkDestroyError> =
9726            serde_json::from_str(&local_var_content).ok();
9727        let local_var_error = ResponseContent {
9728            status: local_var_status,
9729            content: local_var_content,
9730            entity: local_var_entity,
9731        };
9732        Err(Error::ResponseError(local_var_error))
9733    }
9734}
9735
9736/// Patch a list of IPSec proposal objects.
9737pub async fn vpn_ipsec_proposals_bulk_partial_update(
9738    configuration: &configuration::Configuration,
9739    ip_sec_proposal_request: Vec<crate::models::IpSecProposalRequest>,
9740) -> Result<Vec<crate::models::IpSecProposal>, Error<VpnIpsecProposalsBulkPartialUpdateError>> {
9741    let local_var_configuration = configuration;
9742
9743    let local_var_client = &local_var_configuration.client;
9744
9745    let local_var_uri_str = format!(
9746        "{}/api/vpn/ipsec-proposals/",
9747        local_var_configuration.base_path
9748    );
9749    let mut local_var_req_builder =
9750        local_var_client.request(reqwest::Method::PATCH, local_var_uri_str.as_str());
9751
9752    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
9753        local_var_req_builder =
9754            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
9755    }
9756    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
9757        let local_var_key = local_var_apikey.key.clone();
9758        let local_var_value = match local_var_apikey.prefix {
9759            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
9760            None => local_var_key,
9761        };
9762        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
9763    };
9764    local_var_req_builder = local_var_req_builder.json(&ip_sec_proposal_request);
9765
9766    let local_var_req = local_var_req_builder.build()?;
9767    let local_var_resp = local_var_client.execute(local_var_req).await?;
9768
9769    let local_var_status = local_var_resp.status();
9770    let local_var_content = local_var_resp.text().await?;
9771
9772    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
9773        serde_json::from_str(&local_var_content).map_err(Error::from)
9774    } else {
9775        let local_var_entity: Option<VpnIpsecProposalsBulkPartialUpdateError> =
9776            serde_json::from_str(&local_var_content).ok();
9777        let local_var_error = ResponseContent {
9778            status: local_var_status,
9779            content: local_var_content,
9780            entity: local_var_entity,
9781        };
9782        Err(Error::ResponseError(local_var_error))
9783    }
9784}
9785
9786/// Put a list of IPSec proposal objects.
9787pub async fn vpn_ipsec_proposals_bulk_update(
9788    configuration: &configuration::Configuration,
9789    ip_sec_proposal_request: Vec<crate::models::IpSecProposalRequest>,
9790) -> Result<Vec<crate::models::IpSecProposal>, Error<VpnIpsecProposalsBulkUpdateError>> {
9791    let local_var_configuration = configuration;
9792
9793    let local_var_client = &local_var_configuration.client;
9794
9795    let local_var_uri_str = format!(
9796        "{}/api/vpn/ipsec-proposals/",
9797        local_var_configuration.base_path
9798    );
9799    let mut local_var_req_builder =
9800        local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());
9801
9802    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
9803        local_var_req_builder =
9804            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
9805    }
9806    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
9807        let local_var_key = local_var_apikey.key.clone();
9808        let local_var_value = match local_var_apikey.prefix {
9809            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
9810            None => local_var_key,
9811        };
9812        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
9813    };
9814    local_var_req_builder = local_var_req_builder.json(&ip_sec_proposal_request);
9815
9816    let local_var_req = local_var_req_builder.build()?;
9817    let local_var_resp = local_var_client.execute(local_var_req).await?;
9818
9819    let local_var_status = local_var_resp.status();
9820    let local_var_content = local_var_resp.text().await?;
9821
9822    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
9823        serde_json::from_str(&local_var_content).map_err(Error::from)
9824    } else {
9825        let local_var_entity: Option<VpnIpsecProposalsBulkUpdateError> =
9826            serde_json::from_str(&local_var_content).ok();
9827        let local_var_error = ResponseContent {
9828            status: local_var_status,
9829            content: local_var_content,
9830            entity: local_var_entity,
9831        };
9832        Err(Error::ResponseError(local_var_error))
9833    }
9834}
9835
9836/// Post a list of IPSec proposal objects.
9837pub async fn vpn_ipsec_proposals_create(
9838    configuration: &configuration::Configuration,
9839    vpn_ipsec_proposals_create_request: crate::models::VpnIpsecProposalsCreateRequest,
9840) -> Result<crate::models::IpSecProposal, Error<VpnIpsecProposalsCreateError>> {
9841    let local_var_configuration = configuration;
9842
9843    let local_var_client = &local_var_configuration.client;
9844
9845    let local_var_uri_str = format!(
9846        "{}/api/vpn/ipsec-proposals/",
9847        local_var_configuration.base_path
9848    );
9849    let mut local_var_req_builder =
9850        local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
9851
9852    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
9853        local_var_req_builder =
9854            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
9855    }
9856    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
9857        let local_var_key = local_var_apikey.key.clone();
9858        let local_var_value = match local_var_apikey.prefix {
9859            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
9860            None => local_var_key,
9861        };
9862        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
9863    };
9864    local_var_req_builder = local_var_req_builder.json(&vpn_ipsec_proposals_create_request);
9865
9866    let local_var_req = local_var_req_builder.build()?;
9867    let local_var_resp = local_var_client.execute(local_var_req).await?;
9868
9869    let local_var_status = local_var_resp.status();
9870    let local_var_content = local_var_resp.text().await?;
9871
9872    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
9873        serde_json::from_str(&local_var_content).map_err(Error::from)
9874    } else {
9875        let local_var_entity: Option<VpnIpsecProposalsCreateError> =
9876            serde_json::from_str(&local_var_content).ok();
9877        let local_var_error = ResponseContent {
9878            status: local_var_status,
9879            content: local_var_content,
9880            entity: local_var_entity,
9881        };
9882        Err(Error::ResponseError(local_var_error))
9883    }
9884}
9885
9886/// Delete a IPSec proposal object.
9887pub async fn vpn_ipsec_proposals_destroy(
9888    configuration: &configuration::Configuration,
9889    id: i32,
9890) -> Result<(), Error<VpnIpsecProposalsDestroyError>> {
9891    let local_var_configuration = configuration;
9892
9893    let local_var_client = &local_var_configuration.client;
9894
9895    let local_var_uri_str = format!(
9896        "{}/api/vpn/ipsec-proposals/{id}/",
9897        local_var_configuration.base_path,
9898        id = id
9899    );
9900    let mut local_var_req_builder =
9901        local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());
9902
9903    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
9904        local_var_req_builder =
9905            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
9906    }
9907    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
9908        let local_var_key = local_var_apikey.key.clone();
9909        let local_var_value = match local_var_apikey.prefix {
9910            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
9911            None => local_var_key,
9912        };
9913        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
9914    };
9915
9916    let local_var_req = local_var_req_builder.build()?;
9917    let local_var_resp = local_var_client.execute(local_var_req).await?;
9918
9919    let local_var_status = local_var_resp.status();
9920    let local_var_content = local_var_resp.text().await?;
9921
9922    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
9923        Ok(())
9924    } else {
9925        let local_var_entity: Option<VpnIpsecProposalsDestroyError> =
9926            serde_json::from_str(&local_var_content).ok();
9927        let local_var_error = ResponseContent {
9928            status: local_var_status,
9929            content: local_var_content,
9930            entity: local_var_entity,
9931        };
9932        Err(Error::ResponseError(local_var_error))
9933    }
9934}
9935
9936/// Get a list of IPSec proposal objects.
9937pub async fn vpn_ipsec_proposals_list(
9938    configuration: &configuration::Configuration,
9939    authentication_algorithm: Option<Vec<String>>,
9940    authentication_algorithm__empty: Option<bool>,
9941    authentication_algorithm__ic: Option<Vec<String>>,
9942    authentication_algorithm__ie: Option<Vec<String>>,
9943    authentication_algorithm__iew: Option<Vec<String>>,
9944    authentication_algorithm__iregex: Option<Vec<String>>,
9945    authentication_algorithm__isw: Option<Vec<String>>,
9946    authentication_algorithm__n: Option<Vec<String>>,
9947    authentication_algorithm__nic: Option<Vec<String>>,
9948    authentication_algorithm__nie: Option<Vec<String>>,
9949    authentication_algorithm__niew: Option<Vec<String>>,
9950    authentication_algorithm__nisw: Option<Vec<String>>,
9951    authentication_algorithm__regex: Option<Vec<String>>,
9952    created: Option<Vec<String>>,
9953    created__empty: Option<Vec<String>>,
9954    created__gt: Option<Vec<String>>,
9955    created__gte: Option<Vec<String>>,
9956    created__lt: Option<Vec<String>>,
9957    created__lte: Option<Vec<String>>,
9958    created__n: Option<Vec<String>>,
9959    created_by_request: Option<&str>,
9960    description: Option<Vec<String>>,
9961    description__empty: Option<bool>,
9962    description__ic: Option<Vec<String>>,
9963    description__ie: Option<Vec<String>>,
9964    description__iew: Option<Vec<String>>,
9965    description__iregex: Option<Vec<String>>,
9966    description__isw: Option<Vec<String>>,
9967    description__n: Option<Vec<String>>,
9968    description__nic: Option<Vec<String>>,
9969    description__nie: Option<Vec<String>>,
9970    description__niew: Option<Vec<String>>,
9971    description__nisw: Option<Vec<String>>,
9972    description__regex: Option<Vec<String>>,
9973    encryption_algorithm: Option<Vec<String>>,
9974    encryption_algorithm__empty: Option<bool>,
9975    encryption_algorithm__ic: Option<Vec<String>>,
9976    encryption_algorithm__ie: Option<Vec<String>>,
9977    encryption_algorithm__iew: Option<Vec<String>>,
9978    encryption_algorithm__iregex: Option<Vec<String>>,
9979    encryption_algorithm__isw: Option<Vec<String>>,
9980    encryption_algorithm__n: Option<Vec<String>>,
9981    encryption_algorithm__nic: Option<Vec<String>>,
9982    encryption_algorithm__nie: Option<Vec<String>>,
9983    encryption_algorithm__niew: Option<Vec<String>>,
9984    encryption_algorithm__nisw: Option<Vec<String>>,
9985    encryption_algorithm__regex: Option<Vec<String>>,
9986    id: Option<Vec<i32>>,
9987    id__empty: Option<bool>,
9988    id__gt: Option<Vec<i32>>,
9989    id__gte: Option<Vec<i32>>,
9990    id__lt: Option<Vec<i32>>,
9991    id__lte: Option<Vec<i32>>,
9992    id__n: Option<Vec<i32>>,
9993    ipsec_policy: Option<Vec<String>>,
9994    ipsec_policy__n: Option<Vec<String>>,
9995    ipsec_policy_id: Option<Vec<i32>>,
9996    ipsec_policy_id__n: Option<Vec<i32>>,
9997    last_updated: Option<Vec<String>>,
9998    last_updated__empty: Option<Vec<String>>,
9999    last_updated__gt: Option<Vec<String>>,
10000    last_updated__gte: Option<Vec<String>>,
10001    last_updated__lt: Option<Vec<String>>,
10002    last_updated__lte: Option<Vec<String>>,
10003    last_updated__n: Option<Vec<String>>,
10004    limit: Option<i32>,
10005    modified_by_request: Option<&str>,
10006    name: Option<Vec<String>>,
10007    name__empty: Option<bool>,
10008    name__ic: Option<Vec<String>>,
10009    name__ie: Option<Vec<String>>,
10010    name__iew: Option<Vec<String>>,
10011    name__iregex: Option<Vec<String>>,
10012    name__isw: Option<Vec<String>>,
10013    name__n: Option<Vec<String>>,
10014    name__nic: Option<Vec<String>>,
10015    name__nie: Option<Vec<String>>,
10016    name__niew: Option<Vec<String>>,
10017    name__nisw: Option<Vec<String>>,
10018    name__regex: Option<Vec<String>>,
10019    offset: Option<i32>,
10020    ordering: Option<&str>,
10021    owner: Option<Vec<String>>,
10022    owner__n: Option<Vec<String>>,
10023    owner_group: Option<Vec<String>>,
10024    owner_group__n: Option<Vec<String>>,
10025    owner_group_id: Option<Vec<i32>>,
10026    owner_group_id__n: Option<Vec<i32>>,
10027    owner_id: Option<Vec<i32>>,
10028    owner_id__n: Option<Vec<i32>>,
10029    q: Option<&str>,
10030    sa_lifetime_data: Option<Vec<i32>>,
10031    sa_lifetime_data__empty: Option<bool>,
10032    sa_lifetime_data__gt: Option<Vec<i32>>,
10033    sa_lifetime_data__gte: Option<Vec<i32>>,
10034    sa_lifetime_data__lt: Option<Vec<i32>>,
10035    sa_lifetime_data__lte: Option<Vec<i32>>,
10036    sa_lifetime_data__n: Option<Vec<i32>>,
10037    sa_lifetime_seconds: Option<Vec<i32>>,
10038    sa_lifetime_seconds__empty: Option<bool>,
10039    sa_lifetime_seconds__gt: Option<Vec<i32>>,
10040    sa_lifetime_seconds__gte: Option<Vec<i32>>,
10041    sa_lifetime_seconds__lt: Option<Vec<i32>>,
10042    sa_lifetime_seconds__lte: Option<Vec<i32>>,
10043    sa_lifetime_seconds__n: Option<Vec<i32>>,
10044    start: Option<i32>,
10045    tag: Option<Vec<String>>,
10046    tag__n: Option<Vec<String>>,
10047    tag_id: Option<Vec<i32>>,
10048    tag_id__n: Option<Vec<i32>>,
10049    updated_by_request: Option<&str>,
10050) -> Result<crate::models::PaginatedIpSecProposalList, Error<VpnIpsecProposalsListError>> {
10051    let local_var_configuration = configuration;
10052
10053    let local_var_client = &local_var_configuration.client;
10054
10055    let local_var_uri_str = format!(
10056        "{}/api/vpn/ipsec-proposals/",
10057        local_var_configuration.base_path
10058    );
10059    let mut local_var_req_builder =
10060        local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
10061
10062    if let Some(ref local_var_str) = authentication_algorithm {
10063        local_var_req_builder = match "multi" {
10064            "multi" => local_var_req_builder.query(
10065                &local_var_str
10066                    .into_iter()
10067                    .map(|p| ("authentication_algorithm".to_owned(), p.to_string()))
10068                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10069            ),
10070            _ => local_var_req_builder.query(&[(
10071                "authentication_algorithm",
10072                &local_var_str
10073                    .into_iter()
10074                    .map(|p| p.to_string())
10075                    .collect::<Vec<String>>()
10076                    .join(",")
10077                    .to_string(),
10078            )]),
10079        };
10080    }
10081    if let Some(ref local_var_str) = authentication_algorithm__empty {
10082        local_var_req_builder = local_var_req_builder.query(&[(
10083            "authentication_algorithm__empty",
10084            &local_var_str.to_string(),
10085        )]);
10086    }
10087    if let Some(ref local_var_str) = authentication_algorithm__ic {
10088        local_var_req_builder = match "multi" {
10089            "multi" => local_var_req_builder.query(
10090                &local_var_str
10091                    .into_iter()
10092                    .map(|p| ("authentication_algorithm__ic".to_owned(), p.to_string()))
10093                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10094            ),
10095            _ => local_var_req_builder.query(&[(
10096                "authentication_algorithm__ic",
10097                &local_var_str
10098                    .into_iter()
10099                    .map(|p| p.to_string())
10100                    .collect::<Vec<String>>()
10101                    .join(",")
10102                    .to_string(),
10103            )]),
10104        };
10105    }
10106    if let Some(ref local_var_str) = authentication_algorithm__ie {
10107        local_var_req_builder = match "multi" {
10108            "multi" => local_var_req_builder.query(
10109                &local_var_str
10110                    .into_iter()
10111                    .map(|p| ("authentication_algorithm__ie".to_owned(), p.to_string()))
10112                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10113            ),
10114            _ => local_var_req_builder.query(&[(
10115                "authentication_algorithm__ie",
10116                &local_var_str
10117                    .into_iter()
10118                    .map(|p| p.to_string())
10119                    .collect::<Vec<String>>()
10120                    .join(",")
10121                    .to_string(),
10122            )]),
10123        };
10124    }
10125    if let Some(ref local_var_str) = authentication_algorithm__iew {
10126        local_var_req_builder = match "multi" {
10127            "multi" => local_var_req_builder.query(
10128                &local_var_str
10129                    .into_iter()
10130                    .map(|p| ("authentication_algorithm__iew".to_owned(), p.to_string()))
10131                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10132            ),
10133            _ => local_var_req_builder.query(&[(
10134                "authentication_algorithm__iew",
10135                &local_var_str
10136                    .into_iter()
10137                    .map(|p| p.to_string())
10138                    .collect::<Vec<String>>()
10139                    .join(",")
10140                    .to_string(),
10141            )]),
10142        };
10143    }
10144    if let Some(ref local_var_str) = authentication_algorithm__iregex {
10145        local_var_req_builder = match "multi" {
10146            "multi" => local_var_req_builder.query(
10147                &local_var_str
10148                    .into_iter()
10149                    .map(|p| ("authentication_algorithm__iregex".to_owned(), p.to_string()))
10150                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10151            ),
10152            _ => local_var_req_builder.query(&[(
10153                "authentication_algorithm__iregex",
10154                &local_var_str
10155                    .into_iter()
10156                    .map(|p| p.to_string())
10157                    .collect::<Vec<String>>()
10158                    .join(",")
10159                    .to_string(),
10160            )]),
10161        };
10162    }
10163    if let Some(ref local_var_str) = authentication_algorithm__isw {
10164        local_var_req_builder = match "multi" {
10165            "multi" => local_var_req_builder.query(
10166                &local_var_str
10167                    .into_iter()
10168                    .map(|p| ("authentication_algorithm__isw".to_owned(), p.to_string()))
10169                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10170            ),
10171            _ => local_var_req_builder.query(&[(
10172                "authentication_algorithm__isw",
10173                &local_var_str
10174                    .into_iter()
10175                    .map(|p| p.to_string())
10176                    .collect::<Vec<String>>()
10177                    .join(",")
10178                    .to_string(),
10179            )]),
10180        };
10181    }
10182    if let Some(ref local_var_str) = authentication_algorithm__n {
10183        local_var_req_builder = match "multi" {
10184            "multi" => local_var_req_builder.query(
10185                &local_var_str
10186                    .into_iter()
10187                    .map(|p| ("authentication_algorithm__n".to_owned(), p.to_string()))
10188                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10189            ),
10190            _ => local_var_req_builder.query(&[(
10191                "authentication_algorithm__n",
10192                &local_var_str
10193                    .into_iter()
10194                    .map(|p| p.to_string())
10195                    .collect::<Vec<String>>()
10196                    .join(",")
10197                    .to_string(),
10198            )]),
10199        };
10200    }
10201    if let Some(ref local_var_str) = authentication_algorithm__nic {
10202        local_var_req_builder = match "multi" {
10203            "multi" => local_var_req_builder.query(
10204                &local_var_str
10205                    .into_iter()
10206                    .map(|p| ("authentication_algorithm__nic".to_owned(), p.to_string()))
10207                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10208            ),
10209            _ => local_var_req_builder.query(&[(
10210                "authentication_algorithm__nic",
10211                &local_var_str
10212                    .into_iter()
10213                    .map(|p| p.to_string())
10214                    .collect::<Vec<String>>()
10215                    .join(",")
10216                    .to_string(),
10217            )]),
10218        };
10219    }
10220    if let Some(ref local_var_str) = authentication_algorithm__nie {
10221        local_var_req_builder = match "multi" {
10222            "multi" => local_var_req_builder.query(
10223                &local_var_str
10224                    .into_iter()
10225                    .map(|p| ("authentication_algorithm__nie".to_owned(), p.to_string()))
10226                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10227            ),
10228            _ => local_var_req_builder.query(&[(
10229                "authentication_algorithm__nie",
10230                &local_var_str
10231                    .into_iter()
10232                    .map(|p| p.to_string())
10233                    .collect::<Vec<String>>()
10234                    .join(",")
10235                    .to_string(),
10236            )]),
10237        };
10238    }
10239    if let Some(ref local_var_str) = authentication_algorithm__niew {
10240        local_var_req_builder = match "multi" {
10241            "multi" => local_var_req_builder.query(
10242                &local_var_str
10243                    .into_iter()
10244                    .map(|p| ("authentication_algorithm__niew".to_owned(), p.to_string()))
10245                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10246            ),
10247            _ => local_var_req_builder.query(&[(
10248                "authentication_algorithm__niew",
10249                &local_var_str
10250                    .into_iter()
10251                    .map(|p| p.to_string())
10252                    .collect::<Vec<String>>()
10253                    .join(",")
10254                    .to_string(),
10255            )]),
10256        };
10257    }
10258    if let Some(ref local_var_str) = authentication_algorithm__nisw {
10259        local_var_req_builder = match "multi" {
10260            "multi" => local_var_req_builder.query(
10261                &local_var_str
10262                    .into_iter()
10263                    .map(|p| ("authentication_algorithm__nisw".to_owned(), p.to_string()))
10264                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10265            ),
10266            _ => local_var_req_builder.query(&[(
10267                "authentication_algorithm__nisw",
10268                &local_var_str
10269                    .into_iter()
10270                    .map(|p| p.to_string())
10271                    .collect::<Vec<String>>()
10272                    .join(",")
10273                    .to_string(),
10274            )]),
10275        };
10276    }
10277    if let Some(ref local_var_str) = authentication_algorithm__regex {
10278        local_var_req_builder = match "multi" {
10279            "multi" => local_var_req_builder.query(
10280                &local_var_str
10281                    .into_iter()
10282                    .map(|p| ("authentication_algorithm__regex".to_owned(), p.to_string()))
10283                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10284            ),
10285            _ => local_var_req_builder.query(&[(
10286                "authentication_algorithm__regex",
10287                &local_var_str
10288                    .into_iter()
10289                    .map(|p| p.to_string())
10290                    .collect::<Vec<String>>()
10291                    .join(",")
10292                    .to_string(),
10293            )]),
10294        };
10295    }
10296    if let Some(ref local_var_str) = created {
10297        local_var_req_builder = match "multi" {
10298            "multi" => local_var_req_builder.query(
10299                &local_var_str
10300                    .into_iter()
10301                    .map(|p| ("created".to_owned(), p.to_string()))
10302                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10303            ),
10304            _ => local_var_req_builder.query(&[(
10305                "created",
10306                &local_var_str
10307                    .into_iter()
10308                    .map(|p| p.to_string())
10309                    .collect::<Vec<String>>()
10310                    .join(",")
10311                    .to_string(),
10312            )]),
10313        };
10314    }
10315    if let Some(ref local_var_str) = created__empty {
10316        local_var_req_builder = match "multi" {
10317            "multi" => local_var_req_builder.query(
10318                &local_var_str
10319                    .into_iter()
10320                    .map(|p| ("created__empty".to_owned(), p.to_string()))
10321                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10322            ),
10323            _ => local_var_req_builder.query(&[(
10324                "created__empty",
10325                &local_var_str
10326                    .into_iter()
10327                    .map(|p| p.to_string())
10328                    .collect::<Vec<String>>()
10329                    .join(",")
10330                    .to_string(),
10331            )]),
10332        };
10333    }
10334    if let Some(ref local_var_str) = created__gt {
10335        local_var_req_builder = match "multi" {
10336            "multi" => local_var_req_builder.query(
10337                &local_var_str
10338                    .into_iter()
10339                    .map(|p| ("created__gt".to_owned(), p.to_string()))
10340                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10341            ),
10342            _ => local_var_req_builder.query(&[(
10343                "created__gt",
10344                &local_var_str
10345                    .into_iter()
10346                    .map(|p| p.to_string())
10347                    .collect::<Vec<String>>()
10348                    .join(",")
10349                    .to_string(),
10350            )]),
10351        };
10352    }
10353    if let Some(ref local_var_str) = created__gte {
10354        local_var_req_builder = match "multi" {
10355            "multi" => local_var_req_builder.query(
10356                &local_var_str
10357                    .into_iter()
10358                    .map(|p| ("created__gte".to_owned(), p.to_string()))
10359                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10360            ),
10361            _ => local_var_req_builder.query(&[(
10362                "created__gte",
10363                &local_var_str
10364                    .into_iter()
10365                    .map(|p| p.to_string())
10366                    .collect::<Vec<String>>()
10367                    .join(",")
10368                    .to_string(),
10369            )]),
10370        };
10371    }
10372    if let Some(ref local_var_str) = created__lt {
10373        local_var_req_builder = match "multi" {
10374            "multi" => local_var_req_builder.query(
10375                &local_var_str
10376                    .into_iter()
10377                    .map(|p| ("created__lt".to_owned(), p.to_string()))
10378                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10379            ),
10380            _ => local_var_req_builder.query(&[(
10381                "created__lt",
10382                &local_var_str
10383                    .into_iter()
10384                    .map(|p| p.to_string())
10385                    .collect::<Vec<String>>()
10386                    .join(",")
10387                    .to_string(),
10388            )]),
10389        };
10390    }
10391    if let Some(ref local_var_str) = created__lte {
10392        local_var_req_builder = match "multi" {
10393            "multi" => local_var_req_builder.query(
10394                &local_var_str
10395                    .into_iter()
10396                    .map(|p| ("created__lte".to_owned(), p.to_string()))
10397                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10398            ),
10399            _ => local_var_req_builder.query(&[(
10400                "created__lte",
10401                &local_var_str
10402                    .into_iter()
10403                    .map(|p| p.to_string())
10404                    .collect::<Vec<String>>()
10405                    .join(",")
10406                    .to_string(),
10407            )]),
10408        };
10409    }
10410    if let Some(ref local_var_str) = created__n {
10411        local_var_req_builder = match "multi" {
10412            "multi" => local_var_req_builder.query(
10413                &local_var_str
10414                    .into_iter()
10415                    .map(|p| ("created__n".to_owned(), p.to_string()))
10416                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10417            ),
10418            _ => local_var_req_builder.query(&[(
10419                "created__n",
10420                &local_var_str
10421                    .into_iter()
10422                    .map(|p| p.to_string())
10423                    .collect::<Vec<String>>()
10424                    .join(",")
10425                    .to_string(),
10426            )]),
10427        };
10428    }
10429    if let Some(ref local_var_str) = created_by_request {
10430        local_var_req_builder =
10431            local_var_req_builder.query(&[("created_by_request", &local_var_str.to_string())]);
10432    }
10433    if let Some(ref local_var_str) = description {
10434        local_var_req_builder = match "multi" {
10435            "multi" => local_var_req_builder.query(
10436                &local_var_str
10437                    .into_iter()
10438                    .map(|p| ("description".to_owned(), p.to_string()))
10439                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10440            ),
10441            _ => local_var_req_builder.query(&[(
10442                "description",
10443                &local_var_str
10444                    .into_iter()
10445                    .map(|p| p.to_string())
10446                    .collect::<Vec<String>>()
10447                    .join(",")
10448                    .to_string(),
10449            )]),
10450        };
10451    }
10452    if let Some(ref local_var_str) = description__empty {
10453        local_var_req_builder =
10454            local_var_req_builder.query(&[("description__empty", &local_var_str.to_string())]);
10455    }
10456    if let Some(ref local_var_str) = description__ic {
10457        local_var_req_builder = match "multi" {
10458            "multi" => local_var_req_builder.query(
10459                &local_var_str
10460                    .into_iter()
10461                    .map(|p| ("description__ic".to_owned(), p.to_string()))
10462                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10463            ),
10464            _ => local_var_req_builder.query(&[(
10465                "description__ic",
10466                &local_var_str
10467                    .into_iter()
10468                    .map(|p| p.to_string())
10469                    .collect::<Vec<String>>()
10470                    .join(",")
10471                    .to_string(),
10472            )]),
10473        };
10474    }
10475    if let Some(ref local_var_str) = description__ie {
10476        local_var_req_builder = match "multi" {
10477            "multi" => local_var_req_builder.query(
10478                &local_var_str
10479                    .into_iter()
10480                    .map(|p| ("description__ie".to_owned(), p.to_string()))
10481                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10482            ),
10483            _ => local_var_req_builder.query(&[(
10484                "description__ie",
10485                &local_var_str
10486                    .into_iter()
10487                    .map(|p| p.to_string())
10488                    .collect::<Vec<String>>()
10489                    .join(",")
10490                    .to_string(),
10491            )]),
10492        };
10493    }
10494    if let Some(ref local_var_str) = description__iew {
10495        local_var_req_builder = match "multi" {
10496            "multi" => local_var_req_builder.query(
10497                &local_var_str
10498                    .into_iter()
10499                    .map(|p| ("description__iew".to_owned(), p.to_string()))
10500                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10501            ),
10502            _ => local_var_req_builder.query(&[(
10503                "description__iew",
10504                &local_var_str
10505                    .into_iter()
10506                    .map(|p| p.to_string())
10507                    .collect::<Vec<String>>()
10508                    .join(",")
10509                    .to_string(),
10510            )]),
10511        };
10512    }
10513    if let Some(ref local_var_str) = description__iregex {
10514        local_var_req_builder = match "multi" {
10515            "multi" => local_var_req_builder.query(
10516                &local_var_str
10517                    .into_iter()
10518                    .map(|p| ("description__iregex".to_owned(), p.to_string()))
10519                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10520            ),
10521            _ => local_var_req_builder.query(&[(
10522                "description__iregex",
10523                &local_var_str
10524                    .into_iter()
10525                    .map(|p| p.to_string())
10526                    .collect::<Vec<String>>()
10527                    .join(",")
10528                    .to_string(),
10529            )]),
10530        };
10531    }
10532    if let Some(ref local_var_str) = description__isw {
10533        local_var_req_builder = match "multi" {
10534            "multi" => local_var_req_builder.query(
10535                &local_var_str
10536                    .into_iter()
10537                    .map(|p| ("description__isw".to_owned(), p.to_string()))
10538                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10539            ),
10540            _ => local_var_req_builder.query(&[(
10541                "description__isw",
10542                &local_var_str
10543                    .into_iter()
10544                    .map(|p| p.to_string())
10545                    .collect::<Vec<String>>()
10546                    .join(",")
10547                    .to_string(),
10548            )]),
10549        };
10550    }
10551    if let Some(ref local_var_str) = description__n {
10552        local_var_req_builder = match "multi" {
10553            "multi" => local_var_req_builder.query(
10554                &local_var_str
10555                    .into_iter()
10556                    .map(|p| ("description__n".to_owned(), p.to_string()))
10557                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10558            ),
10559            _ => local_var_req_builder.query(&[(
10560                "description__n",
10561                &local_var_str
10562                    .into_iter()
10563                    .map(|p| p.to_string())
10564                    .collect::<Vec<String>>()
10565                    .join(",")
10566                    .to_string(),
10567            )]),
10568        };
10569    }
10570    if let Some(ref local_var_str) = description__nic {
10571        local_var_req_builder = match "multi" {
10572            "multi" => local_var_req_builder.query(
10573                &local_var_str
10574                    .into_iter()
10575                    .map(|p| ("description__nic".to_owned(), p.to_string()))
10576                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10577            ),
10578            _ => local_var_req_builder.query(&[(
10579                "description__nic",
10580                &local_var_str
10581                    .into_iter()
10582                    .map(|p| p.to_string())
10583                    .collect::<Vec<String>>()
10584                    .join(",")
10585                    .to_string(),
10586            )]),
10587        };
10588    }
10589    if let Some(ref local_var_str) = description__nie {
10590        local_var_req_builder = match "multi" {
10591            "multi" => local_var_req_builder.query(
10592                &local_var_str
10593                    .into_iter()
10594                    .map(|p| ("description__nie".to_owned(), p.to_string()))
10595                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10596            ),
10597            _ => local_var_req_builder.query(&[(
10598                "description__nie",
10599                &local_var_str
10600                    .into_iter()
10601                    .map(|p| p.to_string())
10602                    .collect::<Vec<String>>()
10603                    .join(",")
10604                    .to_string(),
10605            )]),
10606        };
10607    }
10608    if let Some(ref local_var_str) = description__niew {
10609        local_var_req_builder = match "multi" {
10610            "multi" => local_var_req_builder.query(
10611                &local_var_str
10612                    .into_iter()
10613                    .map(|p| ("description__niew".to_owned(), p.to_string()))
10614                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10615            ),
10616            _ => local_var_req_builder.query(&[(
10617                "description__niew",
10618                &local_var_str
10619                    .into_iter()
10620                    .map(|p| p.to_string())
10621                    .collect::<Vec<String>>()
10622                    .join(",")
10623                    .to_string(),
10624            )]),
10625        };
10626    }
10627    if let Some(ref local_var_str) = description__nisw {
10628        local_var_req_builder = match "multi" {
10629            "multi" => local_var_req_builder.query(
10630                &local_var_str
10631                    .into_iter()
10632                    .map(|p| ("description__nisw".to_owned(), p.to_string()))
10633                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10634            ),
10635            _ => local_var_req_builder.query(&[(
10636                "description__nisw",
10637                &local_var_str
10638                    .into_iter()
10639                    .map(|p| p.to_string())
10640                    .collect::<Vec<String>>()
10641                    .join(",")
10642                    .to_string(),
10643            )]),
10644        };
10645    }
10646    if let Some(ref local_var_str) = description__regex {
10647        local_var_req_builder = match "multi" {
10648            "multi" => local_var_req_builder.query(
10649                &local_var_str
10650                    .into_iter()
10651                    .map(|p| ("description__regex".to_owned(), p.to_string()))
10652                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10653            ),
10654            _ => local_var_req_builder.query(&[(
10655                "description__regex",
10656                &local_var_str
10657                    .into_iter()
10658                    .map(|p| p.to_string())
10659                    .collect::<Vec<String>>()
10660                    .join(",")
10661                    .to_string(),
10662            )]),
10663        };
10664    }
10665    if let Some(ref local_var_str) = encryption_algorithm {
10666        local_var_req_builder = match "multi" {
10667            "multi" => local_var_req_builder.query(
10668                &local_var_str
10669                    .into_iter()
10670                    .map(|p| ("encryption_algorithm".to_owned(), p.to_string()))
10671                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10672            ),
10673            _ => local_var_req_builder.query(&[(
10674                "encryption_algorithm",
10675                &local_var_str
10676                    .into_iter()
10677                    .map(|p| p.to_string())
10678                    .collect::<Vec<String>>()
10679                    .join(",")
10680                    .to_string(),
10681            )]),
10682        };
10683    }
10684    if let Some(ref local_var_str) = encryption_algorithm__empty {
10685        local_var_req_builder = local_var_req_builder
10686            .query(&[("encryption_algorithm__empty", &local_var_str.to_string())]);
10687    }
10688    if let Some(ref local_var_str) = encryption_algorithm__ic {
10689        local_var_req_builder = match "multi" {
10690            "multi" => local_var_req_builder.query(
10691                &local_var_str
10692                    .into_iter()
10693                    .map(|p| ("encryption_algorithm__ic".to_owned(), p.to_string()))
10694                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10695            ),
10696            _ => local_var_req_builder.query(&[(
10697                "encryption_algorithm__ic",
10698                &local_var_str
10699                    .into_iter()
10700                    .map(|p| p.to_string())
10701                    .collect::<Vec<String>>()
10702                    .join(",")
10703                    .to_string(),
10704            )]),
10705        };
10706    }
10707    if let Some(ref local_var_str) = encryption_algorithm__ie {
10708        local_var_req_builder = match "multi" {
10709            "multi" => local_var_req_builder.query(
10710                &local_var_str
10711                    .into_iter()
10712                    .map(|p| ("encryption_algorithm__ie".to_owned(), p.to_string()))
10713                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10714            ),
10715            _ => local_var_req_builder.query(&[(
10716                "encryption_algorithm__ie",
10717                &local_var_str
10718                    .into_iter()
10719                    .map(|p| p.to_string())
10720                    .collect::<Vec<String>>()
10721                    .join(",")
10722                    .to_string(),
10723            )]),
10724        };
10725    }
10726    if let Some(ref local_var_str) = encryption_algorithm__iew {
10727        local_var_req_builder = match "multi" {
10728            "multi" => local_var_req_builder.query(
10729                &local_var_str
10730                    .into_iter()
10731                    .map(|p| ("encryption_algorithm__iew".to_owned(), p.to_string()))
10732                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10733            ),
10734            _ => local_var_req_builder.query(&[(
10735                "encryption_algorithm__iew",
10736                &local_var_str
10737                    .into_iter()
10738                    .map(|p| p.to_string())
10739                    .collect::<Vec<String>>()
10740                    .join(",")
10741                    .to_string(),
10742            )]),
10743        };
10744    }
10745    if let Some(ref local_var_str) = encryption_algorithm__iregex {
10746        local_var_req_builder = match "multi" {
10747            "multi" => local_var_req_builder.query(
10748                &local_var_str
10749                    .into_iter()
10750                    .map(|p| ("encryption_algorithm__iregex".to_owned(), p.to_string()))
10751                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10752            ),
10753            _ => local_var_req_builder.query(&[(
10754                "encryption_algorithm__iregex",
10755                &local_var_str
10756                    .into_iter()
10757                    .map(|p| p.to_string())
10758                    .collect::<Vec<String>>()
10759                    .join(",")
10760                    .to_string(),
10761            )]),
10762        };
10763    }
10764    if let Some(ref local_var_str) = encryption_algorithm__isw {
10765        local_var_req_builder = match "multi" {
10766            "multi" => local_var_req_builder.query(
10767                &local_var_str
10768                    .into_iter()
10769                    .map(|p| ("encryption_algorithm__isw".to_owned(), p.to_string()))
10770                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10771            ),
10772            _ => local_var_req_builder.query(&[(
10773                "encryption_algorithm__isw",
10774                &local_var_str
10775                    .into_iter()
10776                    .map(|p| p.to_string())
10777                    .collect::<Vec<String>>()
10778                    .join(",")
10779                    .to_string(),
10780            )]),
10781        };
10782    }
10783    if let Some(ref local_var_str) = encryption_algorithm__n {
10784        local_var_req_builder = match "multi" {
10785            "multi" => local_var_req_builder.query(
10786                &local_var_str
10787                    .into_iter()
10788                    .map(|p| ("encryption_algorithm__n".to_owned(), p.to_string()))
10789                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10790            ),
10791            _ => local_var_req_builder.query(&[(
10792                "encryption_algorithm__n",
10793                &local_var_str
10794                    .into_iter()
10795                    .map(|p| p.to_string())
10796                    .collect::<Vec<String>>()
10797                    .join(",")
10798                    .to_string(),
10799            )]),
10800        };
10801    }
10802    if let Some(ref local_var_str) = encryption_algorithm__nic {
10803        local_var_req_builder = match "multi" {
10804            "multi" => local_var_req_builder.query(
10805                &local_var_str
10806                    .into_iter()
10807                    .map(|p| ("encryption_algorithm__nic".to_owned(), p.to_string()))
10808                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10809            ),
10810            _ => local_var_req_builder.query(&[(
10811                "encryption_algorithm__nic",
10812                &local_var_str
10813                    .into_iter()
10814                    .map(|p| p.to_string())
10815                    .collect::<Vec<String>>()
10816                    .join(",")
10817                    .to_string(),
10818            )]),
10819        };
10820    }
10821    if let Some(ref local_var_str) = encryption_algorithm__nie {
10822        local_var_req_builder = match "multi" {
10823            "multi" => local_var_req_builder.query(
10824                &local_var_str
10825                    .into_iter()
10826                    .map(|p| ("encryption_algorithm__nie".to_owned(), p.to_string()))
10827                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10828            ),
10829            _ => local_var_req_builder.query(&[(
10830                "encryption_algorithm__nie",
10831                &local_var_str
10832                    .into_iter()
10833                    .map(|p| p.to_string())
10834                    .collect::<Vec<String>>()
10835                    .join(",")
10836                    .to_string(),
10837            )]),
10838        };
10839    }
10840    if let Some(ref local_var_str) = encryption_algorithm__niew {
10841        local_var_req_builder = match "multi" {
10842            "multi" => local_var_req_builder.query(
10843                &local_var_str
10844                    .into_iter()
10845                    .map(|p| ("encryption_algorithm__niew".to_owned(), p.to_string()))
10846                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10847            ),
10848            _ => local_var_req_builder.query(&[(
10849                "encryption_algorithm__niew",
10850                &local_var_str
10851                    .into_iter()
10852                    .map(|p| p.to_string())
10853                    .collect::<Vec<String>>()
10854                    .join(",")
10855                    .to_string(),
10856            )]),
10857        };
10858    }
10859    if let Some(ref local_var_str) = encryption_algorithm__nisw {
10860        local_var_req_builder = match "multi" {
10861            "multi" => local_var_req_builder.query(
10862                &local_var_str
10863                    .into_iter()
10864                    .map(|p| ("encryption_algorithm__nisw".to_owned(), p.to_string()))
10865                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10866            ),
10867            _ => local_var_req_builder.query(&[(
10868                "encryption_algorithm__nisw",
10869                &local_var_str
10870                    .into_iter()
10871                    .map(|p| p.to_string())
10872                    .collect::<Vec<String>>()
10873                    .join(",")
10874                    .to_string(),
10875            )]),
10876        };
10877    }
10878    if let Some(ref local_var_str) = encryption_algorithm__regex {
10879        local_var_req_builder = match "multi" {
10880            "multi" => local_var_req_builder.query(
10881                &local_var_str
10882                    .into_iter()
10883                    .map(|p| ("encryption_algorithm__regex".to_owned(), p.to_string()))
10884                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10885            ),
10886            _ => local_var_req_builder.query(&[(
10887                "encryption_algorithm__regex",
10888                &local_var_str
10889                    .into_iter()
10890                    .map(|p| p.to_string())
10891                    .collect::<Vec<String>>()
10892                    .join(",")
10893                    .to_string(),
10894            )]),
10895        };
10896    }
10897    if let Some(ref local_var_str) = id {
10898        local_var_req_builder = match "multi" {
10899            "multi" => local_var_req_builder.query(
10900                &local_var_str
10901                    .into_iter()
10902                    .map(|p| ("id".to_owned(), p.to_string()))
10903                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10904            ),
10905            _ => local_var_req_builder.query(&[(
10906                "id",
10907                &local_var_str
10908                    .into_iter()
10909                    .map(|p| p.to_string())
10910                    .collect::<Vec<String>>()
10911                    .join(",")
10912                    .to_string(),
10913            )]),
10914        };
10915    }
10916    if let Some(ref local_var_str) = id__empty {
10917        local_var_req_builder =
10918            local_var_req_builder.query(&[("id__empty", &local_var_str.to_string())]);
10919    }
10920    if let Some(ref local_var_str) = id__gt {
10921        local_var_req_builder = match "multi" {
10922            "multi" => local_var_req_builder.query(
10923                &local_var_str
10924                    .into_iter()
10925                    .map(|p| ("id__gt".to_owned(), p.to_string()))
10926                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10927            ),
10928            _ => local_var_req_builder.query(&[(
10929                "id__gt",
10930                &local_var_str
10931                    .into_iter()
10932                    .map(|p| p.to_string())
10933                    .collect::<Vec<String>>()
10934                    .join(",")
10935                    .to_string(),
10936            )]),
10937        };
10938    }
10939    if let Some(ref local_var_str) = id__gte {
10940        local_var_req_builder = match "multi" {
10941            "multi" => local_var_req_builder.query(
10942                &local_var_str
10943                    .into_iter()
10944                    .map(|p| ("id__gte".to_owned(), p.to_string()))
10945                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10946            ),
10947            _ => local_var_req_builder.query(&[(
10948                "id__gte",
10949                &local_var_str
10950                    .into_iter()
10951                    .map(|p| p.to_string())
10952                    .collect::<Vec<String>>()
10953                    .join(",")
10954                    .to_string(),
10955            )]),
10956        };
10957    }
10958    if let Some(ref local_var_str) = id__lt {
10959        local_var_req_builder = match "multi" {
10960            "multi" => local_var_req_builder.query(
10961                &local_var_str
10962                    .into_iter()
10963                    .map(|p| ("id__lt".to_owned(), p.to_string()))
10964                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10965            ),
10966            _ => local_var_req_builder.query(&[(
10967                "id__lt",
10968                &local_var_str
10969                    .into_iter()
10970                    .map(|p| p.to_string())
10971                    .collect::<Vec<String>>()
10972                    .join(",")
10973                    .to_string(),
10974            )]),
10975        };
10976    }
10977    if let Some(ref local_var_str) = id__lte {
10978        local_var_req_builder = match "multi" {
10979            "multi" => local_var_req_builder.query(
10980                &local_var_str
10981                    .into_iter()
10982                    .map(|p| ("id__lte".to_owned(), p.to_string()))
10983                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10984            ),
10985            _ => local_var_req_builder.query(&[(
10986                "id__lte",
10987                &local_var_str
10988                    .into_iter()
10989                    .map(|p| p.to_string())
10990                    .collect::<Vec<String>>()
10991                    .join(",")
10992                    .to_string(),
10993            )]),
10994        };
10995    }
10996    if let Some(ref local_var_str) = id__n {
10997        local_var_req_builder = match "multi" {
10998            "multi" => local_var_req_builder.query(
10999                &local_var_str
11000                    .into_iter()
11001                    .map(|p| ("id__n".to_owned(), p.to_string()))
11002                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11003            ),
11004            _ => local_var_req_builder.query(&[(
11005                "id__n",
11006                &local_var_str
11007                    .into_iter()
11008                    .map(|p| p.to_string())
11009                    .collect::<Vec<String>>()
11010                    .join(",")
11011                    .to_string(),
11012            )]),
11013        };
11014    }
11015    if let Some(ref local_var_str) = ipsec_policy {
11016        local_var_req_builder = match "multi" {
11017            "multi" => local_var_req_builder.query(
11018                &local_var_str
11019                    .into_iter()
11020                    .map(|p| ("ipsec_policy".to_owned(), p.to_string()))
11021                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11022            ),
11023            _ => local_var_req_builder.query(&[(
11024                "ipsec_policy",
11025                &local_var_str
11026                    .into_iter()
11027                    .map(|p| p.to_string())
11028                    .collect::<Vec<String>>()
11029                    .join(",")
11030                    .to_string(),
11031            )]),
11032        };
11033    }
11034    if let Some(ref local_var_str) = ipsec_policy__n {
11035        local_var_req_builder = match "multi" {
11036            "multi" => local_var_req_builder.query(
11037                &local_var_str
11038                    .into_iter()
11039                    .map(|p| ("ipsec_policy__n".to_owned(), p.to_string()))
11040                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11041            ),
11042            _ => local_var_req_builder.query(&[(
11043                "ipsec_policy__n",
11044                &local_var_str
11045                    .into_iter()
11046                    .map(|p| p.to_string())
11047                    .collect::<Vec<String>>()
11048                    .join(",")
11049                    .to_string(),
11050            )]),
11051        };
11052    }
11053    if let Some(ref local_var_str) = ipsec_policy_id {
11054        local_var_req_builder = match "multi" {
11055            "multi" => local_var_req_builder.query(
11056                &local_var_str
11057                    .into_iter()
11058                    .map(|p| ("ipsec_policy_id".to_owned(), p.to_string()))
11059                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11060            ),
11061            _ => local_var_req_builder.query(&[(
11062                "ipsec_policy_id",
11063                &local_var_str
11064                    .into_iter()
11065                    .map(|p| p.to_string())
11066                    .collect::<Vec<String>>()
11067                    .join(",")
11068                    .to_string(),
11069            )]),
11070        };
11071    }
11072    if let Some(ref local_var_str) = ipsec_policy_id__n {
11073        local_var_req_builder = match "multi" {
11074            "multi" => local_var_req_builder.query(
11075                &local_var_str
11076                    .into_iter()
11077                    .map(|p| ("ipsec_policy_id__n".to_owned(), p.to_string()))
11078                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11079            ),
11080            _ => local_var_req_builder.query(&[(
11081                "ipsec_policy_id__n",
11082                &local_var_str
11083                    .into_iter()
11084                    .map(|p| p.to_string())
11085                    .collect::<Vec<String>>()
11086                    .join(",")
11087                    .to_string(),
11088            )]),
11089        };
11090    }
11091    if let Some(ref local_var_str) = last_updated {
11092        local_var_req_builder = match "multi" {
11093            "multi" => local_var_req_builder.query(
11094                &local_var_str
11095                    .into_iter()
11096                    .map(|p| ("last_updated".to_owned(), p.to_string()))
11097                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11098            ),
11099            _ => local_var_req_builder.query(&[(
11100                "last_updated",
11101                &local_var_str
11102                    .into_iter()
11103                    .map(|p| p.to_string())
11104                    .collect::<Vec<String>>()
11105                    .join(",")
11106                    .to_string(),
11107            )]),
11108        };
11109    }
11110    if let Some(ref local_var_str) = last_updated__empty {
11111        local_var_req_builder = match "multi" {
11112            "multi" => local_var_req_builder.query(
11113                &local_var_str
11114                    .into_iter()
11115                    .map(|p| ("last_updated__empty".to_owned(), p.to_string()))
11116                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11117            ),
11118            _ => local_var_req_builder.query(&[(
11119                "last_updated__empty",
11120                &local_var_str
11121                    .into_iter()
11122                    .map(|p| p.to_string())
11123                    .collect::<Vec<String>>()
11124                    .join(",")
11125                    .to_string(),
11126            )]),
11127        };
11128    }
11129    if let Some(ref local_var_str) = last_updated__gt {
11130        local_var_req_builder = match "multi" {
11131            "multi" => local_var_req_builder.query(
11132                &local_var_str
11133                    .into_iter()
11134                    .map(|p| ("last_updated__gt".to_owned(), p.to_string()))
11135                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11136            ),
11137            _ => local_var_req_builder.query(&[(
11138                "last_updated__gt",
11139                &local_var_str
11140                    .into_iter()
11141                    .map(|p| p.to_string())
11142                    .collect::<Vec<String>>()
11143                    .join(",")
11144                    .to_string(),
11145            )]),
11146        };
11147    }
11148    if let Some(ref local_var_str) = last_updated__gte {
11149        local_var_req_builder = match "multi" {
11150            "multi" => local_var_req_builder.query(
11151                &local_var_str
11152                    .into_iter()
11153                    .map(|p| ("last_updated__gte".to_owned(), p.to_string()))
11154                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11155            ),
11156            _ => local_var_req_builder.query(&[(
11157                "last_updated__gte",
11158                &local_var_str
11159                    .into_iter()
11160                    .map(|p| p.to_string())
11161                    .collect::<Vec<String>>()
11162                    .join(",")
11163                    .to_string(),
11164            )]),
11165        };
11166    }
11167    if let Some(ref local_var_str) = last_updated__lt {
11168        local_var_req_builder = match "multi" {
11169            "multi" => local_var_req_builder.query(
11170                &local_var_str
11171                    .into_iter()
11172                    .map(|p| ("last_updated__lt".to_owned(), p.to_string()))
11173                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11174            ),
11175            _ => local_var_req_builder.query(&[(
11176                "last_updated__lt",
11177                &local_var_str
11178                    .into_iter()
11179                    .map(|p| p.to_string())
11180                    .collect::<Vec<String>>()
11181                    .join(",")
11182                    .to_string(),
11183            )]),
11184        };
11185    }
11186    if let Some(ref local_var_str) = last_updated__lte {
11187        local_var_req_builder = match "multi" {
11188            "multi" => local_var_req_builder.query(
11189                &local_var_str
11190                    .into_iter()
11191                    .map(|p| ("last_updated__lte".to_owned(), p.to_string()))
11192                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11193            ),
11194            _ => local_var_req_builder.query(&[(
11195                "last_updated__lte",
11196                &local_var_str
11197                    .into_iter()
11198                    .map(|p| p.to_string())
11199                    .collect::<Vec<String>>()
11200                    .join(",")
11201                    .to_string(),
11202            )]),
11203        };
11204    }
11205    if let Some(ref local_var_str) = last_updated__n {
11206        local_var_req_builder = match "multi" {
11207            "multi" => local_var_req_builder.query(
11208                &local_var_str
11209                    .into_iter()
11210                    .map(|p| ("last_updated__n".to_owned(), p.to_string()))
11211                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11212            ),
11213            _ => local_var_req_builder.query(&[(
11214                "last_updated__n",
11215                &local_var_str
11216                    .into_iter()
11217                    .map(|p| p.to_string())
11218                    .collect::<Vec<String>>()
11219                    .join(",")
11220                    .to_string(),
11221            )]),
11222        };
11223    }
11224    if let Some(ref local_var_str) = limit {
11225        local_var_req_builder =
11226            local_var_req_builder.query(&[("limit", &local_var_str.to_string())]);
11227    }
11228    if let Some(ref local_var_str) = modified_by_request {
11229        local_var_req_builder =
11230            local_var_req_builder.query(&[("modified_by_request", &local_var_str.to_string())]);
11231    }
11232    if let Some(ref local_var_str) = name {
11233        local_var_req_builder = match "multi" {
11234            "multi" => local_var_req_builder.query(
11235                &local_var_str
11236                    .into_iter()
11237                    .map(|p| ("name".to_owned(), p.to_string()))
11238                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11239            ),
11240            _ => local_var_req_builder.query(&[(
11241                "name",
11242                &local_var_str
11243                    .into_iter()
11244                    .map(|p| p.to_string())
11245                    .collect::<Vec<String>>()
11246                    .join(",")
11247                    .to_string(),
11248            )]),
11249        };
11250    }
11251    if let Some(ref local_var_str) = name__empty {
11252        local_var_req_builder =
11253            local_var_req_builder.query(&[("name__empty", &local_var_str.to_string())]);
11254    }
11255    if let Some(ref local_var_str) = name__ic {
11256        local_var_req_builder = match "multi" {
11257            "multi" => local_var_req_builder.query(
11258                &local_var_str
11259                    .into_iter()
11260                    .map(|p| ("name__ic".to_owned(), p.to_string()))
11261                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11262            ),
11263            _ => local_var_req_builder.query(&[(
11264                "name__ic",
11265                &local_var_str
11266                    .into_iter()
11267                    .map(|p| p.to_string())
11268                    .collect::<Vec<String>>()
11269                    .join(",")
11270                    .to_string(),
11271            )]),
11272        };
11273    }
11274    if let Some(ref local_var_str) = name__ie {
11275        local_var_req_builder = match "multi" {
11276            "multi" => local_var_req_builder.query(
11277                &local_var_str
11278                    .into_iter()
11279                    .map(|p| ("name__ie".to_owned(), p.to_string()))
11280                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11281            ),
11282            _ => local_var_req_builder.query(&[(
11283                "name__ie",
11284                &local_var_str
11285                    .into_iter()
11286                    .map(|p| p.to_string())
11287                    .collect::<Vec<String>>()
11288                    .join(",")
11289                    .to_string(),
11290            )]),
11291        };
11292    }
11293    if let Some(ref local_var_str) = name__iew {
11294        local_var_req_builder = match "multi" {
11295            "multi" => local_var_req_builder.query(
11296                &local_var_str
11297                    .into_iter()
11298                    .map(|p| ("name__iew".to_owned(), p.to_string()))
11299                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11300            ),
11301            _ => local_var_req_builder.query(&[(
11302                "name__iew",
11303                &local_var_str
11304                    .into_iter()
11305                    .map(|p| p.to_string())
11306                    .collect::<Vec<String>>()
11307                    .join(",")
11308                    .to_string(),
11309            )]),
11310        };
11311    }
11312    if let Some(ref local_var_str) = name__iregex {
11313        local_var_req_builder = match "multi" {
11314            "multi" => local_var_req_builder.query(
11315                &local_var_str
11316                    .into_iter()
11317                    .map(|p| ("name__iregex".to_owned(), p.to_string()))
11318                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11319            ),
11320            _ => local_var_req_builder.query(&[(
11321                "name__iregex",
11322                &local_var_str
11323                    .into_iter()
11324                    .map(|p| p.to_string())
11325                    .collect::<Vec<String>>()
11326                    .join(",")
11327                    .to_string(),
11328            )]),
11329        };
11330    }
11331    if let Some(ref local_var_str) = name__isw {
11332        local_var_req_builder = match "multi" {
11333            "multi" => local_var_req_builder.query(
11334                &local_var_str
11335                    .into_iter()
11336                    .map(|p| ("name__isw".to_owned(), p.to_string()))
11337                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11338            ),
11339            _ => local_var_req_builder.query(&[(
11340                "name__isw",
11341                &local_var_str
11342                    .into_iter()
11343                    .map(|p| p.to_string())
11344                    .collect::<Vec<String>>()
11345                    .join(",")
11346                    .to_string(),
11347            )]),
11348        };
11349    }
11350    if let Some(ref local_var_str) = name__n {
11351        local_var_req_builder = match "multi" {
11352            "multi" => local_var_req_builder.query(
11353                &local_var_str
11354                    .into_iter()
11355                    .map(|p| ("name__n".to_owned(), p.to_string()))
11356                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11357            ),
11358            _ => local_var_req_builder.query(&[(
11359                "name__n",
11360                &local_var_str
11361                    .into_iter()
11362                    .map(|p| p.to_string())
11363                    .collect::<Vec<String>>()
11364                    .join(",")
11365                    .to_string(),
11366            )]),
11367        };
11368    }
11369    if let Some(ref local_var_str) = name__nic {
11370        local_var_req_builder = match "multi" {
11371            "multi" => local_var_req_builder.query(
11372                &local_var_str
11373                    .into_iter()
11374                    .map(|p| ("name__nic".to_owned(), p.to_string()))
11375                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11376            ),
11377            _ => local_var_req_builder.query(&[(
11378                "name__nic",
11379                &local_var_str
11380                    .into_iter()
11381                    .map(|p| p.to_string())
11382                    .collect::<Vec<String>>()
11383                    .join(",")
11384                    .to_string(),
11385            )]),
11386        };
11387    }
11388    if let Some(ref local_var_str) = name__nie {
11389        local_var_req_builder = match "multi" {
11390            "multi" => local_var_req_builder.query(
11391                &local_var_str
11392                    .into_iter()
11393                    .map(|p| ("name__nie".to_owned(), p.to_string()))
11394                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11395            ),
11396            _ => local_var_req_builder.query(&[(
11397                "name__nie",
11398                &local_var_str
11399                    .into_iter()
11400                    .map(|p| p.to_string())
11401                    .collect::<Vec<String>>()
11402                    .join(",")
11403                    .to_string(),
11404            )]),
11405        };
11406    }
11407    if let Some(ref local_var_str) = name__niew {
11408        local_var_req_builder = match "multi" {
11409            "multi" => local_var_req_builder.query(
11410                &local_var_str
11411                    .into_iter()
11412                    .map(|p| ("name__niew".to_owned(), p.to_string()))
11413                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11414            ),
11415            _ => local_var_req_builder.query(&[(
11416                "name__niew",
11417                &local_var_str
11418                    .into_iter()
11419                    .map(|p| p.to_string())
11420                    .collect::<Vec<String>>()
11421                    .join(",")
11422                    .to_string(),
11423            )]),
11424        };
11425    }
11426    if let Some(ref local_var_str) = name__nisw {
11427        local_var_req_builder = match "multi" {
11428            "multi" => local_var_req_builder.query(
11429                &local_var_str
11430                    .into_iter()
11431                    .map(|p| ("name__nisw".to_owned(), p.to_string()))
11432                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11433            ),
11434            _ => local_var_req_builder.query(&[(
11435                "name__nisw",
11436                &local_var_str
11437                    .into_iter()
11438                    .map(|p| p.to_string())
11439                    .collect::<Vec<String>>()
11440                    .join(",")
11441                    .to_string(),
11442            )]),
11443        };
11444    }
11445    if let Some(ref local_var_str) = name__regex {
11446        local_var_req_builder = match "multi" {
11447            "multi" => local_var_req_builder.query(
11448                &local_var_str
11449                    .into_iter()
11450                    .map(|p| ("name__regex".to_owned(), p.to_string()))
11451                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11452            ),
11453            _ => local_var_req_builder.query(&[(
11454                "name__regex",
11455                &local_var_str
11456                    .into_iter()
11457                    .map(|p| p.to_string())
11458                    .collect::<Vec<String>>()
11459                    .join(",")
11460                    .to_string(),
11461            )]),
11462        };
11463    }
11464    if let Some(ref local_var_str) = offset {
11465        local_var_req_builder =
11466            local_var_req_builder.query(&[("offset", &local_var_str.to_string())]);
11467    }
11468    if let Some(ref local_var_str) = ordering {
11469        local_var_req_builder =
11470            local_var_req_builder.query(&[("ordering", &local_var_str.to_string())]);
11471    }
11472    if let Some(ref local_var_str) = owner {
11473        local_var_req_builder = match "multi" {
11474            "multi" => local_var_req_builder.query(
11475                &local_var_str
11476                    .into_iter()
11477                    .map(|p| ("owner".to_owned(), p.to_string()))
11478                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11479            ),
11480            _ => local_var_req_builder.query(&[(
11481                "owner",
11482                &local_var_str
11483                    .into_iter()
11484                    .map(|p| p.to_string())
11485                    .collect::<Vec<String>>()
11486                    .join(",")
11487                    .to_string(),
11488            )]),
11489        };
11490    }
11491    if let Some(ref local_var_str) = owner__n {
11492        local_var_req_builder = match "multi" {
11493            "multi" => local_var_req_builder.query(
11494                &local_var_str
11495                    .into_iter()
11496                    .map(|p| ("owner__n".to_owned(), p.to_string()))
11497                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11498            ),
11499            _ => local_var_req_builder.query(&[(
11500                "owner__n",
11501                &local_var_str
11502                    .into_iter()
11503                    .map(|p| p.to_string())
11504                    .collect::<Vec<String>>()
11505                    .join(",")
11506                    .to_string(),
11507            )]),
11508        };
11509    }
11510    if let Some(ref local_var_str) = owner_group {
11511        local_var_req_builder = match "multi" {
11512            "multi" => local_var_req_builder.query(
11513                &local_var_str
11514                    .into_iter()
11515                    .map(|p| ("owner_group".to_owned(), p.to_string()))
11516                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11517            ),
11518            _ => local_var_req_builder.query(&[(
11519                "owner_group",
11520                &local_var_str
11521                    .into_iter()
11522                    .map(|p| p.to_string())
11523                    .collect::<Vec<String>>()
11524                    .join(",")
11525                    .to_string(),
11526            )]),
11527        };
11528    }
11529    if let Some(ref local_var_str) = owner_group__n {
11530        local_var_req_builder = match "multi" {
11531            "multi" => local_var_req_builder.query(
11532                &local_var_str
11533                    .into_iter()
11534                    .map(|p| ("owner_group__n".to_owned(), p.to_string()))
11535                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11536            ),
11537            _ => local_var_req_builder.query(&[(
11538                "owner_group__n",
11539                &local_var_str
11540                    .into_iter()
11541                    .map(|p| p.to_string())
11542                    .collect::<Vec<String>>()
11543                    .join(",")
11544                    .to_string(),
11545            )]),
11546        };
11547    }
11548    if let Some(ref local_var_str) = owner_group_id {
11549        local_var_req_builder = match "multi" {
11550            "multi" => local_var_req_builder.query(
11551                &local_var_str
11552                    .into_iter()
11553                    .map(|p| ("owner_group_id".to_owned(), p.to_string()))
11554                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11555            ),
11556            _ => local_var_req_builder.query(&[(
11557                "owner_group_id",
11558                &local_var_str
11559                    .into_iter()
11560                    .map(|p| p.to_string())
11561                    .collect::<Vec<String>>()
11562                    .join(",")
11563                    .to_string(),
11564            )]),
11565        };
11566    }
11567    if let Some(ref local_var_str) = owner_group_id__n {
11568        local_var_req_builder = match "multi" {
11569            "multi" => local_var_req_builder.query(
11570                &local_var_str
11571                    .into_iter()
11572                    .map(|p| ("owner_group_id__n".to_owned(), p.to_string()))
11573                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11574            ),
11575            _ => local_var_req_builder.query(&[(
11576                "owner_group_id__n",
11577                &local_var_str
11578                    .into_iter()
11579                    .map(|p| p.to_string())
11580                    .collect::<Vec<String>>()
11581                    .join(",")
11582                    .to_string(),
11583            )]),
11584        };
11585    }
11586    if let Some(ref local_var_str) = owner_id {
11587        local_var_req_builder = match "multi" {
11588            "multi" => local_var_req_builder.query(
11589                &local_var_str
11590                    .into_iter()
11591                    .map(|p| ("owner_id".to_owned(), p.to_string()))
11592                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11593            ),
11594            _ => local_var_req_builder.query(&[(
11595                "owner_id",
11596                &local_var_str
11597                    .into_iter()
11598                    .map(|p| p.to_string())
11599                    .collect::<Vec<String>>()
11600                    .join(",")
11601                    .to_string(),
11602            )]),
11603        };
11604    }
11605    if let Some(ref local_var_str) = owner_id__n {
11606        local_var_req_builder = match "multi" {
11607            "multi" => local_var_req_builder.query(
11608                &local_var_str
11609                    .into_iter()
11610                    .map(|p| ("owner_id__n".to_owned(), p.to_string()))
11611                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11612            ),
11613            _ => local_var_req_builder.query(&[(
11614                "owner_id__n",
11615                &local_var_str
11616                    .into_iter()
11617                    .map(|p| p.to_string())
11618                    .collect::<Vec<String>>()
11619                    .join(",")
11620                    .to_string(),
11621            )]),
11622        };
11623    }
11624    if let Some(ref local_var_str) = q {
11625        local_var_req_builder = local_var_req_builder.query(&[("q", &local_var_str.to_string())]);
11626    }
11627    if let Some(ref local_var_str) = sa_lifetime_data {
11628        local_var_req_builder = match "multi" {
11629            "multi" => local_var_req_builder.query(
11630                &local_var_str
11631                    .into_iter()
11632                    .map(|p| ("sa_lifetime_data".to_owned(), p.to_string()))
11633                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11634            ),
11635            _ => local_var_req_builder.query(&[(
11636                "sa_lifetime_data",
11637                &local_var_str
11638                    .into_iter()
11639                    .map(|p| p.to_string())
11640                    .collect::<Vec<String>>()
11641                    .join(",")
11642                    .to_string(),
11643            )]),
11644        };
11645    }
11646    if let Some(ref local_var_str) = sa_lifetime_data__empty {
11647        local_var_req_builder =
11648            local_var_req_builder.query(&[("sa_lifetime_data__empty", &local_var_str.to_string())]);
11649    }
11650    if let Some(ref local_var_str) = sa_lifetime_data__gt {
11651        local_var_req_builder = match "multi" {
11652            "multi" => local_var_req_builder.query(
11653                &local_var_str
11654                    .into_iter()
11655                    .map(|p| ("sa_lifetime_data__gt".to_owned(), p.to_string()))
11656                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11657            ),
11658            _ => local_var_req_builder.query(&[(
11659                "sa_lifetime_data__gt",
11660                &local_var_str
11661                    .into_iter()
11662                    .map(|p| p.to_string())
11663                    .collect::<Vec<String>>()
11664                    .join(",")
11665                    .to_string(),
11666            )]),
11667        };
11668    }
11669    if let Some(ref local_var_str) = sa_lifetime_data__gte {
11670        local_var_req_builder = match "multi" {
11671            "multi" => local_var_req_builder.query(
11672                &local_var_str
11673                    .into_iter()
11674                    .map(|p| ("sa_lifetime_data__gte".to_owned(), p.to_string()))
11675                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11676            ),
11677            _ => local_var_req_builder.query(&[(
11678                "sa_lifetime_data__gte",
11679                &local_var_str
11680                    .into_iter()
11681                    .map(|p| p.to_string())
11682                    .collect::<Vec<String>>()
11683                    .join(",")
11684                    .to_string(),
11685            )]),
11686        };
11687    }
11688    if let Some(ref local_var_str) = sa_lifetime_data__lt {
11689        local_var_req_builder = match "multi" {
11690            "multi" => local_var_req_builder.query(
11691                &local_var_str
11692                    .into_iter()
11693                    .map(|p| ("sa_lifetime_data__lt".to_owned(), p.to_string()))
11694                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11695            ),
11696            _ => local_var_req_builder.query(&[(
11697                "sa_lifetime_data__lt",
11698                &local_var_str
11699                    .into_iter()
11700                    .map(|p| p.to_string())
11701                    .collect::<Vec<String>>()
11702                    .join(",")
11703                    .to_string(),
11704            )]),
11705        };
11706    }
11707    if let Some(ref local_var_str) = sa_lifetime_data__lte {
11708        local_var_req_builder = match "multi" {
11709            "multi" => local_var_req_builder.query(
11710                &local_var_str
11711                    .into_iter()
11712                    .map(|p| ("sa_lifetime_data__lte".to_owned(), p.to_string()))
11713                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11714            ),
11715            _ => local_var_req_builder.query(&[(
11716                "sa_lifetime_data__lte",
11717                &local_var_str
11718                    .into_iter()
11719                    .map(|p| p.to_string())
11720                    .collect::<Vec<String>>()
11721                    .join(",")
11722                    .to_string(),
11723            )]),
11724        };
11725    }
11726    if let Some(ref local_var_str) = sa_lifetime_data__n {
11727        local_var_req_builder = match "multi" {
11728            "multi" => local_var_req_builder.query(
11729                &local_var_str
11730                    .into_iter()
11731                    .map(|p| ("sa_lifetime_data__n".to_owned(), p.to_string()))
11732                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11733            ),
11734            _ => local_var_req_builder.query(&[(
11735                "sa_lifetime_data__n",
11736                &local_var_str
11737                    .into_iter()
11738                    .map(|p| p.to_string())
11739                    .collect::<Vec<String>>()
11740                    .join(",")
11741                    .to_string(),
11742            )]),
11743        };
11744    }
11745    if let Some(ref local_var_str) = sa_lifetime_seconds {
11746        local_var_req_builder = match "multi" {
11747            "multi" => local_var_req_builder.query(
11748                &local_var_str
11749                    .into_iter()
11750                    .map(|p| ("sa_lifetime_seconds".to_owned(), p.to_string()))
11751                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11752            ),
11753            _ => local_var_req_builder.query(&[(
11754                "sa_lifetime_seconds",
11755                &local_var_str
11756                    .into_iter()
11757                    .map(|p| p.to_string())
11758                    .collect::<Vec<String>>()
11759                    .join(",")
11760                    .to_string(),
11761            )]),
11762        };
11763    }
11764    if let Some(ref local_var_str) = sa_lifetime_seconds__empty {
11765        local_var_req_builder = local_var_req_builder
11766            .query(&[("sa_lifetime_seconds__empty", &local_var_str.to_string())]);
11767    }
11768    if let Some(ref local_var_str) = sa_lifetime_seconds__gt {
11769        local_var_req_builder = match "multi" {
11770            "multi" => local_var_req_builder.query(
11771                &local_var_str
11772                    .into_iter()
11773                    .map(|p| ("sa_lifetime_seconds__gt".to_owned(), p.to_string()))
11774                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11775            ),
11776            _ => local_var_req_builder.query(&[(
11777                "sa_lifetime_seconds__gt",
11778                &local_var_str
11779                    .into_iter()
11780                    .map(|p| p.to_string())
11781                    .collect::<Vec<String>>()
11782                    .join(",")
11783                    .to_string(),
11784            )]),
11785        };
11786    }
11787    if let Some(ref local_var_str) = sa_lifetime_seconds__gte {
11788        local_var_req_builder = match "multi" {
11789            "multi" => local_var_req_builder.query(
11790                &local_var_str
11791                    .into_iter()
11792                    .map(|p| ("sa_lifetime_seconds__gte".to_owned(), p.to_string()))
11793                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11794            ),
11795            _ => local_var_req_builder.query(&[(
11796                "sa_lifetime_seconds__gte",
11797                &local_var_str
11798                    .into_iter()
11799                    .map(|p| p.to_string())
11800                    .collect::<Vec<String>>()
11801                    .join(",")
11802                    .to_string(),
11803            )]),
11804        };
11805    }
11806    if let Some(ref local_var_str) = sa_lifetime_seconds__lt {
11807        local_var_req_builder = match "multi" {
11808            "multi" => local_var_req_builder.query(
11809                &local_var_str
11810                    .into_iter()
11811                    .map(|p| ("sa_lifetime_seconds__lt".to_owned(), p.to_string()))
11812                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11813            ),
11814            _ => local_var_req_builder.query(&[(
11815                "sa_lifetime_seconds__lt",
11816                &local_var_str
11817                    .into_iter()
11818                    .map(|p| p.to_string())
11819                    .collect::<Vec<String>>()
11820                    .join(",")
11821                    .to_string(),
11822            )]),
11823        };
11824    }
11825    if let Some(ref local_var_str) = sa_lifetime_seconds__lte {
11826        local_var_req_builder = match "multi" {
11827            "multi" => local_var_req_builder.query(
11828                &local_var_str
11829                    .into_iter()
11830                    .map(|p| ("sa_lifetime_seconds__lte".to_owned(), p.to_string()))
11831                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11832            ),
11833            _ => local_var_req_builder.query(&[(
11834                "sa_lifetime_seconds__lte",
11835                &local_var_str
11836                    .into_iter()
11837                    .map(|p| p.to_string())
11838                    .collect::<Vec<String>>()
11839                    .join(",")
11840                    .to_string(),
11841            )]),
11842        };
11843    }
11844    if let Some(ref local_var_str) = sa_lifetime_seconds__n {
11845        local_var_req_builder = match "multi" {
11846            "multi" => local_var_req_builder.query(
11847                &local_var_str
11848                    .into_iter()
11849                    .map(|p| ("sa_lifetime_seconds__n".to_owned(), p.to_string()))
11850                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11851            ),
11852            _ => local_var_req_builder.query(&[(
11853                "sa_lifetime_seconds__n",
11854                &local_var_str
11855                    .into_iter()
11856                    .map(|p| p.to_string())
11857                    .collect::<Vec<String>>()
11858                    .join(",")
11859                    .to_string(),
11860            )]),
11861        };
11862    }
11863    if let Some(ref local_var_str) = start {
11864        local_var_req_builder =
11865            local_var_req_builder.query(&[("start", &local_var_str.to_string())]);
11866    }
11867    if let Some(ref local_var_str) = tag {
11868        local_var_req_builder = match "multi" {
11869            "multi" => local_var_req_builder.query(
11870                &local_var_str
11871                    .into_iter()
11872                    .map(|p| ("tag".to_owned(), p.to_string()))
11873                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11874            ),
11875            _ => local_var_req_builder.query(&[(
11876                "tag",
11877                &local_var_str
11878                    .into_iter()
11879                    .map(|p| p.to_string())
11880                    .collect::<Vec<String>>()
11881                    .join(",")
11882                    .to_string(),
11883            )]),
11884        };
11885    }
11886    if let Some(ref local_var_str) = tag__n {
11887        local_var_req_builder = match "multi" {
11888            "multi" => local_var_req_builder.query(
11889                &local_var_str
11890                    .into_iter()
11891                    .map(|p| ("tag__n".to_owned(), p.to_string()))
11892                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11893            ),
11894            _ => local_var_req_builder.query(&[(
11895                "tag__n",
11896                &local_var_str
11897                    .into_iter()
11898                    .map(|p| p.to_string())
11899                    .collect::<Vec<String>>()
11900                    .join(",")
11901                    .to_string(),
11902            )]),
11903        };
11904    }
11905    if let Some(ref local_var_str) = tag_id {
11906        local_var_req_builder = match "multi" {
11907            "multi" => local_var_req_builder.query(
11908                &local_var_str
11909                    .into_iter()
11910                    .map(|p| ("tag_id".to_owned(), p.to_string()))
11911                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11912            ),
11913            _ => local_var_req_builder.query(&[(
11914                "tag_id",
11915                &local_var_str
11916                    .into_iter()
11917                    .map(|p| p.to_string())
11918                    .collect::<Vec<String>>()
11919                    .join(",")
11920                    .to_string(),
11921            )]),
11922        };
11923    }
11924    if let Some(ref local_var_str) = tag_id__n {
11925        local_var_req_builder = match "multi" {
11926            "multi" => local_var_req_builder.query(
11927                &local_var_str
11928                    .into_iter()
11929                    .map(|p| ("tag_id__n".to_owned(), p.to_string()))
11930                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11931            ),
11932            _ => local_var_req_builder.query(&[(
11933                "tag_id__n",
11934                &local_var_str
11935                    .into_iter()
11936                    .map(|p| p.to_string())
11937                    .collect::<Vec<String>>()
11938                    .join(",")
11939                    .to_string(),
11940            )]),
11941        };
11942    }
11943    if let Some(ref local_var_str) = updated_by_request {
11944        local_var_req_builder =
11945            local_var_req_builder.query(&[("updated_by_request", &local_var_str.to_string())]);
11946    }
11947    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
11948        local_var_req_builder =
11949            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
11950    }
11951    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
11952        let local_var_key = local_var_apikey.key.clone();
11953        let local_var_value = match local_var_apikey.prefix {
11954            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
11955            None => local_var_key,
11956        };
11957        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
11958    };
11959
11960    let local_var_req = local_var_req_builder.build()?;
11961    let local_var_resp = local_var_client.execute(local_var_req).await?;
11962
11963    let local_var_status = local_var_resp.status();
11964    let local_var_content = local_var_resp.text().await?;
11965
11966    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
11967        serde_json::from_str(&local_var_content).map_err(Error::from)
11968    } else {
11969        let local_var_entity: Option<VpnIpsecProposalsListError> =
11970            serde_json::from_str(&local_var_content).ok();
11971        let local_var_error = ResponseContent {
11972            status: local_var_status,
11973            content: local_var_content,
11974            entity: local_var_entity,
11975        };
11976        Err(Error::ResponseError(local_var_error))
11977    }
11978}
11979
11980/// Patch a IPSec proposal object.
11981pub async fn vpn_ipsec_proposals_partial_update(
11982    configuration: &configuration::Configuration,
11983    id: i32,
11984    patched_writable_ip_sec_proposal_request: Option<
11985        crate::models::PatchedWritableIpSecProposalRequest,
11986    >,
11987) -> Result<crate::models::IpSecProposal, Error<VpnIpsecProposalsPartialUpdateError>> {
11988    let local_var_configuration = configuration;
11989
11990    let local_var_client = &local_var_configuration.client;
11991
11992    let local_var_uri_str = format!(
11993        "{}/api/vpn/ipsec-proposals/{id}/",
11994        local_var_configuration.base_path,
11995        id = id
11996    );
11997    let mut local_var_req_builder =
11998        local_var_client.request(reqwest::Method::PATCH, local_var_uri_str.as_str());
11999
12000    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
12001        local_var_req_builder =
12002            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
12003    }
12004    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
12005        let local_var_key = local_var_apikey.key.clone();
12006        let local_var_value = match local_var_apikey.prefix {
12007            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
12008            None => local_var_key,
12009        };
12010        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
12011    };
12012    local_var_req_builder = local_var_req_builder.json(&patched_writable_ip_sec_proposal_request);
12013
12014    let local_var_req = local_var_req_builder.build()?;
12015    let local_var_resp = local_var_client.execute(local_var_req).await?;
12016
12017    let local_var_status = local_var_resp.status();
12018    let local_var_content = local_var_resp.text().await?;
12019
12020    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
12021        serde_json::from_str(&local_var_content).map_err(Error::from)
12022    } else {
12023        let local_var_entity: Option<VpnIpsecProposalsPartialUpdateError> =
12024            serde_json::from_str(&local_var_content).ok();
12025        let local_var_error = ResponseContent {
12026            status: local_var_status,
12027            content: local_var_content,
12028            entity: local_var_entity,
12029        };
12030        Err(Error::ResponseError(local_var_error))
12031    }
12032}
12033
12034/// Get a IPSec proposal object.
12035pub async fn vpn_ipsec_proposals_retrieve(
12036    configuration: &configuration::Configuration,
12037    id: i32,
12038) -> Result<crate::models::IpSecProposal, Error<VpnIpsecProposalsRetrieveError>> {
12039    let local_var_configuration = configuration;
12040
12041    let local_var_client = &local_var_configuration.client;
12042
12043    let local_var_uri_str = format!(
12044        "{}/api/vpn/ipsec-proposals/{id}/",
12045        local_var_configuration.base_path,
12046        id = id
12047    );
12048    let mut local_var_req_builder =
12049        local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
12050
12051    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
12052        local_var_req_builder =
12053            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
12054    }
12055    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
12056        let local_var_key = local_var_apikey.key.clone();
12057        let local_var_value = match local_var_apikey.prefix {
12058            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
12059            None => local_var_key,
12060        };
12061        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
12062    };
12063
12064    let local_var_req = local_var_req_builder.build()?;
12065    let local_var_resp = local_var_client.execute(local_var_req).await?;
12066
12067    let local_var_status = local_var_resp.status();
12068    let local_var_content = local_var_resp.text().await?;
12069
12070    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
12071        serde_json::from_str(&local_var_content).map_err(Error::from)
12072    } else {
12073        let local_var_entity: Option<VpnIpsecProposalsRetrieveError> =
12074            serde_json::from_str(&local_var_content).ok();
12075        let local_var_error = ResponseContent {
12076            status: local_var_status,
12077            content: local_var_content,
12078            entity: local_var_entity,
12079        };
12080        Err(Error::ResponseError(local_var_error))
12081    }
12082}
12083
12084/// Put a IPSec proposal object.
12085pub async fn vpn_ipsec_proposals_update(
12086    configuration: &configuration::Configuration,
12087    id: i32,
12088    writable_ip_sec_proposal_request: crate::models::WritableIpSecProposalRequest,
12089) -> Result<crate::models::IpSecProposal, Error<VpnIpsecProposalsUpdateError>> {
12090    let local_var_configuration = configuration;
12091
12092    let local_var_client = &local_var_configuration.client;
12093
12094    let local_var_uri_str = format!(
12095        "{}/api/vpn/ipsec-proposals/{id}/",
12096        local_var_configuration.base_path,
12097        id = id
12098    );
12099    let mut local_var_req_builder =
12100        local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());
12101
12102    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
12103        local_var_req_builder =
12104            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
12105    }
12106    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
12107        let local_var_key = local_var_apikey.key.clone();
12108        let local_var_value = match local_var_apikey.prefix {
12109            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
12110            None => local_var_key,
12111        };
12112        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
12113    };
12114    local_var_req_builder = local_var_req_builder.json(&writable_ip_sec_proposal_request);
12115
12116    let local_var_req = local_var_req_builder.build()?;
12117    let local_var_resp = local_var_client.execute(local_var_req).await?;
12118
12119    let local_var_status = local_var_resp.status();
12120    let local_var_content = local_var_resp.text().await?;
12121
12122    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
12123        serde_json::from_str(&local_var_content).map_err(Error::from)
12124    } else {
12125        let local_var_entity: Option<VpnIpsecProposalsUpdateError> =
12126            serde_json::from_str(&local_var_content).ok();
12127        let local_var_error = ResponseContent {
12128            status: local_var_status,
12129            content: local_var_content,
12130            entity: local_var_entity,
12131        };
12132        Err(Error::ResponseError(local_var_error))
12133    }
12134}
12135
12136/// Delete a list of L2VPN termination objects.
12137pub async fn vpn_l2vpn_terminations_bulk_destroy(
12138    configuration: &configuration::Configuration,
12139    l2_vpn_termination_request: Vec<crate::models::L2VpnTerminationRequest>,
12140) -> Result<(), Error<VpnL2vpnTerminationsBulkDestroyError>> {
12141    let local_var_configuration = configuration;
12142
12143    let local_var_client = &local_var_configuration.client;
12144
12145    let local_var_uri_str = format!(
12146        "{}/api/vpn/l2vpn-terminations/",
12147        local_var_configuration.base_path
12148    );
12149    let mut local_var_req_builder =
12150        local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());
12151
12152    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
12153        local_var_req_builder =
12154            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
12155    }
12156    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
12157        let local_var_key = local_var_apikey.key.clone();
12158        let local_var_value = match local_var_apikey.prefix {
12159            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
12160            None => local_var_key,
12161        };
12162        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
12163    };
12164    local_var_req_builder = local_var_req_builder.json(&l2_vpn_termination_request);
12165
12166    let local_var_req = local_var_req_builder.build()?;
12167    let local_var_resp = local_var_client.execute(local_var_req).await?;
12168
12169    let local_var_status = local_var_resp.status();
12170    let local_var_content = local_var_resp.text().await?;
12171
12172    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
12173        Ok(())
12174    } else {
12175        let local_var_entity: Option<VpnL2vpnTerminationsBulkDestroyError> =
12176            serde_json::from_str(&local_var_content).ok();
12177        let local_var_error = ResponseContent {
12178            status: local_var_status,
12179            content: local_var_content,
12180            entity: local_var_entity,
12181        };
12182        Err(Error::ResponseError(local_var_error))
12183    }
12184}
12185
12186/// Patch a list of L2VPN termination objects.
12187pub async fn vpn_l2vpn_terminations_bulk_partial_update(
12188    configuration: &configuration::Configuration,
12189    l2_vpn_termination_request: Vec<crate::models::L2VpnTerminationRequest>,
12190) -> Result<Vec<crate::models::L2VpnTermination>, Error<VpnL2vpnTerminationsBulkPartialUpdateError>>
12191{
12192    let local_var_configuration = configuration;
12193
12194    let local_var_client = &local_var_configuration.client;
12195
12196    let local_var_uri_str = format!(
12197        "{}/api/vpn/l2vpn-terminations/",
12198        local_var_configuration.base_path
12199    );
12200    let mut local_var_req_builder =
12201        local_var_client.request(reqwest::Method::PATCH, local_var_uri_str.as_str());
12202
12203    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
12204        local_var_req_builder =
12205            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
12206    }
12207    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
12208        let local_var_key = local_var_apikey.key.clone();
12209        let local_var_value = match local_var_apikey.prefix {
12210            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
12211            None => local_var_key,
12212        };
12213        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
12214    };
12215    local_var_req_builder = local_var_req_builder.json(&l2_vpn_termination_request);
12216
12217    let local_var_req = local_var_req_builder.build()?;
12218    let local_var_resp = local_var_client.execute(local_var_req).await?;
12219
12220    let local_var_status = local_var_resp.status();
12221    let local_var_content = local_var_resp.text().await?;
12222
12223    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
12224        serde_json::from_str(&local_var_content).map_err(Error::from)
12225    } else {
12226        let local_var_entity: Option<VpnL2vpnTerminationsBulkPartialUpdateError> =
12227            serde_json::from_str(&local_var_content).ok();
12228        let local_var_error = ResponseContent {
12229            status: local_var_status,
12230            content: local_var_content,
12231            entity: local_var_entity,
12232        };
12233        Err(Error::ResponseError(local_var_error))
12234    }
12235}
12236
12237/// Put a list of L2VPN termination objects.
12238pub async fn vpn_l2vpn_terminations_bulk_update(
12239    configuration: &configuration::Configuration,
12240    l2_vpn_termination_request: Vec<crate::models::L2VpnTerminationRequest>,
12241) -> Result<Vec<crate::models::L2VpnTermination>, Error<VpnL2vpnTerminationsBulkUpdateError>> {
12242    let local_var_configuration = configuration;
12243
12244    let local_var_client = &local_var_configuration.client;
12245
12246    let local_var_uri_str = format!(
12247        "{}/api/vpn/l2vpn-terminations/",
12248        local_var_configuration.base_path
12249    );
12250    let mut local_var_req_builder =
12251        local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());
12252
12253    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
12254        local_var_req_builder =
12255            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
12256    }
12257    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
12258        let local_var_key = local_var_apikey.key.clone();
12259        let local_var_value = match local_var_apikey.prefix {
12260            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
12261            None => local_var_key,
12262        };
12263        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
12264    };
12265    local_var_req_builder = local_var_req_builder.json(&l2_vpn_termination_request);
12266
12267    let local_var_req = local_var_req_builder.build()?;
12268    let local_var_resp = local_var_client.execute(local_var_req).await?;
12269
12270    let local_var_status = local_var_resp.status();
12271    let local_var_content = local_var_resp.text().await?;
12272
12273    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
12274        serde_json::from_str(&local_var_content).map_err(Error::from)
12275    } else {
12276        let local_var_entity: Option<VpnL2vpnTerminationsBulkUpdateError> =
12277            serde_json::from_str(&local_var_content).ok();
12278        let local_var_error = ResponseContent {
12279            status: local_var_status,
12280            content: local_var_content,
12281            entity: local_var_entity,
12282        };
12283        Err(Error::ResponseError(local_var_error))
12284    }
12285}
12286
12287/// Post a list of L2VPN termination objects.
12288pub async fn vpn_l2vpn_terminations_create(
12289    configuration: &configuration::Configuration,
12290    vpn_l2vpn_terminations_create_request: crate::models::VpnL2vpnTerminationsCreateRequest,
12291) -> Result<crate::models::L2VpnTermination, Error<VpnL2vpnTerminationsCreateError>> {
12292    let local_var_configuration = configuration;
12293
12294    let local_var_client = &local_var_configuration.client;
12295
12296    let local_var_uri_str = format!(
12297        "{}/api/vpn/l2vpn-terminations/",
12298        local_var_configuration.base_path
12299    );
12300    let mut local_var_req_builder =
12301        local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
12302
12303    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
12304        local_var_req_builder =
12305            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
12306    }
12307    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
12308        let local_var_key = local_var_apikey.key.clone();
12309        let local_var_value = match local_var_apikey.prefix {
12310            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
12311            None => local_var_key,
12312        };
12313        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
12314    };
12315    local_var_req_builder = local_var_req_builder.json(&vpn_l2vpn_terminations_create_request);
12316
12317    let local_var_req = local_var_req_builder.build()?;
12318    let local_var_resp = local_var_client.execute(local_var_req).await?;
12319
12320    let local_var_status = local_var_resp.status();
12321    let local_var_content = local_var_resp.text().await?;
12322
12323    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
12324        serde_json::from_str(&local_var_content).map_err(Error::from)
12325    } else {
12326        let local_var_entity: Option<VpnL2vpnTerminationsCreateError> =
12327            serde_json::from_str(&local_var_content).ok();
12328        let local_var_error = ResponseContent {
12329            status: local_var_status,
12330            content: local_var_content,
12331            entity: local_var_entity,
12332        };
12333        Err(Error::ResponseError(local_var_error))
12334    }
12335}
12336
12337/// Delete a L2VPN termination object.
12338pub async fn vpn_l2vpn_terminations_destroy(
12339    configuration: &configuration::Configuration,
12340    id: i32,
12341) -> Result<(), Error<VpnL2vpnTerminationsDestroyError>> {
12342    let local_var_configuration = configuration;
12343
12344    let local_var_client = &local_var_configuration.client;
12345
12346    let local_var_uri_str = format!(
12347        "{}/api/vpn/l2vpn-terminations/{id}/",
12348        local_var_configuration.base_path,
12349        id = id
12350    );
12351    let mut local_var_req_builder =
12352        local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());
12353
12354    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
12355        local_var_req_builder =
12356            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
12357    }
12358    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
12359        let local_var_key = local_var_apikey.key.clone();
12360        let local_var_value = match local_var_apikey.prefix {
12361            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
12362            None => local_var_key,
12363        };
12364        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
12365    };
12366
12367    let local_var_req = local_var_req_builder.build()?;
12368    let local_var_resp = local_var_client.execute(local_var_req).await?;
12369
12370    let local_var_status = local_var_resp.status();
12371    let local_var_content = local_var_resp.text().await?;
12372
12373    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
12374        Ok(())
12375    } else {
12376        let local_var_entity: Option<VpnL2vpnTerminationsDestroyError> =
12377            serde_json::from_str(&local_var_content).ok();
12378        let local_var_error = ResponseContent {
12379            status: local_var_status,
12380            content: local_var_content,
12381            entity: local_var_entity,
12382        };
12383        Err(Error::ResponseError(local_var_error))
12384    }
12385}
12386
12387/// Get a list of L2VPN termination objects.
12388pub async fn vpn_l2vpn_terminations_list(
12389    configuration: &configuration::Configuration,
12390    assigned_object_id: Option<Vec<i32>>,
12391    assigned_object_id__empty: Option<bool>,
12392    assigned_object_id__gt: Option<Vec<i32>>,
12393    assigned_object_id__gte: Option<Vec<i32>>,
12394    assigned_object_id__lt: Option<Vec<i32>>,
12395    assigned_object_id__lte: Option<Vec<i32>>,
12396    assigned_object_id__n: Option<Vec<i32>>,
12397    assigned_object_type: Option<Vec<String>>,
12398    assigned_object_type__n: Option<Vec<String>>,
12399    assigned_object_type_id: Option<Vec<i32>>,
12400    assigned_object_type_id__n: Option<Vec<i32>>,
12401    created: Option<Vec<String>>,
12402    created__empty: Option<Vec<String>>,
12403    created__gt: Option<Vec<String>>,
12404    created__gte: Option<Vec<String>>,
12405    created__lt: Option<Vec<String>>,
12406    created__lte: Option<Vec<String>>,
12407    created__n: Option<Vec<String>>,
12408    created_by_request: Option<&str>,
12409    device: Option<Vec<String>>,
12410    device__n: Option<Vec<String>>,
12411    device_id: Option<Vec<i32>>,
12412    device_id__n: Option<Vec<i32>>,
12413    id: Option<Vec<i32>>,
12414    id__empty: Option<bool>,
12415    id__gt: Option<Vec<i32>>,
12416    id__gte: Option<Vec<i32>>,
12417    id__lt: Option<Vec<i32>>,
12418    id__lte: Option<Vec<i32>>,
12419    id__n: Option<Vec<i32>>,
12420    interface: Option<Vec<String>>,
12421    interface__n: Option<Vec<String>>,
12422    interface_id: Option<Vec<i32>>,
12423    interface_id__n: Option<Vec<i32>>,
12424    l2vpn: Option<Vec<String>>,
12425    l2vpn__n: Option<Vec<String>>,
12426    l2vpn_id: Option<Vec<i32>>,
12427    l2vpn_id__n: Option<Vec<i32>>,
12428    last_updated: Option<Vec<String>>,
12429    last_updated__empty: Option<Vec<String>>,
12430    last_updated__gt: Option<Vec<String>>,
12431    last_updated__gte: Option<Vec<String>>,
12432    last_updated__lt: Option<Vec<String>>,
12433    last_updated__lte: Option<Vec<String>>,
12434    last_updated__n: Option<Vec<String>>,
12435    limit: Option<i32>,
12436    modified_by_request: Option<&str>,
12437    offset: Option<i32>,
12438    ordering: Option<&str>,
12439    q: Option<&str>,
12440    region: Option<Vec<String>>,
12441    region_id: Option<Vec<i32>>,
12442    site: Option<Vec<String>>,
12443    site_id: Option<Vec<i32>>,
12444    start: Option<i32>,
12445    tag: Option<Vec<String>>,
12446    tag__n: Option<Vec<String>>,
12447    tag_id: Option<Vec<i32>>,
12448    tag_id__n: Option<Vec<i32>>,
12449    updated_by_request: Option<&str>,
12450    virtual_machine: Option<Vec<String>>,
12451    virtual_machine__n: Option<Vec<String>>,
12452    virtual_machine_id: Option<Vec<i32>>,
12453    virtual_machine_id__n: Option<Vec<i32>>,
12454    vlan: Option<Vec<String>>,
12455    vlan__n: Option<Vec<String>>,
12456    vlan_id: Option<Vec<i32>>,
12457    vlan_id__n: Option<Vec<i32>>,
12458    vlan_vid: Option<i32>,
12459    vlan_vid__empty: Option<i32>,
12460    vlan_vid__gt: Option<i32>,
12461    vlan_vid__gte: Option<i32>,
12462    vlan_vid__lt: Option<i32>,
12463    vlan_vid__lte: Option<i32>,
12464    vlan_vid__n: Option<i32>,
12465    vminterface: Option<Vec<String>>,
12466    vminterface__n: Option<Vec<String>>,
12467    vminterface_id: Option<Vec<i32>>,
12468    vminterface_id__n: Option<Vec<i32>>,
12469) -> Result<crate::models::PaginatedL2VpnTerminationList, Error<VpnL2vpnTerminationsListError>> {
12470    let local_var_configuration = configuration;
12471
12472    let local_var_client = &local_var_configuration.client;
12473
12474    let local_var_uri_str = format!(
12475        "{}/api/vpn/l2vpn-terminations/",
12476        local_var_configuration.base_path
12477    );
12478    let mut local_var_req_builder =
12479        local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
12480
12481    if let Some(ref local_var_str) = assigned_object_id {
12482        local_var_req_builder = match "multi" {
12483            "multi" => local_var_req_builder.query(
12484                &local_var_str
12485                    .into_iter()
12486                    .map(|p| ("assigned_object_id".to_owned(), p.to_string()))
12487                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12488            ),
12489            _ => local_var_req_builder.query(&[(
12490                "assigned_object_id",
12491                &local_var_str
12492                    .into_iter()
12493                    .map(|p| p.to_string())
12494                    .collect::<Vec<String>>()
12495                    .join(",")
12496                    .to_string(),
12497            )]),
12498        };
12499    }
12500    if let Some(ref local_var_str) = assigned_object_id__empty {
12501        local_var_req_builder = local_var_req_builder
12502            .query(&[("assigned_object_id__empty", &local_var_str.to_string())]);
12503    }
12504    if let Some(ref local_var_str) = assigned_object_id__gt {
12505        local_var_req_builder = match "multi" {
12506            "multi" => local_var_req_builder.query(
12507                &local_var_str
12508                    .into_iter()
12509                    .map(|p| ("assigned_object_id__gt".to_owned(), p.to_string()))
12510                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12511            ),
12512            _ => local_var_req_builder.query(&[(
12513                "assigned_object_id__gt",
12514                &local_var_str
12515                    .into_iter()
12516                    .map(|p| p.to_string())
12517                    .collect::<Vec<String>>()
12518                    .join(",")
12519                    .to_string(),
12520            )]),
12521        };
12522    }
12523    if let Some(ref local_var_str) = assigned_object_id__gte {
12524        local_var_req_builder = match "multi" {
12525            "multi" => local_var_req_builder.query(
12526                &local_var_str
12527                    .into_iter()
12528                    .map(|p| ("assigned_object_id__gte".to_owned(), p.to_string()))
12529                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12530            ),
12531            _ => local_var_req_builder.query(&[(
12532                "assigned_object_id__gte",
12533                &local_var_str
12534                    .into_iter()
12535                    .map(|p| p.to_string())
12536                    .collect::<Vec<String>>()
12537                    .join(",")
12538                    .to_string(),
12539            )]),
12540        };
12541    }
12542    if let Some(ref local_var_str) = assigned_object_id__lt {
12543        local_var_req_builder = match "multi" {
12544            "multi" => local_var_req_builder.query(
12545                &local_var_str
12546                    .into_iter()
12547                    .map(|p| ("assigned_object_id__lt".to_owned(), p.to_string()))
12548                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12549            ),
12550            _ => local_var_req_builder.query(&[(
12551                "assigned_object_id__lt",
12552                &local_var_str
12553                    .into_iter()
12554                    .map(|p| p.to_string())
12555                    .collect::<Vec<String>>()
12556                    .join(",")
12557                    .to_string(),
12558            )]),
12559        };
12560    }
12561    if let Some(ref local_var_str) = assigned_object_id__lte {
12562        local_var_req_builder = match "multi" {
12563            "multi" => local_var_req_builder.query(
12564                &local_var_str
12565                    .into_iter()
12566                    .map(|p| ("assigned_object_id__lte".to_owned(), p.to_string()))
12567                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12568            ),
12569            _ => local_var_req_builder.query(&[(
12570                "assigned_object_id__lte",
12571                &local_var_str
12572                    .into_iter()
12573                    .map(|p| p.to_string())
12574                    .collect::<Vec<String>>()
12575                    .join(",")
12576                    .to_string(),
12577            )]),
12578        };
12579    }
12580    if let Some(ref local_var_str) = assigned_object_id__n {
12581        local_var_req_builder = match "multi" {
12582            "multi" => local_var_req_builder.query(
12583                &local_var_str
12584                    .into_iter()
12585                    .map(|p| ("assigned_object_id__n".to_owned(), p.to_string()))
12586                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12587            ),
12588            _ => local_var_req_builder.query(&[(
12589                "assigned_object_id__n",
12590                &local_var_str
12591                    .into_iter()
12592                    .map(|p| p.to_string())
12593                    .collect::<Vec<String>>()
12594                    .join(",")
12595                    .to_string(),
12596            )]),
12597        };
12598    }
12599    if let Some(ref local_var_str) = assigned_object_type {
12600        local_var_req_builder = match "multi" {
12601            "multi" => local_var_req_builder.query(
12602                &local_var_str
12603                    .into_iter()
12604                    .map(|p| ("assigned_object_type".to_owned(), p.to_string()))
12605                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12606            ),
12607            _ => local_var_req_builder.query(&[(
12608                "assigned_object_type",
12609                &local_var_str
12610                    .into_iter()
12611                    .map(|p| p.to_string())
12612                    .collect::<Vec<String>>()
12613                    .join(",")
12614                    .to_string(),
12615            )]),
12616        };
12617    }
12618    if let Some(ref local_var_str) = assigned_object_type__n {
12619        local_var_req_builder = match "multi" {
12620            "multi" => local_var_req_builder.query(
12621                &local_var_str
12622                    .into_iter()
12623                    .map(|p| ("assigned_object_type__n".to_owned(), p.to_string()))
12624                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12625            ),
12626            _ => local_var_req_builder.query(&[(
12627                "assigned_object_type__n",
12628                &local_var_str
12629                    .into_iter()
12630                    .map(|p| p.to_string())
12631                    .collect::<Vec<String>>()
12632                    .join(",")
12633                    .to_string(),
12634            )]),
12635        };
12636    }
12637    if let Some(ref local_var_str) = assigned_object_type_id {
12638        local_var_req_builder = match "multi" {
12639            "multi" => local_var_req_builder.query(
12640                &local_var_str
12641                    .into_iter()
12642                    .map(|p| ("assigned_object_type_id".to_owned(), p.to_string()))
12643                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12644            ),
12645            _ => local_var_req_builder.query(&[(
12646                "assigned_object_type_id",
12647                &local_var_str
12648                    .into_iter()
12649                    .map(|p| p.to_string())
12650                    .collect::<Vec<String>>()
12651                    .join(",")
12652                    .to_string(),
12653            )]),
12654        };
12655    }
12656    if let Some(ref local_var_str) = assigned_object_type_id__n {
12657        local_var_req_builder = match "multi" {
12658            "multi" => local_var_req_builder.query(
12659                &local_var_str
12660                    .into_iter()
12661                    .map(|p| ("assigned_object_type_id__n".to_owned(), p.to_string()))
12662                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12663            ),
12664            _ => local_var_req_builder.query(&[(
12665                "assigned_object_type_id__n",
12666                &local_var_str
12667                    .into_iter()
12668                    .map(|p| p.to_string())
12669                    .collect::<Vec<String>>()
12670                    .join(",")
12671                    .to_string(),
12672            )]),
12673        };
12674    }
12675    if let Some(ref local_var_str) = created {
12676        local_var_req_builder = match "multi" {
12677            "multi" => local_var_req_builder.query(
12678                &local_var_str
12679                    .into_iter()
12680                    .map(|p| ("created".to_owned(), p.to_string()))
12681                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12682            ),
12683            _ => local_var_req_builder.query(&[(
12684                "created",
12685                &local_var_str
12686                    .into_iter()
12687                    .map(|p| p.to_string())
12688                    .collect::<Vec<String>>()
12689                    .join(",")
12690                    .to_string(),
12691            )]),
12692        };
12693    }
12694    if let Some(ref local_var_str) = created__empty {
12695        local_var_req_builder = match "multi" {
12696            "multi" => local_var_req_builder.query(
12697                &local_var_str
12698                    .into_iter()
12699                    .map(|p| ("created__empty".to_owned(), p.to_string()))
12700                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12701            ),
12702            _ => local_var_req_builder.query(&[(
12703                "created__empty",
12704                &local_var_str
12705                    .into_iter()
12706                    .map(|p| p.to_string())
12707                    .collect::<Vec<String>>()
12708                    .join(",")
12709                    .to_string(),
12710            )]),
12711        };
12712    }
12713    if let Some(ref local_var_str) = created__gt {
12714        local_var_req_builder = match "multi" {
12715            "multi" => local_var_req_builder.query(
12716                &local_var_str
12717                    .into_iter()
12718                    .map(|p| ("created__gt".to_owned(), p.to_string()))
12719                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12720            ),
12721            _ => local_var_req_builder.query(&[(
12722                "created__gt",
12723                &local_var_str
12724                    .into_iter()
12725                    .map(|p| p.to_string())
12726                    .collect::<Vec<String>>()
12727                    .join(",")
12728                    .to_string(),
12729            )]),
12730        };
12731    }
12732    if let Some(ref local_var_str) = created__gte {
12733        local_var_req_builder = match "multi" {
12734            "multi" => local_var_req_builder.query(
12735                &local_var_str
12736                    .into_iter()
12737                    .map(|p| ("created__gte".to_owned(), p.to_string()))
12738                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12739            ),
12740            _ => local_var_req_builder.query(&[(
12741                "created__gte",
12742                &local_var_str
12743                    .into_iter()
12744                    .map(|p| p.to_string())
12745                    .collect::<Vec<String>>()
12746                    .join(",")
12747                    .to_string(),
12748            )]),
12749        };
12750    }
12751    if let Some(ref local_var_str) = created__lt {
12752        local_var_req_builder = match "multi" {
12753            "multi" => local_var_req_builder.query(
12754                &local_var_str
12755                    .into_iter()
12756                    .map(|p| ("created__lt".to_owned(), p.to_string()))
12757                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12758            ),
12759            _ => local_var_req_builder.query(&[(
12760                "created__lt",
12761                &local_var_str
12762                    .into_iter()
12763                    .map(|p| p.to_string())
12764                    .collect::<Vec<String>>()
12765                    .join(",")
12766                    .to_string(),
12767            )]),
12768        };
12769    }
12770    if let Some(ref local_var_str) = created__lte {
12771        local_var_req_builder = match "multi" {
12772            "multi" => local_var_req_builder.query(
12773                &local_var_str
12774                    .into_iter()
12775                    .map(|p| ("created__lte".to_owned(), p.to_string()))
12776                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12777            ),
12778            _ => local_var_req_builder.query(&[(
12779                "created__lte",
12780                &local_var_str
12781                    .into_iter()
12782                    .map(|p| p.to_string())
12783                    .collect::<Vec<String>>()
12784                    .join(",")
12785                    .to_string(),
12786            )]),
12787        };
12788    }
12789    if let Some(ref local_var_str) = created__n {
12790        local_var_req_builder = match "multi" {
12791            "multi" => local_var_req_builder.query(
12792                &local_var_str
12793                    .into_iter()
12794                    .map(|p| ("created__n".to_owned(), p.to_string()))
12795                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12796            ),
12797            _ => local_var_req_builder.query(&[(
12798                "created__n",
12799                &local_var_str
12800                    .into_iter()
12801                    .map(|p| p.to_string())
12802                    .collect::<Vec<String>>()
12803                    .join(",")
12804                    .to_string(),
12805            )]),
12806        };
12807    }
12808    if let Some(ref local_var_str) = created_by_request {
12809        local_var_req_builder =
12810            local_var_req_builder.query(&[("created_by_request", &local_var_str.to_string())]);
12811    }
12812    if let Some(ref local_var_str) = device {
12813        local_var_req_builder = match "multi" {
12814            "multi" => local_var_req_builder.query(
12815                &local_var_str
12816                    .into_iter()
12817                    .map(|p| ("device".to_owned(), p.to_string()))
12818                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12819            ),
12820            _ => local_var_req_builder.query(&[(
12821                "device",
12822                &local_var_str
12823                    .into_iter()
12824                    .map(|p| p.to_string())
12825                    .collect::<Vec<String>>()
12826                    .join(",")
12827                    .to_string(),
12828            )]),
12829        };
12830    }
12831    if let Some(ref local_var_str) = device__n {
12832        local_var_req_builder = match "multi" {
12833            "multi" => local_var_req_builder.query(
12834                &local_var_str
12835                    .into_iter()
12836                    .map(|p| ("device__n".to_owned(), p.to_string()))
12837                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12838            ),
12839            _ => local_var_req_builder.query(&[(
12840                "device__n",
12841                &local_var_str
12842                    .into_iter()
12843                    .map(|p| p.to_string())
12844                    .collect::<Vec<String>>()
12845                    .join(",")
12846                    .to_string(),
12847            )]),
12848        };
12849    }
12850    if let Some(ref local_var_str) = device_id {
12851        local_var_req_builder = match "multi" {
12852            "multi" => local_var_req_builder.query(
12853                &local_var_str
12854                    .into_iter()
12855                    .map(|p| ("device_id".to_owned(), p.to_string()))
12856                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12857            ),
12858            _ => local_var_req_builder.query(&[(
12859                "device_id",
12860                &local_var_str
12861                    .into_iter()
12862                    .map(|p| p.to_string())
12863                    .collect::<Vec<String>>()
12864                    .join(",")
12865                    .to_string(),
12866            )]),
12867        };
12868    }
12869    if let Some(ref local_var_str) = device_id__n {
12870        local_var_req_builder = match "multi" {
12871            "multi" => local_var_req_builder.query(
12872                &local_var_str
12873                    .into_iter()
12874                    .map(|p| ("device_id__n".to_owned(), p.to_string()))
12875                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12876            ),
12877            _ => local_var_req_builder.query(&[(
12878                "device_id__n",
12879                &local_var_str
12880                    .into_iter()
12881                    .map(|p| p.to_string())
12882                    .collect::<Vec<String>>()
12883                    .join(",")
12884                    .to_string(),
12885            )]),
12886        };
12887    }
12888    if let Some(ref local_var_str) = id {
12889        local_var_req_builder = match "multi" {
12890            "multi" => local_var_req_builder.query(
12891                &local_var_str
12892                    .into_iter()
12893                    .map(|p| ("id".to_owned(), p.to_string()))
12894                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12895            ),
12896            _ => local_var_req_builder.query(&[(
12897                "id",
12898                &local_var_str
12899                    .into_iter()
12900                    .map(|p| p.to_string())
12901                    .collect::<Vec<String>>()
12902                    .join(",")
12903                    .to_string(),
12904            )]),
12905        };
12906    }
12907    if let Some(ref local_var_str) = id__empty {
12908        local_var_req_builder =
12909            local_var_req_builder.query(&[("id__empty", &local_var_str.to_string())]);
12910    }
12911    if let Some(ref local_var_str) = id__gt {
12912        local_var_req_builder = match "multi" {
12913            "multi" => local_var_req_builder.query(
12914                &local_var_str
12915                    .into_iter()
12916                    .map(|p| ("id__gt".to_owned(), p.to_string()))
12917                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12918            ),
12919            _ => local_var_req_builder.query(&[(
12920                "id__gt",
12921                &local_var_str
12922                    .into_iter()
12923                    .map(|p| p.to_string())
12924                    .collect::<Vec<String>>()
12925                    .join(",")
12926                    .to_string(),
12927            )]),
12928        };
12929    }
12930    if let Some(ref local_var_str) = id__gte {
12931        local_var_req_builder = match "multi" {
12932            "multi" => local_var_req_builder.query(
12933                &local_var_str
12934                    .into_iter()
12935                    .map(|p| ("id__gte".to_owned(), p.to_string()))
12936                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12937            ),
12938            _ => local_var_req_builder.query(&[(
12939                "id__gte",
12940                &local_var_str
12941                    .into_iter()
12942                    .map(|p| p.to_string())
12943                    .collect::<Vec<String>>()
12944                    .join(",")
12945                    .to_string(),
12946            )]),
12947        };
12948    }
12949    if let Some(ref local_var_str) = id__lt {
12950        local_var_req_builder = match "multi" {
12951            "multi" => local_var_req_builder.query(
12952                &local_var_str
12953                    .into_iter()
12954                    .map(|p| ("id__lt".to_owned(), p.to_string()))
12955                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12956            ),
12957            _ => local_var_req_builder.query(&[(
12958                "id__lt",
12959                &local_var_str
12960                    .into_iter()
12961                    .map(|p| p.to_string())
12962                    .collect::<Vec<String>>()
12963                    .join(",")
12964                    .to_string(),
12965            )]),
12966        };
12967    }
12968    if let Some(ref local_var_str) = id__lte {
12969        local_var_req_builder = match "multi" {
12970            "multi" => local_var_req_builder.query(
12971                &local_var_str
12972                    .into_iter()
12973                    .map(|p| ("id__lte".to_owned(), p.to_string()))
12974                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12975            ),
12976            _ => local_var_req_builder.query(&[(
12977                "id__lte",
12978                &local_var_str
12979                    .into_iter()
12980                    .map(|p| p.to_string())
12981                    .collect::<Vec<String>>()
12982                    .join(",")
12983                    .to_string(),
12984            )]),
12985        };
12986    }
12987    if let Some(ref local_var_str) = id__n {
12988        local_var_req_builder = match "multi" {
12989            "multi" => local_var_req_builder.query(
12990                &local_var_str
12991                    .into_iter()
12992                    .map(|p| ("id__n".to_owned(), p.to_string()))
12993                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12994            ),
12995            _ => local_var_req_builder.query(&[(
12996                "id__n",
12997                &local_var_str
12998                    .into_iter()
12999                    .map(|p| p.to_string())
13000                    .collect::<Vec<String>>()
13001                    .join(",")
13002                    .to_string(),
13003            )]),
13004        };
13005    }
13006    if let Some(ref local_var_str) = interface {
13007        local_var_req_builder = match "multi" {
13008            "multi" => local_var_req_builder.query(
13009                &local_var_str
13010                    .into_iter()
13011                    .map(|p| ("interface".to_owned(), p.to_string()))
13012                    .collect::<Vec<(std::string::String, std::string::String)>>(),
13013            ),
13014            _ => local_var_req_builder.query(&[(
13015                "interface",
13016                &local_var_str
13017                    .into_iter()
13018                    .map(|p| p.to_string())
13019                    .collect::<Vec<String>>()
13020                    .join(",")
13021                    .to_string(),
13022            )]),
13023        };
13024    }
13025    if let Some(ref local_var_str) = interface__n {
13026        local_var_req_builder = match "multi" {
13027            "multi" => local_var_req_builder.query(
13028                &local_var_str
13029                    .into_iter()
13030                    .map(|p| ("interface__n".to_owned(), p.to_string()))
13031                    .collect::<Vec<(std::string::String, std::string::String)>>(),
13032            ),
13033            _ => local_var_req_builder.query(&[(
13034                "interface__n",
13035                &local_var_str
13036                    .into_iter()
13037                    .map(|p| p.to_string())
13038                    .collect::<Vec<String>>()
13039                    .join(",")
13040                    .to_string(),
13041            )]),
13042        };
13043    }
13044    if let Some(ref local_var_str) = interface_id {
13045        local_var_req_builder = match "multi" {
13046            "multi" => local_var_req_builder.query(
13047                &local_var_str
13048                    .into_iter()
13049                    .map(|p| ("interface_id".to_owned(), p.to_string()))
13050                    .collect::<Vec<(std::string::String, std::string::String)>>(),
13051            ),
13052            _ => local_var_req_builder.query(&[(
13053                "interface_id",
13054                &local_var_str
13055                    .into_iter()
13056                    .map(|p| p.to_string())
13057                    .collect::<Vec<String>>()
13058                    .join(",")
13059                    .to_string(),
13060            )]),
13061        };
13062    }
13063    if let Some(ref local_var_str) = interface_id__n {
13064        local_var_req_builder = match "multi" {
13065            "multi" => local_var_req_builder.query(
13066                &local_var_str
13067                    .into_iter()
13068                    .map(|p| ("interface_id__n".to_owned(), p.to_string()))
13069                    .collect::<Vec<(std::string::String, std::string::String)>>(),
13070            ),
13071            _ => local_var_req_builder.query(&[(
13072                "interface_id__n",
13073                &local_var_str
13074                    .into_iter()
13075                    .map(|p| p.to_string())
13076                    .collect::<Vec<String>>()
13077                    .join(",")
13078                    .to_string(),
13079            )]),
13080        };
13081    }
13082    if let Some(ref local_var_str) = l2vpn {
13083        local_var_req_builder = match "multi" {
13084            "multi" => local_var_req_builder.query(
13085                &local_var_str
13086                    .into_iter()
13087                    .map(|p| ("l2vpn".to_owned(), p.to_string()))
13088                    .collect::<Vec<(std::string::String, std::string::String)>>(),
13089            ),
13090            _ => local_var_req_builder.query(&[(
13091                "l2vpn",
13092                &local_var_str
13093                    .into_iter()
13094                    .map(|p| p.to_string())
13095                    .collect::<Vec<String>>()
13096                    .join(",")
13097                    .to_string(),
13098            )]),
13099        };
13100    }
13101    if let Some(ref local_var_str) = l2vpn__n {
13102        local_var_req_builder = match "multi" {
13103            "multi" => local_var_req_builder.query(
13104                &local_var_str
13105                    .into_iter()
13106                    .map(|p| ("l2vpn__n".to_owned(), p.to_string()))
13107                    .collect::<Vec<(std::string::String, std::string::String)>>(),
13108            ),
13109            _ => local_var_req_builder.query(&[(
13110                "l2vpn__n",
13111                &local_var_str
13112                    .into_iter()
13113                    .map(|p| p.to_string())
13114                    .collect::<Vec<String>>()
13115                    .join(",")
13116                    .to_string(),
13117            )]),
13118        };
13119    }
13120    if let Some(ref local_var_str) = l2vpn_id {
13121        local_var_req_builder = match "multi" {
13122            "multi" => local_var_req_builder.query(
13123                &local_var_str
13124                    .into_iter()
13125                    .map(|p| ("l2vpn_id".to_owned(), p.to_string()))
13126                    .collect::<Vec<(std::string::String, std::string::String)>>(),
13127            ),
13128            _ => local_var_req_builder.query(&[(
13129                "l2vpn_id",
13130                &local_var_str
13131                    .into_iter()
13132                    .map(|p| p.to_string())
13133                    .collect::<Vec<String>>()
13134                    .join(",")
13135                    .to_string(),
13136            )]),
13137        };
13138    }
13139    if let Some(ref local_var_str) = l2vpn_id__n {
13140        local_var_req_builder = match "multi" {
13141            "multi" => local_var_req_builder.query(
13142                &local_var_str
13143                    .into_iter()
13144                    .map(|p| ("l2vpn_id__n".to_owned(), p.to_string()))
13145                    .collect::<Vec<(std::string::String, std::string::String)>>(),
13146            ),
13147            _ => local_var_req_builder.query(&[(
13148                "l2vpn_id__n",
13149                &local_var_str
13150                    .into_iter()
13151                    .map(|p| p.to_string())
13152                    .collect::<Vec<String>>()
13153                    .join(",")
13154                    .to_string(),
13155            )]),
13156        };
13157    }
13158    if let Some(ref local_var_str) = last_updated {
13159        local_var_req_builder = match "multi" {
13160            "multi" => local_var_req_builder.query(
13161                &local_var_str
13162                    .into_iter()
13163                    .map(|p| ("last_updated".to_owned(), p.to_string()))
13164                    .collect::<Vec<(std::string::String, std::string::String)>>(),
13165            ),
13166            _ => local_var_req_builder.query(&[(
13167                "last_updated",
13168                &local_var_str
13169                    .into_iter()
13170                    .map(|p| p.to_string())
13171                    .collect::<Vec<String>>()
13172                    .join(",")
13173                    .to_string(),
13174            )]),
13175        };
13176    }
13177    if let Some(ref local_var_str) = last_updated__empty {
13178        local_var_req_builder = match "multi" {
13179            "multi" => local_var_req_builder.query(
13180                &local_var_str
13181                    .into_iter()
13182                    .map(|p| ("last_updated__empty".to_owned(), p.to_string()))
13183                    .collect::<Vec<(std::string::String, std::string::String)>>(),
13184            ),
13185            _ => local_var_req_builder.query(&[(
13186                "last_updated__empty",
13187                &local_var_str
13188                    .into_iter()
13189                    .map(|p| p.to_string())
13190                    .collect::<Vec<String>>()
13191                    .join(",")
13192                    .to_string(),
13193            )]),
13194        };
13195    }
13196    if let Some(ref local_var_str) = last_updated__gt {
13197        local_var_req_builder = match "multi" {
13198            "multi" => local_var_req_builder.query(
13199                &local_var_str
13200                    .into_iter()
13201                    .map(|p| ("last_updated__gt".to_owned(), p.to_string()))
13202                    .collect::<Vec<(std::string::String, std::string::String)>>(),
13203            ),
13204            _ => local_var_req_builder.query(&[(
13205                "last_updated__gt",
13206                &local_var_str
13207                    .into_iter()
13208                    .map(|p| p.to_string())
13209                    .collect::<Vec<String>>()
13210                    .join(",")
13211                    .to_string(),
13212            )]),
13213        };
13214    }
13215    if let Some(ref local_var_str) = last_updated__gte {
13216        local_var_req_builder = match "multi" {
13217            "multi" => local_var_req_builder.query(
13218                &local_var_str
13219                    .into_iter()
13220                    .map(|p| ("last_updated__gte".to_owned(), p.to_string()))
13221                    .collect::<Vec<(std::string::String, std::string::String)>>(),
13222            ),
13223            _ => local_var_req_builder.query(&[(
13224                "last_updated__gte",
13225                &local_var_str
13226                    .into_iter()
13227                    .map(|p| p.to_string())
13228                    .collect::<Vec<String>>()
13229                    .join(",")
13230                    .to_string(),
13231            )]),
13232        };
13233    }
13234    if let Some(ref local_var_str) = last_updated__lt {
13235        local_var_req_builder = match "multi" {
13236            "multi" => local_var_req_builder.query(
13237                &local_var_str
13238                    .into_iter()
13239                    .map(|p| ("last_updated__lt".to_owned(), p.to_string()))
13240                    .collect::<Vec<(std::string::String, std::string::String)>>(),
13241            ),
13242            _ => local_var_req_builder.query(&[(
13243                "last_updated__lt",
13244                &local_var_str
13245                    .into_iter()
13246                    .map(|p| p.to_string())
13247                    .collect::<Vec<String>>()
13248                    .join(",")
13249                    .to_string(),
13250            )]),
13251        };
13252    }
13253    if let Some(ref local_var_str) = last_updated__lte {
13254        local_var_req_builder = match "multi" {
13255            "multi" => local_var_req_builder.query(
13256                &local_var_str
13257                    .into_iter()
13258                    .map(|p| ("last_updated__lte".to_owned(), p.to_string()))
13259                    .collect::<Vec<(std::string::String, std::string::String)>>(),
13260            ),
13261            _ => local_var_req_builder.query(&[(
13262                "last_updated__lte",
13263                &local_var_str
13264                    .into_iter()
13265                    .map(|p| p.to_string())
13266                    .collect::<Vec<String>>()
13267                    .join(",")
13268                    .to_string(),
13269            )]),
13270        };
13271    }
13272    if let Some(ref local_var_str) = last_updated__n {
13273        local_var_req_builder = match "multi" {
13274            "multi" => local_var_req_builder.query(
13275                &local_var_str
13276                    .into_iter()
13277                    .map(|p| ("last_updated__n".to_owned(), p.to_string()))
13278                    .collect::<Vec<(std::string::String, std::string::String)>>(),
13279            ),
13280            _ => local_var_req_builder.query(&[(
13281                "last_updated__n",
13282                &local_var_str
13283                    .into_iter()
13284                    .map(|p| p.to_string())
13285                    .collect::<Vec<String>>()
13286                    .join(",")
13287                    .to_string(),
13288            )]),
13289        };
13290    }
13291    if let Some(ref local_var_str) = limit {
13292        local_var_req_builder =
13293            local_var_req_builder.query(&[("limit", &local_var_str.to_string())]);
13294    }
13295    if let Some(ref local_var_str) = modified_by_request {
13296        local_var_req_builder =
13297            local_var_req_builder.query(&[("modified_by_request", &local_var_str.to_string())]);
13298    }
13299    if let Some(ref local_var_str) = offset {
13300        local_var_req_builder =
13301            local_var_req_builder.query(&[("offset", &local_var_str.to_string())]);
13302    }
13303    if let Some(ref local_var_str) = ordering {
13304        local_var_req_builder =
13305            local_var_req_builder.query(&[("ordering", &local_var_str.to_string())]);
13306    }
13307    if let Some(ref local_var_str) = q {
13308        local_var_req_builder = local_var_req_builder.query(&[("q", &local_var_str.to_string())]);
13309    }
13310    if let Some(ref local_var_str) = region {
13311        local_var_req_builder = match "multi" {
13312            "multi" => local_var_req_builder.query(
13313                &local_var_str
13314                    .into_iter()
13315                    .map(|p| ("region".to_owned(), p.to_string()))
13316                    .collect::<Vec<(std::string::String, std::string::String)>>(),
13317            ),
13318            _ => local_var_req_builder.query(&[(
13319                "region",
13320                &local_var_str
13321                    .into_iter()
13322                    .map(|p| p.to_string())
13323                    .collect::<Vec<String>>()
13324                    .join(",")
13325                    .to_string(),
13326            )]),
13327        };
13328    }
13329    if let Some(ref local_var_str) = region_id {
13330        local_var_req_builder = match "multi" {
13331            "multi" => local_var_req_builder.query(
13332                &local_var_str
13333                    .into_iter()
13334                    .map(|p| ("region_id".to_owned(), p.to_string()))
13335                    .collect::<Vec<(std::string::String, std::string::String)>>(),
13336            ),
13337            _ => local_var_req_builder.query(&[(
13338                "region_id",
13339                &local_var_str
13340                    .into_iter()
13341                    .map(|p| p.to_string())
13342                    .collect::<Vec<String>>()
13343                    .join(",")
13344                    .to_string(),
13345            )]),
13346        };
13347    }
13348    if let Some(ref local_var_str) = site {
13349        local_var_req_builder = match "multi" {
13350            "multi" => local_var_req_builder.query(
13351                &local_var_str
13352                    .into_iter()
13353                    .map(|p| ("site".to_owned(), p.to_string()))
13354                    .collect::<Vec<(std::string::String, std::string::String)>>(),
13355            ),
13356            _ => local_var_req_builder.query(&[(
13357                "site",
13358                &local_var_str
13359                    .into_iter()
13360                    .map(|p| p.to_string())
13361                    .collect::<Vec<String>>()
13362                    .join(",")
13363                    .to_string(),
13364            )]),
13365        };
13366    }
13367    if let Some(ref local_var_str) = site_id {
13368        local_var_req_builder = match "multi" {
13369            "multi" => local_var_req_builder.query(
13370                &local_var_str
13371                    .into_iter()
13372                    .map(|p| ("site_id".to_owned(), p.to_string()))
13373                    .collect::<Vec<(std::string::String, std::string::String)>>(),
13374            ),
13375            _ => local_var_req_builder.query(&[(
13376                "site_id",
13377                &local_var_str
13378                    .into_iter()
13379                    .map(|p| p.to_string())
13380                    .collect::<Vec<String>>()
13381                    .join(",")
13382                    .to_string(),
13383            )]),
13384        };
13385    }
13386    if let Some(ref local_var_str) = start {
13387        local_var_req_builder =
13388            local_var_req_builder.query(&[("start", &local_var_str.to_string())]);
13389    }
13390    if let Some(ref local_var_str) = tag {
13391        local_var_req_builder = match "multi" {
13392            "multi" => local_var_req_builder.query(
13393                &local_var_str
13394                    .into_iter()
13395                    .map(|p| ("tag".to_owned(), p.to_string()))
13396                    .collect::<Vec<(std::string::String, std::string::String)>>(),
13397            ),
13398            _ => local_var_req_builder.query(&[(
13399                "tag",
13400                &local_var_str
13401                    .into_iter()
13402                    .map(|p| p.to_string())
13403                    .collect::<Vec<String>>()
13404                    .join(",")
13405                    .to_string(),
13406            )]),
13407        };
13408    }
13409    if let Some(ref local_var_str) = tag__n {
13410        local_var_req_builder = match "multi" {
13411            "multi" => local_var_req_builder.query(
13412                &local_var_str
13413                    .into_iter()
13414                    .map(|p| ("tag__n".to_owned(), p.to_string()))
13415                    .collect::<Vec<(std::string::String, std::string::String)>>(),
13416            ),
13417            _ => local_var_req_builder.query(&[(
13418                "tag__n",
13419                &local_var_str
13420                    .into_iter()
13421                    .map(|p| p.to_string())
13422                    .collect::<Vec<String>>()
13423                    .join(",")
13424                    .to_string(),
13425            )]),
13426        };
13427    }
13428    if let Some(ref local_var_str) = tag_id {
13429        local_var_req_builder = match "multi" {
13430            "multi" => local_var_req_builder.query(
13431                &local_var_str
13432                    .into_iter()
13433                    .map(|p| ("tag_id".to_owned(), p.to_string()))
13434                    .collect::<Vec<(std::string::String, std::string::String)>>(),
13435            ),
13436            _ => local_var_req_builder.query(&[(
13437                "tag_id",
13438                &local_var_str
13439                    .into_iter()
13440                    .map(|p| p.to_string())
13441                    .collect::<Vec<String>>()
13442                    .join(",")
13443                    .to_string(),
13444            )]),
13445        };
13446    }
13447    if let Some(ref local_var_str) = tag_id__n {
13448        local_var_req_builder = match "multi" {
13449            "multi" => local_var_req_builder.query(
13450                &local_var_str
13451                    .into_iter()
13452                    .map(|p| ("tag_id__n".to_owned(), p.to_string()))
13453                    .collect::<Vec<(std::string::String, std::string::String)>>(),
13454            ),
13455            _ => local_var_req_builder.query(&[(
13456                "tag_id__n",
13457                &local_var_str
13458                    .into_iter()
13459                    .map(|p| p.to_string())
13460                    .collect::<Vec<String>>()
13461                    .join(",")
13462                    .to_string(),
13463            )]),
13464        };
13465    }
13466    if let Some(ref local_var_str) = updated_by_request {
13467        local_var_req_builder =
13468            local_var_req_builder.query(&[("updated_by_request", &local_var_str.to_string())]);
13469    }
13470    if let Some(ref local_var_str) = virtual_machine {
13471        local_var_req_builder = match "multi" {
13472            "multi" => local_var_req_builder.query(
13473                &local_var_str
13474                    .into_iter()
13475                    .map(|p| ("virtual_machine".to_owned(), p.to_string()))
13476                    .collect::<Vec<(std::string::String, std::string::String)>>(),
13477            ),
13478            _ => local_var_req_builder.query(&[(
13479                "virtual_machine",
13480                &local_var_str
13481                    .into_iter()
13482                    .map(|p| p.to_string())
13483                    .collect::<Vec<String>>()
13484                    .join(",")
13485                    .to_string(),
13486            )]),
13487        };
13488    }
13489    if let Some(ref local_var_str) = virtual_machine__n {
13490        local_var_req_builder = match "multi" {
13491            "multi" => local_var_req_builder.query(
13492                &local_var_str
13493                    .into_iter()
13494                    .map(|p| ("virtual_machine__n".to_owned(), p.to_string()))
13495                    .collect::<Vec<(std::string::String, std::string::String)>>(),
13496            ),
13497            _ => local_var_req_builder.query(&[(
13498                "virtual_machine__n",
13499                &local_var_str
13500                    .into_iter()
13501                    .map(|p| p.to_string())
13502                    .collect::<Vec<String>>()
13503                    .join(",")
13504                    .to_string(),
13505            )]),
13506        };
13507    }
13508    if let Some(ref local_var_str) = virtual_machine_id {
13509        local_var_req_builder = match "multi" {
13510            "multi" => local_var_req_builder.query(
13511                &local_var_str
13512                    .into_iter()
13513                    .map(|p| ("virtual_machine_id".to_owned(), p.to_string()))
13514                    .collect::<Vec<(std::string::String, std::string::String)>>(),
13515            ),
13516            _ => local_var_req_builder.query(&[(
13517                "virtual_machine_id",
13518                &local_var_str
13519                    .into_iter()
13520                    .map(|p| p.to_string())
13521                    .collect::<Vec<String>>()
13522                    .join(",")
13523                    .to_string(),
13524            )]),
13525        };
13526    }
13527    if let Some(ref local_var_str) = virtual_machine_id__n {
13528        local_var_req_builder = match "multi" {
13529            "multi" => local_var_req_builder.query(
13530                &local_var_str
13531                    .into_iter()
13532                    .map(|p| ("virtual_machine_id__n".to_owned(), p.to_string()))
13533                    .collect::<Vec<(std::string::String, std::string::String)>>(),
13534            ),
13535            _ => local_var_req_builder.query(&[(
13536                "virtual_machine_id__n",
13537                &local_var_str
13538                    .into_iter()
13539                    .map(|p| p.to_string())
13540                    .collect::<Vec<String>>()
13541                    .join(",")
13542                    .to_string(),
13543            )]),
13544        };
13545    }
13546    if let Some(ref local_var_str) = vlan {
13547        local_var_req_builder = match "multi" {
13548            "multi" => local_var_req_builder.query(
13549                &local_var_str
13550                    .into_iter()
13551                    .map(|p| ("vlan".to_owned(), p.to_string()))
13552                    .collect::<Vec<(std::string::String, std::string::String)>>(),
13553            ),
13554            _ => local_var_req_builder.query(&[(
13555                "vlan",
13556                &local_var_str
13557                    .into_iter()
13558                    .map(|p| p.to_string())
13559                    .collect::<Vec<String>>()
13560                    .join(",")
13561                    .to_string(),
13562            )]),
13563        };
13564    }
13565    if let Some(ref local_var_str) = vlan__n {
13566        local_var_req_builder = match "multi" {
13567            "multi" => local_var_req_builder.query(
13568                &local_var_str
13569                    .into_iter()
13570                    .map(|p| ("vlan__n".to_owned(), p.to_string()))
13571                    .collect::<Vec<(std::string::String, std::string::String)>>(),
13572            ),
13573            _ => local_var_req_builder.query(&[(
13574                "vlan__n",
13575                &local_var_str
13576                    .into_iter()
13577                    .map(|p| p.to_string())
13578                    .collect::<Vec<String>>()
13579                    .join(",")
13580                    .to_string(),
13581            )]),
13582        };
13583    }
13584    if let Some(ref local_var_str) = vlan_id {
13585        local_var_req_builder = match "multi" {
13586            "multi" => local_var_req_builder.query(
13587                &local_var_str
13588                    .into_iter()
13589                    .map(|p| ("vlan_id".to_owned(), p.to_string()))
13590                    .collect::<Vec<(std::string::String, std::string::String)>>(),
13591            ),
13592            _ => local_var_req_builder.query(&[(
13593                "vlan_id",
13594                &local_var_str
13595                    .into_iter()
13596                    .map(|p| p.to_string())
13597                    .collect::<Vec<String>>()
13598                    .join(",")
13599                    .to_string(),
13600            )]),
13601        };
13602    }
13603    if let Some(ref local_var_str) = vlan_id__n {
13604        local_var_req_builder = match "multi" {
13605            "multi" => local_var_req_builder.query(
13606                &local_var_str
13607                    .into_iter()
13608                    .map(|p| ("vlan_id__n".to_owned(), p.to_string()))
13609                    .collect::<Vec<(std::string::String, std::string::String)>>(),
13610            ),
13611            _ => local_var_req_builder.query(&[(
13612                "vlan_id__n",
13613                &local_var_str
13614                    .into_iter()
13615                    .map(|p| p.to_string())
13616                    .collect::<Vec<String>>()
13617                    .join(",")
13618                    .to_string(),
13619            )]),
13620        };
13621    }
13622    if let Some(ref local_var_str) = vlan_vid {
13623        local_var_req_builder =
13624            local_var_req_builder.query(&[("vlan_vid", &local_var_str.to_string())]);
13625    }
13626    if let Some(ref local_var_str) = vlan_vid__empty {
13627        local_var_req_builder =
13628            local_var_req_builder.query(&[("vlan_vid__empty", &local_var_str.to_string())]);
13629    }
13630    if let Some(ref local_var_str) = vlan_vid__gt {
13631        local_var_req_builder =
13632            local_var_req_builder.query(&[("vlan_vid__gt", &local_var_str.to_string())]);
13633    }
13634    if let Some(ref local_var_str) = vlan_vid__gte {
13635        local_var_req_builder =
13636            local_var_req_builder.query(&[("vlan_vid__gte", &local_var_str.to_string())]);
13637    }
13638    if let Some(ref local_var_str) = vlan_vid__lt {
13639        local_var_req_builder =
13640            local_var_req_builder.query(&[("vlan_vid__lt", &local_var_str.to_string())]);
13641    }
13642    if let Some(ref local_var_str) = vlan_vid__lte {
13643        local_var_req_builder =
13644            local_var_req_builder.query(&[("vlan_vid__lte", &local_var_str.to_string())]);
13645    }
13646    if let Some(ref local_var_str) = vlan_vid__n {
13647        local_var_req_builder =
13648            local_var_req_builder.query(&[("vlan_vid__n", &local_var_str.to_string())]);
13649    }
13650    if let Some(ref local_var_str) = vminterface {
13651        local_var_req_builder = match "multi" {
13652            "multi" => local_var_req_builder.query(
13653                &local_var_str
13654                    .into_iter()
13655                    .map(|p| ("vminterface".to_owned(), p.to_string()))
13656                    .collect::<Vec<(std::string::String, std::string::String)>>(),
13657            ),
13658            _ => local_var_req_builder.query(&[(
13659                "vminterface",
13660                &local_var_str
13661                    .into_iter()
13662                    .map(|p| p.to_string())
13663                    .collect::<Vec<String>>()
13664                    .join(",")
13665                    .to_string(),
13666            )]),
13667        };
13668    }
13669    if let Some(ref local_var_str) = vminterface__n {
13670        local_var_req_builder = match "multi" {
13671            "multi" => local_var_req_builder.query(
13672                &local_var_str
13673                    .into_iter()
13674                    .map(|p| ("vminterface__n".to_owned(), p.to_string()))
13675                    .collect::<Vec<(std::string::String, std::string::String)>>(),
13676            ),
13677            _ => local_var_req_builder.query(&[(
13678                "vminterface__n",
13679                &local_var_str
13680                    .into_iter()
13681                    .map(|p| p.to_string())
13682                    .collect::<Vec<String>>()
13683                    .join(",")
13684                    .to_string(),
13685            )]),
13686        };
13687    }
13688    if let Some(ref local_var_str) = vminterface_id {
13689        local_var_req_builder = match "multi" {
13690            "multi" => local_var_req_builder.query(
13691                &local_var_str
13692                    .into_iter()
13693                    .map(|p| ("vminterface_id".to_owned(), p.to_string()))
13694                    .collect::<Vec<(std::string::String, std::string::String)>>(),
13695            ),
13696            _ => local_var_req_builder.query(&[(
13697                "vminterface_id",
13698                &local_var_str
13699                    .into_iter()
13700                    .map(|p| p.to_string())
13701                    .collect::<Vec<String>>()
13702                    .join(",")
13703                    .to_string(),
13704            )]),
13705        };
13706    }
13707    if let Some(ref local_var_str) = vminterface_id__n {
13708        local_var_req_builder = match "multi" {
13709            "multi" => local_var_req_builder.query(
13710                &local_var_str
13711                    .into_iter()
13712                    .map(|p| ("vminterface_id__n".to_owned(), p.to_string()))
13713                    .collect::<Vec<(std::string::String, std::string::String)>>(),
13714            ),
13715            _ => local_var_req_builder.query(&[(
13716                "vminterface_id__n",
13717                &local_var_str
13718                    .into_iter()
13719                    .map(|p| p.to_string())
13720                    .collect::<Vec<String>>()
13721                    .join(",")
13722                    .to_string(),
13723            )]),
13724        };
13725    }
13726    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
13727        local_var_req_builder =
13728            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
13729    }
13730    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
13731        let local_var_key = local_var_apikey.key.clone();
13732        let local_var_value = match local_var_apikey.prefix {
13733            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
13734            None => local_var_key,
13735        };
13736        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
13737    };
13738
13739    let local_var_req = local_var_req_builder.build()?;
13740    let local_var_resp = local_var_client.execute(local_var_req).await?;
13741
13742    let local_var_status = local_var_resp.status();
13743    let local_var_content = local_var_resp.text().await?;
13744
13745    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
13746        serde_json::from_str(&local_var_content).map_err(Error::from)
13747    } else {
13748        let local_var_entity: Option<VpnL2vpnTerminationsListError> =
13749            serde_json::from_str(&local_var_content).ok();
13750        let local_var_error = ResponseContent {
13751            status: local_var_status,
13752            content: local_var_content,
13753            entity: local_var_entity,
13754        };
13755        Err(Error::ResponseError(local_var_error))
13756    }
13757}
13758
13759/// Patch a L2VPN termination object.
13760pub async fn vpn_l2vpn_terminations_partial_update(
13761    configuration: &configuration::Configuration,
13762    id: i32,
13763    patched_l2_vpn_termination_request: Option<crate::models::PatchedL2VpnTerminationRequest>,
13764) -> Result<crate::models::L2VpnTermination, Error<VpnL2vpnTerminationsPartialUpdateError>> {
13765    let local_var_configuration = configuration;
13766
13767    let local_var_client = &local_var_configuration.client;
13768
13769    let local_var_uri_str = format!(
13770        "{}/api/vpn/l2vpn-terminations/{id}/",
13771        local_var_configuration.base_path,
13772        id = id
13773    );
13774    let mut local_var_req_builder =
13775        local_var_client.request(reqwest::Method::PATCH, local_var_uri_str.as_str());
13776
13777    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
13778        local_var_req_builder =
13779            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
13780    }
13781    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
13782        let local_var_key = local_var_apikey.key.clone();
13783        let local_var_value = match local_var_apikey.prefix {
13784            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
13785            None => local_var_key,
13786        };
13787        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
13788    };
13789    local_var_req_builder = local_var_req_builder.json(&patched_l2_vpn_termination_request);
13790
13791    let local_var_req = local_var_req_builder.build()?;
13792    let local_var_resp = local_var_client.execute(local_var_req).await?;
13793
13794    let local_var_status = local_var_resp.status();
13795    let local_var_content = local_var_resp.text().await?;
13796
13797    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
13798        serde_json::from_str(&local_var_content).map_err(Error::from)
13799    } else {
13800        let local_var_entity: Option<VpnL2vpnTerminationsPartialUpdateError> =
13801            serde_json::from_str(&local_var_content).ok();
13802        let local_var_error = ResponseContent {
13803            status: local_var_status,
13804            content: local_var_content,
13805            entity: local_var_entity,
13806        };
13807        Err(Error::ResponseError(local_var_error))
13808    }
13809}
13810
13811/// Get a L2VPN termination object.
13812pub async fn vpn_l2vpn_terminations_retrieve(
13813    configuration: &configuration::Configuration,
13814    id: i32,
13815) -> Result<crate::models::L2VpnTermination, Error<VpnL2vpnTerminationsRetrieveError>> {
13816    let local_var_configuration = configuration;
13817
13818    let local_var_client = &local_var_configuration.client;
13819
13820    let local_var_uri_str = format!(
13821        "{}/api/vpn/l2vpn-terminations/{id}/",
13822        local_var_configuration.base_path,
13823        id = id
13824    );
13825    let mut local_var_req_builder =
13826        local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
13827
13828    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
13829        local_var_req_builder =
13830            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
13831    }
13832    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
13833        let local_var_key = local_var_apikey.key.clone();
13834        let local_var_value = match local_var_apikey.prefix {
13835            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
13836            None => local_var_key,
13837        };
13838        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
13839    };
13840
13841    let local_var_req = local_var_req_builder.build()?;
13842    let local_var_resp = local_var_client.execute(local_var_req).await?;
13843
13844    let local_var_status = local_var_resp.status();
13845    let local_var_content = local_var_resp.text().await?;
13846
13847    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
13848        serde_json::from_str(&local_var_content).map_err(Error::from)
13849    } else {
13850        let local_var_entity: Option<VpnL2vpnTerminationsRetrieveError> =
13851            serde_json::from_str(&local_var_content).ok();
13852        let local_var_error = ResponseContent {
13853            status: local_var_status,
13854            content: local_var_content,
13855            entity: local_var_entity,
13856        };
13857        Err(Error::ResponseError(local_var_error))
13858    }
13859}
13860
13861/// Put a L2VPN termination object.
13862pub async fn vpn_l2vpn_terminations_update(
13863    configuration: &configuration::Configuration,
13864    id: i32,
13865    l2_vpn_termination_request: crate::models::L2VpnTerminationRequest,
13866) -> Result<crate::models::L2VpnTermination, Error<VpnL2vpnTerminationsUpdateError>> {
13867    let local_var_configuration = configuration;
13868
13869    let local_var_client = &local_var_configuration.client;
13870
13871    let local_var_uri_str = format!(
13872        "{}/api/vpn/l2vpn-terminations/{id}/",
13873        local_var_configuration.base_path,
13874        id = id
13875    );
13876    let mut local_var_req_builder =
13877        local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());
13878
13879    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
13880        local_var_req_builder =
13881            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
13882    }
13883    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
13884        let local_var_key = local_var_apikey.key.clone();
13885        let local_var_value = match local_var_apikey.prefix {
13886            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
13887            None => local_var_key,
13888        };
13889        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
13890    };
13891    local_var_req_builder = local_var_req_builder.json(&l2_vpn_termination_request);
13892
13893    let local_var_req = local_var_req_builder.build()?;
13894    let local_var_resp = local_var_client.execute(local_var_req).await?;
13895
13896    let local_var_status = local_var_resp.status();
13897    let local_var_content = local_var_resp.text().await?;
13898
13899    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
13900        serde_json::from_str(&local_var_content).map_err(Error::from)
13901    } else {
13902        let local_var_entity: Option<VpnL2vpnTerminationsUpdateError> =
13903            serde_json::from_str(&local_var_content).ok();
13904        let local_var_error = ResponseContent {
13905            status: local_var_status,
13906            content: local_var_content,
13907            entity: local_var_entity,
13908        };
13909        Err(Error::ResponseError(local_var_error))
13910    }
13911}
13912
13913/// Delete a list of L2VPN objects.
13914pub async fn vpn_l2vpns_bulk_destroy(
13915    configuration: &configuration::Configuration,
13916    l2_vpn_request: Vec<crate::models::L2VpnRequest>,
13917) -> Result<(), Error<VpnL2vpnsBulkDestroyError>> {
13918    let local_var_configuration = configuration;
13919
13920    let local_var_client = &local_var_configuration.client;
13921
13922    let local_var_uri_str = format!("{}/api/vpn/l2vpns/", local_var_configuration.base_path);
13923    let mut local_var_req_builder =
13924        local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());
13925
13926    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
13927        local_var_req_builder =
13928            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
13929    }
13930    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
13931        let local_var_key = local_var_apikey.key.clone();
13932        let local_var_value = match local_var_apikey.prefix {
13933            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
13934            None => local_var_key,
13935        };
13936        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
13937    };
13938    local_var_req_builder = local_var_req_builder.json(&l2_vpn_request);
13939
13940    let local_var_req = local_var_req_builder.build()?;
13941    let local_var_resp = local_var_client.execute(local_var_req).await?;
13942
13943    let local_var_status = local_var_resp.status();
13944    let local_var_content = local_var_resp.text().await?;
13945
13946    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
13947        Ok(())
13948    } else {
13949        let local_var_entity: Option<VpnL2vpnsBulkDestroyError> =
13950            serde_json::from_str(&local_var_content).ok();
13951        let local_var_error = ResponseContent {
13952            status: local_var_status,
13953            content: local_var_content,
13954            entity: local_var_entity,
13955        };
13956        Err(Error::ResponseError(local_var_error))
13957    }
13958}
13959
13960/// Patch a list of L2VPN objects.
13961pub async fn vpn_l2vpns_bulk_partial_update(
13962    configuration: &configuration::Configuration,
13963    l2_vpn_request: Vec<crate::models::L2VpnRequest>,
13964) -> Result<Vec<crate::models::L2Vpn>, Error<VpnL2vpnsBulkPartialUpdateError>> {
13965    let local_var_configuration = configuration;
13966
13967    let local_var_client = &local_var_configuration.client;
13968
13969    let local_var_uri_str = format!("{}/api/vpn/l2vpns/", local_var_configuration.base_path);
13970    let mut local_var_req_builder =
13971        local_var_client.request(reqwest::Method::PATCH, local_var_uri_str.as_str());
13972
13973    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
13974        local_var_req_builder =
13975            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
13976    }
13977    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
13978        let local_var_key = local_var_apikey.key.clone();
13979        let local_var_value = match local_var_apikey.prefix {
13980            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
13981            None => local_var_key,
13982        };
13983        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
13984    };
13985    local_var_req_builder = local_var_req_builder.json(&l2_vpn_request);
13986
13987    let local_var_req = local_var_req_builder.build()?;
13988    let local_var_resp = local_var_client.execute(local_var_req).await?;
13989
13990    let local_var_status = local_var_resp.status();
13991    let local_var_content = local_var_resp.text().await?;
13992
13993    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
13994        serde_json::from_str(&local_var_content).map_err(Error::from)
13995    } else {
13996        let local_var_entity: Option<VpnL2vpnsBulkPartialUpdateError> =
13997            serde_json::from_str(&local_var_content).ok();
13998        let local_var_error = ResponseContent {
13999            status: local_var_status,
14000            content: local_var_content,
14001            entity: local_var_entity,
14002        };
14003        Err(Error::ResponseError(local_var_error))
14004    }
14005}
14006
14007/// Put a list of L2VPN objects.
14008pub async fn vpn_l2vpns_bulk_update(
14009    configuration: &configuration::Configuration,
14010    l2_vpn_request: Vec<crate::models::L2VpnRequest>,
14011) -> Result<Vec<crate::models::L2Vpn>, Error<VpnL2vpnsBulkUpdateError>> {
14012    let local_var_configuration = configuration;
14013
14014    let local_var_client = &local_var_configuration.client;
14015
14016    let local_var_uri_str = format!("{}/api/vpn/l2vpns/", local_var_configuration.base_path);
14017    let mut local_var_req_builder =
14018        local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());
14019
14020    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
14021        local_var_req_builder =
14022            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
14023    }
14024    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
14025        let local_var_key = local_var_apikey.key.clone();
14026        let local_var_value = match local_var_apikey.prefix {
14027            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
14028            None => local_var_key,
14029        };
14030        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
14031    };
14032    local_var_req_builder = local_var_req_builder.json(&l2_vpn_request);
14033
14034    let local_var_req = local_var_req_builder.build()?;
14035    let local_var_resp = local_var_client.execute(local_var_req).await?;
14036
14037    let local_var_status = local_var_resp.status();
14038    let local_var_content = local_var_resp.text().await?;
14039
14040    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
14041        serde_json::from_str(&local_var_content).map_err(Error::from)
14042    } else {
14043        let local_var_entity: Option<VpnL2vpnsBulkUpdateError> =
14044            serde_json::from_str(&local_var_content).ok();
14045        let local_var_error = ResponseContent {
14046            status: local_var_status,
14047            content: local_var_content,
14048            entity: local_var_entity,
14049        };
14050        Err(Error::ResponseError(local_var_error))
14051    }
14052}
14053
14054/// Post a list of L2VPN objects.
14055pub async fn vpn_l2vpns_create(
14056    configuration: &configuration::Configuration,
14057    vpn_l2vpns_create_request: crate::models::VpnL2vpnsCreateRequest,
14058) -> Result<crate::models::L2Vpn, Error<VpnL2vpnsCreateError>> {
14059    let local_var_configuration = configuration;
14060
14061    let local_var_client = &local_var_configuration.client;
14062
14063    let local_var_uri_str = format!("{}/api/vpn/l2vpns/", local_var_configuration.base_path);
14064    let mut local_var_req_builder =
14065        local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
14066
14067    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
14068        local_var_req_builder =
14069            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
14070    }
14071    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
14072        let local_var_key = local_var_apikey.key.clone();
14073        let local_var_value = match local_var_apikey.prefix {
14074            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
14075            None => local_var_key,
14076        };
14077        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
14078    };
14079    local_var_req_builder = local_var_req_builder.json(&vpn_l2vpns_create_request);
14080
14081    let local_var_req = local_var_req_builder.build()?;
14082    let local_var_resp = local_var_client.execute(local_var_req).await?;
14083
14084    let local_var_status = local_var_resp.status();
14085    let local_var_content = local_var_resp.text().await?;
14086
14087    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
14088        serde_json::from_str(&local_var_content).map_err(Error::from)
14089    } else {
14090        let local_var_entity: Option<VpnL2vpnsCreateError> =
14091            serde_json::from_str(&local_var_content).ok();
14092        let local_var_error = ResponseContent {
14093            status: local_var_status,
14094            content: local_var_content,
14095            entity: local_var_entity,
14096        };
14097        Err(Error::ResponseError(local_var_error))
14098    }
14099}
14100
14101/// Delete a L2VPN object.
14102pub async fn vpn_l2vpns_destroy(
14103    configuration: &configuration::Configuration,
14104    id: i32,
14105) -> Result<(), Error<VpnL2vpnsDestroyError>> {
14106    let local_var_configuration = configuration;
14107
14108    let local_var_client = &local_var_configuration.client;
14109
14110    let local_var_uri_str = format!(
14111        "{}/api/vpn/l2vpns/{id}/",
14112        local_var_configuration.base_path,
14113        id = id
14114    );
14115    let mut local_var_req_builder =
14116        local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());
14117
14118    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
14119        local_var_req_builder =
14120            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
14121    }
14122    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
14123        let local_var_key = local_var_apikey.key.clone();
14124        let local_var_value = match local_var_apikey.prefix {
14125            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
14126            None => local_var_key,
14127        };
14128        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
14129    };
14130
14131    let local_var_req = local_var_req_builder.build()?;
14132    let local_var_resp = local_var_client.execute(local_var_req).await?;
14133
14134    let local_var_status = local_var_resp.status();
14135    let local_var_content = local_var_resp.text().await?;
14136
14137    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
14138        Ok(())
14139    } else {
14140        let local_var_entity: Option<VpnL2vpnsDestroyError> =
14141            serde_json::from_str(&local_var_content).ok();
14142        let local_var_error = ResponseContent {
14143            status: local_var_status,
14144            content: local_var_content,
14145            entity: local_var_entity,
14146        };
14147        Err(Error::ResponseError(local_var_error))
14148    }
14149}
14150
14151/// Get a list of L2VPN objects.
14152pub async fn vpn_l2vpns_list(
14153    configuration: &configuration::Configuration,
14154    contact: Option<Vec<i32>>,
14155    contact__n: Option<Vec<i32>>,
14156    contact_group: Option<Vec<String>>,
14157    contact_group__n: Option<Vec<String>>,
14158    contact_role: Option<Vec<i32>>,
14159    contact_role__n: Option<Vec<i32>>,
14160    created: Option<Vec<String>>,
14161    created__empty: Option<Vec<String>>,
14162    created__gt: Option<Vec<String>>,
14163    created__gte: Option<Vec<String>>,
14164    created__lt: Option<Vec<String>>,
14165    created__lte: Option<Vec<String>>,
14166    created__n: Option<Vec<String>>,
14167    created_by_request: Option<&str>,
14168    description: Option<Vec<String>>,
14169    description__empty: Option<bool>,
14170    description__ic: Option<Vec<String>>,
14171    description__ie: Option<Vec<String>>,
14172    description__iew: Option<Vec<String>>,
14173    description__iregex: Option<Vec<String>>,
14174    description__isw: Option<Vec<String>>,
14175    description__n: Option<Vec<String>>,
14176    description__nic: Option<Vec<String>>,
14177    description__nie: Option<Vec<String>>,
14178    description__niew: Option<Vec<String>>,
14179    description__nisw: Option<Vec<String>>,
14180    description__regex: Option<Vec<String>>,
14181    export_target: Option<Vec<String>>,
14182    export_target__n: Option<Vec<String>>,
14183    export_target_id: Option<Vec<i32>>,
14184    export_target_id__n: Option<Vec<i32>>,
14185    id: Option<Vec<i32>>,
14186    id__empty: Option<bool>,
14187    id__gt: Option<Vec<i32>>,
14188    id__gte: Option<Vec<i32>>,
14189    id__lt: Option<Vec<i32>>,
14190    id__lte: Option<Vec<i32>>,
14191    id__n: Option<Vec<i32>>,
14192    identifier: Option<Vec<i32>>,
14193    identifier__empty: Option<bool>,
14194    identifier__gt: Option<Vec<i32>>,
14195    identifier__gte: Option<Vec<i32>>,
14196    identifier__lt: Option<Vec<i32>>,
14197    identifier__lte: Option<Vec<i32>>,
14198    identifier__n: Option<Vec<i32>>,
14199    import_target: Option<Vec<String>>,
14200    import_target__n: Option<Vec<String>>,
14201    import_target_id: Option<Vec<i32>>,
14202    import_target_id__n: Option<Vec<i32>>,
14203    last_updated: Option<Vec<String>>,
14204    last_updated__empty: Option<Vec<String>>,
14205    last_updated__gt: Option<Vec<String>>,
14206    last_updated__gte: Option<Vec<String>>,
14207    last_updated__lt: Option<Vec<String>>,
14208    last_updated__lte: Option<Vec<String>>,
14209    last_updated__n: Option<Vec<String>>,
14210    limit: Option<i32>,
14211    modified_by_request: Option<&str>,
14212    name: Option<Vec<String>>,
14213    name__empty: Option<bool>,
14214    name__ic: Option<Vec<String>>,
14215    name__ie: Option<Vec<String>>,
14216    name__iew: Option<Vec<String>>,
14217    name__iregex: Option<Vec<String>>,
14218    name__isw: Option<Vec<String>>,
14219    name__n: Option<Vec<String>>,
14220    name__nic: Option<Vec<String>>,
14221    name__nie: Option<Vec<String>>,
14222    name__niew: Option<Vec<String>>,
14223    name__nisw: Option<Vec<String>>,
14224    name__regex: Option<Vec<String>>,
14225    offset: Option<i32>,
14226    ordering: Option<&str>,
14227    owner: Option<Vec<String>>,
14228    owner__n: Option<Vec<String>>,
14229    owner_group: Option<Vec<String>>,
14230    owner_group__n: Option<Vec<String>>,
14231    owner_group_id: Option<Vec<i32>>,
14232    owner_group_id__n: Option<Vec<i32>>,
14233    owner_id: Option<Vec<i32>>,
14234    owner_id__n: Option<Vec<i32>>,
14235    q: Option<&str>,
14236    slug: Option<Vec<String>>,
14237    slug__empty: Option<bool>,
14238    slug__ic: Option<Vec<String>>,
14239    slug__ie: Option<Vec<String>>,
14240    slug__iew: Option<Vec<String>>,
14241    slug__iregex: Option<Vec<String>>,
14242    slug__isw: Option<Vec<String>>,
14243    slug__n: Option<Vec<String>>,
14244    slug__nic: Option<Vec<String>>,
14245    slug__nie: Option<Vec<String>>,
14246    slug__niew: Option<Vec<String>>,
14247    slug__nisw: Option<Vec<String>>,
14248    slug__regex: Option<Vec<String>>,
14249    start: Option<i32>,
14250    status: Option<Vec<String>>,
14251    status__empty: Option<bool>,
14252    status__ic: Option<Vec<String>>,
14253    status__ie: Option<Vec<String>>,
14254    status__iew: Option<Vec<String>>,
14255    status__iregex: Option<Vec<String>>,
14256    status__isw: Option<Vec<String>>,
14257    status__n: Option<Vec<String>>,
14258    status__nic: Option<Vec<String>>,
14259    status__nie: Option<Vec<String>>,
14260    status__niew: Option<Vec<String>>,
14261    status__nisw: Option<Vec<String>>,
14262    status__regex: Option<Vec<String>>,
14263    tag: Option<Vec<String>>,
14264    tag__n: Option<Vec<String>>,
14265    tag_id: Option<Vec<i32>>,
14266    tag_id__n: Option<Vec<i32>>,
14267    tenant: Option<Vec<String>>,
14268    tenant__n: Option<Vec<String>>,
14269    tenant_group: Option<Vec<String>>,
14270    tenant_group__n: Option<Vec<String>>,
14271    tenant_group_id: Option<Vec<String>>,
14272    tenant_group_id__n: Option<Vec<String>>,
14273    tenant_id: Option<Vec<i32>>,
14274    tenant_id__n: Option<Vec<i32>>,
14275    r#type: Option<Vec<String>>,
14276    type__empty: Option<bool>,
14277    type__ic: Option<Vec<String>>,
14278    type__ie: Option<Vec<String>>,
14279    type__iew: Option<Vec<String>>,
14280    type__iregex: Option<Vec<String>>,
14281    type__isw: Option<Vec<String>>,
14282    type__n: Option<Vec<String>>,
14283    type__nic: Option<Vec<String>>,
14284    type__nie: Option<Vec<String>>,
14285    type__niew: Option<Vec<String>>,
14286    type__nisw: Option<Vec<String>>,
14287    type__regex: Option<Vec<String>>,
14288    updated_by_request: Option<&str>,
14289) -> Result<crate::models::PaginatedL2VpnList, Error<VpnL2vpnsListError>> {
14290    let local_var_configuration = configuration;
14291
14292    let local_var_client = &local_var_configuration.client;
14293
14294    let local_var_uri_str = format!("{}/api/vpn/l2vpns/", local_var_configuration.base_path);
14295    let mut local_var_req_builder =
14296        local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
14297
14298    if let Some(ref local_var_str) = contact {
14299        local_var_req_builder = match "multi" {
14300            "multi" => local_var_req_builder.query(
14301                &local_var_str
14302                    .into_iter()
14303                    .map(|p| ("contact".to_owned(), p.to_string()))
14304                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14305            ),
14306            _ => local_var_req_builder.query(&[(
14307                "contact",
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) = contact__n {
14318        local_var_req_builder = match "multi" {
14319            "multi" => local_var_req_builder.query(
14320                &local_var_str
14321                    .into_iter()
14322                    .map(|p| ("contact__n".to_owned(), p.to_string()))
14323                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14324            ),
14325            _ => local_var_req_builder.query(&[(
14326                "contact__n",
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) = contact_group {
14337        local_var_req_builder = match "multi" {
14338            "multi" => local_var_req_builder.query(
14339                &local_var_str
14340                    .into_iter()
14341                    .map(|p| ("contact_group".to_owned(), p.to_string()))
14342                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14343            ),
14344            _ => local_var_req_builder.query(&[(
14345                "contact_group",
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) = contact_group__n {
14356        local_var_req_builder = match "multi" {
14357            "multi" => local_var_req_builder.query(
14358                &local_var_str
14359                    .into_iter()
14360                    .map(|p| ("contact_group__n".to_owned(), p.to_string()))
14361                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14362            ),
14363            _ => local_var_req_builder.query(&[(
14364                "contact_group__n",
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) = contact_role {
14375        local_var_req_builder = match "multi" {
14376            "multi" => local_var_req_builder.query(
14377                &local_var_str
14378                    .into_iter()
14379                    .map(|p| ("contact_role".to_owned(), p.to_string()))
14380                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14381            ),
14382            _ => local_var_req_builder.query(&[(
14383                "contact_role",
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) = contact_role__n {
14394        local_var_req_builder = match "multi" {
14395            "multi" => local_var_req_builder.query(
14396                &local_var_str
14397                    .into_iter()
14398                    .map(|p| ("contact_role__n".to_owned(), p.to_string()))
14399                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14400            ),
14401            _ => local_var_req_builder.query(&[(
14402                "contact_role__n",
14403                &local_var_str
14404                    .into_iter()
14405                    .map(|p| p.to_string())
14406                    .collect::<Vec<String>>()
14407                    .join(",")
14408                    .to_string(),
14409            )]),
14410        };
14411    }
14412    if let Some(ref local_var_str) = created {
14413        local_var_req_builder = match "multi" {
14414            "multi" => local_var_req_builder.query(
14415                &local_var_str
14416                    .into_iter()
14417                    .map(|p| ("created".to_owned(), p.to_string()))
14418                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14419            ),
14420            _ => local_var_req_builder.query(&[(
14421                "created",
14422                &local_var_str
14423                    .into_iter()
14424                    .map(|p| p.to_string())
14425                    .collect::<Vec<String>>()
14426                    .join(",")
14427                    .to_string(),
14428            )]),
14429        };
14430    }
14431    if let Some(ref local_var_str) = created__empty {
14432        local_var_req_builder = match "multi" {
14433            "multi" => local_var_req_builder.query(
14434                &local_var_str
14435                    .into_iter()
14436                    .map(|p| ("created__empty".to_owned(), p.to_string()))
14437                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14438            ),
14439            _ => local_var_req_builder.query(&[(
14440                "created__empty",
14441                &local_var_str
14442                    .into_iter()
14443                    .map(|p| p.to_string())
14444                    .collect::<Vec<String>>()
14445                    .join(",")
14446                    .to_string(),
14447            )]),
14448        };
14449    }
14450    if let Some(ref local_var_str) = created__gt {
14451        local_var_req_builder = match "multi" {
14452            "multi" => local_var_req_builder.query(
14453                &local_var_str
14454                    .into_iter()
14455                    .map(|p| ("created__gt".to_owned(), p.to_string()))
14456                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14457            ),
14458            _ => local_var_req_builder.query(&[(
14459                "created__gt",
14460                &local_var_str
14461                    .into_iter()
14462                    .map(|p| p.to_string())
14463                    .collect::<Vec<String>>()
14464                    .join(",")
14465                    .to_string(),
14466            )]),
14467        };
14468    }
14469    if let Some(ref local_var_str) = created__gte {
14470        local_var_req_builder = match "multi" {
14471            "multi" => local_var_req_builder.query(
14472                &local_var_str
14473                    .into_iter()
14474                    .map(|p| ("created__gte".to_owned(), p.to_string()))
14475                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14476            ),
14477            _ => local_var_req_builder.query(&[(
14478                "created__gte",
14479                &local_var_str
14480                    .into_iter()
14481                    .map(|p| p.to_string())
14482                    .collect::<Vec<String>>()
14483                    .join(",")
14484                    .to_string(),
14485            )]),
14486        };
14487    }
14488    if let Some(ref local_var_str) = created__lt {
14489        local_var_req_builder = match "multi" {
14490            "multi" => local_var_req_builder.query(
14491                &local_var_str
14492                    .into_iter()
14493                    .map(|p| ("created__lt".to_owned(), p.to_string()))
14494                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14495            ),
14496            _ => local_var_req_builder.query(&[(
14497                "created__lt",
14498                &local_var_str
14499                    .into_iter()
14500                    .map(|p| p.to_string())
14501                    .collect::<Vec<String>>()
14502                    .join(",")
14503                    .to_string(),
14504            )]),
14505        };
14506    }
14507    if let Some(ref local_var_str) = created__lte {
14508        local_var_req_builder = match "multi" {
14509            "multi" => local_var_req_builder.query(
14510                &local_var_str
14511                    .into_iter()
14512                    .map(|p| ("created__lte".to_owned(), p.to_string()))
14513                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14514            ),
14515            _ => local_var_req_builder.query(&[(
14516                "created__lte",
14517                &local_var_str
14518                    .into_iter()
14519                    .map(|p| p.to_string())
14520                    .collect::<Vec<String>>()
14521                    .join(",")
14522                    .to_string(),
14523            )]),
14524        };
14525    }
14526    if let Some(ref local_var_str) = created__n {
14527        local_var_req_builder = match "multi" {
14528            "multi" => local_var_req_builder.query(
14529                &local_var_str
14530                    .into_iter()
14531                    .map(|p| ("created__n".to_owned(), p.to_string()))
14532                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14533            ),
14534            _ => local_var_req_builder.query(&[(
14535                "created__n",
14536                &local_var_str
14537                    .into_iter()
14538                    .map(|p| p.to_string())
14539                    .collect::<Vec<String>>()
14540                    .join(",")
14541                    .to_string(),
14542            )]),
14543        };
14544    }
14545    if let Some(ref local_var_str) = created_by_request {
14546        local_var_req_builder =
14547            local_var_req_builder.query(&[("created_by_request", &local_var_str.to_string())]);
14548    }
14549    if let Some(ref local_var_str) = description {
14550        local_var_req_builder = match "multi" {
14551            "multi" => local_var_req_builder.query(
14552                &local_var_str
14553                    .into_iter()
14554                    .map(|p| ("description".to_owned(), p.to_string()))
14555                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14556            ),
14557            _ => local_var_req_builder.query(&[(
14558                "description",
14559                &local_var_str
14560                    .into_iter()
14561                    .map(|p| p.to_string())
14562                    .collect::<Vec<String>>()
14563                    .join(",")
14564                    .to_string(),
14565            )]),
14566        };
14567    }
14568    if let Some(ref local_var_str) = description__empty {
14569        local_var_req_builder =
14570            local_var_req_builder.query(&[("description__empty", &local_var_str.to_string())]);
14571    }
14572    if let Some(ref local_var_str) = description__ic {
14573        local_var_req_builder = match "multi" {
14574            "multi" => local_var_req_builder.query(
14575                &local_var_str
14576                    .into_iter()
14577                    .map(|p| ("description__ic".to_owned(), p.to_string()))
14578                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14579            ),
14580            _ => local_var_req_builder.query(&[(
14581                "description__ic",
14582                &local_var_str
14583                    .into_iter()
14584                    .map(|p| p.to_string())
14585                    .collect::<Vec<String>>()
14586                    .join(",")
14587                    .to_string(),
14588            )]),
14589        };
14590    }
14591    if let Some(ref local_var_str) = description__ie {
14592        local_var_req_builder = match "multi" {
14593            "multi" => local_var_req_builder.query(
14594                &local_var_str
14595                    .into_iter()
14596                    .map(|p| ("description__ie".to_owned(), p.to_string()))
14597                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14598            ),
14599            _ => local_var_req_builder.query(&[(
14600                "description__ie",
14601                &local_var_str
14602                    .into_iter()
14603                    .map(|p| p.to_string())
14604                    .collect::<Vec<String>>()
14605                    .join(",")
14606                    .to_string(),
14607            )]),
14608        };
14609    }
14610    if let Some(ref local_var_str) = description__iew {
14611        local_var_req_builder = match "multi" {
14612            "multi" => local_var_req_builder.query(
14613                &local_var_str
14614                    .into_iter()
14615                    .map(|p| ("description__iew".to_owned(), p.to_string()))
14616                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14617            ),
14618            _ => local_var_req_builder.query(&[(
14619                "description__iew",
14620                &local_var_str
14621                    .into_iter()
14622                    .map(|p| p.to_string())
14623                    .collect::<Vec<String>>()
14624                    .join(",")
14625                    .to_string(),
14626            )]),
14627        };
14628    }
14629    if let Some(ref local_var_str) = description__iregex {
14630        local_var_req_builder = match "multi" {
14631            "multi" => local_var_req_builder.query(
14632                &local_var_str
14633                    .into_iter()
14634                    .map(|p| ("description__iregex".to_owned(), p.to_string()))
14635                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14636            ),
14637            _ => local_var_req_builder.query(&[(
14638                "description__iregex",
14639                &local_var_str
14640                    .into_iter()
14641                    .map(|p| p.to_string())
14642                    .collect::<Vec<String>>()
14643                    .join(",")
14644                    .to_string(),
14645            )]),
14646        };
14647    }
14648    if let Some(ref local_var_str) = description__isw {
14649        local_var_req_builder = match "multi" {
14650            "multi" => local_var_req_builder.query(
14651                &local_var_str
14652                    .into_iter()
14653                    .map(|p| ("description__isw".to_owned(), p.to_string()))
14654                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14655            ),
14656            _ => local_var_req_builder.query(&[(
14657                "description__isw",
14658                &local_var_str
14659                    .into_iter()
14660                    .map(|p| p.to_string())
14661                    .collect::<Vec<String>>()
14662                    .join(",")
14663                    .to_string(),
14664            )]),
14665        };
14666    }
14667    if let Some(ref local_var_str) = description__n {
14668        local_var_req_builder = match "multi" {
14669            "multi" => local_var_req_builder.query(
14670                &local_var_str
14671                    .into_iter()
14672                    .map(|p| ("description__n".to_owned(), p.to_string()))
14673                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14674            ),
14675            _ => local_var_req_builder.query(&[(
14676                "description__n",
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) = description__nic {
14687        local_var_req_builder = match "multi" {
14688            "multi" => local_var_req_builder.query(
14689                &local_var_str
14690                    .into_iter()
14691                    .map(|p| ("description__nic".to_owned(), p.to_string()))
14692                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14693            ),
14694            _ => local_var_req_builder.query(&[(
14695                "description__nic",
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) = description__nie {
14706        local_var_req_builder = match "multi" {
14707            "multi" => local_var_req_builder.query(
14708                &local_var_str
14709                    .into_iter()
14710                    .map(|p| ("description__nie".to_owned(), p.to_string()))
14711                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14712            ),
14713            _ => local_var_req_builder.query(&[(
14714                "description__nie",
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) = description__niew {
14725        local_var_req_builder = match "multi" {
14726            "multi" => local_var_req_builder.query(
14727                &local_var_str
14728                    .into_iter()
14729                    .map(|p| ("description__niew".to_owned(), p.to_string()))
14730                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14731            ),
14732            _ => local_var_req_builder.query(&[(
14733                "description__niew",
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) = description__nisw {
14744        local_var_req_builder = match "multi" {
14745            "multi" => local_var_req_builder.query(
14746                &local_var_str
14747                    .into_iter()
14748                    .map(|p| ("description__nisw".to_owned(), p.to_string()))
14749                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14750            ),
14751            _ => local_var_req_builder.query(&[(
14752                "description__nisw",
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) = description__regex {
14763        local_var_req_builder = match "multi" {
14764            "multi" => local_var_req_builder.query(
14765                &local_var_str
14766                    .into_iter()
14767                    .map(|p| ("description__regex".to_owned(), p.to_string()))
14768                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14769            ),
14770            _ => local_var_req_builder.query(&[(
14771                "description__regex",
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) = export_target {
14782        local_var_req_builder = match "multi" {
14783            "multi" => local_var_req_builder.query(
14784                &local_var_str
14785                    .into_iter()
14786                    .map(|p| ("export_target".to_owned(), p.to_string()))
14787                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14788            ),
14789            _ => local_var_req_builder.query(&[(
14790                "export_target",
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) = export_target__n {
14801        local_var_req_builder = match "multi" {
14802            "multi" => local_var_req_builder.query(
14803                &local_var_str
14804                    .into_iter()
14805                    .map(|p| ("export_target__n".to_owned(), p.to_string()))
14806                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14807            ),
14808            _ => local_var_req_builder.query(&[(
14809                "export_target__n",
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) = export_target_id {
14820        local_var_req_builder = match "multi" {
14821            "multi" => local_var_req_builder.query(
14822                &local_var_str
14823                    .into_iter()
14824                    .map(|p| ("export_target_id".to_owned(), p.to_string()))
14825                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14826            ),
14827            _ => local_var_req_builder.query(&[(
14828                "export_target_id",
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) = export_target_id__n {
14839        local_var_req_builder = match "multi" {
14840            "multi" => local_var_req_builder.query(
14841                &local_var_str
14842                    .into_iter()
14843                    .map(|p| ("export_target_id__n".to_owned(), p.to_string()))
14844                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14845            ),
14846            _ => local_var_req_builder.query(&[(
14847                "export_target_id__n",
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) = id {
14858        local_var_req_builder = match "multi" {
14859            "multi" => local_var_req_builder.query(
14860                &local_var_str
14861                    .into_iter()
14862                    .map(|p| ("id".to_owned(), p.to_string()))
14863                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14864            ),
14865            _ => local_var_req_builder.query(&[(
14866                "id",
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) = id__empty {
14877        local_var_req_builder =
14878            local_var_req_builder.query(&[("id__empty", &local_var_str.to_string())]);
14879    }
14880    if let Some(ref local_var_str) = id__gt {
14881        local_var_req_builder = match "multi" {
14882            "multi" => local_var_req_builder.query(
14883                &local_var_str
14884                    .into_iter()
14885                    .map(|p| ("id__gt".to_owned(), p.to_string()))
14886                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14887            ),
14888            _ => local_var_req_builder.query(&[(
14889                "id__gt",
14890                &local_var_str
14891                    .into_iter()
14892                    .map(|p| p.to_string())
14893                    .collect::<Vec<String>>()
14894                    .join(",")
14895                    .to_string(),
14896            )]),
14897        };
14898    }
14899    if let Some(ref local_var_str) = id__gte {
14900        local_var_req_builder = match "multi" {
14901            "multi" => local_var_req_builder.query(
14902                &local_var_str
14903                    .into_iter()
14904                    .map(|p| ("id__gte".to_owned(), p.to_string()))
14905                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14906            ),
14907            _ => local_var_req_builder.query(&[(
14908                "id__gte",
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) = id__lt {
14919        local_var_req_builder = match "multi" {
14920            "multi" => local_var_req_builder.query(
14921                &local_var_str
14922                    .into_iter()
14923                    .map(|p| ("id__lt".to_owned(), p.to_string()))
14924                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14925            ),
14926            _ => local_var_req_builder.query(&[(
14927                "id__lt",
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) = id__lte {
14938        local_var_req_builder = match "multi" {
14939            "multi" => local_var_req_builder.query(
14940                &local_var_str
14941                    .into_iter()
14942                    .map(|p| ("id__lte".to_owned(), p.to_string()))
14943                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14944            ),
14945            _ => local_var_req_builder.query(&[(
14946                "id__lte",
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) = id__n {
14957        local_var_req_builder = match "multi" {
14958            "multi" => local_var_req_builder.query(
14959                &local_var_str
14960                    .into_iter()
14961                    .map(|p| ("id__n".to_owned(), p.to_string()))
14962                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14963            ),
14964            _ => local_var_req_builder.query(&[(
14965                "id__n",
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) = identifier {
14976        local_var_req_builder = match "multi" {
14977            "multi" => local_var_req_builder.query(
14978                &local_var_str
14979                    .into_iter()
14980                    .map(|p| ("identifier".to_owned(), p.to_string()))
14981                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14982            ),
14983            _ => local_var_req_builder.query(&[(
14984                "identifier",
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) = identifier__empty {
14995        local_var_req_builder =
14996            local_var_req_builder.query(&[("identifier__empty", &local_var_str.to_string())]);
14997    }
14998    if let Some(ref local_var_str) = identifier__gt {
14999        local_var_req_builder = match "multi" {
15000            "multi" => local_var_req_builder.query(
15001                &local_var_str
15002                    .into_iter()
15003                    .map(|p| ("identifier__gt".to_owned(), p.to_string()))
15004                    .collect::<Vec<(std::string::String, std::string::String)>>(),
15005            ),
15006            _ => local_var_req_builder.query(&[(
15007                "identifier__gt",
15008                &local_var_str
15009                    .into_iter()
15010                    .map(|p| p.to_string())
15011                    .collect::<Vec<String>>()
15012                    .join(",")
15013                    .to_string(),
15014            )]),
15015        };
15016    }
15017    if let Some(ref local_var_str) = identifier__gte {
15018        local_var_req_builder = match "multi" {
15019            "multi" => local_var_req_builder.query(
15020                &local_var_str
15021                    .into_iter()
15022                    .map(|p| ("identifier__gte".to_owned(), p.to_string()))
15023                    .collect::<Vec<(std::string::String, std::string::String)>>(),
15024            ),
15025            _ => local_var_req_builder.query(&[(
15026                "identifier__gte",
15027                &local_var_str
15028                    .into_iter()
15029                    .map(|p| p.to_string())
15030                    .collect::<Vec<String>>()
15031                    .join(",")
15032                    .to_string(),
15033            )]),
15034        };
15035    }
15036    if let Some(ref local_var_str) = identifier__lt {
15037        local_var_req_builder = match "multi" {
15038            "multi" => local_var_req_builder.query(
15039                &local_var_str
15040                    .into_iter()
15041                    .map(|p| ("identifier__lt".to_owned(), p.to_string()))
15042                    .collect::<Vec<(std::string::String, std::string::String)>>(),
15043            ),
15044            _ => local_var_req_builder.query(&[(
15045                "identifier__lt",
15046                &local_var_str
15047                    .into_iter()
15048                    .map(|p| p.to_string())
15049                    .collect::<Vec<String>>()
15050                    .join(",")
15051                    .to_string(),
15052            )]),
15053        };
15054    }
15055    if let Some(ref local_var_str) = identifier__lte {
15056        local_var_req_builder = match "multi" {
15057            "multi" => local_var_req_builder.query(
15058                &local_var_str
15059                    .into_iter()
15060                    .map(|p| ("identifier__lte".to_owned(), p.to_string()))
15061                    .collect::<Vec<(std::string::String, std::string::String)>>(),
15062            ),
15063            _ => local_var_req_builder.query(&[(
15064                "identifier__lte",
15065                &local_var_str
15066                    .into_iter()
15067                    .map(|p| p.to_string())
15068                    .collect::<Vec<String>>()
15069                    .join(",")
15070                    .to_string(),
15071            )]),
15072        };
15073    }
15074    if let Some(ref local_var_str) = identifier__n {
15075        local_var_req_builder = match "multi" {
15076            "multi" => local_var_req_builder.query(
15077                &local_var_str
15078                    .into_iter()
15079                    .map(|p| ("identifier__n".to_owned(), p.to_string()))
15080                    .collect::<Vec<(std::string::String, std::string::String)>>(),
15081            ),
15082            _ => local_var_req_builder.query(&[(
15083                "identifier__n",
15084                &local_var_str
15085                    .into_iter()
15086                    .map(|p| p.to_string())
15087                    .collect::<Vec<String>>()
15088                    .join(",")
15089                    .to_string(),
15090            )]),
15091        };
15092    }
15093    if let Some(ref local_var_str) = import_target {
15094        local_var_req_builder = match "multi" {
15095            "multi" => local_var_req_builder.query(
15096                &local_var_str
15097                    .into_iter()
15098                    .map(|p| ("import_target".to_owned(), p.to_string()))
15099                    .collect::<Vec<(std::string::String, std::string::String)>>(),
15100            ),
15101            _ => local_var_req_builder.query(&[(
15102                "import_target",
15103                &local_var_str
15104                    .into_iter()
15105                    .map(|p| p.to_string())
15106                    .collect::<Vec<String>>()
15107                    .join(",")
15108                    .to_string(),
15109            )]),
15110        };
15111    }
15112    if let Some(ref local_var_str) = import_target__n {
15113        local_var_req_builder = match "multi" {
15114            "multi" => local_var_req_builder.query(
15115                &local_var_str
15116                    .into_iter()
15117                    .map(|p| ("import_target__n".to_owned(), p.to_string()))
15118                    .collect::<Vec<(std::string::String, std::string::String)>>(),
15119            ),
15120            _ => local_var_req_builder.query(&[(
15121                "import_target__n",
15122                &local_var_str
15123                    .into_iter()
15124                    .map(|p| p.to_string())
15125                    .collect::<Vec<String>>()
15126                    .join(",")
15127                    .to_string(),
15128            )]),
15129        };
15130    }
15131    if let Some(ref local_var_str) = import_target_id {
15132        local_var_req_builder = match "multi" {
15133            "multi" => local_var_req_builder.query(
15134                &local_var_str
15135                    .into_iter()
15136                    .map(|p| ("import_target_id".to_owned(), p.to_string()))
15137                    .collect::<Vec<(std::string::String, std::string::String)>>(),
15138            ),
15139            _ => local_var_req_builder.query(&[(
15140                "import_target_id",
15141                &local_var_str
15142                    .into_iter()
15143                    .map(|p| p.to_string())
15144                    .collect::<Vec<String>>()
15145                    .join(",")
15146                    .to_string(),
15147            )]),
15148        };
15149    }
15150    if let Some(ref local_var_str) = import_target_id__n {
15151        local_var_req_builder = match "multi" {
15152            "multi" => local_var_req_builder.query(
15153                &local_var_str
15154                    .into_iter()
15155                    .map(|p| ("import_target_id__n".to_owned(), p.to_string()))
15156                    .collect::<Vec<(std::string::String, std::string::String)>>(),
15157            ),
15158            _ => local_var_req_builder.query(&[(
15159                "import_target_id__n",
15160                &local_var_str
15161                    .into_iter()
15162                    .map(|p| p.to_string())
15163                    .collect::<Vec<String>>()
15164                    .join(",")
15165                    .to_string(),
15166            )]),
15167        };
15168    }
15169    if let Some(ref local_var_str) = last_updated {
15170        local_var_req_builder = match "multi" {
15171            "multi" => local_var_req_builder.query(
15172                &local_var_str
15173                    .into_iter()
15174                    .map(|p| ("last_updated".to_owned(), p.to_string()))
15175                    .collect::<Vec<(std::string::String, std::string::String)>>(),
15176            ),
15177            _ => local_var_req_builder.query(&[(
15178                "last_updated",
15179                &local_var_str
15180                    .into_iter()
15181                    .map(|p| p.to_string())
15182                    .collect::<Vec<String>>()
15183                    .join(",")
15184                    .to_string(),
15185            )]),
15186        };
15187    }
15188    if let Some(ref local_var_str) = last_updated__empty {
15189        local_var_req_builder = match "multi" {
15190            "multi" => local_var_req_builder.query(
15191                &local_var_str
15192                    .into_iter()
15193                    .map(|p| ("last_updated__empty".to_owned(), p.to_string()))
15194                    .collect::<Vec<(std::string::String, std::string::String)>>(),
15195            ),
15196            _ => local_var_req_builder.query(&[(
15197                "last_updated__empty",
15198                &local_var_str
15199                    .into_iter()
15200                    .map(|p| p.to_string())
15201                    .collect::<Vec<String>>()
15202                    .join(",")
15203                    .to_string(),
15204            )]),
15205        };
15206    }
15207    if let Some(ref local_var_str) = last_updated__gt {
15208        local_var_req_builder = match "multi" {
15209            "multi" => local_var_req_builder.query(
15210                &local_var_str
15211                    .into_iter()
15212                    .map(|p| ("last_updated__gt".to_owned(), p.to_string()))
15213                    .collect::<Vec<(std::string::String, std::string::String)>>(),
15214            ),
15215            _ => local_var_req_builder.query(&[(
15216                "last_updated__gt",
15217                &local_var_str
15218                    .into_iter()
15219                    .map(|p| p.to_string())
15220                    .collect::<Vec<String>>()
15221                    .join(",")
15222                    .to_string(),
15223            )]),
15224        };
15225    }
15226    if let Some(ref local_var_str) = last_updated__gte {
15227        local_var_req_builder = match "multi" {
15228            "multi" => local_var_req_builder.query(
15229                &local_var_str
15230                    .into_iter()
15231                    .map(|p| ("last_updated__gte".to_owned(), p.to_string()))
15232                    .collect::<Vec<(std::string::String, std::string::String)>>(),
15233            ),
15234            _ => local_var_req_builder.query(&[(
15235                "last_updated__gte",
15236                &local_var_str
15237                    .into_iter()
15238                    .map(|p| p.to_string())
15239                    .collect::<Vec<String>>()
15240                    .join(",")
15241                    .to_string(),
15242            )]),
15243        };
15244    }
15245    if let Some(ref local_var_str) = last_updated__lt {
15246        local_var_req_builder = match "multi" {
15247            "multi" => local_var_req_builder.query(
15248                &local_var_str
15249                    .into_iter()
15250                    .map(|p| ("last_updated__lt".to_owned(), p.to_string()))
15251                    .collect::<Vec<(std::string::String, std::string::String)>>(),
15252            ),
15253            _ => local_var_req_builder.query(&[(
15254                "last_updated__lt",
15255                &local_var_str
15256                    .into_iter()
15257                    .map(|p| p.to_string())
15258                    .collect::<Vec<String>>()
15259                    .join(",")
15260                    .to_string(),
15261            )]),
15262        };
15263    }
15264    if let Some(ref local_var_str) = last_updated__lte {
15265        local_var_req_builder = match "multi" {
15266            "multi" => local_var_req_builder.query(
15267                &local_var_str
15268                    .into_iter()
15269                    .map(|p| ("last_updated__lte".to_owned(), p.to_string()))
15270                    .collect::<Vec<(std::string::String, std::string::String)>>(),
15271            ),
15272            _ => local_var_req_builder.query(&[(
15273                "last_updated__lte",
15274                &local_var_str
15275                    .into_iter()
15276                    .map(|p| p.to_string())
15277                    .collect::<Vec<String>>()
15278                    .join(",")
15279                    .to_string(),
15280            )]),
15281        };
15282    }
15283    if let Some(ref local_var_str) = last_updated__n {
15284        local_var_req_builder = match "multi" {
15285            "multi" => local_var_req_builder.query(
15286                &local_var_str
15287                    .into_iter()
15288                    .map(|p| ("last_updated__n".to_owned(), p.to_string()))
15289                    .collect::<Vec<(std::string::String, std::string::String)>>(),
15290            ),
15291            _ => local_var_req_builder.query(&[(
15292                "last_updated__n",
15293                &local_var_str
15294                    .into_iter()
15295                    .map(|p| p.to_string())
15296                    .collect::<Vec<String>>()
15297                    .join(",")
15298                    .to_string(),
15299            )]),
15300        };
15301    }
15302    if let Some(ref local_var_str) = limit {
15303        local_var_req_builder =
15304            local_var_req_builder.query(&[("limit", &local_var_str.to_string())]);
15305    }
15306    if let Some(ref local_var_str) = modified_by_request {
15307        local_var_req_builder =
15308            local_var_req_builder.query(&[("modified_by_request", &local_var_str.to_string())]);
15309    }
15310    if let Some(ref local_var_str) = name {
15311        local_var_req_builder = match "multi" {
15312            "multi" => local_var_req_builder.query(
15313                &local_var_str
15314                    .into_iter()
15315                    .map(|p| ("name".to_owned(), p.to_string()))
15316                    .collect::<Vec<(std::string::String, std::string::String)>>(),
15317            ),
15318            _ => local_var_req_builder.query(&[(
15319                "name",
15320                &local_var_str
15321                    .into_iter()
15322                    .map(|p| p.to_string())
15323                    .collect::<Vec<String>>()
15324                    .join(",")
15325                    .to_string(),
15326            )]),
15327        };
15328    }
15329    if let Some(ref local_var_str) = name__empty {
15330        local_var_req_builder =
15331            local_var_req_builder.query(&[("name__empty", &local_var_str.to_string())]);
15332    }
15333    if let Some(ref local_var_str) = name__ic {
15334        local_var_req_builder = match "multi" {
15335            "multi" => local_var_req_builder.query(
15336                &local_var_str
15337                    .into_iter()
15338                    .map(|p| ("name__ic".to_owned(), p.to_string()))
15339                    .collect::<Vec<(std::string::String, std::string::String)>>(),
15340            ),
15341            _ => local_var_req_builder.query(&[(
15342                "name__ic",
15343                &local_var_str
15344                    .into_iter()
15345                    .map(|p| p.to_string())
15346                    .collect::<Vec<String>>()
15347                    .join(",")
15348                    .to_string(),
15349            )]),
15350        };
15351    }
15352    if let Some(ref local_var_str) = name__ie {
15353        local_var_req_builder = match "multi" {
15354            "multi" => local_var_req_builder.query(
15355                &local_var_str
15356                    .into_iter()
15357                    .map(|p| ("name__ie".to_owned(), p.to_string()))
15358                    .collect::<Vec<(std::string::String, std::string::String)>>(),
15359            ),
15360            _ => local_var_req_builder.query(&[(
15361                "name__ie",
15362                &local_var_str
15363                    .into_iter()
15364                    .map(|p| p.to_string())
15365                    .collect::<Vec<String>>()
15366                    .join(",")
15367                    .to_string(),
15368            )]),
15369        };
15370    }
15371    if let Some(ref local_var_str) = name__iew {
15372        local_var_req_builder = match "multi" {
15373            "multi" => local_var_req_builder.query(
15374                &local_var_str
15375                    .into_iter()
15376                    .map(|p| ("name__iew".to_owned(), p.to_string()))
15377                    .collect::<Vec<(std::string::String, std::string::String)>>(),
15378            ),
15379            _ => local_var_req_builder.query(&[(
15380                "name__iew",
15381                &local_var_str
15382                    .into_iter()
15383                    .map(|p| p.to_string())
15384                    .collect::<Vec<String>>()
15385                    .join(",")
15386                    .to_string(),
15387            )]),
15388        };
15389    }
15390    if let Some(ref local_var_str) = name__iregex {
15391        local_var_req_builder = match "multi" {
15392            "multi" => local_var_req_builder.query(
15393                &local_var_str
15394                    .into_iter()
15395                    .map(|p| ("name__iregex".to_owned(), p.to_string()))
15396                    .collect::<Vec<(std::string::String, std::string::String)>>(),
15397            ),
15398            _ => local_var_req_builder.query(&[(
15399                "name__iregex",
15400                &local_var_str
15401                    .into_iter()
15402                    .map(|p| p.to_string())
15403                    .collect::<Vec<String>>()
15404                    .join(",")
15405                    .to_string(),
15406            )]),
15407        };
15408    }
15409    if let Some(ref local_var_str) = name__isw {
15410        local_var_req_builder = match "multi" {
15411            "multi" => local_var_req_builder.query(
15412                &local_var_str
15413                    .into_iter()
15414                    .map(|p| ("name__isw".to_owned(), p.to_string()))
15415                    .collect::<Vec<(std::string::String, std::string::String)>>(),
15416            ),
15417            _ => local_var_req_builder.query(&[(
15418                "name__isw",
15419                &local_var_str
15420                    .into_iter()
15421                    .map(|p| p.to_string())
15422                    .collect::<Vec<String>>()
15423                    .join(",")
15424                    .to_string(),
15425            )]),
15426        };
15427    }
15428    if let Some(ref local_var_str) = name__n {
15429        local_var_req_builder = match "multi" {
15430            "multi" => local_var_req_builder.query(
15431                &local_var_str
15432                    .into_iter()
15433                    .map(|p| ("name__n".to_owned(), p.to_string()))
15434                    .collect::<Vec<(std::string::String, std::string::String)>>(),
15435            ),
15436            _ => local_var_req_builder.query(&[(
15437                "name__n",
15438                &local_var_str
15439                    .into_iter()
15440                    .map(|p| p.to_string())
15441                    .collect::<Vec<String>>()
15442                    .join(",")
15443                    .to_string(),
15444            )]),
15445        };
15446    }
15447    if let Some(ref local_var_str) = name__nic {
15448        local_var_req_builder = match "multi" {
15449            "multi" => local_var_req_builder.query(
15450                &local_var_str
15451                    .into_iter()
15452                    .map(|p| ("name__nic".to_owned(), p.to_string()))
15453                    .collect::<Vec<(std::string::String, std::string::String)>>(),
15454            ),
15455            _ => local_var_req_builder.query(&[(
15456                "name__nic",
15457                &local_var_str
15458                    .into_iter()
15459                    .map(|p| p.to_string())
15460                    .collect::<Vec<String>>()
15461                    .join(",")
15462                    .to_string(),
15463            )]),
15464        };
15465    }
15466    if let Some(ref local_var_str) = name__nie {
15467        local_var_req_builder = match "multi" {
15468            "multi" => local_var_req_builder.query(
15469                &local_var_str
15470                    .into_iter()
15471                    .map(|p| ("name__nie".to_owned(), p.to_string()))
15472                    .collect::<Vec<(std::string::String, std::string::String)>>(),
15473            ),
15474            _ => local_var_req_builder.query(&[(
15475                "name__nie",
15476                &local_var_str
15477                    .into_iter()
15478                    .map(|p| p.to_string())
15479                    .collect::<Vec<String>>()
15480                    .join(",")
15481                    .to_string(),
15482            )]),
15483        };
15484    }
15485    if let Some(ref local_var_str) = name__niew {
15486        local_var_req_builder = match "multi" {
15487            "multi" => local_var_req_builder.query(
15488                &local_var_str
15489                    .into_iter()
15490                    .map(|p| ("name__niew".to_owned(), p.to_string()))
15491                    .collect::<Vec<(std::string::String, std::string::String)>>(),
15492            ),
15493            _ => local_var_req_builder.query(&[(
15494                "name__niew",
15495                &local_var_str
15496                    .into_iter()
15497                    .map(|p| p.to_string())
15498                    .collect::<Vec<String>>()
15499                    .join(",")
15500                    .to_string(),
15501            )]),
15502        };
15503    }
15504    if let Some(ref local_var_str) = name__nisw {
15505        local_var_req_builder = match "multi" {
15506            "multi" => local_var_req_builder.query(
15507                &local_var_str
15508                    .into_iter()
15509                    .map(|p| ("name__nisw".to_owned(), p.to_string()))
15510                    .collect::<Vec<(std::string::String, std::string::String)>>(),
15511            ),
15512            _ => local_var_req_builder.query(&[(
15513                "name__nisw",
15514                &local_var_str
15515                    .into_iter()
15516                    .map(|p| p.to_string())
15517                    .collect::<Vec<String>>()
15518                    .join(",")
15519                    .to_string(),
15520            )]),
15521        };
15522    }
15523    if let Some(ref local_var_str) = name__regex {
15524        local_var_req_builder = match "multi" {
15525            "multi" => local_var_req_builder.query(
15526                &local_var_str
15527                    .into_iter()
15528                    .map(|p| ("name__regex".to_owned(), p.to_string()))
15529                    .collect::<Vec<(std::string::String, std::string::String)>>(),
15530            ),
15531            _ => local_var_req_builder.query(&[(
15532                "name__regex",
15533                &local_var_str
15534                    .into_iter()
15535                    .map(|p| p.to_string())
15536                    .collect::<Vec<String>>()
15537                    .join(",")
15538                    .to_string(),
15539            )]),
15540        };
15541    }
15542    if let Some(ref local_var_str) = offset {
15543        local_var_req_builder =
15544            local_var_req_builder.query(&[("offset", &local_var_str.to_string())]);
15545    }
15546    if let Some(ref local_var_str) = ordering {
15547        local_var_req_builder =
15548            local_var_req_builder.query(&[("ordering", &local_var_str.to_string())]);
15549    }
15550    if let Some(ref local_var_str) = owner {
15551        local_var_req_builder = match "multi" {
15552            "multi" => local_var_req_builder.query(
15553                &local_var_str
15554                    .into_iter()
15555                    .map(|p| ("owner".to_owned(), p.to_string()))
15556                    .collect::<Vec<(std::string::String, std::string::String)>>(),
15557            ),
15558            _ => local_var_req_builder.query(&[(
15559                "owner",
15560                &local_var_str
15561                    .into_iter()
15562                    .map(|p| p.to_string())
15563                    .collect::<Vec<String>>()
15564                    .join(",")
15565                    .to_string(),
15566            )]),
15567        };
15568    }
15569    if let Some(ref local_var_str) = owner__n {
15570        local_var_req_builder = match "multi" {
15571            "multi" => local_var_req_builder.query(
15572                &local_var_str
15573                    .into_iter()
15574                    .map(|p| ("owner__n".to_owned(), p.to_string()))
15575                    .collect::<Vec<(std::string::String, std::string::String)>>(),
15576            ),
15577            _ => local_var_req_builder.query(&[(
15578                "owner__n",
15579                &local_var_str
15580                    .into_iter()
15581                    .map(|p| p.to_string())
15582                    .collect::<Vec<String>>()
15583                    .join(",")
15584                    .to_string(),
15585            )]),
15586        };
15587    }
15588    if let Some(ref local_var_str) = owner_group {
15589        local_var_req_builder = match "multi" {
15590            "multi" => local_var_req_builder.query(
15591                &local_var_str
15592                    .into_iter()
15593                    .map(|p| ("owner_group".to_owned(), p.to_string()))
15594                    .collect::<Vec<(std::string::String, std::string::String)>>(),
15595            ),
15596            _ => local_var_req_builder.query(&[(
15597                "owner_group",
15598                &local_var_str
15599                    .into_iter()
15600                    .map(|p| p.to_string())
15601                    .collect::<Vec<String>>()
15602                    .join(",")
15603                    .to_string(),
15604            )]),
15605        };
15606    }
15607    if let Some(ref local_var_str) = owner_group__n {
15608        local_var_req_builder = match "multi" {
15609            "multi" => local_var_req_builder.query(
15610                &local_var_str
15611                    .into_iter()
15612                    .map(|p| ("owner_group__n".to_owned(), p.to_string()))
15613                    .collect::<Vec<(std::string::String, std::string::String)>>(),
15614            ),
15615            _ => local_var_req_builder.query(&[(
15616                "owner_group__n",
15617                &local_var_str
15618                    .into_iter()
15619                    .map(|p| p.to_string())
15620                    .collect::<Vec<String>>()
15621                    .join(",")
15622                    .to_string(),
15623            )]),
15624        };
15625    }
15626    if let Some(ref local_var_str) = owner_group_id {
15627        local_var_req_builder = match "multi" {
15628            "multi" => local_var_req_builder.query(
15629                &local_var_str
15630                    .into_iter()
15631                    .map(|p| ("owner_group_id".to_owned(), p.to_string()))
15632                    .collect::<Vec<(std::string::String, std::string::String)>>(),
15633            ),
15634            _ => local_var_req_builder.query(&[(
15635                "owner_group_id",
15636                &local_var_str
15637                    .into_iter()
15638                    .map(|p| p.to_string())
15639                    .collect::<Vec<String>>()
15640                    .join(",")
15641                    .to_string(),
15642            )]),
15643        };
15644    }
15645    if let Some(ref local_var_str) = owner_group_id__n {
15646        local_var_req_builder = match "multi" {
15647            "multi" => local_var_req_builder.query(
15648                &local_var_str
15649                    .into_iter()
15650                    .map(|p| ("owner_group_id__n".to_owned(), p.to_string()))
15651                    .collect::<Vec<(std::string::String, std::string::String)>>(),
15652            ),
15653            _ => local_var_req_builder.query(&[(
15654                "owner_group_id__n",
15655                &local_var_str
15656                    .into_iter()
15657                    .map(|p| p.to_string())
15658                    .collect::<Vec<String>>()
15659                    .join(",")
15660                    .to_string(),
15661            )]),
15662        };
15663    }
15664    if let Some(ref local_var_str) = owner_id {
15665        local_var_req_builder = match "multi" {
15666            "multi" => local_var_req_builder.query(
15667                &local_var_str
15668                    .into_iter()
15669                    .map(|p| ("owner_id".to_owned(), p.to_string()))
15670                    .collect::<Vec<(std::string::String, std::string::String)>>(),
15671            ),
15672            _ => local_var_req_builder.query(&[(
15673                "owner_id",
15674                &local_var_str
15675                    .into_iter()
15676                    .map(|p| p.to_string())
15677                    .collect::<Vec<String>>()
15678                    .join(",")
15679                    .to_string(),
15680            )]),
15681        };
15682    }
15683    if let Some(ref local_var_str) = owner_id__n {
15684        local_var_req_builder = match "multi" {
15685            "multi" => local_var_req_builder.query(
15686                &local_var_str
15687                    .into_iter()
15688                    .map(|p| ("owner_id__n".to_owned(), p.to_string()))
15689                    .collect::<Vec<(std::string::String, std::string::String)>>(),
15690            ),
15691            _ => local_var_req_builder.query(&[(
15692                "owner_id__n",
15693                &local_var_str
15694                    .into_iter()
15695                    .map(|p| p.to_string())
15696                    .collect::<Vec<String>>()
15697                    .join(",")
15698                    .to_string(),
15699            )]),
15700        };
15701    }
15702    if let Some(ref local_var_str) = q {
15703        local_var_req_builder = local_var_req_builder.query(&[("q", &local_var_str.to_string())]);
15704    }
15705    if let Some(ref local_var_str) = slug {
15706        local_var_req_builder = match "multi" {
15707            "multi" => local_var_req_builder.query(
15708                &local_var_str
15709                    .into_iter()
15710                    .map(|p| ("slug".to_owned(), p.to_string()))
15711                    .collect::<Vec<(std::string::String, std::string::String)>>(),
15712            ),
15713            _ => local_var_req_builder.query(&[(
15714                "slug",
15715                &local_var_str
15716                    .into_iter()
15717                    .map(|p| p.to_string())
15718                    .collect::<Vec<String>>()
15719                    .join(",")
15720                    .to_string(),
15721            )]),
15722        };
15723    }
15724    if let Some(ref local_var_str) = slug__empty {
15725        local_var_req_builder =
15726            local_var_req_builder.query(&[("slug__empty", &local_var_str.to_string())]);
15727    }
15728    if let Some(ref local_var_str) = slug__ic {
15729        local_var_req_builder = match "multi" {
15730            "multi" => local_var_req_builder.query(
15731                &local_var_str
15732                    .into_iter()
15733                    .map(|p| ("slug__ic".to_owned(), p.to_string()))
15734                    .collect::<Vec<(std::string::String, std::string::String)>>(),
15735            ),
15736            _ => local_var_req_builder.query(&[(
15737                "slug__ic",
15738                &local_var_str
15739                    .into_iter()
15740                    .map(|p| p.to_string())
15741                    .collect::<Vec<String>>()
15742                    .join(",")
15743                    .to_string(),
15744            )]),
15745        };
15746    }
15747    if let Some(ref local_var_str) = slug__ie {
15748        local_var_req_builder = match "multi" {
15749            "multi" => local_var_req_builder.query(
15750                &local_var_str
15751                    .into_iter()
15752                    .map(|p| ("slug__ie".to_owned(), p.to_string()))
15753                    .collect::<Vec<(std::string::String, std::string::String)>>(),
15754            ),
15755            _ => local_var_req_builder.query(&[(
15756                "slug__ie",
15757                &local_var_str
15758                    .into_iter()
15759                    .map(|p| p.to_string())
15760                    .collect::<Vec<String>>()
15761                    .join(",")
15762                    .to_string(),
15763            )]),
15764        };
15765    }
15766    if let Some(ref local_var_str) = slug__iew {
15767        local_var_req_builder = match "multi" {
15768            "multi" => local_var_req_builder.query(
15769                &local_var_str
15770                    .into_iter()
15771                    .map(|p| ("slug__iew".to_owned(), p.to_string()))
15772                    .collect::<Vec<(std::string::String, std::string::String)>>(),
15773            ),
15774            _ => local_var_req_builder.query(&[(
15775                "slug__iew",
15776                &local_var_str
15777                    .into_iter()
15778                    .map(|p| p.to_string())
15779                    .collect::<Vec<String>>()
15780                    .join(",")
15781                    .to_string(),
15782            )]),
15783        };
15784    }
15785    if let Some(ref local_var_str) = slug__iregex {
15786        local_var_req_builder = match "multi" {
15787            "multi" => local_var_req_builder.query(
15788                &local_var_str
15789                    .into_iter()
15790                    .map(|p| ("slug__iregex".to_owned(), p.to_string()))
15791                    .collect::<Vec<(std::string::String, std::string::String)>>(),
15792            ),
15793            _ => local_var_req_builder.query(&[(
15794                "slug__iregex",
15795                &local_var_str
15796                    .into_iter()
15797                    .map(|p| p.to_string())
15798                    .collect::<Vec<String>>()
15799                    .join(",")
15800                    .to_string(),
15801            )]),
15802        };
15803    }
15804    if let Some(ref local_var_str) = slug__isw {
15805        local_var_req_builder = match "multi" {
15806            "multi" => local_var_req_builder.query(
15807                &local_var_str
15808                    .into_iter()
15809                    .map(|p| ("slug__isw".to_owned(), p.to_string()))
15810                    .collect::<Vec<(std::string::String, std::string::String)>>(),
15811            ),
15812            _ => local_var_req_builder.query(&[(
15813                "slug__isw",
15814                &local_var_str
15815                    .into_iter()
15816                    .map(|p| p.to_string())
15817                    .collect::<Vec<String>>()
15818                    .join(",")
15819                    .to_string(),
15820            )]),
15821        };
15822    }
15823    if let Some(ref local_var_str) = slug__n {
15824        local_var_req_builder = match "multi" {
15825            "multi" => local_var_req_builder.query(
15826                &local_var_str
15827                    .into_iter()
15828                    .map(|p| ("slug__n".to_owned(), p.to_string()))
15829                    .collect::<Vec<(std::string::String, std::string::String)>>(),
15830            ),
15831            _ => local_var_req_builder.query(&[(
15832                "slug__n",
15833                &local_var_str
15834                    .into_iter()
15835                    .map(|p| p.to_string())
15836                    .collect::<Vec<String>>()
15837                    .join(",")
15838                    .to_string(),
15839            )]),
15840        };
15841    }
15842    if let Some(ref local_var_str) = slug__nic {
15843        local_var_req_builder = match "multi" {
15844            "multi" => local_var_req_builder.query(
15845                &local_var_str
15846                    .into_iter()
15847                    .map(|p| ("slug__nic".to_owned(), p.to_string()))
15848                    .collect::<Vec<(std::string::String, std::string::String)>>(),
15849            ),
15850            _ => local_var_req_builder.query(&[(
15851                "slug__nic",
15852                &local_var_str
15853                    .into_iter()
15854                    .map(|p| p.to_string())
15855                    .collect::<Vec<String>>()
15856                    .join(",")
15857                    .to_string(),
15858            )]),
15859        };
15860    }
15861    if let Some(ref local_var_str) = slug__nie {
15862        local_var_req_builder = match "multi" {
15863            "multi" => local_var_req_builder.query(
15864                &local_var_str
15865                    .into_iter()
15866                    .map(|p| ("slug__nie".to_owned(), p.to_string()))
15867                    .collect::<Vec<(std::string::String, std::string::String)>>(),
15868            ),
15869            _ => local_var_req_builder.query(&[(
15870                "slug__nie",
15871                &local_var_str
15872                    .into_iter()
15873                    .map(|p| p.to_string())
15874                    .collect::<Vec<String>>()
15875                    .join(",")
15876                    .to_string(),
15877            )]),
15878        };
15879    }
15880    if let Some(ref local_var_str) = slug__niew {
15881        local_var_req_builder = match "multi" {
15882            "multi" => local_var_req_builder.query(
15883                &local_var_str
15884                    .into_iter()
15885                    .map(|p| ("slug__niew".to_owned(), p.to_string()))
15886                    .collect::<Vec<(std::string::String, std::string::String)>>(),
15887            ),
15888            _ => local_var_req_builder.query(&[(
15889                "slug__niew",
15890                &local_var_str
15891                    .into_iter()
15892                    .map(|p| p.to_string())
15893                    .collect::<Vec<String>>()
15894                    .join(",")
15895                    .to_string(),
15896            )]),
15897        };
15898    }
15899    if let Some(ref local_var_str) = slug__nisw {
15900        local_var_req_builder = match "multi" {
15901            "multi" => local_var_req_builder.query(
15902                &local_var_str
15903                    .into_iter()
15904                    .map(|p| ("slug__nisw".to_owned(), p.to_string()))
15905                    .collect::<Vec<(std::string::String, std::string::String)>>(),
15906            ),
15907            _ => local_var_req_builder.query(&[(
15908                "slug__nisw",
15909                &local_var_str
15910                    .into_iter()
15911                    .map(|p| p.to_string())
15912                    .collect::<Vec<String>>()
15913                    .join(",")
15914                    .to_string(),
15915            )]),
15916        };
15917    }
15918    if let Some(ref local_var_str) = slug__regex {
15919        local_var_req_builder = match "multi" {
15920            "multi" => local_var_req_builder.query(
15921                &local_var_str
15922                    .into_iter()
15923                    .map(|p| ("slug__regex".to_owned(), p.to_string()))
15924                    .collect::<Vec<(std::string::String, std::string::String)>>(),
15925            ),
15926            _ => local_var_req_builder.query(&[(
15927                "slug__regex",
15928                &local_var_str
15929                    .into_iter()
15930                    .map(|p| p.to_string())
15931                    .collect::<Vec<String>>()
15932                    .join(",")
15933                    .to_string(),
15934            )]),
15935        };
15936    }
15937    if let Some(ref local_var_str) = start {
15938        local_var_req_builder =
15939            local_var_req_builder.query(&[("start", &local_var_str.to_string())]);
15940    }
15941    if let Some(ref local_var_str) = status {
15942        local_var_req_builder = match "multi" {
15943            "multi" => local_var_req_builder.query(
15944                &local_var_str
15945                    .into_iter()
15946                    .map(|p| ("status".to_owned(), p.to_string()))
15947                    .collect::<Vec<(std::string::String, std::string::String)>>(),
15948            ),
15949            _ => local_var_req_builder.query(&[(
15950                "status",
15951                &local_var_str
15952                    .into_iter()
15953                    .map(|p| p.to_string())
15954                    .collect::<Vec<String>>()
15955                    .join(",")
15956                    .to_string(),
15957            )]),
15958        };
15959    }
15960    if let Some(ref local_var_str) = status__empty {
15961        local_var_req_builder =
15962            local_var_req_builder.query(&[("status__empty", &local_var_str.to_string())]);
15963    }
15964    if let Some(ref local_var_str) = status__ic {
15965        local_var_req_builder = match "multi" {
15966            "multi" => local_var_req_builder.query(
15967                &local_var_str
15968                    .into_iter()
15969                    .map(|p| ("status__ic".to_owned(), p.to_string()))
15970                    .collect::<Vec<(std::string::String, std::string::String)>>(),
15971            ),
15972            _ => local_var_req_builder.query(&[(
15973                "status__ic",
15974                &local_var_str
15975                    .into_iter()
15976                    .map(|p| p.to_string())
15977                    .collect::<Vec<String>>()
15978                    .join(",")
15979                    .to_string(),
15980            )]),
15981        };
15982    }
15983    if let Some(ref local_var_str) = status__ie {
15984        local_var_req_builder = match "multi" {
15985            "multi" => local_var_req_builder.query(
15986                &local_var_str
15987                    .into_iter()
15988                    .map(|p| ("status__ie".to_owned(), p.to_string()))
15989                    .collect::<Vec<(std::string::String, std::string::String)>>(),
15990            ),
15991            _ => local_var_req_builder.query(&[(
15992                "status__ie",
15993                &local_var_str
15994                    .into_iter()
15995                    .map(|p| p.to_string())
15996                    .collect::<Vec<String>>()
15997                    .join(",")
15998                    .to_string(),
15999            )]),
16000        };
16001    }
16002    if let Some(ref local_var_str) = status__iew {
16003        local_var_req_builder = match "multi" {
16004            "multi" => local_var_req_builder.query(
16005                &local_var_str
16006                    .into_iter()
16007                    .map(|p| ("status__iew".to_owned(), p.to_string()))
16008                    .collect::<Vec<(std::string::String, std::string::String)>>(),
16009            ),
16010            _ => local_var_req_builder.query(&[(
16011                "status__iew",
16012                &local_var_str
16013                    .into_iter()
16014                    .map(|p| p.to_string())
16015                    .collect::<Vec<String>>()
16016                    .join(",")
16017                    .to_string(),
16018            )]),
16019        };
16020    }
16021    if let Some(ref local_var_str) = status__iregex {
16022        local_var_req_builder = match "multi" {
16023            "multi" => local_var_req_builder.query(
16024                &local_var_str
16025                    .into_iter()
16026                    .map(|p| ("status__iregex".to_owned(), p.to_string()))
16027                    .collect::<Vec<(std::string::String, std::string::String)>>(),
16028            ),
16029            _ => local_var_req_builder.query(&[(
16030                "status__iregex",
16031                &local_var_str
16032                    .into_iter()
16033                    .map(|p| p.to_string())
16034                    .collect::<Vec<String>>()
16035                    .join(",")
16036                    .to_string(),
16037            )]),
16038        };
16039    }
16040    if let Some(ref local_var_str) = status__isw {
16041        local_var_req_builder = match "multi" {
16042            "multi" => local_var_req_builder.query(
16043                &local_var_str
16044                    .into_iter()
16045                    .map(|p| ("status__isw".to_owned(), p.to_string()))
16046                    .collect::<Vec<(std::string::String, std::string::String)>>(),
16047            ),
16048            _ => local_var_req_builder.query(&[(
16049                "status__isw",
16050                &local_var_str
16051                    .into_iter()
16052                    .map(|p| p.to_string())
16053                    .collect::<Vec<String>>()
16054                    .join(",")
16055                    .to_string(),
16056            )]),
16057        };
16058    }
16059    if let Some(ref local_var_str) = status__n {
16060        local_var_req_builder = match "multi" {
16061            "multi" => local_var_req_builder.query(
16062                &local_var_str
16063                    .into_iter()
16064                    .map(|p| ("status__n".to_owned(), p.to_string()))
16065                    .collect::<Vec<(std::string::String, std::string::String)>>(),
16066            ),
16067            _ => local_var_req_builder.query(&[(
16068                "status__n",
16069                &local_var_str
16070                    .into_iter()
16071                    .map(|p| p.to_string())
16072                    .collect::<Vec<String>>()
16073                    .join(",")
16074                    .to_string(),
16075            )]),
16076        };
16077    }
16078    if let Some(ref local_var_str) = status__nic {
16079        local_var_req_builder = match "multi" {
16080            "multi" => local_var_req_builder.query(
16081                &local_var_str
16082                    .into_iter()
16083                    .map(|p| ("status__nic".to_owned(), p.to_string()))
16084                    .collect::<Vec<(std::string::String, std::string::String)>>(),
16085            ),
16086            _ => local_var_req_builder.query(&[(
16087                "status__nic",
16088                &local_var_str
16089                    .into_iter()
16090                    .map(|p| p.to_string())
16091                    .collect::<Vec<String>>()
16092                    .join(",")
16093                    .to_string(),
16094            )]),
16095        };
16096    }
16097    if let Some(ref local_var_str) = status__nie {
16098        local_var_req_builder = match "multi" {
16099            "multi" => local_var_req_builder.query(
16100                &local_var_str
16101                    .into_iter()
16102                    .map(|p| ("status__nie".to_owned(), p.to_string()))
16103                    .collect::<Vec<(std::string::String, std::string::String)>>(),
16104            ),
16105            _ => local_var_req_builder.query(&[(
16106                "status__nie",
16107                &local_var_str
16108                    .into_iter()
16109                    .map(|p| p.to_string())
16110                    .collect::<Vec<String>>()
16111                    .join(",")
16112                    .to_string(),
16113            )]),
16114        };
16115    }
16116    if let Some(ref local_var_str) = status__niew {
16117        local_var_req_builder = match "multi" {
16118            "multi" => local_var_req_builder.query(
16119                &local_var_str
16120                    .into_iter()
16121                    .map(|p| ("status__niew".to_owned(), p.to_string()))
16122                    .collect::<Vec<(std::string::String, std::string::String)>>(),
16123            ),
16124            _ => local_var_req_builder.query(&[(
16125                "status__niew",
16126                &local_var_str
16127                    .into_iter()
16128                    .map(|p| p.to_string())
16129                    .collect::<Vec<String>>()
16130                    .join(",")
16131                    .to_string(),
16132            )]),
16133        };
16134    }
16135    if let Some(ref local_var_str) = status__nisw {
16136        local_var_req_builder = match "multi" {
16137            "multi" => local_var_req_builder.query(
16138                &local_var_str
16139                    .into_iter()
16140                    .map(|p| ("status__nisw".to_owned(), p.to_string()))
16141                    .collect::<Vec<(std::string::String, std::string::String)>>(),
16142            ),
16143            _ => local_var_req_builder.query(&[(
16144                "status__nisw",
16145                &local_var_str
16146                    .into_iter()
16147                    .map(|p| p.to_string())
16148                    .collect::<Vec<String>>()
16149                    .join(",")
16150                    .to_string(),
16151            )]),
16152        };
16153    }
16154    if let Some(ref local_var_str) = status__regex {
16155        local_var_req_builder = match "multi" {
16156            "multi" => local_var_req_builder.query(
16157                &local_var_str
16158                    .into_iter()
16159                    .map(|p| ("status__regex".to_owned(), p.to_string()))
16160                    .collect::<Vec<(std::string::String, std::string::String)>>(),
16161            ),
16162            _ => local_var_req_builder.query(&[(
16163                "status__regex",
16164                &local_var_str
16165                    .into_iter()
16166                    .map(|p| p.to_string())
16167                    .collect::<Vec<String>>()
16168                    .join(",")
16169                    .to_string(),
16170            )]),
16171        };
16172    }
16173    if let Some(ref local_var_str) = tag {
16174        local_var_req_builder = match "multi" {
16175            "multi" => local_var_req_builder.query(
16176                &local_var_str
16177                    .into_iter()
16178                    .map(|p| ("tag".to_owned(), p.to_string()))
16179                    .collect::<Vec<(std::string::String, std::string::String)>>(),
16180            ),
16181            _ => local_var_req_builder.query(&[(
16182                "tag",
16183                &local_var_str
16184                    .into_iter()
16185                    .map(|p| p.to_string())
16186                    .collect::<Vec<String>>()
16187                    .join(",")
16188                    .to_string(),
16189            )]),
16190        };
16191    }
16192    if let Some(ref local_var_str) = tag__n {
16193        local_var_req_builder = match "multi" {
16194            "multi" => local_var_req_builder.query(
16195                &local_var_str
16196                    .into_iter()
16197                    .map(|p| ("tag__n".to_owned(), p.to_string()))
16198                    .collect::<Vec<(std::string::String, std::string::String)>>(),
16199            ),
16200            _ => local_var_req_builder.query(&[(
16201                "tag__n",
16202                &local_var_str
16203                    .into_iter()
16204                    .map(|p| p.to_string())
16205                    .collect::<Vec<String>>()
16206                    .join(",")
16207                    .to_string(),
16208            )]),
16209        };
16210    }
16211    if let Some(ref local_var_str) = tag_id {
16212        local_var_req_builder = match "multi" {
16213            "multi" => local_var_req_builder.query(
16214                &local_var_str
16215                    .into_iter()
16216                    .map(|p| ("tag_id".to_owned(), p.to_string()))
16217                    .collect::<Vec<(std::string::String, std::string::String)>>(),
16218            ),
16219            _ => local_var_req_builder.query(&[(
16220                "tag_id",
16221                &local_var_str
16222                    .into_iter()
16223                    .map(|p| p.to_string())
16224                    .collect::<Vec<String>>()
16225                    .join(",")
16226                    .to_string(),
16227            )]),
16228        };
16229    }
16230    if let Some(ref local_var_str) = tag_id__n {
16231        local_var_req_builder = match "multi" {
16232            "multi" => local_var_req_builder.query(
16233                &local_var_str
16234                    .into_iter()
16235                    .map(|p| ("tag_id__n".to_owned(), p.to_string()))
16236                    .collect::<Vec<(std::string::String, std::string::String)>>(),
16237            ),
16238            _ => local_var_req_builder.query(&[(
16239                "tag_id__n",
16240                &local_var_str
16241                    .into_iter()
16242                    .map(|p| p.to_string())
16243                    .collect::<Vec<String>>()
16244                    .join(",")
16245                    .to_string(),
16246            )]),
16247        };
16248    }
16249    if let Some(ref local_var_str) = tenant {
16250        local_var_req_builder = match "multi" {
16251            "multi" => local_var_req_builder.query(
16252                &local_var_str
16253                    .into_iter()
16254                    .map(|p| ("tenant".to_owned(), p.to_string()))
16255                    .collect::<Vec<(std::string::String, std::string::String)>>(),
16256            ),
16257            _ => local_var_req_builder.query(&[(
16258                "tenant",
16259                &local_var_str
16260                    .into_iter()
16261                    .map(|p| p.to_string())
16262                    .collect::<Vec<String>>()
16263                    .join(",")
16264                    .to_string(),
16265            )]),
16266        };
16267    }
16268    if let Some(ref local_var_str) = tenant__n {
16269        local_var_req_builder = match "multi" {
16270            "multi" => local_var_req_builder.query(
16271                &local_var_str
16272                    .into_iter()
16273                    .map(|p| ("tenant__n".to_owned(), p.to_string()))
16274                    .collect::<Vec<(std::string::String, std::string::String)>>(),
16275            ),
16276            _ => local_var_req_builder.query(&[(
16277                "tenant__n",
16278                &local_var_str
16279                    .into_iter()
16280                    .map(|p| p.to_string())
16281                    .collect::<Vec<String>>()
16282                    .join(",")
16283                    .to_string(),
16284            )]),
16285        };
16286    }
16287    if let Some(ref local_var_str) = tenant_group {
16288        local_var_req_builder = match "multi" {
16289            "multi" => local_var_req_builder.query(
16290                &local_var_str
16291                    .into_iter()
16292                    .map(|p| ("tenant_group".to_owned(), p.to_string()))
16293                    .collect::<Vec<(std::string::String, std::string::String)>>(),
16294            ),
16295            _ => local_var_req_builder.query(&[(
16296                "tenant_group",
16297                &local_var_str
16298                    .into_iter()
16299                    .map(|p| p.to_string())
16300                    .collect::<Vec<String>>()
16301                    .join(",")
16302                    .to_string(),
16303            )]),
16304        };
16305    }
16306    if let Some(ref local_var_str) = tenant_group__n {
16307        local_var_req_builder = match "multi" {
16308            "multi" => local_var_req_builder.query(
16309                &local_var_str
16310                    .into_iter()
16311                    .map(|p| ("tenant_group__n".to_owned(), p.to_string()))
16312                    .collect::<Vec<(std::string::String, std::string::String)>>(),
16313            ),
16314            _ => local_var_req_builder.query(&[(
16315                "tenant_group__n",
16316                &local_var_str
16317                    .into_iter()
16318                    .map(|p| p.to_string())
16319                    .collect::<Vec<String>>()
16320                    .join(",")
16321                    .to_string(),
16322            )]),
16323        };
16324    }
16325    if let Some(ref local_var_str) = tenant_group_id {
16326        local_var_req_builder = match "multi" {
16327            "multi" => local_var_req_builder.query(
16328                &local_var_str
16329                    .into_iter()
16330                    .map(|p| ("tenant_group_id".to_owned(), p.to_string()))
16331                    .collect::<Vec<(std::string::String, std::string::String)>>(),
16332            ),
16333            _ => local_var_req_builder.query(&[(
16334                "tenant_group_id",
16335                &local_var_str
16336                    .into_iter()
16337                    .map(|p| p.to_string())
16338                    .collect::<Vec<String>>()
16339                    .join(",")
16340                    .to_string(),
16341            )]),
16342        };
16343    }
16344    if let Some(ref local_var_str) = tenant_group_id__n {
16345        local_var_req_builder = match "multi" {
16346            "multi" => local_var_req_builder.query(
16347                &local_var_str
16348                    .into_iter()
16349                    .map(|p| ("tenant_group_id__n".to_owned(), p.to_string()))
16350                    .collect::<Vec<(std::string::String, std::string::String)>>(),
16351            ),
16352            _ => local_var_req_builder.query(&[(
16353                "tenant_group_id__n",
16354                &local_var_str
16355                    .into_iter()
16356                    .map(|p| p.to_string())
16357                    .collect::<Vec<String>>()
16358                    .join(",")
16359                    .to_string(),
16360            )]),
16361        };
16362    }
16363    if let Some(ref local_var_str) = tenant_id {
16364        local_var_req_builder = match "multi" {
16365            "multi" => local_var_req_builder.query(
16366                &local_var_str
16367                    .into_iter()
16368                    .map(|p| ("tenant_id".to_owned(), p.to_string()))
16369                    .collect::<Vec<(std::string::String, std::string::String)>>(),
16370            ),
16371            _ => local_var_req_builder.query(&[(
16372                "tenant_id",
16373                &local_var_str
16374                    .into_iter()
16375                    .map(|p| p.to_string())
16376                    .collect::<Vec<String>>()
16377                    .join(",")
16378                    .to_string(),
16379            )]),
16380        };
16381    }
16382    if let Some(ref local_var_str) = tenant_id__n {
16383        local_var_req_builder = match "multi" {
16384            "multi" => local_var_req_builder.query(
16385                &local_var_str
16386                    .into_iter()
16387                    .map(|p| ("tenant_id__n".to_owned(), p.to_string()))
16388                    .collect::<Vec<(std::string::String, std::string::String)>>(),
16389            ),
16390            _ => local_var_req_builder.query(&[(
16391                "tenant_id__n",
16392                &local_var_str
16393                    .into_iter()
16394                    .map(|p| p.to_string())
16395                    .collect::<Vec<String>>()
16396                    .join(",")
16397                    .to_string(),
16398            )]),
16399        };
16400    }
16401    if let Some(ref local_var_str) = r#type {
16402        local_var_req_builder = match "multi" {
16403            "multi" => local_var_req_builder.query(
16404                &local_var_str
16405                    .into_iter()
16406                    .map(|p| ("type".to_owned(), p.to_string()))
16407                    .collect::<Vec<(std::string::String, std::string::String)>>(),
16408            ),
16409            _ => local_var_req_builder.query(&[(
16410                "type",
16411                &local_var_str
16412                    .into_iter()
16413                    .map(|p| p.to_string())
16414                    .collect::<Vec<String>>()
16415                    .join(",")
16416                    .to_string(),
16417            )]),
16418        };
16419    }
16420    if let Some(ref local_var_str) = type__empty {
16421        local_var_req_builder =
16422            local_var_req_builder.query(&[("type__empty", &local_var_str.to_string())]);
16423    }
16424    if let Some(ref local_var_str) = type__ic {
16425        local_var_req_builder = match "multi" {
16426            "multi" => local_var_req_builder.query(
16427                &local_var_str
16428                    .into_iter()
16429                    .map(|p| ("type__ic".to_owned(), p.to_string()))
16430                    .collect::<Vec<(std::string::String, std::string::String)>>(),
16431            ),
16432            _ => local_var_req_builder.query(&[(
16433                "type__ic",
16434                &local_var_str
16435                    .into_iter()
16436                    .map(|p| p.to_string())
16437                    .collect::<Vec<String>>()
16438                    .join(",")
16439                    .to_string(),
16440            )]),
16441        };
16442    }
16443    if let Some(ref local_var_str) = type__ie {
16444        local_var_req_builder = match "multi" {
16445            "multi" => local_var_req_builder.query(
16446                &local_var_str
16447                    .into_iter()
16448                    .map(|p| ("type__ie".to_owned(), p.to_string()))
16449                    .collect::<Vec<(std::string::String, std::string::String)>>(),
16450            ),
16451            _ => local_var_req_builder.query(&[(
16452                "type__ie",
16453                &local_var_str
16454                    .into_iter()
16455                    .map(|p| p.to_string())
16456                    .collect::<Vec<String>>()
16457                    .join(",")
16458                    .to_string(),
16459            )]),
16460        };
16461    }
16462    if let Some(ref local_var_str) = type__iew {
16463        local_var_req_builder = match "multi" {
16464            "multi" => local_var_req_builder.query(
16465                &local_var_str
16466                    .into_iter()
16467                    .map(|p| ("type__iew".to_owned(), p.to_string()))
16468                    .collect::<Vec<(std::string::String, std::string::String)>>(),
16469            ),
16470            _ => local_var_req_builder.query(&[(
16471                "type__iew",
16472                &local_var_str
16473                    .into_iter()
16474                    .map(|p| p.to_string())
16475                    .collect::<Vec<String>>()
16476                    .join(",")
16477                    .to_string(),
16478            )]),
16479        };
16480    }
16481    if let Some(ref local_var_str) = type__iregex {
16482        local_var_req_builder = match "multi" {
16483            "multi" => local_var_req_builder.query(
16484                &local_var_str
16485                    .into_iter()
16486                    .map(|p| ("type__iregex".to_owned(), p.to_string()))
16487                    .collect::<Vec<(std::string::String, std::string::String)>>(),
16488            ),
16489            _ => local_var_req_builder.query(&[(
16490                "type__iregex",
16491                &local_var_str
16492                    .into_iter()
16493                    .map(|p| p.to_string())
16494                    .collect::<Vec<String>>()
16495                    .join(",")
16496                    .to_string(),
16497            )]),
16498        };
16499    }
16500    if let Some(ref local_var_str) = type__isw {
16501        local_var_req_builder = match "multi" {
16502            "multi" => local_var_req_builder.query(
16503                &local_var_str
16504                    .into_iter()
16505                    .map(|p| ("type__isw".to_owned(), p.to_string()))
16506                    .collect::<Vec<(std::string::String, std::string::String)>>(),
16507            ),
16508            _ => local_var_req_builder.query(&[(
16509                "type__isw",
16510                &local_var_str
16511                    .into_iter()
16512                    .map(|p| p.to_string())
16513                    .collect::<Vec<String>>()
16514                    .join(",")
16515                    .to_string(),
16516            )]),
16517        };
16518    }
16519    if let Some(ref local_var_str) = type__n {
16520        local_var_req_builder = match "multi" {
16521            "multi" => local_var_req_builder.query(
16522                &local_var_str
16523                    .into_iter()
16524                    .map(|p| ("type__n".to_owned(), p.to_string()))
16525                    .collect::<Vec<(std::string::String, std::string::String)>>(),
16526            ),
16527            _ => local_var_req_builder.query(&[(
16528                "type__n",
16529                &local_var_str
16530                    .into_iter()
16531                    .map(|p| p.to_string())
16532                    .collect::<Vec<String>>()
16533                    .join(",")
16534                    .to_string(),
16535            )]),
16536        };
16537    }
16538    if let Some(ref local_var_str) = type__nic {
16539        local_var_req_builder = match "multi" {
16540            "multi" => local_var_req_builder.query(
16541                &local_var_str
16542                    .into_iter()
16543                    .map(|p| ("type__nic".to_owned(), p.to_string()))
16544                    .collect::<Vec<(std::string::String, std::string::String)>>(),
16545            ),
16546            _ => local_var_req_builder.query(&[(
16547                "type__nic",
16548                &local_var_str
16549                    .into_iter()
16550                    .map(|p| p.to_string())
16551                    .collect::<Vec<String>>()
16552                    .join(",")
16553                    .to_string(),
16554            )]),
16555        };
16556    }
16557    if let Some(ref local_var_str) = type__nie {
16558        local_var_req_builder = match "multi" {
16559            "multi" => local_var_req_builder.query(
16560                &local_var_str
16561                    .into_iter()
16562                    .map(|p| ("type__nie".to_owned(), p.to_string()))
16563                    .collect::<Vec<(std::string::String, std::string::String)>>(),
16564            ),
16565            _ => local_var_req_builder.query(&[(
16566                "type__nie",
16567                &local_var_str
16568                    .into_iter()
16569                    .map(|p| p.to_string())
16570                    .collect::<Vec<String>>()
16571                    .join(",")
16572                    .to_string(),
16573            )]),
16574        };
16575    }
16576    if let Some(ref local_var_str) = type__niew {
16577        local_var_req_builder = match "multi" {
16578            "multi" => local_var_req_builder.query(
16579                &local_var_str
16580                    .into_iter()
16581                    .map(|p| ("type__niew".to_owned(), p.to_string()))
16582                    .collect::<Vec<(std::string::String, std::string::String)>>(),
16583            ),
16584            _ => local_var_req_builder.query(&[(
16585                "type__niew",
16586                &local_var_str
16587                    .into_iter()
16588                    .map(|p| p.to_string())
16589                    .collect::<Vec<String>>()
16590                    .join(",")
16591                    .to_string(),
16592            )]),
16593        };
16594    }
16595    if let Some(ref local_var_str) = type__nisw {
16596        local_var_req_builder = match "multi" {
16597            "multi" => local_var_req_builder.query(
16598                &local_var_str
16599                    .into_iter()
16600                    .map(|p| ("type__nisw".to_owned(), p.to_string()))
16601                    .collect::<Vec<(std::string::String, std::string::String)>>(),
16602            ),
16603            _ => local_var_req_builder.query(&[(
16604                "type__nisw",
16605                &local_var_str
16606                    .into_iter()
16607                    .map(|p| p.to_string())
16608                    .collect::<Vec<String>>()
16609                    .join(",")
16610                    .to_string(),
16611            )]),
16612        };
16613    }
16614    if let Some(ref local_var_str) = type__regex {
16615        local_var_req_builder = match "multi" {
16616            "multi" => local_var_req_builder.query(
16617                &local_var_str
16618                    .into_iter()
16619                    .map(|p| ("type__regex".to_owned(), p.to_string()))
16620                    .collect::<Vec<(std::string::String, std::string::String)>>(),
16621            ),
16622            _ => local_var_req_builder.query(&[(
16623                "type__regex",
16624                &local_var_str
16625                    .into_iter()
16626                    .map(|p| p.to_string())
16627                    .collect::<Vec<String>>()
16628                    .join(",")
16629                    .to_string(),
16630            )]),
16631        };
16632    }
16633    if let Some(ref local_var_str) = updated_by_request {
16634        local_var_req_builder =
16635            local_var_req_builder.query(&[("updated_by_request", &local_var_str.to_string())]);
16636    }
16637    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
16638        local_var_req_builder =
16639            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
16640    }
16641    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
16642        let local_var_key = local_var_apikey.key.clone();
16643        let local_var_value = match local_var_apikey.prefix {
16644            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
16645            None => local_var_key,
16646        };
16647        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
16648    };
16649
16650    let local_var_req = local_var_req_builder.build()?;
16651    let local_var_resp = local_var_client.execute(local_var_req).await?;
16652
16653    let local_var_status = local_var_resp.status();
16654    let local_var_content = local_var_resp.text().await?;
16655
16656    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
16657        serde_json::from_str(&local_var_content).map_err(Error::from)
16658    } else {
16659        let local_var_entity: Option<VpnL2vpnsListError> =
16660            serde_json::from_str(&local_var_content).ok();
16661        let local_var_error = ResponseContent {
16662            status: local_var_status,
16663            content: local_var_content,
16664            entity: local_var_entity,
16665        };
16666        Err(Error::ResponseError(local_var_error))
16667    }
16668}
16669
16670/// Patch a L2VPN object.
16671pub async fn vpn_l2vpns_partial_update(
16672    configuration: &configuration::Configuration,
16673    id: i32,
16674    patched_writable_l2_vpn_request: Option<crate::models::PatchedWritableL2VpnRequest>,
16675) -> Result<crate::models::L2Vpn, Error<VpnL2vpnsPartialUpdateError>> {
16676    let local_var_configuration = configuration;
16677
16678    let local_var_client = &local_var_configuration.client;
16679
16680    let local_var_uri_str = format!(
16681        "{}/api/vpn/l2vpns/{id}/",
16682        local_var_configuration.base_path,
16683        id = id
16684    );
16685    let mut local_var_req_builder =
16686        local_var_client.request(reqwest::Method::PATCH, local_var_uri_str.as_str());
16687
16688    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
16689        local_var_req_builder =
16690            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
16691    }
16692    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
16693        let local_var_key = local_var_apikey.key.clone();
16694        let local_var_value = match local_var_apikey.prefix {
16695            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
16696            None => local_var_key,
16697        };
16698        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
16699    };
16700    local_var_req_builder = local_var_req_builder.json(&patched_writable_l2_vpn_request);
16701
16702    let local_var_req = local_var_req_builder.build()?;
16703    let local_var_resp = local_var_client.execute(local_var_req).await?;
16704
16705    let local_var_status = local_var_resp.status();
16706    let local_var_content = local_var_resp.text().await?;
16707
16708    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
16709        serde_json::from_str(&local_var_content).map_err(Error::from)
16710    } else {
16711        let local_var_entity: Option<VpnL2vpnsPartialUpdateError> =
16712            serde_json::from_str(&local_var_content).ok();
16713        let local_var_error = ResponseContent {
16714            status: local_var_status,
16715            content: local_var_content,
16716            entity: local_var_entity,
16717        };
16718        Err(Error::ResponseError(local_var_error))
16719    }
16720}
16721
16722/// Get a L2VPN object.
16723pub async fn vpn_l2vpns_retrieve(
16724    configuration: &configuration::Configuration,
16725    id: i32,
16726) -> Result<crate::models::L2Vpn, Error<VpnL2vpnsRetrieveError>> {
16727    let local_var_configuration = configuration;
16728
16729    let local_var_client = &local_var_configuration.client;
16730
16731    let local_var_uri_str = format!(
16732        "{}/api/vpn/l2vpns/{id}/",
16733        local_var_configuration.base_path,
16734        id = id
16735    );
16736    let mut local_var_req_builder =
16737        local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
16738
16739    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
16740        local_var_req_builder =
16741            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
16742    }
16743    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
16744        let local_var_key = local_var_apikey.key.clone();
16745        let local_var_value = match local_var_apikey.prefix {
16746            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
16747            None => local_var_key,
16748        };
16749        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
16750    };
16751
16752    let local_var_req = local_var_req_builder.build()?;
16753    let local_var_resp = local_var_client.execute(local_var_req).await?;
16754
16755    let local_var_status = local_var_resp.status();
16756    let local_var_content = local_var_resp.text().await?;
16757
16758    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
16759        serde_json::from_str(&local_var_content).map_err(Error::from)
16760    } else {
16761        let local_var_entity: Option<VpnL2vpnsRetrieveError> =
16762            serde_json::from_str(&local_var_content).ok();
16763        let local_var_error = ResponseContent {
16764            status: local_var_status,
16765            content: local_var_content,
16766            entity: local_var_entity,
16767        };
16768        Err(Error::ResponseError(local_var_error))
16769    }
16770}
16771
16772/// Put a L2VPN object.
16773pub async fn vpn_l2vpns_update(
16774    configuration: &configuration::Configuration,
16775    id: i32,
16776    writable_l2_vpn_request: crate::models::WritableL2VpnRequest,
16777) -> Result<crate::models::L2Vpn, Error<VpnL2vpnsUpdateError>> {
16778    let local_var_configuration = configuration;
16779
16780    let local_var_client = &local_var_configuration.client;
16781
16782    let local_var_uri_str = format!(
16783        "{}/api/vpn/l2vpns/{id}/",
16784        local_var_configuration.base_path,
16785        id = id
16786    );
16787    let mut local_var_req_builder =
16788        local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());
16789
16790    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
16791        local_var_req_builder =
16792            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
16793    }
16794    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
16795        let local_var_key = local_var_apikey.key.clone();
16796        let local_var_value = match local_var_apikey.prefix {
16797            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
16798            None => local_var_key,
16799        };
16800        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
16801    };
16802    local_var_req_builder = local_var_req_builder.json(&writable_l2_vpn_request);
16803
16804    let local_var_req = local_var_req_builder.build()?;
16805    let local_var_resp = local_var_client.execute(local_var_req).await?;
16806
16807    let local_var_status = local_var_resp.status();
16808    let local_var_content = local_var_resp.text().await?;
16809
16810    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
16811        serde_json::from_str(&local_var_content).map_err(Error::from)
16812    } else {
16813        let local_var_entity: Option<VpnL2vpnsUpdateError> =
16814            serde_json::from_str(&local_var_content).ok();
16815        let local_var_error = ResponseContent {
16816            status: local_var_status,
16817            content: local_var_content,
16818            entity: local_var_entity,
16819        };
16820        Err(Error::ResponseError(local_var_error))
16821    }
16822}
16823
16824/// Delete a list of tunnel group objects.
16825pub async fn vpn_tunnel_groups_bulk_destroy(
16826    configuration: &configuration::Configuration,
16827    tunnel_group_request: Vec<crate::models::TunnelGroupRequest>,
16828) -> Result<(), Error<VpnTunnelGroupsBulkDestroyError>> {
16829    let local_var_configuration = configuration;
16830
16831    let local_var_client = &local_var_configuration.client;
16832
16833    let local_var_uri_str = format!(
16834        "{}/api/vpn/tunnel-groups/",
16835        local_var_configuration.base_path
16836    );
16837    let mut local_var_req_builder =
16838        local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());
16839
16840    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
16841        local_var_req_builder =
16842            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
16843    }
16844    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
16845        let local_var_key = local_var_apikey.key.clone();
16846        let local_var_value = match local_var_apikey.prefix {
16847            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
16848            None => local_var_key,
16849        };
16850        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
16851    };
16852    local_var_req_builder = local_var_req_builder.json(&tunnel_group_request);
16853
16854    let local_var_req = local_var_req_builder.build()?;
16855    let local_var_resp = local_var_client.execute(local_var_req).await?;
16856
16857    let local_var_status = local_var_resp.status();
16858    let local_var_content = local_var_resp.text().await?;
16859
16860    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
16861        Ok(())
16862    } else {
16863        let local_var_entity: Option<VpnTunnelGroupsBulkDestroyError> =
16864            serde_json::from_str(&local_var_content).ok();
16865        let local_var_error = ResponseContent {
16866            status: local_var_status,
16867            content: local_var_content,
16868            entity: local_var_entity,
16869        };
16870        Err(Error::ResponseError(local_var_error))
16871    }
16872}
16873
16874/// Patch a list of tunnel group objects.
16875pub async fn vpn_tunnel_groups_bulk_partial_update(
16876    configuration: &configuration::Configuration,
16877    tunnel_group_request: Vec<crate::models::TunnelGroupRequest>,
16878) -> Result<Vec<crate::models::TunnelGroup>, Error<VpnTunnelGroupsBulkPartialUpdateError>> {
16879    let local_var_configuration = configuration;
16880
16881    let local_var_client = &local_var_configuration.client;
16882
16883    let local_var_uri_str = format!(
16884        "{}/api/vpn/tunnel-groups/",
16885        local_var_configuration.base_path
16886    );
16887    let mut local_var_req_builder =
16888        local_var_client.request(reqwest::Method::PATCH, local_var_uri_str.as_str());
16889
16890    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
16891        local_var_req_builder =
16892            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
16893    }
16894    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
16895        let local_var_key = local_var_apikey.key.clone();
16896        let local_var_value = match local_var_apikey.prefix {
16897            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
16898            None => local_var_key,
16899        };
16900        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
16901    };
16902    local_var_req_builder = local_var_req_builder.json(&tunnel_group_request);
16903
16904    let local_var_req = local_var_req_builder.build()?;
16905    let local_var_resp = local_var_client.execute(local_var_req).await?;
16906
16907    let local_var_status = local_var_resp.status();
16908    let local_var_content = local_var_resp.text().await?;
16909
16910    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
16911        serde_json::from_str(&local_var_content).map_err(Error::from)
16912    } else {
16913        let local_var_entity: Option<VpnTunnelGroupsBulkPartialUpdateError> =
16914            serde_json::from_str(&local_var_content).ok();
16915        let local_var_error = ResponseContent {
16916            status: local_var_status,
16917            content: local_var_content,
16918            entity: local_var_entity,
16919        };
16920        Err(Error::ResponseError(local_var_error))
16921    }
16922}
16923
16924/// Put a list of tunnel group objects.
16925pub async fn vpn_tunnel_groups_bulk_update(
16926    configuration: &configuration::Configuration,
16927    tunnel_group_request: Vec<crate::models::TunnelGroupRequest>,
16928) -> Result<Vec<crate::models::TunnelGroup>, Error<VpnTunnelGroupsBulkUpdateError>> {
16929    let local_var_configuration = configuration;
16930
16931    let local_var_client = &local_var_configuration.client;
16932
16933    let local_var_uri_str = format!(
16934        "{}/api/vpn/tunnel-groups/",
16935        local_var_configuration.base_path
16936    );
16937    let mut local_var_req_builder =
16938        local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());
16939
16940    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
16941        local_var_req_builder =
16942            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
16943    }
16944    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
16945        let local_var_key = local_var_apikey.key.clone();
16946        let local_var_value = match local_var_apikey.prefix {
16947            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
16948            None => local_var_key,
16949        };
16950        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
16951    };
16952    local_var_req_builder = local_var_req_builder.json(&tunnel_group_request);
16953
16954    let local_var_req = local_var_req_builder.build()?;
16955    let local_var_resp = local_var_client.execute(local_var_req).await?;
16956
16957    let local_var_status = local_var_resp.status();
16958    let local_var_content = local_var_resp.text().await?;
16959
16960    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
16961        serde_json::from_str(&local_var_content).map_err(Error::from)
16962    } else {
16963        let local_var_entity: Option<VpnTunnelGroupsBulkUpdateError> =
16964            serde_json::from_str(&local_var_content).ok();
16965        let local_var_error = ResponseContent {
16966            status: local_var_status,
16967            content: local_var_content,
16968            entity: local_var_entity,
16969        };
16970        Err(Error::ResponseError(local_var_error))
16971    }
16972}
16973
16974/// Post a list of tunnel group objects.
16975pub async fn vpn_tunnel_groups_create(
16976    configuration: &configuration::Configuration,
16977    vpn_tunnel_groups_create_request: crate::models::VpnTunnelGroupsCreateRequest,
16978) -> Result<crate::models::TunnelGroup, Error<VpnTunnelGroupsCreateError>> {
16979    let local_var_configuration = configuration;
16980
16981    let local_var_client = &local_var_configuration.client;
16982
16983    let local_var_uri_str = format!(
16984        "{}/api/vpn/tunnel-groups/",
16985        local_var_configuration.base_path
16986    );
16987    let mut local_var_req_builder =
16988        local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
16989
16990    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
16991        local_var_req_builder =
16992            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
16993    }
16994    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
16995        let local_var_key = local_var_apikey.key.clone();
16996        let local_var_value = match local_var_apikey.prefix {
16997            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
16998            None => local_var_key,
16999        };
17000        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
17001    };
17002    local_var_req_builder = local_var_req_builder.json(&vpn_tunnel_groups_create_request);
17003
17004    let local_var_req = local_var_req_builder.build()?;
17005    let local_var_resp = local_var_client.execute(local_var_req).await?;
17006
17007    let local_var_status = local_var_resp.status();
17008    let local_var_content = local_var_resp.text().await?;
17009
17010    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
17011        serde_json::from_str(&local_var_content).map_err(Error::from)
17012    } else {
17013        let local_var_entity: Option<VpnTunnelGroupsCreateError> =
17014            serde_json::from_str(&local_var_content).ok();
17015        let local_var_error = ResponseContent {
17016            status: local_var_status,
17017            content: local_var_content,
17018            entity: local_var_entity,
17019        };
17020        Err(Error::ResponseError(local_var_error))
17021    }
17022}
17023
17024/// Delete a tunnel group object.
17025pub async fn vpn_tunnel_groups_destroy(
17026    configuration: &configuration::Configuration,
17027    id: i32,
17028) -> Result<(), Error<VpnTunnelGroupsDestroyError>> {
17029    let local_var_configuration = configuration;
17030
17031    let local_var_client = &local_var_configuration.client;
17032
17033    let local_var_uri_str = format!(
17034        "{}/api/vpn/tunnel-groups/{id}/",
17035        local_var_configuration.base_path,
17036        id = id
17037    );
17038    let mut local_var_req_builder =
17039        local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());
17040
17041    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
17042        local_var_req_builder =
17043            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
17044    }
17045    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
17046        let local_var_key = local_var_apikey.key.clone();
17047        let local_var_value = match local_var_apikey.prefix {
17048            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
17049            None => local_var_key,
17050        };
17051        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
17052    };
17053
17054    let local_var_req = local_var_req_builder.build()?;
17055    let local_var_resp = local_var_client.execute(local_var_req).await?;
17056
17057    let local_var_status = local_var_resp.status();
17058    let local_var_content = local_var_resp.text().await?;
17059
17060    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
17061        Ok(())
17062    } else {
17063        let local_var_entity: Option<VpnTunnelGroupsDestroyError> =
17064            serde_json::from_str(&local_var_content).ok();
17065        let local_var_error = ResponseContent {
17066            status: local_var_status,
17067            content: local_var_content,
17068            entity: local_var_entity,
17069        };
17070        Err(Error::ResponseError(local_var_error))
17071    }
17072}
17073
17074/// Get a list of tunnel group objects.
17075pub async fn vpn_tunnel_groups_list(
17076    configuration: &configuration::Configuration,
17077    contact: Option<Vec<i32>>,
17078    contact__n: Option<Vec<i32>>,
17079    contact_group: Option<Vec<String>>,
17080    contact_group__n: Option<Vec<String>>,
17081    contact_role: Option<Vec<i32>>,
17082    contact_role__n: Option<Vec<i32>>,
17083    created: Option<Vec<String>>,
17084    created__empty: Option<Vec<String>>,
17085    created__gt: Option<Vec<String>>,
17086    created__gte: Option<Vec<String>>,
17087    created__lt: Option<Vec<String>>,
17088    created__lte: Option<Vec<String>>,
17089    created__n: Option<Vec<String>>,
17090    created_by_request: Option<&str>,
17091    description: Option<Vec<String>>,
17092    description__empty: Option<bool>,
17093    description__ic: Option<Vec<String>>,
17094    description__ie: Option<Vec<String>>,
17095    description__iew: Option<Vec<String>>,
17096    description__iregex: Option<Vec<String>>,
17097    description__isw: Option<Vec<String>>,
17098    description__n: Option<Vec<String>>,
17099    description__nic: Option<Vec<String>>,
17100    description__nie: Option<Vec<String>>,
17101    description__niew: Option<Vec<String>>,
17102    description__nisw: Option<Vec<String>>,
17103    description__regex: Option<Vec<String>>,
17104    id: Option<Vec<i32>>,
17105    id__empty: Option<bool>,
17106    id__gt: Option<Vec<i32>>,
17107    id__gte: Option<Vec<i32>>,
17108    id__lt: Option<Vec<i32>>,
17109    id__lte: Option<Vec<i32>>,
17110    id__n: Option<Vec<i32>>,
17111    last_updated: Option<Vec<String>>,
17112    last_updated__empty: Option<Vec<String>>,
17113    last_updated__gt: Option<Vec<String>>,
17114    last_updated__gte: Option<Vec<String>>,
17115    last_updated__lt: Option<Vec<String>>,
17116    last_updated__lte: Option<Vec<String>>,
17117    last_updated__n: Option<Vec<String>>,
17118    limit: Option<i32>,
17119    modified_by_request: Option<&str>,
17120    name: Option<Vec<String>>,
17121    name__empty: Option<bool>,
17122    name__ic: Option<Vec<String>>,
17123    name__ie: Option<Vec<String>>,
17124    name__iew: Option<Vec<String>>,
17125    name__iregex: Option<Vec<String>>,
17126    name__isw: Option<Vec<String>>,
17127    name__n: Option<Vec<String>>,
17128    name__nic: Option<Vec<String>>,
17129    name__nie: Option<Vec<String>>,
17130    name__niew: Option<Vec<String>>,
17131    name__nisw: Option<Vec<String>>,
17132    name__regex: Option<Vec<String>>,
17133    offset: Option<i32>,
17134    ordering: Option<&str>,
17135    owner: Option<Vec<String>>,
17136    owner__n: Option<Vec<String>>,
17137    owner_group: Option<Vec<String>>,
17138    owner_group__n: Option<Vec<String>>,
17139    owner_group_id: Option<Vec<i32>>,
17140    owner_group_id__n: Option<Vec<i32>>,
17141    owner_id: Option<Vec<i32>>,
17142    owner_id__n: Option<Vec<i32>>,
17143    q: Option<&str>,
17144    slug: Option<Vec<String>>,
17145    slug__empty: Option<bool>,
17146    slug__ic: Option<Vec<String>>,
17147    slug__ie: Option<Vec<String>>,
17148    slug__iew: Option<Vec<String>>,
17149    slug__iregex: Option<Vec<String>>,
17150    slug__isw: Option<Vec<String>>,
17151    slug__n: Option<Vec<String>>,
17152    slug__nic: Option<Vec<String>>,
17153    slug__nie: Option<Vec<String>>,
17154    slug__niew: Option<Vec<String>>,
17155    slug__nisw: Option<Vec<String>>,
17156    slug__regex: Option<Vec<String>>,
17157    start: Option<i32>,
17158    tag: Option<Vec<String>>,
17159    tag__n: Option<Vec<String>>,
17160    tag_id: Option<Vec<i32>>,
17161    tag_id__n: Option<Vec<i32>>,
17162    updated_by_request: Option<&str>,
17163) -> Result<crate::models::PaginatedTunnelGroupList, Error<VpnTunnelGroupsListError>> {
17164    let local_var_configuration = configuration;
17165
17166    let local_var_client = &local_var_configuration.client;
17167
17168    let local_var_uri_str = format!(
17169        "{}/api/vpn/tunnel-groups/",
17170        local_var_configuration.base_path
17171    );
17172    let mut local_var_req_builder =
17173        local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
17174
17175    if let Some(ref local_var_str) = contact {
17176        local_var_req_builder = match "multi" {
17177            "multi" => local_var_req_builder.query(
17178                &local_var_str
17179                    .into_iter()
17180                    .map(|p| ("contact".to_owned(), p.to_string()))
17181                    .collect::<Vec<(std::string::String, std::string::String)>>(),
17182            ),
17183            _ => local_var_req_builder.query(&[(
17184                "contact",
17185                &local_var_str
17186                    .into_iter()
17187                    .map(|p| p.to_string())
17188                    .collect::<Vec<String>>()
17189                    .join(",")
17190                    .to_string(),
17191            )]),
17192        };
17193    }
17194    if let Some(ref local_var_str) = contact__n {
17195        local_var_req_builder = match "multi" {
17196            "multi" => local_var_req_builder.query(
17197                &local_var_str
17198                    .into_iter()
17199                    .map(|p| ("contact__n".to_owned(), p.to_string()))
17200                    .collect::<Vec<(std::string::String, std::string::String)>>(),
17201            ),
17202            _ => local_var_req_builder.query(&[(
17203                "contact__n",
17204                &local_var_str
17205                    .into_iter()
17206                    .map(|p| p.to_string())
17207                    .collect::<Vec<String>>()
17208                    .join(",")
17209                    .to_string(),
17210            )]),
17211        };
17212    }
17213    if let Some(ref local_var_str) = contact_group {
17214        local_var_req_builder = match "multi" {
17215            "multi" => local_var_req_builder.query(
17216                &local_var_str
17217                    .into_iter()
17218                    .map(|p| ("contact_group".to_owned(), p.to_string()))
17219                    .collect::<Vec<(std::string::String, std::string::String)>>(),
17220            ),
17221            _ => local_var_req_builder.query(&[(
17222                "contact_group",
17223                &local_var_str
17224                    .into_iter()
17225                    .map(|p| p.to_string())
17226                    .collect::<Vec<String>>()
17227                    .join(",")
17228                    .to_string(),
17229            )]),
17230        };
17231    }
17232    if let Some(ref local_var_str) = contact_group__n {
17233        local_var_req_builder = match "multi" {
17234            "multi" => local_var_req_builder.query(
17235                &local_var_str
17236                    .into_iter()
17237                    .map(|p| ("contact_group__n".to_owned(), p.to_string()))
17238                    .collect::<Vec<(std::string::String, std::string::String)>>(),
17239            ),
17240            _ => local_var_req_builder.query(&[(
17241                "contact_group__n",
17242                &local_var_str
17243                    .into_iter()
17244                    .map(|p| p.to_string())
17245                    .collect::<Vec<String>>()
17246                    .join(",")
17247                    .to_string(),
17248            )]),
17249        };
17250    }
17251    if let Some(ref local_var_str) = contact_role {
17252        local_var_req_builder = match "multi" {
17253            "multi" => local_var_req_builder.query(
17254                &local_var_str
17255                    .into_iter()
17256                    .map(|p| ("contact_role".to_owned(), p.to_string()))
17257                    .collect::<Vec<(std::string::String, std::string::String)>>(),
17258            ),
17259            _ => local_var_req_builder.query(&[(
17260                "contact_role",
17261                &local_var_str
17262                    .into_iter()
17263                    .map(|p| p.to_string())
17264                    .collect::<Vec<String>>()
17265                    .join(",")
17266                    .to_string(),
17267            )]),
17268        };
17269    }
17270    if let Some(ref local_var_str) = contact_role__n {
17271        local_var_req_builder = match "multi" {
17272            "multi" => local_var_req_builder.query(
17273                &local_var_str
17274                    .into_iter()
17275                    .map(|p| ("contact_role__n".to_owned(), p.to_string()))
17276                    .collect::<Vec<(std::string::String, std::string::String)>>(),
17277            ),
17278            _ => local_var_req_builder.query(&[(
17279                "contact_role__n",
17280                &local_var_str
17281                    .into_iter()
17282                    .map(|p| p.to_string())
17283                    .collect::<Vec<String>>()
17284                    .join(",")
17285                    .to_string(),
17286            )]),
17287        };
17288    }
17289    if let Some(ref local_var_str) = created {
17290        local_var_req_builder = match "multi" {
17291            "multi" => local_var_req_builder.query(
17292                &local_var_str
17293                    .into_iter()
17294                    .map(|p| ("created".to_owned(), p.to_string()))
17295                    .collect::<Vec<(std::string::String, std::string::String)>>(),
17296            ),
17297            _ => local_var_req_builder.query(&[(
17298                "created",
17299                &local_var_str
17300                    .into_iter()
17301                    .map(|p| p.to_string())
17302                    .collect::<Vec<String>>()
17303                    .join(",")
17304                    .to_string(),
17305            )]),
17306        };
17307    }
17308    if let Some(ref local_var_str) = created__empty {
17309        local_var_req_builder = match "multi" {
17310            "multi" => local_var_req_builder.query(
17311                &local_var_str
17312                    .into_iter()
17313                    .map(|p| ("created__empty".to_owned(), p.to_string()))
17314                    .collect::<Vec<(std::string::String, std::string::String)>>(),
17315            ),
17316            _ => local_var_req_builder.query(&[(
17317                "created__empty",
17318                &local_var_str
17319                    .into_iter()
17320                    .map(|p| p.to_string())
17321                    .collect::<Vec<String>>()
17322                    .join(",")
17323                    .to_string(),
17324            )]),
17325        };
17326    }
17327    if let Some(ref local_var_str) = created__gt {
17328        local_var_req_builder = match "multi" {
17329            "multi" => local_var_req_builder.query(
17330                &local_var_str
17331                    .into_iter()
17332                    .map(|p| ("created__gt".to_owned(), p.to_string()))
17333                    .collect::<Vec<(std::string::String, std::string::String)>>(),
17334            ),
17335            _ => local_var_req_builder.query(&[(
17336                "created__gt",
17337                &local_var_str
17338                    .into_iter()
17339                    .map(|p| p.to_string())
17340                    .collect::<Vec<String>>()
17341                    .join(",")
17342                    .to_string(),
17343            )]),
17344        };
17345    }
17346    if let Some(ref local_var_str) = created__gte {
17347        local_var_req_builder = match "multi" {
17348            "multi" => local_var_req_builder.query(
17349                &local_var_str
17350                    .into_iter()
17351                    .map(|p| ("created__gte".to_owned(), p.to_string()))
17352                    .collect::<Vec<(std::string::String, std::string::String)>>(),
17353            ),
17354            _ => local_var_req_builder.query(&[(
17355                "created__gte",
17356                &local_var_str
17357                    .into_iter()
17358                    .map(|p| p.to_string())
17359                    .collect::<Vec<String>>()
17360                    .join(",")
17361                    .to_string(),
17362            )]),
17363        };
17364    }
17365    if let Some(ref local_var_str) = created__lt {
17366        local_var_req_builder = match "multi" {
17367            "multi" => local_var_req_builder.query(
17368                &local_var_str
17369                    .into_iter()
17370                    .map(|p| ("created__lt".to_owned(), p.to_string()))
17371                    .collect::<Vec<(std::string::String, std::string::String)>>(),
17372            ),
17373            _ => local_var_req_builder.query(&[(
17374                "created__lt",
17375                &local_var_str
17376                    .into_iter()
17377                    .map(|p| p.to_string())
17378                    .collect::<Vec<String>>()
17379                    .join(",")
17380                    .to_string(),
17381            )]),
17382        };
17383    }
17384    if let Some(ref local_var_str) = created__lte {
17385        local_var_req_builder = match "multi" {
17386            "multi" => local_var_req_builder.query(
17387                &local_var_str
17388                    .into_iter()
17389                    .map(|p| ("created__lte".to_owned(), p.to_string()))
17390                    .collect::<Vec<(std::string::String, std::string::String)>>(),
17391            ),
17392            _ => local_var_req_builder.query(&[(
17393                "created__lte",
17394                &local_var_str
17395                    .into_iter()
17396                    .map(|p| p.to_string())
17397                    .collect::<Vec<String>>()
17398                    .join(",")
17399                    .to_string(),
17400            )]),
17401        };
17402    }
17403    if let Some(ref local_var_str) = created__n {
17404        local_var_req_builder = match "multi" {
17405            "multi" => local_var_req_builder.query(
17406                &local_var_str
17407                    .into_iter()
17408                    .map(|p| ("created__n".to_owned(), p.to_string()))
17409                    .collect::<Vec<(std::string::String, std::string::String)>>(),
17410            ),
17411            _ => local_var_req_builder.query(&[(
17412                "created__n",
17413                &local_var_str
17414                    .into_iter()
17415                    .map(|p| p.to_string())
17416                    .collect::<Vec<String>>()
17417                    .join(",")
17418                    .to_string(),
17419            )]),
17420        };
17421    }
17422    if let Some(ref local_var_str) = created_by_request {
17423        local_var_req_builder =
17424            local_var_req_builder.query(&[("created_by_request", &local_var_str.to_string())]);
17425    }
17426    if let Some(ref local_var_str) = description {
17427        local_var_req_builder = match "multi" {
17428            "multi" => local_var_req_builder.query(
17429                &local_var_str
17430                    .into_iter()
17431                    .map(|p| ("description".to_owned(), p.to_string()))
17432                    .collect::<Vec<(std::string::String, std::string::String)>>(),
17433            ),
17434            _ => local_var_req_builder.query(&[(
17435                "description",
17436                &local_var_str
17437                    .into_iter()
17438                    .map(|p| p.to_string())
17439                    .collect::<Vec<String>>()
17440                    .join(",")
17441                    .to_string(),
17442            )]),
17443        };
17444    }
17445    if let Some(ref local_var_str) = description__empty {
17446        local_var_req_builder =
17447            local_var_req_builder.query(&[("description__empty", &local_var_str.to_string())]);
17448    }
17449    if let Some(ref local_var_str) = description__ic {
17450        local_var_req_builder = match "multi" {
17451            "multi" => local_var_req_builder.query(
17452                &local_var_str
17453                    .into_iter()
17454                    .map(|p| ("description__ic".to_owned(), p.to_string()))
17455                    .collect::<Vec<(std::string::String, std::string::String)>>(),
17456            ),
17457            _ => local_var_req_builder.query(&[(
17458                "description__ic",
17459                &local_var_str
17460                    .into_iter()
17461                    .map(|p| p.to_string())
17462                    .collect::<Vec<String>>()
17463                    .join(",")
17464                    .to_string(),
17465            )]),
17466        };
17467    }
17468    if let Some(ref local_var_str) = description__ie {
17469        local_var_req_builder = match "multi" {
17470            "multi" => local_var_req_builder.query(
17471                &local_var_str
17472                    .into_iter()
17473                    .map(|p| ("description__ie".to_owned(), p.to_string()))
17474                    .collect::<Vec<(std::string::String, std::string::String)>>(),
17475            ),
17476            _ => local_var_req_builder.query(&[(
17477                "description__ie",
17478                &local_var_str
17479                    .into_iter()
17480                    .map(|p| p.to_string())
17481                    .collect::<Vec<String>>()
17482                    .join(",")
17483                    .to_string(),
17484            )]),
17485        };
17486    }
17487    if let Some(ref local_var_str) = description__iew {
17488        local_var_req_builder = match "multi" {
17489            "multi" => local_var_req_builder.query(
17490                &local_var_str
17491                    .into_iter()
17492                    .map(|p| ("description__iew".to_owned(), p.to_string()))
17493                    .collect::<Vec<(std::string::String, std::string::String)>>(),
17494            ),
17495            _ => local_var_req_builder.query(&[(
17496                "description__iew",
17497                &local_var_str
17498                    .into_iter()
17499                    .map(|p| p.to_string())
17500                    .collect::<Vec<String>>()
17501                    .join(",")
17502                    .to_string(),
17503            )]),
17504        };
17505    }
17506    if let Some(ref local_var_str) = description__iregex {
17507        local_var_req_builder = match "multi" {
17508            "multi" => local_var_req_builder.query(
17509                &local_var_str
17510                    .into_iter()
17511                    .map(|p| ("description__iregex".to_owned(), p.to_string()))
17512                    .collect::<Vec<(std::string::String, std::string::String)>>(),
17513            ),
17514            _ => local_var_req_builder.query(&[(
17515                "description__iregex",
17516                &local_var_str
17517                    .into_iter()
17518                    .map(|p| p.to_string())
17519                    .collect::<Vec<String>>()
17520                    .join(",")
17521                    .to_string(),
17522            )]),
17523        };
17524    }
17525    if let Some(ref local_var_str) = description__isw {
17526        local_var_req_builder = match "multi" {
17527            "multi" => local_var_req_builder.query(
17528                &local_var_str
17529                    .into_iter()
17530                    .map(|p| ("description__isw".to_owned(), p.to_string()))
17531                    .collect::<Vec<(std::string::String, std::string::String)>>(),
17532            ),
17533            _ => local_var_req_builder.query(&[(
17534                "description__isw",
17535                &local_var_str
17536                    .into_iter()
17537                    .map(|p| p.to_string())
17538                    .collect::<Vec<String>>()
17539                    .join(",")
17540                    .to_string(),
17541            )]),
17542        };
17543    }
17544    if let Some(ref local_var_str) = description__n {
17545        local_var_req_builder = match "multi" {
17546            "multi" => local_var_req_builder.query(
17547                &local_var_str
17548                    .into_iter()
17549                    .map(|p| ("description__n".to_owned(), p.to_string()))
17550                    .collect::<Vec<(std::string::String, std::string::String)>>(),
17551            ),
17552            _ => local_var_req_builder.query(&[(
17553                "description__n",
17554                &local_var_str
17555                    .into_iter()
17556                    .map(|p| p.to_string())
17557                    .collect::<Vec<String>>()
17558                    .join(",")
17559                    .to_string(),
17560            )]),
17561        };
17562    }
17563    if let Some(ref local_var_str) = description__nic {
17564        local_var_req_builder = match "multi" {
17565            "multi" => local_var_req_builder.query(
17566                &local_var_str
17567                    .into_iter()
17568                    .map(|p| ("description__nic".to_owned(), p.to_string()))
17569                    .collect::<Vec<(std::string::String, std::string::String)>>(),
17570            ),
17571            _ => local_var_req_builder.query(&[(
17572                "description__nic",
17573                &local_var_str
17574                    .into_iter()
17575                    .map(|p| p.to_string())
17576                    .collect::<Vec<String>>()
17577                    .join(",")
17578                    .to_string(),
17579            )]),
17580        };
17581    }
17582    if let Some(ref local_var_str) = description__nie {
17583        local_var_req_builder = match "multi" {
17584            "multi" => local_var_req_builder.query(
17585                &local_var_str
17586                    .into_iter()
17587                    .map(|p| ("description__nie".to_owned(), p.to_string()))
17588                    .collect::<Vec<(std::string::String, std::string::String)>>(),
17589            ),
17590            _ => local_var_req_builder.query(&[(
17591                "description__nie",
17592                &local_var_str
17593                    .into_iter()
17594                    .map(|p| p.to_string())
17595                    .collect::<Vec<String>>()
17596                    .join(",")
17597                    .to_string(),
17598            )]),
17599        };
17600    }
17601    if let Some(ref local_var_str) = description__niew {
17602        local_var_req_builder = match "multi" {
17603            "multi" => local_var_req_builder.query(
17604                &local_var_str
17605                    .into_iter()
17606                    .map(|p| ("description__niew".to_owned(), p.to_string()))
17607                    .collect::<Vec<(std::string::String, std::string::String)>>(),
17608            ),
17609            _ => local_var_req_builder.query(&[(
17610                "description__niew",
17611                &local_var_str
17612                    .into_iter()
17613                    .map(|p| p.to_string())
17614                    .collect::<Vec<String>>()
17615                    .join(",")
17616                    .to_string(),
17617            )]),
17618        };
17619    }
17620    if let Some(ref local_var_str) = description__nisw {
17621        local_var_req_builder = match "multi" {
17622            "multi" => local_var_req_builder.query(
17623                &local_var_str
17624                    .into_iter()
17625                    .map(|p| ("description__nisw".to_owned(), p.to_string()))
17626                    .collect::<Vec<(std::string::String, std::string::String)>>(),
17627            ),
17628            _ => local_var_req_builder.query(&[(
17629                "description__nisw",
17630                &local_var_str
17631                    .into_iter()
17632                    .map(|p| p.to_string())
17633                    .collect::<Vec<String>>()
17634                    .join(",")
17635                    .to_string(),
17636            )]),
17637        };
17638    }
17639    if let Some(ref local_var_str) = description__regex {
17640        local_var_req_builder = match "multi" {
17641            "multi" => local_var_req_builder.query(
17642                &local_var_str
17643                    .into_iter()
17644                    .map(|p| ("description__regex".to_owned(), p.to_string()))
17645                    .collect::<Vec<(std::string::String, std::string::String)>>(),
17646            ),
17647            _ => local_var_req_builder.query(&[(
17648                "description__regex",
17649                &local_var_str
17650                    .into_iter()
17651                    .map(|p| p.to_string())
17652                    .collect::<Vec<String>>()
17653                    .join(",")
17654                    .to_string(),
17655            )]),
17656        };
17657    }
17658    if let Some(ref local_var_str) = id {
17659        local_var_req_builder = match "multi" {
17660            "multi" => local_var_req_builder.query(
17661                &local_var_str
17662                    .into_iter()
17663                    .map(|p| ("id".to_owned(), p.to_string()))
17664                    .collect::<Vec<(std::string::String, std::string::String)>>(),
17665            ),
17666            _ => local_var_req_builder.query(&[(
17667                "id",
17668                &local_var_str
17669                    .into_iter()
17670                    .map(|p| p.to_string())
17671                    .collect::<Vec<String>>()
17672                    .join(",")
17673                    .to_string(),
17674            )]),
17675        };
17676    }
17677    if let Some(ref local_var_str) = id__empty {
17678        local_var_req_builder =
17679            local_var_req_builder.query(&[("id__empty", &local_var_str.to_string())]);
17680    }
17681    if let Some(ref local_var_str) = id__gt {
17682        local_var_req_builder = match "multi" {
17683            "multi" => local_var_req_builder.query(
17684                &local_var_str
17685                    .into_iter()
17686                    .map(|p| ("id__gt".to_owned(), p.to_string()))
17687                    .collect::<Vec<(std::string::String, std::string::String)>>(),
17688            ),
17689            _ => local_var_req_builder.query(&[(
17690                "id__gt",
17691                &local_var_str
17692                    .into_iter()
17693                    .map(|p| p.to_string())
17694                    .collect::<Vec<String>>()
17695                    .join(",")
17696                    .to_string(),
17697            )]),
17698        };
17699    }
17700    if let Some(ref local_var_str) = id__gte {
17701        local_var_req_builder = match "multi" {
17702            "multi" => local_var_req_builder.query(
17703                &local_var_str
17704                    .into_iter()
17705                    .map(|p| ("id__gte".to_owned(), p.to_string()))
17706                    .collect::<Vec<(std::string::String, std::string::String)>>(),
17707            ),
17708            _ => local_var_req_builder.query(&[(
17709                "id__gte",
17710                &local_var_str
17711                    .into_iter()
17712                    .map(|p| p.to_string())
17713                    .collect::<Vec<String>>()
17714                    .join(",")
17715                    .to_string(),
17716            )]),
17717        };
17718    }
17719    if let Some(ref local_var_str) = id__lt {
17720        local_var_req_builder = match "multi" {
17721            "multi" => local_var_req_builder.query(
17722                &local_var_str
17723                    .into_iter()
17724                    .map(|p| ("id__lt".to_owned(), p.to_string()))
17725                    .collect::<Vec<(std::string::String, std::string::String)>>(),
17726            ),
17727            _ => local_var_req_builder.query(&[(
17728                "id__lt",
17729                &local_var_str
17730                    .into_iter()
17731                    .map(|p| p.to_string())
17732                    .collect::<Vec<String>>()
17733                    .join(",")
17734                    .to_string(),
17735            )]),
17736        };
17737    }
17738    if let Some(ref local_var_str) = id__lte {
17739        local_var_req_builder = match "multi" {
17740            "multi" => local_var_req_builder.query(
17741                &local_var_str
17742                    .into_iter()
17743                    .map(|p| ("id__lte".to_owned(), p.to_string()))
17744                    .collect::<Vec<(std::string::String, std::string::String)>>(),
17745            ),
17746            _ => local_var_req_builder.query(&[(
17747                "id__lte",
17748                &local_var_str
17749                    .into_iter()
17750                    .map(|p| p.to_string())
17751                    .collect::<Vec<String>>()
17752                    .join(",")
17753                    .to_string(),
17754            )]),
17755        };
17756    }
17757    if let Some(ref local_var_str) = id__n {
17758        local_var_req_builder = match "multi" {
17759            "multi" => local_var_req_builder.query(
17760                &local_var_str
17761                    .into_iter()
17762                    .map(|p| ("id__n".to_owned(), p.to_string()))
17763                    .collect::<Vec<(std::string::String, std::string::String)>>(),
17764            ),
17765            _ => local_var_req_builder.query(&[(
17766                "id__n",
17767                &local_var_str
17768                    .into_iter()
17769                    .map(|p| p.to_string())
17770                    .collect::<Vec<String>>()
17771                    .join(",")
17772                    .to_string(),
17773            )]),
17774        };
17775    }
17776    if let Some(ref local_var_str) = last_updated {
17777        local_var_req_builder = match "multi" {
17778            "multi" => local_var_req_builder.query(
17779                &local_var_str
17780                    .into_iter()
17781                    .map(|p| ("last_updated".to_owned(), p.to_string()))
17782                    .collect::<Vec<(std::string::String, std::string::String)>>(),
17783            ),
17784            _ => local_var_req_builder.query(&[(
17785                "last_updated",
17786                &local_var_str
17787                    .into_iter()
17788                    .map(|p| p.to_string())
17789                    .collect::<Vec<String>>()
17790                    .join(",")
17791                    .to_string(),
17792            )]),
17793        };
17794    }
17795    if let Some(ref local_var_str) = last_updated__empty {
17796        local_var_req_builder = match "multi" {
17797            "multi" => local_var_req_builder.query(
17798                &local_var_str
17799                    .into_iter()
17800                    .map(|p| ("last_updated__empty".to_owned(), p.to_string()))
17801                    .collect::<Vec<(std::string::String, std::string::String)>>(),
17802            ),
17803            _ => local_var_req_builder.query(&[(
17804                "last_updated__empty",
17805                &local_var_str
17806                    .into_iter()
17807                    .map(|p| p.to_string())
17808                    .collect::<Vec<String>>()
17809                    .join(",")
17810                    .to_string(),
17811            )]),
17812        };
17813    }
17814    if let Some(ref local_var_str) = last_updated__gt {
17815        local_var_req_builder = match "multi" {
17816            "multi" => local_var_req_builder.query(
17817                &local_var_str
17818                    .into_iter()
17819                    .map(|p| ("last_updated__gt".to_owned(), p.to_string()))
17820                    .collect::<Vec<(std::string::String, std::string::String)>>(),
17821            ),
17822            _ => local_var_req_builder.query(&[(
17823                "last_updated__gt",
17824                &local_var_str
17825                    .into_iter()
17826                    .map(|p| p.to_string())
17827                    .collect::<Vec<String>>()
17828                    .join(",")
17829                    .to_string(),
17830            )]),
17831        };
17832    }
17833    if let Some(ref local_var_str) = last_updated__gte {
17834        local_var_req_builder = match "multi" {
17835            "multi" => local_var_req_builder.query(
17836                &local_var_str
17837                    .into_iter()
17838                    .map(|p| ("last_updated__gte".to_owned(), p.to_string()))
17839                    .collect::<Vec<(std::string::String, std::string::String)>>(),
17840            ),
17841            _ => local_var_req_builder.query(&[(
17842                "last_updated__gte",
17843                &local_var_str
17844                    .into_iter()
17845                    .map(|p| p.to_string())
17846                    .collect::<Vec<String>>()
17847                    .join(",")
17848                    .to_string(),
17849            )]),
17850        };
17851    }
17852    if let Some(ref local_var_str) = last_updated__lt {
17853        local_var_req_builder = match "multi" {
17854            "multi" => local_var_req_builder.query(
17855                &local_var_str
17856                    .into_iter()
17857                    .map(|p| ("last_updated__lt".to_owned(), p.to_string()))
17858                    .collect::<Vec<(std::string::String, std::string::String)>>(),
17859            ),
17860            _ => local_var_req_builder.query(&[(
17861                "last_updated__lt",
17862                &local_var_str
17863                    .into_iter()
17864                    .map(|p| p.to_string())
17865                    .collect::<Vec<String>>()
17866                    .join(",")
17867                    .to_string(),
17868            )]),
17869        };
17870    }
17871    if let Some(ref local_var_str) = last_updated__lte {
17872        local_var_req_builder = match "multi" {
17873            "multi" => local_var_req_builder.query(
17874                &local_var_str
17875                    .into_iter()
17876                    .map(|p| ("last_updated__lte".to_owned(), p.to_string()))
17877                    .collect::<Vec<(std::string::String, std::string::String)>>(),
17878            ),
17879            _ => local_var_req_builder.query(&[(
17880                "last_updated__lte",
17881                &local_var_str
17882                    .into_iter()
17883                    .map(|p| p.to_string())
17884                    .collect::<Vec<String>>()
17885                    .join(",")
17886                    .to_string(),
17887            )]),
17888        };
17889    }
17890    if let Some(ref local_var_str) = last_updated__n {
17891        local_var_req_builder = match "multi" {
17892            "multi" => local_var_req_builder.query(
17893                &local_var_str
17894                    .into_iter()
17895                    .map(|p| ("last_updated__n".to_owned(), p.to_string()))
17896                    .collect::<Vec<(std::string::String, std::string::String)>>(),
17897            ),
17898            _ => local_var_req_builder.query(&[(
17899                "last_updated__n",
17900                &local_var_str
17901                    .into_iter()
17902                    .map(|p| p.to_string())
17903                    .collect::<Vec<String>>()
17904                    .join(",")
17905                    .to_string(),
17906            )]),
17907        };
17908    }
17909    if let Some(ref local_var_str) = limit {
17910        local_var_req_builder =
17911            local_var_req_builder.query(&[("limit", &local_var_str.to_string())]);
17912    }
17913    if let Some(ref local_var_str) = modified_by_request {
17914        local_var_req_builder =
17915            local_var_req_builder.query(&[("modified_by_request", &local_var_str.to_string())]);
17916    }
17917    if let Some(ref local_var_str) = name {
17918        local_var_req_builder = match "multi" {
17919            "multi" => local_var_req_builder.query(
17920                &local_var_str
17921                    .into_iter()
17922                    .map(|p| ("name".to_owned(), p.to_string()))
17923                    .collect::<Vec<(std::string::String, std::string::String)>>(),
17924            ),
17925            _ => local_var_req_builder.query(&[(
17926                "name",
17927                &local_var_str
17928                    .into_iter()
17929                    .map(|p| p.to_string())
17930                    .collect::<Vec<String>>()
17931                    .join(",")
17932                    .to_string(),
17933            )]),
17934        };
17935    }
17936    if let Some(ref local_var_str) = name__empty {
17937        local_var_req_builder =
17938            local_var_req_builder.query(&[("name__empty", &local_var_str.to_string())]);
17939    }
17940    if let Some(ref local_var_str) = name__ic {
17941        local_var_req_builder = match "multi" {
17942            "multi" => local_var_req_builder.query(
17943                &local_var_str
17944                    .into_iter()
17945                    .map(|p| ("name__ic".to_owned(), p.to_string()))
17946                    .collect::<Vec<(std::string::String, std::string::String)>>(),
17947            ),
17948            _ => local_var_req_builder.query(&[(
17949                "name__ic",
17950                &local_var_str
17951                    .into_iter()
17952                    .map(|p| p.to_string())
17953                    .collect::<Vec<String>>()
17954                    .join(",")
17955                    .to_string(),
17956            )]),
17957        };
17958    }
17959    if let Some(ref local_var_str) = name__ie {
17960        local_var_req_builder = match "multi" {
17961            "multi" => local_var_req_builder.query(
17962                &local_var_str
17963                    .into_iter()
17964                    .map(|p| ("name__ie".to_owned(), p.to_string()))
17965                    .collect::<Vec<(std::string::String, std::string::String)>>(),
17966            ),
17967            _ => local_var_req_builder.query(&[(
17968                "name__ie",
17969                &local_var_str
17970                    .into_iter()
17971                    .map(|p| p.to_string())
17972                    .collect::<Vec<String>>()
17973                    .join(",")
17974                    .to_string(),
17975            )]),
17976        };
17977    }
17978    if let Some(ref local_var_str) = name__iew {
17979        local_var_req_builder = match "multi" {
17980            "multi" => local_var_req_builder.query(
17981                &local_var_str
17982                    .into_iter()
17983                    .map(|p| ("name__iew".to_owned(), p.to_string()))
17984                    .collect::<Vec<(std::string::String, std::string::String)>>(),
17985            ),
17986            _ => local_var_req_builder.query(&[(
17987                "name__iew",
17988                &local_var_str
17989                    .into_iter()
17990                    .map(|p| p.to_string())
17991                    .collect::<Vec<String>>()
17992                    .join(",")
17993                    .to_string(),
17994            )]),
17995        };
17996    }
17997    if let Some(ref local_var_str) = name__iregex {
17998        local_var_req_builder = match "multi" {
17999            "multi" => local_var_req_builder.query(
18000                &local_var_str
18001                    .into_iter()
18002                    .map(|p| ("name__iregex".to_owned(), p.to_string()))
18003                    .collect::<Vec<(std::string::String, std::string::String)>>(),
18004            ),
18005            _ => local_var_req_builder.query(&[(
18006                "name__iregex",
18007                &local_var_str
18008                    .into_iter()
18009                    .map(|p| p.to_string())
18010                    .collect::<Vec<String>>()
18011                    .join(",")
18012                    .to_string(),
18013            )]),
18014        };
18015    }
18016    if let Some(ref local_var_str) = name__isw {
18017        local_var_req_builder = match "multi" {
18018            "multi" => local_var_req_builder.query(
18019                &local_var_str
18020                    .into_iter()
18021                    .map(|p| ("name__isw".to_owned(), p.to_string()))
18022                    .collect::<Vec<(std::string::String, std::string::String)>>(),
18023            ),
18024            _ => local_var_req_builder.query(&[(
18025                "name__isw",
18026                &local_var_str
18027                    .into_iter()
18028                    .map(|p| p.to_string())
18029                    .collect::<Vec<String>>()
18030                    .join(",")
18031                    .to_string(),
18032            )]),
18033        };
18034    }
18035    if let Some(ref local_var_str) = name__n {
18036        local_var_req_builder = match "multi" {
18037            "multi" => local_var_req_builder.query(
18038                &local_var_str
18039                    .into_iter()
18040                    .map(|p| ("name__n".to_owned(), p.to_string()))
18041                    .collect::<Vec<(std::string::String, std::string::String)>>(),
18042            ),
18043            _ => local_var_req_builder.query(&[(
18044                "name__n",
18045                &local_var_str
18046                    .into_iter()
18047                    .map(|p| p.to_string())
18048                    .collect::<Vec<String>>()
18049                    .join(",")
18050                    .to_string(),
18051            )]),
18052        };
18053    }
18054    if let Some(ref local_var_str) = name__nic {
18055        local_var_req_builder = match "multi" {
18056            "multi" => local_var_req_builder.query(
18057                &local_var_str
18058                    .into_iter()
18059                    .map(|p| ("name__nic".to_owned(), p.to_string()))
18060                    .collect::<Vec<(std::string::String, std::string::String)>>(),
18061            ),
18062            _ => local_var_req_builder.query(&[(
18063                "name__nic",
18064                &local_var_str
18065                    .into_iter()
18066                    .map(|p| p.to_string())
18067                    .collect::<Vec<String>>()
18068                    .join(",")
18069                    .to_string(),
18070            )]),
18071        };
18072    }
18073    if let Some(ref local_var_str) = name__nie {
18074        local_var_req_builder = match "multi" {
18075            "multi" => local_var_req_builder.query(
18076                &local_var_str
18077                    .into_iter()
18078                    .map(|p| ("name__nie".to_owned(), p.to_string()))
18079                    .collect::<Vec<(std::string::String, std::string::String)>>(),
18080            ),
18081            _ => local_var_req_builder.query(&[(
18082                "name__nie",
18083                &local_var_str
18084                    .into_iter()
18085                    .map(|p| p.to_string())
18086                    .collect::<Vec<String>>()
18087                    .join(",")
18088                    .to_string(),
18089            )]),
18090        };
18091    }
18092    if let Some(ref local_var_str) = name__niew {
18093        local_var_req_builder = match "multi" {
18094            "multi" => local_var_req_builder.query(
18095                &local_var_str
18096                    .into_iter()
18097                    .map(|p| ("name__niew".to_owned(), p.to_string()))
18098                    .collect::<Vec<(std::string::String, std::string::String)>>(),
18099            ),
18100            _ => local_var_req_builder.query(&[(
18101                "name__niew",
18102                &local_var_str
18103                    .into_iter()
18104                    .map(|p| p.to_string())
18105                    .collect::<Vec<String>>()
18106                    .join(",")
18107                    .to_string(),
18108            )]),
18109        };
18110    }
18111    if let Some(ref local_var_str) = name__nisw {
18112        local_var_req_builder = match "multi" {
18113            "multi" => local_var_req_builder.query(
18114                &local_var_str
18115                    .into_iter()
18116                    .map(|p| ("name__nisw".to_owned(), p.to_string()))
18117                    .collect::<Vec<(std::string::String, std::string::String)>>(),
18118            ),
18119            _ => local_var_req_builder.query(&[(
18120                "name__nisw",
18121                &local_var_str
18122                    .into_iter()
18123                    .map(|p| p.to_string())
18124                    .collect::<Vec<String>>()
18125                    .join(",")
18126                    .to_string(),
18127            )]),
18128        };
18129    }
18130    if let Some(ref local_var_str) = name__regex {
18131        local_var_req_builder = match "multi" {
18132            "multi" => local_var_req_builder.query(
18133                &local_var_str
18134                    .into_iter()
18135                    .map(|p| ("name__regex".to_owned(), p.to_string()))
18136                    .collect::<Vec<(std::string::String, std::string::String)>>(),
18137            ),
18138            _ => local_var_req_builder.query(&[(
18139                "name__regex",
18140                &local_var_str
18141                    .into_iter()
18142                    .map(|p| p.to_string())
18143                    .collect::<Vec<String>>()
18144                    .join(",")
18145                    .to_string(),
18146            )]),
18147        };
18148    }
18149    if let Some(ref local_var_str) = offset {
18150        local_var_req_builder =
18151            local_var_req_builder.query(&[("offset", &local_var_str.to_string())]);
18152    }
18153    if let Some(ref local_var_str) = ordering {
18154        local_var_req_builder =
18155            local_var_req_builder.query(&[("ordering", &local_var_str.to_string())]);
18156    }
18157    if let Some(ref local_var_str) = owner {
18158        local_var_req_builder = match "multi" {
18159            "multi" => local_var_req_builder.query(
18160                &local_var_str
18161                    .into_iter()
18162                    .map(|p| ("owner".to_owned(), p.to_string()))
18163                    .collect::<Vec<(std::string::String, std::string::String)>>(),
18164            ),
18165            _ => local_var_req_builder.query(&[(
18166                "owner",
18167                &local_var_str
18168                    .into_iter()
18169                    .map(|p| p.to_string())
18170                    .collect::<Vec<String>>()
18171                    .join(",")
18172                    .to_string(),
18173            )]),
18174        };
18175    }
18176    if let Some(ref local_var_str) = owner__n {
18177        local_var_req_builder = match "multi" {
18178            "multi" => local_var_req_builder.query(
18179                &local_var_str
18180                    .into_iter()
18181                    .map(|p| ("owner__n".to_owned(), p.to_string()))
18182                    .collect::<Vec<(std::string::String, std::string::String)>>(),
18183            ),
18184            _ => local_var_req_builder.query(&[(
18185                "owner__n",
18186                &local_var_str
18187                    .into_iter()
18188                    .map(|p| p.to_string())
18189                    .collect::<Vec<String>>()
18190                    .join(",")
18191                    .to_string(),
18192            )]),
18193        };
18194    }
18195    if let Some(ref local_var_str) = owner_group {
18196        local_var_req_builder = match "multi" {
18197            "multi" => local_var_req_builder.query(
18198                &local_var_str
18199                    .into_iter()
18200                    .map(|p| ("owner_group".to_owned(), p.to_string()))
18201                    .collect::<Vec<(std::string::String, std::string::String)>>(),
18202            ),
18203            _ => local_var_req_builder.query(&[(
18204                "owner_group",
18205                &local_var_str
18206                    .into_iter()
18207                    .map(|p| p.to_string())
18208                    .collect::<Vec<String>>()
18209                    .join(",")
18210                    .to_string(),
18211            )]),
18212        };
18213    }
18214    if let Some(ref local_var_str) = owner_group__n {
18215        local_var_req_builder = match "multi" {
18216            "multi" => local_var_req_builder.query(
18217                &local_var_str
18218                    .into_iter()
18219                    .map(|p| ("owner_group__n".to_owned(), p.to_string()))
18220                    .collect::<Vec<(std::string::String, std::string::String)>>(),
18221            ),
18222            _ => local_var_req_builder.query(&[(
18223                "owner_group__n",
18224                &local_var_str
18225                    .into_iter()
18226                    .map(|p| p.to_string())
18227                    .collect::<Vec<String>>()
18228                    .join(",")
18229                    .to_string(),
18230            )]),
18231        };
18232    }
18233    if let Some(ref local_var_str) = owner_group_id {
18234        local_var_req_builder = match "multi" {
18235            "multi" => local_var_req_builder.query(
18236                &local_var_str
18237                    .into_iter()
18238                    .map(|p| ("owner_group_id".to_owned(), p.to_string()))
18239                    .collect::<Vec<(std::string::String, std::string::String)>>(),
18240            ),
18241            _ => local_var_req_builder.query(&[(
18242                "owner_group_id",
18243                &local_var_str
18244                    .into_iter()
18245                    .map(|p| p.to_string())
18246                    .collect::<Vec<String>>()
18247                    .join(",")
18248                    .to_string(),
18249            )]),
18250        };
18251    }
18252    if let Some(ref local_var_str) = owner_group_id__n {
18253        local_var_req_builder = match "multi" {
18254            "multi" => local_var_req_builder.query(
18255                &local_var_str
18256                    .into_iter()
18257                    .map(|p| ("owner_group_id__n".to_owned(), p.to_string()))
18258                    .collect::<Vec<(std::string::String, std::string::String)>>(),
18259            ),
18260            _ => local_var_req_builder.query(&[(
18261                "owner_group_id__n",
18262                &local_var_str
18263                    .into_iter()
18264                    .map(|p| p.to_string())
18265                    .collect::<Vec<String>>()
18266                    .join(",")
18267                    .to_string(),
18268            )]),
18269        };
18270    }
18271    if let Some(ref local_var_str) = owner_id {
18272        local_var_req_builder = match "multi" {
18273            "multi" => local_var_req_builder.query(
18274                &local_var_str
18275                    .into_iter()
18276                    .map(|p| ("owner_id".to_owned(), p.to_string()))
18277                    .collect::<Vec<(std::string::String, std::string::String)>>(),
18278            ),
18279            _ => local_var_req_builder.query(&[(
18280                "owner_id",
18281                &local_var_str
18282                    .into_iter()
18283                    .map(|p| p.to_string())
18284                    .collect::<Vec<String>>()
18285                    .join(",")
18286                    .to_string(),
18287            )]),
18288        };
18289    }
18290    if let Some(ref local_var_str) = owner_id__n {
18291        local_var_req_builder = match "multi" {
18292            "multi" => local_var_req_builder.query(
18293                &local_var_str
18294                    .into_iter()
18295                    .map(|p| ("owner_id__n".to_owned(), p.to_string()))
18296                    .collect::<Vec<(std::string::String, std::string::String)>>(),
18297            ),
18298            _ => local_var_req_builder.query(&[(
18299                "owner_id__n",
18300                &local_var_str
18301                    .into_iter()
18302                    .map(|p| p.to_string())
18303                    .collect::<Vec<String>>()
18304                    .join(",")
18305                    .to_string(),
18306            )]),
18307        };
18308    }
18309    if let Some(ref local_var_str) = q {
18310        local_var_req_builder = local_var_req_builder.query(&[("q", &local_var_str.to_string())]);
18311    }
18312    if let Some(ref local_var_str) = slug {
18313        local_var_req_builder = match "multi" {
18314            "multi" => local_var_req_builder.query(
18315                &local_var_str
18316                    .into_iter()
18317                    .map(|p| ("slug".to_owned(), p.to_string()))
18318                    .collect::<Vec<(std::string::String, std::string::String)>>(),
18319            ),
18320            _ => local_var_req_builder.query(&[(
18321                "slug",
18322                &local_var_str
18323                    .into_iter()
18324                    .map(|p| p.to_string())
18325                    .collect::<Vec<String>>()
18326                    .join(",")
18327                    .to_string(),
18328            )]),
18329        };
18330    }
18331    if let Some(ref local_var_str) = slug__empty {
18332        local_var_req_builder =
18333            local_var_req_builder.query(&[("slug__empty", &local_var_str.to_string())]);
18334    }
18335    if let Some(ref local_var_str) = slug__ic {
18336        local_var_req_builder = match "multi" {
18337            "multi" => local_var_req_builder.query(
18338                &local_var_str
18339                    .into_iter()
18340                    .map(|p| ("slug__ic".to_owned(), p.to_string()))
18341                    .collect::<Vec<(std::string::String, std::string::String)>>(),
18342            ),
18343            _ => local_var_req_builder.query(&[(
18344                "slug__ic",
18345                &local_var_str
18346                    .into_iter()
18347                    .map(|p| p.to_string())
18348                    .collect::<Vec<String>>()
18349                    .join(",")
18350                    .to_string(),
18351            )]),
18352        };
18353    }
18354    if let Some(ref local_var_str) = slug__ie {
18355        local_var_req_builder = match "multi" {
18356            "multi" => local_var_req_builder.query(
18357                &local_var_str
18358                    .into_iter()
18359                    .map(|p| ("slug__ie".to_owned(), p.to_string()))
18360                    .collect::<Vec<(std::string::String, std::string::String)>>(),
18361            ),
18362            _ => local_var_req_builder.query(&[(
18363                "slug__ie",
18364                &local_var_str
18365                    .into_iter()
18366                    .map(|p| p.to_string())
18367                    .collect::<Vec<String>>()
18368                    .join(",")
18369                    .to_string(),
18370            )]),
18371        };
18372    }
18373    if let Some(ref local_var_str) = slug__iew {
18374        local_var_req_builder = match "multi" {
18375            "multi" => local_var_req_builder.query(
18376                &local_var_str
18377                    .into_iter()
18378                    .map(|p| ("slug__iew".to_owned(), p.to_string()))
18379                    .collect::<Vec<(std::string::String, std::string::String)>>(),
18380            ),
18381            _ => local_var_req_builder.query(&[(
18382                "slug__iew",
18383                &local_var_str
18384                    .into_iter()
18385                    .map(|p| p.to_string())
18386                    .collect::<Vec<String>>()
18387                    .join(",")
18388                    .to_string(),
18389            )]),
18390        };
18391    }
18392    if let Some(ref local_var_str) = slug__iregex {
18393        local_var_req_builder = match "multi" {
18394            "multi" => local_var_req_builder.query(
18395                &local_var_str
18396                    .into_iter()
18397                    .map(|p| ("slug__iregex".to_owned(), p.to_string()))
18398                    .collect::<Vec<(std::string::String, std::string::String)>>(),
18399            ),
18400            _ => local_var_req_builder.query(&[(
18401                "slug__iregex",
18402                &local_var_str
18403                    .into_iter()
18404                    .map(|p| p.to_string())
18405                    .collect::<Vec<String>>()
18406                    .join(",")
18407                    .to_string(),
18408            )]),
18409        };
18410    }
18411    if let Some(ref local_var_str) = slug__isw {
18412        local_var_req_builder = match "multi" {
18413            "multi" => local_var_req_builder.query(
18414                &local_var_str
18415                    .into_iter()
18416                    .map(|p| ("slug__isw".to_owned(), p.to_string()))
18417                    .collect::<Vec<(std::string::String, std::string::String)>>(),
18418            ),
18419            _ => local_var_req_builder.query(&[(
18420                "slug__isw",
18421                &local_var_str
18422                    .into_iter()
18423                    .map(|p| p.to_string())
18424                    .collect::<Vec<String>>()
18425                    .join(",")
18426                    .to_string(),
18427            )]),
18428        };
18429    }
18430    if let Some(ref local_var_str) = slug__n {
18431        local_var_req_builder = match "multi" {
18432            "multi" => local_var_req_builder.query(
18433                &local_var_str
18434                    .into_iter()
18435                    .map(|p| ("slug__n".to_owned(), p.to_string()))
18436                    .collect::<Vec<(std::string::String, std::string::String)>>(),
18437            ),
18438            _ => local_var_req_builder.query(&[(
18439                "slug__n",
18440                &local_var_str
18441                    .into_iter()
18442                    .map(|p| p.to_string())
18443                    .collect::<Vec<String>>()
18444                    .join(",")
18445                    .to_string(),
18446            )]),
18447        };
18448    }
18449    if let Some(ref local_var_str) = slug__nic {
18450        local_var_req_builder = match "multi" {
18451            "multi" => local_var_req_builder.query(
18452                &local_var_str
18453                    .into_iter()
18454                    .map(|p| ("slug__nic".to_owned(), p.to_string()))
18455                    .collect::<Vec<(std::string::String, std::string::String)>>(),
18456            ),
18457            _ => local_var_req_builder.query(&[(
18458                "slug__nic",
18459                &local_var_str
18460                    .into_iter()
18461                    .map(|p| p.to_string())
18462                    .collect::<Vec<String>>()
18463                    .join(",")
18464                    .to_string(),
18465            )]),
18466        };
18467    }
18468    if let Some(ref local_var_str) = slug__nie {
18469        local_var_req_builder = match "multi" {
18470            "multi" => local_var_req_builder.query(
18471                &local_var_str
18472                    .into_iter()
18473                    .map(|p| ("slug__nie".to_owned(), p.to_string()))
18474                    .collect::<Vec<(std::string::String, std::string::String)>>(),
18475            ),
18476            _ => local_var_req_builder.query(&[(
18477                "slug__nie",
18478                &local_var_str
18479                    .into_iter()
18480                    .map(|p| p.to_string())
18481                    .collect::<Vec<String>>()
18482                    .join(",")
18483                    .to_string(),
18484            )]),
18485        };
18486    }
18487    if let Some(ref local_var_str) = slug__niew {
18488        local_var_req_builder = match "multi" {
18489            "multi" => local_var_req_builder.query(
18490                &local_var_str
18491                    .into_iter()
18492                    .map(|p| ("slug__niew".to_owned(), p.to_string()))
18493                    .collect::<Vec<(std::string::String, std::string::String)>>(),
18494            ),
18495            _ => local_var_req_builder.query(&[(
18496                "slug__niew",
18497                &local_var_str
18498                    .into_iter()
18499                    .map(|p| p.to_string())
18500                    .collect::<Vec<String>>()
18501                    .join(",")
18502                    .to_string(),
18503            )]),
18504        };
18505    }
18506    if let Some(ref local_var_str) = slug__nisw {
18507        local_var_req_builder = match "multi" {
18508            "multi" => local_var_req_builder.query(
18509                &local_var_str
18510                    .into_iter()
18511                    .map(|p| ("slug__nisw".to_owned(), p.to_string()))
18512                    .collect::<Vec<(std::string::String, std::string::String)>>(),
18513            ),
18514            _ => local_var_req_builder.query(&[(
18515                "slug__nisw",
18516                &local_var_str
18517                    .into_iter()
18518                    .map(|p| p.to_string())
18519                    .collect::<Vec<String>>()
18520                    .join(",")
18521                    .to_string(),
18522            )]),
18523        };
18524    }
18525    if let Some(ref local_var_str) = slug__regex {
18526        local_var_req_builder = match "multi" {
18527            "multi" => local_var_req_builder.query(
18528                &local_var_str
18529                    .into_iter()
18530                    .map(|p| ("slug__regex".to_owned(), p.to_string()))
18531                    .collect::<Vec<(std::string::String, std::string::String)>>(),
18532            ),
18533            _ => local_var_req_builder.query(&[(
18534                "slug__regex",
18535                &local_var_str
18536                    .into_iter()
18537                    .map(|p| p.to_string())
18538                    .collect::<Vec<String>>()
18539                    .join(",")
18540                    .to_string(),
18541            )]),
18542        };
18543    }
18544    if let Some(ref local_var_str) = start {
18545        local_var_req_builder =
18546            local_var_req_builder.query(&[("start", &local_var_str.to_string())]);
18547    }
18548    if let Some(ref local_var_str) = tag {
18549        local_var_req_builder = match "multi" {
18550            "multi" => local_var_req_builder.query(
18551                &local_var_str
18552                    .into_iter()
18553                    .map(|p| ("tag".to_owned(), p.to_string()))
18554                    .collect::<Vec<(std::string::String, std::string::String)>>(),
18555            ),
18556            _ => local_var_req_builder.query(&[(
18557                "tag",
18558                &local_var_str
18559                    .into_iter()
18560                    .map(|p| p.to_string())
18561                    .collect::<Vec<String>>()
18562                    .join(",")
18563                    .to_string(),
18564            )]),
18565        };
18566    }
18567    if let Some(ref local_var_str) = tag__n {
18568        local_var_req_builder = match "multi" {
18569            "multi" => local_var_req_builder.query(
18570                &local_var_str
18571                    .into_iter()
18572                    .map(|p| ("tag__n".to_owned(), p.to_string()))
18573                    .collect::<Vec<(std::string::String, std::string::String)>>(),
18574            ),
18575            _ => local_var_req_builder.query(&[(
18576                "tag__n",
18577                &local_var_str
18578                    .into_iter()
18579                    .map(|p| p.to_string())
18580                    .collect::<Vec<String>>()
18581                    .join(",")
18582                    .to_string(),
18583            )]),
18584        };
18585    }
18586    if let Some(ref local_var_str) = tag_id {
18587        local_var_req_builder = match "multi" {
18588            "multi" => local_var_req_builder.query(
18589                &local_var_str
18590                    .into_iter()
18591                    .map(|p| ("tag_id".to_owned(), p.to_string()))
18592                    .collect::<Vec<(std::string::String, std::string::String)>>(),
18593            ),
18594            _ => local_var_req_builder.query(&[(
18595                "tag_id",
18596                &local_var_str
18597                    .into_iter()
18598                    .map(|p| p.to_string())
18599                    .collect::<Vec<String>>()
18600                    .join(",")
18601                    .to_string(),
18602            )]),
18603        };
18604    }
18605    if let Some(ref local_var_str) = tag_id__n {
18606        local_var_req_builder = match "multi" {
18607            "multi" => local_var_req_builder.query(
18608                &local_var_str
18609                    .into_iter()
18610                    .map(|p| ("tag_id__n".to_owned(), p.to_string()))
18611                    .collect::<Vec<(std::string::String, std::string::String)>>(),
18612            ),
18613            _ => local_var_req_builder.query(&[(
18614                "tag_id__n",
18615                &local_var_str
18616                    .into_iter()
18617                    .map(|p| p.to_string())
18618                    .collect::<Vec<String>>()
18619                    .join(",")
18620                    .to_string(),
18621            )]),
18622        };
18623    }
18624    if let Some(ref local_var_str) = updated_by_request {
18625        local_var_req_builder =
18626            local_var_req_builder.query(&[("updated_by_request", &local_var_str.to_string())]);
18627    }
18628    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
18629        local_var_req_builder =
18630            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
18631    }
18632    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
18633        let local_var_key = local_var_apikey.key.clone();
18634        let local_var_value = match local_var_apikey.prefix {
18635            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
18636            None => local_var_key,
18637        };
18638        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
18639    };
18640
18641    let local_var_req = local_var_req_builder.build()?;
18642    let local_var_resp = local_var_client.execute(local_var_req).await?;
18643
18644    let local_var_status = local_var_resp.status();
18645    let local_var_content = local_var_resp.text().await?;
18646
18647    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
18648        serde_json::from_str(&local_var_content).map_err(Error::from)
18649    } else {
18650        let local_var_entity: Option<VpnTunnelGroupsListError> =
18651            serde_json::from_str(&local_var_content).ok();
18652        let local_var_error = ResponseContent {
18653            status: local_var_status,
18654            content: local_var_content,
18655            entity: local_var_entity,
18656        };
18657        Err(Error::ResponseError(local_var_error))
18658    }
18659}
18660
18661/// Patch a tunnel group object.
18662pub async fn vpn_tunnel_groups_partial_update(
18663    configuration: &configuration::Configuration,
18664    id: i32,
18665    patched_tunnel_group_request: Option<crate::models::PatchedTunnelGroupRequest>,
18666) -> Result<crate::models::TunnelGroup, Error<VpnTunnelGroupsPartialUpdateError>> {
18667    let local_var_configuration = configuration;
18668
18669    let local_var_client = &local_var_configuration.client;
18670
18671    let local_var_uri_str = format!(
18672        "{}/api/vpn/tunnel-groups/{id}/",
18673        local_var_configuration.base_path,
18674        id = id
18675    );
18676    let mut local_var_req_builder =
18677        local_var_client.request(reqwest::Method::PATCH, local_var_uri_str.as_str());
18678
18679    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
18680        local_var_req_builder =
18681            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
18682    }
18683    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
18684        let local_var_key = local_var_apikey.key.clone();
18685        let local_var_value = match local_var_apikey.prefix {
18686            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
18687            None => local_var_key,
18688        };
18689        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
18690    };
18691    local_var_req_builder = local_var_req_builder.json(&patched_tunnel_group_request);
18692
18693    let local_var_req = local_var_req_builder.build()?;
18694    let local_var_resp = local_var_client.execute(local_var_req).await?;
18695
18696    let local_var_status = local_var_resp.status();
18697    let local_var_content = local_var_resp.text().await?;
18698
18699    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
18700        serde_json::from_str(&local_var_content).map_err(Error::from)
18701    } else {
18702        let local_var_entity: Option<VpnTunnelGroupsPartialUpdateError> =
18703            serde_json::from_str(&local_var_content).ok();
18704        let local_var_error = ResponseContent {
18705            status: local_var_status,
18706            content: local_var_content,
18707            entity: local_var_entity,
18708        };
18709        Err(Error::ResponseError(local_var_error))
18710    }
18711}
18712
18713/// Get a tunnel group object.
18714pub async fn vpn_tunnel_groups_retrieve(
18715    configuration: &configuration::Configuration,
18716    id: i32,
18717) -> Result<crate::models::TunnelGroup, Error<VpnTunnelGroupsRetrieveError>> {
18718    let local_var_configuration = configuration;
18719
18720    let local_var_client = &local_var_configuration.client;
18721
18722    let local_var_uri_str = format!(
18723        "{}/api/vpn/tunnel-groups/{id}/",
18724        local_var_configuration.base_path,
18725        id = id
18726    );
18727    let mut local_var_req_builder =
18728        local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
18729
18730    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
18731        local_var_req_builder =
18732            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
18733    }
18734    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
18735        let local_var_key = local_var_apikey.key.clone();
18736        let local_var_value = match local_var_apikey.prefix {
18737            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
18738            None => local_var_key,
18739        };
18740        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
18741    };
18742
18743    let local_var_req = local_var_req_builder.build()?;
18744    let local_var_resp = local_var_client.execute(local_var_req).await?;
18745
18746    let local_var_status = local_var_resp.status();
18747    let local_var_content = local_var_resp.text().await?;
18748
18749    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
18750        serde_json::from_str(&local_var_content).map_err(Error::from)
18751    } else {
18752        let local_var_entity: Option<VpnTunnelGroupsRetrieveError> =
18753            serde_json::from_str(&local_var_content).ok();
18754        let local_var_error = ResponseContent {
18755            status: local_var_status,
18756            content: local_var_content,
18757            entity: local_var_entity,
18758        };
18759        Err(Error::ResponseError(local_var_error))
18760    }
18761}
18762
18763/// Put a tunnel group object.
18764pub async fn vpn_tunnel_groups_update(
18765    configuration: &configuration::Configuration,
18766    id: i32,
18767    tunnel_group_request: crate::models::TunnelGroupRequest,
18768) -> Result<crate::models::TunnelGroup, Error<VpnTunnelGroupsUpdateError>> {
18769    let local_var_configuration = configuration;
18770
18771    let local_var_client = &local_var_configuration.client;
18772
18773    let local_var_uri_str = format!(
18774        "{}/api/vpn/tunnel-groups/{id}/",
18775        local_var_configuration.base_path,
18776        id = id
18777    );
18778    let mut local_var_req_builder =
18779        local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());
18780
18781    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
18782        local_var_req_builder =
18783            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
18784    }
18785    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
18786        let local_var_key = local_var_apikey.key.clone();
18787        let local_var_value = match local_var_apikey.prefix {
18788            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
18789            None => local_var_key,
18790        };
18791        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
18792    };
18793    local_var_req_builder = local_var_req_builder.json(&tunnel_group_request);
18794
18795    let local_var_req = local_var_req_builder.build()?;
18796    let local_var_resp = local_var_client.execute(local_var_req).await?;
18797
18798    let local_var_status = local_var_resp.status();
18799    let local_var_content = local_var_resp.text().await?;
18800
18801    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
18802        serde_json::from_str(&local_var_content).map_err(Error::from)
18803    } else {
18804        let local_var_entity: Option<VpnTunnelGroupsUpdateError> =
18805            serde_json::from_str(&local_var_content).ok();
18806        let local_var_error = ResponseContent {
18807            status: local_var_status,
18808            content: local_var_content,
18809            entity: local_var_entity,
18810        };
18811        Err(Error::ResponseError(local_var_error))
18812    }
18813}
18814
18815/// Delete a list of tunnel termination objects.
18816pub async fn vpn_tunnel_terminations_bulk_destroy(
18817    configuration: &configuration::Configuration,
18818    tunnel_termination_request: Vec<crate::models::TunnelTerminationRequest>,
18819) -> Result<(), Error<VpnTunnelTerminationsBulkDestroyError>> {
18820    let local_var_configuration = configuration;
18821
18822    let local_var_client = &local_var_configuration.client;
18823
18824    let local_var_uri_str = format!(
18825        "{}/api/vpn/tunnel-terminations/",
18826        local_var_configuration.base_path
18827    );
18828    let mut local_var_req_builder =
18829        local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());
18830
18831    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
18832        local_var_req_builder =
18833            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
18834    }
18835    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
18836        let local_var_key = local_var_apikey.key.clone();
18837        let local_var_value = match local_var_apikey.prefix {
18838            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
18839            None => local_var_key,
18840        };
18841        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
18842    };
18843    local_var_req_builder = local_var_req_builder.json(&tunnel_termination_request);
18844
18845    let local_var_req = local_var_req_builder.build()?;
18846    let local_var_resp = local_var_client.execute(local_var_req).await?;
18847
18848    let local_var_status = local_var_resp.status();
18849    let local_var_content = local_var_resp.text().await?;
18850
18851    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
18852        Ok(())
18853    } else {
18854        let local_var_entity: Option<VpnTunnelTerminationsBulkDestroyError> =
18855            serde_json::from_str(&local_var_content).ok();
18856        let local_var_error = ResponseContent {
18857            status: local_var_status,
18858            content: local_var_content,
18859            entity: local_var_entity,
18860        };
18861        Err(Error::ResponseError(local_var_error))
18862    }
18863}
18864
18865/// Patch a list of tunnel termination objects.
18866pub async fn vpn_tunnel_terminations_bulk_partial_update(
18867    configuration: &configuration::Configuration,
18868    tunnel_termination_request: Vec<crate::models::TunnelTerminationRequest>,
18869) -> Result<Vec<crate::models::TunnelTermination>, Error<VpnTunnelTerminationsBulkPartialUpdateError>>
18870{
18871    let local_var_configuration = configuration;
18872
18873    let local_var_client = &local_var_configuration.client;
18874
18875    let local_var_uri_str = format!(
18876        "{}/api/vpn/tunnel-terminations/",
18877        local_var_configuration.base_path
18878    );
18879    let mut local_var_req_builder =
18880        local_var_client.request(reqwest::Method::PATCH, local_var_uri_str.as_str());
18881
18882    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
18883        local_var_req_builder =
18884            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
18885    }
18886    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
18887        let local_var_key = local_var_apikey.key.clone();
18888        let local_var_value = match local_var_apikey.prefix {
18889            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
18890            None => local_var_key,
18891        };
18892        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
18893    };
18894    local_var_req_builder = local_var_req_builder.json(&tunnel_termination_request);
18895
18896    let local_var_req = local_var_req_builder.build()?;
18897    let local_var_resp = local_var_client.execute(local_var_req).await?;
18898
18899    let local_var_status = local_var_resp.status();
18900    let local_var_content = local_var_resp.text().await?;
18901
18902    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
18903        serde_json::from_str(&local_var_content).map_err(Error::from)
18904    } else {
18905        let local_var_entity: Option<VpnTunnelTerminationsBulkPartialUpdateError> =
18906            serde_json::from_str(&local_var_content).ok();
18907        let local_var_error = ResponseContent {
18908            status: local_var_status,
18909            content: local_var_content,
18910            entity: local_var_entity,
18911        };
18912        Err(Error::ResponseError(local_var_error))
18913    }
18914}
18915
18916/// Put a list of tunnel termination objects.
18917pub async fn vpn_tunnel_terminations_bulk_update(
18918    configuration: &configuration::Configuration,
18919    tunnel_termination_request: Vec<crate::models::TunnelTerminationRequest>,
18920) -> Result<Vec<crate::models::TunnelTermination>, Error<VpnTunnelTerminationsBulkUpdateError>> {
18921    let local_var_configuration = configuration;
18922
18923    let local_var_client = &local_var_configuration.client;
18924
18925    let local_var_uri_str = format!(
18926        "{}/api/vpn/tunnel-terminations/",
18927        local_var_configuration.base_path
18928    );
18929    let mut local_var_req_builder =
18930        local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());
18931
18932    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
18933        local_var_req_builder =
18934            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
18935    }
18936    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
18937        let local_var_key = local_var_apikey.key.clone();
18938        let local_var_value = match local_var_apikey.prefix {
18939            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
18940            None => local_var_key,
18941        };
18942        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
18943    };
18944    local_var_req_builder = local_var_req_builder.json(&tunnel_termination_request);
18945
18946    let local_var_req = local_var_req_builder.build()?;
18947    let local_var_resp = local_var_client.execute(local_var_req).await?;
18948
18949    let local_var_status = local_var_resp.status();
18950    let local_var_content = local_var_resp.text().await?;
18951
18952    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
18953        serde_json::from_str(&local_var_content).map_err(Error::from)
18954    } else {
18955        let local_var_entity: Option<VpnTunnelTerminationsBulkUpdateError> =
18956            serde_json::from_str(&local_var_content).ok();
18957        let local_var_error = ResponseContent {
18958            status: local_var_status,
18959            content: local_var_content,
18960            entity: local_var_entity,
18961        };
18962        Err(Error::ResponseError(local_var_error))
18963    }
18964}
18965
18966/// Post a list of tunnel termination objects.
18967pub async fn vpn_tunnel_terminations_create(
18968    configuration: &configuration::Configuration,
18969    vpn_tunnel_terminations_create_request: crate::models::VpnTunnelTerminationsCreateRequest,
18970) -> Result<crate::models::TunnelTermination, Error<VpnTunnelTerminationsCreateError>> {
18971    let local_var_configuration = configuration;
18972
18973    let local_var_client = &local_var_configuration.client;
18974
18975    let local_var_uri_str = format!(
18976        "{}/api/vpn/tunnel-terminations/",
18977        local_var_configuration.base_path
18978    );
18979    let mut local_var_req_builder =
18980        local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
18981
18982    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
18983        local_var_req_builder =
18984            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
18985    }
18986    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
18987        let local_var_key = local_var_apikey.key.clone();
18988        let local_var_value = match local_var_apikey.prefix {
18989            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
18990            None => local_var_key,
18991        };
18992        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
18993    };
18994    local_var_req_builder = local_var_req_builder.json(&vpn_tunnel_terminations_create_request);
18995
18996    let local_var_req = local_var_req_builder.build()?;
18997    let local_var_resp = local_var_client.execute(local_var_req).await?;
18998
18999    let local_var_status = local_var_resp.status();
19000    let local_var_content = local_var_resp.text().await?;
19001
19002    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
19003        serde_json::from_str(&local_var_content).map_err(Error::from)
19004    } else {
19005        let local_var_entity: Option<VpnTunnelTerminationsCreateError> =
19006            serde_json::from_str(&local_var_content).ok();
19007        let local_var_error = ResponseContent {
19008            status: local_var_status,
19009            content: local_var_content,
19010            entity: local_var_entity,
19011        };
19012        Err(Error::ResponseError(local_var_error))
19013    }
19014}
19015
19016/// Delete a tunnel termination object.
19017pub async fn vpn_tunnel_terminations_destroy(
19018    configuration: &configuration::Configuration,
19019    id: i32,
19020) -> Result<(), Error<VpnTunnelTerminationsDestroyError>> {
19021    let local_var_configuration = configuration;
19022
19023    let local_var_client = &local_var_configuration.client;
19024
19025    let local_var_uri_str = format!(
19026        "{}/api/vpn/tunnel-terminations/{id}/",
19027        local_var_configuration.base_path,
19028        id = id
19029    );
19030    let mut local_var_req_builder =
19031        local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());
19032
19033    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
19034        local_var_req_builder =
19035            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
19036    }
19037    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
19038        let local_var_key = local_var_apikey.key.clone();
19039        let local_var_value = match local_var_apikey.prefix {
19040            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
19041            None => local_var_key,
19042        };
19043        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
19044    };
19045
19046    let local_var_req = local_var_req_builder.build()?;
19047    let local_var_resp = local_var_client.execute(local_var_req).await?;
19048
19049    let local_var_status = local_var_resp.status();
19050    let local_var_content = local_var_resp.text().await?;
19051
19052    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
19053        Ok(())
19054    } else {
19055        let local_var_entity: Option<VpnTunnelTerminationsDestroyError> =
19056            serde_json::from_str(&local_var_content).ok();
19057        let local_var_error = ResponseContent {
19058            status: local_var_status,
19059            content: local_var_content,
19060            entity: local_var_entity,
19061        };
19062        Err(Error::ResponseError(local_var_error))
19063    }
19064}
19065
19066/// Get a list of tunnel termination objects.
19067pub async fn vpn_tunnel_terminations_list(
19068    configuration: &configuration::Configuration,
19069    created: Option<Vec<String>>,
19070    created__empty: Option<Vec<String>>,
19071    created__gt: Option<Vec<String>>,
19072    created__gte: Option<Vec<String>>,
19073    created__lt: Option<Vec<String>>,
19074    created__lte: Option<Vec<String>>,
19075    created__n: Option<Vec<String>>,
19076    created_by_request: Option<&str>,
19077    id: Option<Vec<i32>>,
19078    id__empty: Option<bool>,
19079    id__gt: Option<Vec<i32>>,
19080    id__gte: Option<Vec<i32>>,
19081    id__lt: Option<Vec<i32>>,
19082    id__lte: Option<Vec<i32>>,
19083    id__n: Option<Vec<i32>>,
19084    interface: Option<Vec<String>>,
19085    interface__n: Option<Vec<String>>,
19086    interface_id: Option<Vec<i32>>,
19087    interface_id__n: Option<Vec<i32>>,
19088    last_updated: Option<Vec<String>>,
19089    last_updated__empty: Option<Vec<String>>,
19090    last_updated__gt: Option<Vec<String>>,
19091    last_updated__gte: Option<Vec<String>>,
19092    last_updated__lt: Option<Vec<String>>,
19093    last_updated__lte: Option<Vec<String>>,
19094    last_updated__n: Option<Vec<String>>,
19095    limit: Option<i32>,
19096    modified_by_request: Option<&str>,
19097    offset: Option<i32>,
19098    ordering: Option<&str>,
19099    outside_ip_id: Option<Vec<i32>>,
19100    outside_ip_id__n: Option<Vec<i32>>,
19101    q: Option<&str>,
19102    role: Option<Vec<String>>,
19103    role__empty: Option<bool>,
19104    role__ic: Option<Vec<String>>,
19105    role__ie: Option<Vec<String>>,
19106    role__iew: Option<Vec<String>>,
19107    role__iregex: Option<Vec<String>>,
19108    role__isw: Option<Vec<String>>,
19109    role__n: Option<Vec<String>>,
19110    role__nic: Option<Vec<String>>,
19111    role__nie: Option<Vec<String>>,
19112    role__niew: Option<Vec<String>>,
19113    role__nisw: Option<Vec<String>>,
19114    role__regex: Option<Vec<String>>,
19115    start: Option<i32>,
19116    tag: Option<Vec<String>>,
19117    tag__n: Option<Vec<String>>,
19118    tag_id: Option<Vec<i32>>,
19119    tag_id__n: Option<Vec<i32>>,
19120    termination_id: Option<Vec<i32>>,
19121    termination_id__empty: Option<bool>,
19122    termination_id__gt: Option<Vec<i32>>,
19123    termination_id__gte: Option<Vec<i32>>,
19124    termination_id__lt: Option<Vec<i32>>,
19125    termination_id__lte: Option<Vec<i32>>,
19126    termination_id__n: Option<Vec<i32>>,
19127    termination_type: Option<Vec<String>>,
19128    termination_type__n: Option<Vec<String>>,
19129    tunnel: Option<Vec<String>>,
19130    tunnel__n: Option<Vec<String>>,
19131    tunnel_id: Option<Vec<i32>>,
19132    tunnel_id__n: Option<Vec<i32>>,
19133    updated_by_request: Option<&str>,
19134    vminterface: Option<Vec<String>>,
19135    vminterface__n: Option<Vec<String>>,
19136    vminterface_id: Option<Vec<i32>>,
19137    vminterface_id__n: Option<Vec<i32>>,
19138) -> Result<crate::models::PaginatedTunnelTerminationList, Error<VpnTunnelTerminationsListError>> {
19139    let local_var_configuration = configuration;
19140
19141    let local_var_client = &local_var_configuration.client;
19142
19143    let local_var_uri_str = format!(
19144        "{}/api/vpn/tunnel-terminations/",
19145        local_var_configuration.base_path
19146    );
19147    let mut local_var_req_builder =
19148        local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
19149
19150    if let Some(ref local_var_str) = created {
19151        local_var_req_builder = match "multi" {
19152            "multi" => local_var_req_builder.query(
19153                &local_var_str
19154                    .into_iter()
19155                    .map(|p| ("created".to_owned(), p.to_string()))
19156                    .collect::<Vec<(std::string::String, std::string::String)>>(),
19157            ),
19158            _ => local_var_req_builder.query(&[(
19159                "created",
19160                &local_var_str
19161                    .into_iter()
19162                    .map(|p| p.to_string())
19163                    .collect::<Vec<String>>()
19164                    .join(",")
19165                    .to_string(),
19166            )]),
19167        };
19168    }
19169    if let Some(ref local_var_str) = created__empty {
19170        local_var_req_builder = match "multi" {
19171            "multi" => local_var_req_builder.query(
19172                &local_var_str
19173                    .into_iter()
19174                    .map(|p| ("created__empty".to_owned(), p.to_string()))
19175                    .collect::<Vec<(std::string::String, std::string::String)>>(),
19176            ),
19177            _ => local_var_req_builder.query(&[(
19178                "created__empty",
19179                &local_var_str
19180                    .into_iter()
19181                    .map(|p| p.to_string())
19182                    .collect::<Vec<String>>()
19183                    .join(",")
19184                    .to_string(),
19185            )]),
19186        };
19187    }
19188    if let Some(ref local_var_str) = created__gt {
19189        local_var_req_builder = match "multi" {
19190            "multi" => local_var_req_builder.query(
19191                &local_var_str
19192                    .into_iter()
19193                    .map(|p| ("created__gt".to_owned(), p.to_string()))
19194                    .collect::<Vec<(std::string::String, std::string::String)>>(),
19195            ),
19196            _ => local_var_req_builder.query(&[(
19197                "created__gt",
19198                &local_var_str
19199                    .into_iter()
19200                    .map(|p| p.to_string())
19201                    .collect::<Vec<String>>()
19202                    .join(",")
19203                    .to_string(),
19204            )]),
19205        };
19206    }
19207    if let Some(ref local_var_str) = created__gte {
19208        local_var_req_builder = match "multi" {
19209            "multi" => local_var_req_builder.query(
19210                &local_var_str
19211                    .into_iter()
19212                    .map(|p| ("created__gte".to_owned(), p.to_string()))
19213                    .collect::<Vec<(std::string::String, std::string::String)>>(),
19214            ),
19215            _ => local_var_req_builder.query(&[(
19216                "created__gte",
19217                &local_var_str
19218                    .into_iter()
19219                    .map(|p| p.to_string())
19220                    .collect::<Vec<String>>()
19221                    .join(",")
19222                    .to_string(),
19223            )]),
19224        };
19225    }
19226    if let Some(ref local_var_str) = created__lt {
19227        local_var_req_builder = match "multi" {
19228            "multi" => local_var_req_builder.query(
19229                &local_var_str
19230                    .into_iter()
19231                    .map(|p| ("created__lt".to_owned(), p.to_string()))
19232                    .collect::<Vec<(std::string::String, std::string::String)>>(),
19233            ),
19234            _ => local_var_req_builder.query(&[(
19235                "created__lt",
19236                &local_var_str
19237                    .into_iter()
19238                    .map(|p| p.to_string())
19239                    .collect::<Vec<String>>()
19240                    .join(",")
19241                    .to_string(),
19242            )]),
19243        };
19244    }
19245    if let Some(ref local_var_str) = created__lte {
19246        local_var_req_builder = match "multi" {
19247            "multi" => local_var_req_builder.query(
19248                &local_var_str
19249                    .into_iter()
19250                    .map(|p| ("created__lte".to_owned(), p.to_string()))
19251                    .collect::<Vec<(std::string::String, std::string::String)>>(),
19252            ),
19253            _ => local_var_req_builder.query(&[(
19254                "created__lte",
19255                &local_var_str
19256                    .into_iter()
19257                    .map(|p| p.to_string())
19258                    .collect::<Vec<String>>()
19259                    .join(",")
19260                    .to_string(),
19261            )]),
19262        };
19263    }
19264    if let Some(ref local_var_str) = created__n {
19265        local_var_req_builder = match "multi" {
19266            "multi" => local_var_req_builder.query(
19267                &local_var_str
19268                    .into_iter()
19269                    .map(|p| ("created__n".to_owned(), p.to_string()))
19270                    .collect::<Vec<(std::string::String, std::string::String)>>(),
19271            ),
19272            _ => local_var_req_builder.query(&[(
19273                "created__n",
19274                &local_var_str
19275                    .into_iter()
19276                    .map(|p| p.to_string())
19277                    .collect::<Vec<String>>()
19278                    .join(",")
19279                    .to_string(),
19280            )]),
19281        };
19282    }
19283    if let Some(ref local_var_str) = created_by_request {
19284        local_var_req_builder =
19285            local_var_req_builder.query(&[("created_by_request", &local_var_str.to_string())]);
19286    }
19287    if let Some(ref local_var_str) = id {
19288        local_var_req_builder = match "multi" {
19289            "multi" => local_var_req_builder.query(
19290                &local_var_str
19291                    .into_iter()
19292                    .map(|p| ("id".to_owned(), p.to_string()))
19293                    .collect::<Vec<(std::string::String, std::string::String)>>(),
19294            ),
19295            _ => local_var_req_builder.query(&[(
19296                "id",
19297                &local_var_str
19298                    .into_iter()
19299                    .map(|p| p.to_string())
19300                    .collect::<Vec<String>>()
19301                    .join(",")
19302                    .to_string(),
19303            )]),
19304        };
19305    }
19306    if let Some(ref local_var_str) = id__empty {
19307        local_var_req_builder =
19308            local_var_req_builder.query(&[("id__empty", &local_var_str.to_string())]);
19309    }
19310    if let Some(ref local_var_str) = id__gt {
19311        local_var_req_builder = match "multi" {
19312            "multi" => local_var_req_builder.query(
19313                &local_var_str
19314                    .into_iter()
19315                    .map(|p| ("id__gt".to_owned(), p.to_string()))
19316                    .collect::<Vec<(std::string::String, std::string::String)>>(),
19317            ),
19318            _ => local_var_req_builder.query(&[(
19319                "id__gt",
19320                &local_var_str
19321                    .into_iter()
19322                    .map(|p| p.to_string())
19323                    .collect::<Vec<String>>()
19324                    .join(",")
19325                    .to_string(),
19326            )]),
19327        };
19328    }
19329    if let Some(ref local_var_str) = id__gte {
19330        local_var_req_builder = match "multi" {
19331            "multi" => local_var_req_builder.query(
19332                &local_var_str
19333                    .into_iter()
19334                    .map(|p| ("id__gte".to_owned(), p.to_string()))
19335                    .collect::<Vec<(std::string::String, std::string::String)>>(),
19336            ),
19337            _ => local_var_req_builder.query(&[(
19338                "id__gte",
19339                &local_var_str
19340                    .into_iter()
19341                    .map(|p| p.to_string())
19342                    .collect::<Vec<String>>()
19343                    .join(",")
19344                    .to_string(),
19345            )]),
19346        };
19347    }
19348    if let Some(ref local_var_str) = id__lt {
19349        local_var_req_builder = match "multi" {
19350            "multi" => local_var_req_builder.query(
19351                &local_var_str
19352                    .into_iter()
19353                    .map(|p| ("id__lt".to_owned(), p.to_string()))
19354                    .collect::<Vec<(std::string::String, std::string::String)>>(),
19355            ),
19356            _ => local_var_req_builder.query(&[(
19357                "id__lt",
19358                &local_var_str
19359                    .into_iter()
19360                    .map(|p| p.to_string())
19361                    .collect::<Vec<String>>()
19362                    .join(",")
19363                    .to_string(),
19364            )]),
19365        };
19366    }
19367    if let Some(ref local_var_str) = id__lte {
19368        local_var_req_builder = match "multi" {
19369            "multi" => local_var_req_builder.query(
19370                &local_var_str
19371                    .into_iter()
19372                    .map(|p| ("id__lte".to_owned(), p.to_string()))
19373                    .collect::<Vec<(std::string::String, std::string::String)>>(),
19374            ),
19375            _ => local_var_req_builder.query(&[(
19376                "id__lte",
19377                &local_var_str
19378                    .into_iter()
19379                    .map(|p| p.to_string())
19380                    .collect::<Vec<String>>()
19381                    .join(",")
19382                    .to_string(),
19383            )]),
19384        };
19385    }
19386    if let Some(ref local_var_str) = id__n {
19387        local_var_req_builder = match "multi" {
19388            "multi" => local_var_req_builder.query(
19389                &local_var_str
19390                    .into_iter()
19391                    .map(|p| ("id__n".to_owned(), p.to_string()))
19392                    .collect::<Vec<(std::string::String, std::string::String)>>(),
19393            ),
19394            _ => local_var_req_builder.query(&[(
19395                "id__n",
19396                &local_var_str
19397                    .into_iter()
19398                    .map(|p| p.to_string())
19399                    .collect::<Vec<String>>()
19400                    .join(",")
19401                    .to_string(),
19402            )]),
19403        };
19404    }
19405    if let Some(ref local_var_str) = interface {
19406        local_var_req_builder = match "multi" {
19407            "multi" => local_var_req_builder.query(
19408                &local_var_str
19409                    .into_iter()
19410                    .map(|p| ("interface".to_owned(), p.to_string()))
19411                    .collect::<Vec<(std::string::String, std::string::String)>>(),
19412            ),
19413            _ => local_var_req_builder.query(&[(
19414                "interface",
19415                &local_var_str
19416                    .into_iter()
19417                    .map(|p| p.to_string())
19418                    .collect::<Vec<String>>()
19419                    .join(",")
19420                    .to_string(),
19421            )]),
19422        };
19423    }
19424    if let Some(ref local_var_str) = interface__n {
19425        local_var_req_builder = match "multi" {
19426            "multi" => local_var_req_builder.query(
19427                &local_var_str
19428                    .into_iter()
19429                    .map(|p| ("interface__n".to_owned(), p.to_string()))
19430                    .collect::<Vec<(std::string::String, std::string::String)>>(),
19431            ),
19432            _ => local_var_req_builder.query(&[(
19433                "interface__n",
19434                &local_var_str
19435                    .into_iter()
19436                    .map(|p| p.to_string())
19437                    .collect::<Vec<String>>()
19438                    .join(",")
19439                    .to_string(),
19440            )]),
19441        };
19442    }
19443    if let Some(ref local_var_str) = interface_id {
19444        local_var_req_builder = match "multi" {
19445            "multi" => local_var_req_builder.query(
19446                &local_var_str
19447                    .into_iter()
19448                    .map(|p| ("interface_id".to_owned(), p.to_string()))
19449                    .collect::<Vec<(std::string::String, std::string::String)>>(),
19450            ),
19451            _ => local_var_req_builder.query(&[(
19452                "interface_id",
19453                &local_var_str
19454                    .into_iter()
19455                    .map(|p| p.to_string())
19456                    .collect::<Vec<String>>()
19457                    .join(",")
19458                    .to_string(),
19459            )]),
19460        };
19461    }
19462    if let Some(ref local_var_str) = interface_id__n {
19463        local_var_req_builder = match "multi" {
19464            "multi" => local_var_req_builder.query(
19465                &local_var_str
19466                    .into_iter()
19467                    .map(|p| ("interface_id__n".to_owned(), p.to_string()))
19468                    .collect::<Vec<(std::string::String, std::string::String)>>(),
19469            ),
19470            _ => local_var_req_builder.query(&[(
19471                "interface_id__n",
19472                &local_var_str
19473                    .into_iter()
19474                    .map(|p| p.to_string())
19475                    .collect::<Vec<String>>()
19476                    .join(",")
19477                    .to_string(),
19478            )]),
19479        };
19480    }
19481    if let Some(ref local_var_str) = last_updated {
19482        local_var_req_builder = match "multi" {
19483            "multi" => local_var_req_builder.query(
19484                &local_var_str
19485                    .into_iter()
19486                    .map(|p| ("last_updated".to_owned(), p.to_string()))
19487                    .collect::<Vec<(std::string::String, std::string::String)>>(),
19488            ),
19489            _ => local_var_req_builder.query(&[(
19490                "last_updated",
19491                &local_var_str
19492                    .into_iter()
19493                    .map(|p| p.to_string())
19494                    .collect::<Vec<String>>()
19495                    .join(",")
19496                    .to_string(),
19497            )]),
19498        };
19499    }
19500    if let Some(ref local_var_str) = last_updated__empty {
19501        local_var_req_builder = match "multi" {
19502            "multi" => local_var_req_builder.query(
19503                &local_var_str
19504                    .into_iter()
19505                    .map(|p| ("last_updated__empty".to_owned(), p.to_string()))
19506                    .collect::<Vec<(std::string::String, std::string::String)>>(),
19507            ),
19508            _ => local_var_req_builder.query(&[(
19509                "last_updated__empty",
19510                &local_var_str
19511                    .into_iter()
19512                    .map(|p| p.to_string())
19513                    .collect::<Vec<String>>()
19514                    .join(",")
19515                    .to_string(),
19516            )]),
19517        };
19518    }
19519    if let Some(ref local_var_str) = last_updated__gt {
19520        local_var_req_builder = match "multi" {
19521            "multi" => local_var_req_builder.query(
19522                &local_var_str
19523                    .into_iter()
19524                    .map(|p| ("last_updated__gt".to_owned(), p.to_string()))
19525                    .collect::<Vec<(std::string::String, std::string::String)>>(),
19526            ),
19527            _ => local_var_req_builder.query(&[(
19528                "last_updated__gt",
19529                &local_var_str
19530                    .into_iter()
19531                    .map(|p| p.to_string())
19532                    .collect::<Vec<String>>()
19533                    .join(",")
19534                    .to_string(),
19535            )]),
19536        };
19537    }
19538    if let Some(ref local_var_str) = last_updated__gte {
19539        local_var_req_builder = match "multi" {
19540            "multi" => local_var_req_builder.query(
19541                &local_var_str
19542                    .into_iter()
19543                    .map(|p| ("last_updated__gte".to_owned(), p.to_string()))
19544                    .collect::<Vec<(std::string::String, std::string::String)>>(),
19545            ),
19546            _ => local_var_req_builder.query(&[(
19547                "last_updated__gte",
19548                &local_var_str
19549                    .into_iter()
19550                    .map(|p| p.to_string())
19551                    .collect::<Vec<String>>()
19552                    .join(",")
19553                    .to_string(),
19554            )]),
19555        };
19556    }
19557    if let Some(ref local_var_str) = last_updated__lt {
19558        local_var_req_builder = match "multi" {
19559            "multi" => local_var_req_builder.query(
19560                &local_var_str
19561                    .into_iter()
19562                    .map(|p| ("last_updated__lt".to_owned(), p.to_string()))
19563                    .collect::<Vec<(std::string::String, std::string::String)>>(),
19564            ),
19565            _ => local_var_req_builder.query(&[(
19566                "last_updated__lt",
19567                &local_var_str
19568                    .into_iter()
19569                    .map(|p| p.to_string())
19570                    .collect::<Vec<String>>()
19571                    .join(",")
19572                    .to_string(),
19573            )]),
19574        };
19575    }
19576    if let Some(ref local_var_str) = last_updated__lte {
19577        local_var_req_builder = match "multi" {
19578            "multi" => local_var_req_builder.query(
19579                &local_var_str
19580                    .into_iter()
19581                    .map(|p| ("last_updated__lte".to_owned(), p.to_string()))
19582                    .collect::<Vec<(std::string::String, std::string::String)>>(),
19583            ),
19584            _ => local_var_req_builder.query(&[(
19585                "last_updated__lte",
19586                &local_var_str
19587                    .into_iter()
19588                    .map(|p| p.to_string())
19589                    .collect::<Vec<String>>()
19590                    .join(",")
19591                    .to_string(),
19592            )]),
19593        };
19594    }
19595    if let Some(ref local_var_str) = last_updated__n {
19596        local_var_req_builder = match "multi" {
19597            "multi" => local_var_req_builder.query(
19598                &local_var_str
19599                    .into_iter()
19600                    .map(|p| ("last_updated__n".to_owned(), p.to_string()))
19601                    .collect::<Vec<(std::string::String, std::string::String)>>(),
19602            ),
19603            _ => local_var_req_builder.query(&[(
19604                "last_updated__n",
19605                &local_var_str
19606                    .into_iter()
19607                    .map(|p| p.to_string())
19608                    .collect::<Vec<String>>()
19609                    .join(",")
19610                    .to_string(),
19611            )]),
19612        };
19613    }
19614    if let Some(ref local_var_str) = limit {
19615        local_var_req_builder =
19616            local_var_req_builder.query(&[("limit", &local_var_str.to_string())]);
19617    }
19618    if let Some(ref local_var_str) = modified_by_request {
19619        local_var_req_builder =
19620            local_var_req_builder.query(&[("modified_by_request", &local_var_str.to_string())]);
19621    }
19622    if let Some(ref local_var_str) = offset {
19623        local_var_req_builder =
19624            local_var_req_builder.query(&[("offset", &local_var_str.to_string())]);
19625    }
19626    if let Some(ref local_var_str) = ordering {
19627        local_var_req_builder =
19628            local_var_req_builder.query(&[("ordering", &local_var_str.to_string())]);
19629    }
19630    if let Some(ref local_var_str) = outside_ip_id {
19631        local_var_req_builder = match "multi" {
19632            "multi" => local_var_req_builder.query(
19633                &local_var_str
19634                    .into_iter()
19635                    .map(|p| ("outside_ip_id".to_owned(), p.to_string()))
19636                    .collect::<Vec<(std::string::String, std::string::String)>>(),
19637            ),
19638            _ => local_var_req_builder.query(&[(
19639                "outside_ip_id",
19640                &local_var_str
19641                    .into_iter()
19642                    .map(|p| p.to_string())
19643                    .collect::<Vec<String>>()
19644                    .join(",")
19645                    .to_string(),
19646            )]),
19647        };
19648    }
19649    if let Some(ref local_var_str) = outside_ip_id__n {
19650        local_var_req_builder = match "multi" {
19651            "multi" => local_var_req_builder.query(
19652                &local_var_str
19653                    .into_iter()
19654                    .map(|p| ("outside_ip_id__n".to_owned(), p.to_string()))
19655                    .collect::<Vec<(std::string::String, std::string::String)>>(),
19656            ),
19657            _ => local_var_req_builder.query(&[(
19658                "outside_ip_id__n",
19659                &local_var_str
19660                    .into_iter()
19661                    .map(|p| p.to_string())
19662                    .collect::<Vec<String>>()
19663                    .join(",")
19664                    .to_string(),
19665            )]),
19666        };
19667    }
19668    if let Some(ref local_var_str) = q {
19669        local_var_req_builder = local_var_req_builder.query(&[("q", &local_var_str.to_string())]);
19670    }
19671    if let Some(ref local_var_str) = role {
19672        local_var_req_builder = match "multi" {
19673            "multi" => local_var_req_builder.query(
19674                &local_var_str
19675                    .into_iter()
19676                    .map(|p| ("role".to_owned(), p.to_string()))
19677                    .collect::<Vec<(std::string::String, std::string::String)>>(),
19678            ),
19679            _ => local_var_req_builder.query(&[(
19680                "role",
19681                &local_var_str
19682                    .into_iter()
19683                    .map(|p| p.to_string())
19684                    .collect::<Vec<String>>()
19685                    .join(",")
19686                    .to_string(),
19687            )]),
19688        };
19689    }
19690    if let Some(ref local_var_str) = role__empty {
19691        local_var_req_builder =
19692            local_var_req_builder.query(&[("role__empty", &local_var_str.to_string())]);
19693    }
19694    if let Some(ref local_var_str) = role__ic {
19695        local_var_req_builder = match "multi" {
19696            "multi" => local_var_req_builder.query(
19697                &local_var_str
19698                    .into_iter()
19699                    .map(|p| ("role__ic".to_owned(), p.to_string()))
19700                    .collect::<Vec<(std::string::String, std::string::String)>>(),
19701            ),
19702            _ => local_var_req_builder.query(&[(
19703                "role__ic",
19704                &local_var_str
19705                    .into_iter()
19706                    .map(|p| p.to_string())
19707                    .collect::<Vec<String>>()
19708                    .join(",")
19709                    .to_string(),
19710            )]),
19711        };
19712    }
19713    if let Some(ref local_var_str) = role__ie {
19714        local_var_req_builder = match "multi" {
19715            "multi" => local_var_req_builder.query(
19716                &local_var_str
19717                    .into_iter()
19718                    .map(|p| ("role__ie".to_owned(), p.to_string()))
19719                    .collect::<Vec<(std::string::String, std::string::String)>>(),
19720            ),
19721            _ => local_var_req_builder.query(&[(
19722                "role__ie",
19723                &local_var_str
19724                    .into_iter()
19725                    .map(|p| p.to_string())
19726                    .collect::<Vec<String>>()
19727                    .join(",")
19728                    .to_string(),
19729            )]),
19730        };
19731    }
19732    if let Some(ref local_var_str) = role__iew {
19733        local_var_req_builder = match "multi" {
19734            "multi" => local_var_req_builder.query(
19735                &local_var_str
19736                    .into_iter()
19737                    .map(|p| ("role__iew".to_owned(), p.to_string()))
19738                    .collect::<Vec<(std::string::String, std::string::String)>>(),
19739            ),
19740            _ => local_var_req_builder.query(&[(
19741                "role__iew",
19742                &local_var_str
19743                    .into_iter()
19744                    .map(|p| p.to_string())
19745                    .collect::<Vec<String>>()
19746                    .join(",")
19747                    .to_string(),
19748            )]),
19749        };
19750    }
19751    if let Some(ref local_var_str) = role__iregex {
19752        local_var_req_builder = match "multi" {
19753            "multi" => local_var_req_builder.query(
19754                &local_var_str
19755                    .into_iter()
19756                    .map(|p| ("role__iregex".to_owned(), p.to_string()))
19757                    .collect::<Vec<(std::string::String, std::string::String)>>(),
19758            ),
19759            _ => local_var_req_builder.query(&[(
19760                "role__iregex",
19761                &local_var_str
19762                    .into_iter()
19763                    .map(|p| p.to_string())
19764                    .collect::<Vec<String>>()
19765                    .join(",")
19766                    .to_string(),
19767            )]),
19768        };
19769    }
19770    if let Some(ref local_var_str) = role__isw {
19771        local_var_req_builder = match "multi" {
19772            "multi" => local_var_req_builder.query(
19773                &local_var_str
19774                    .into_iter()
19775                    .map(|p| ("role__isw".to_owned(), p.to_string()))
19776                    .collect::<Vec<(std::string::String, std::string::String)>>(),
19777            ),
19778            _ => local_var_req_builder.query(&[(
19779                "role__isw",
19780                &local_var_str
19781                    .into_iter()
19782                    .map(|p| p.to_string())
19783                    .collect::<Vec<String>>()
19784                    .join(",")
19785                    .to_string(),
19786            )]),
19787        };
19788    }
19789    if let Some(ref local_var_str) = role__n {
19790        local_var_req_builder = match "multi" {
19791            "multi" => local_var_req_builder.query(
19792                &local_var_str
19793                    .into_iter()
19794                    .map(|p| ("role__n".to_owned(), p.to_string()))
19795                    .collect::<Vec<(std::string::String, std::string::String)>>(),
19796            ),
19797            _ => local_var_req_builder.query(&[(
19798                "role__n",
19799                &local_var_str
19800                    .into_iter()
19801                    .map(|p| p.to_string())
19802                    .collect::<Vec<String>>()
19803                    .join(",")
19804                    .to_string(),
19805            )]),
19806        };
19807    }
19808    if let Some(ref local_var_str) = role__nic {
19809        local_var_req_builder = match "multi" {
19810            "multi" => local_var_req_builder.query(
19811                &local_var_str
19812                    .into_iter()
19813                    .map(|p| ("role__nic".to_owned(), p.to_string()))
19814                    .collect::<Vec<(std::string::String, std::string::String)>>(),
19815            ),
19816            _ => local_var_req_builder.query(&[(
19817                "role__nic",
19818                &local_var_str
19819                    .into_iter()
19820                    .map(|p| p.to_string())
19821                    .collect::<Vec<String>>()
19822                    .join(",")
19823                    .to_string(),
19824            )]),
19825        };
19826    }
19827    if let Some(ref local_var_str) = role__nie {
19828        local_var_req_builder = match "multi" {
19829            "multi" => local_var_req_builder.query(
19830                &local_var_str
19831                    .into_iter()
19832                    .map(|p| ("role__nie".to_owned(), p.to_string()))
19833                    .collect::<Vec<(std::string::String, std::string::String)>>(),
19834            ),
19835            _ => local_var_req_builder.query(&[(
19836                "role__nie",
19837                &local_var_str
19838                    .into_iter()
19839                    .map(|p| p.to_string())
19840                    .collect::<Vec<String>>()
19841                    .join(",")
19842                    .to_string(),
19843            )]),
19844        };
19845    }
19846    if let Some(ref local_var_str) = role__niew {
19847        local_var_req_builder = match "multi" {
19848            "multi" => local_var_req_builder.query(
19849                &local_var_str
19850                    .into_iter()
19851                    .map(|p| ("role__niew".to_owned(), p.to_string()))
19852                    .collect::<Vec<(std::string::String, std::string::String)>>(),
19853            ),
19854            _ => local_var_req_builder.query(&[(
19855                "role__niew",
19856                &local_var_str
19857                    .into_iter()
19858                    .map(|p| p.to_string())
19859                    .collect::<Vec<String>>()
19860                    .join(",")
19861                    .to_string(),
19862            )]),
19863        };
19864    }
19865    if let Some(ref local_var_str) = role__nisw {
19866        local_var_req_builder = match "multi" {
19867            "multi" => local_var_req_builder.query(
19868                &local_var_str
19869                    .into_iter()
19870                    .map(|p| ("role__nisw".to_owned(), p.to_string()))
19871                    .collect::<Vec<(std::string::String, std::string::String)>>(),
19872            ),
19873            _ => local_var_req_builder.query(&[(
19874                "role__nisw",
19875                &local_var_str
19876                    .into_iter()
19877                    .map(|p| p.to_string())
19878                    .collect::<Vec<String>>()
19879                    .join(",")
19880                    .to_string(),
19881            )]),
19882        };
19883    }
19884    if let Some(ref local_var_str) = role__regex {
19885        local_var_req_builder = match "multi" {
19886            "multi" => local_var_req_builder.query(
19887                &local_var_str
19888                    .into_iter()
19889                    .map(|p| ("role__regex".to_owned(), p.to_string()))
19890                    .collect::<Vec<(std::string::String, std::string::String)>>(),
19891            ),
19892            _ => local_var_req_builder.query(&[(
19893                "role__regex",
19894                &local_var_str
19895                    .into_iter()
19896                    .map(|p| p.to_string())
19897                    .collect::<Vec<String>>()
19898                    .join(",")
19899                    .to_string(),
19900            )]),
19901        };
19902    }
19903    if let Some(ref local_var_str) = start {
19904        local_var_req_builder =
19905            local_var_req_builder.query(&[("start", &local_var_str.to_string())]);
19906    }
19907    if let Some(ref local_var_str) = tag {
19908        local_var_req_builder = match "multi" {
19909            "multi" => local_var_req_builder.query(
19910                &local_var_str
19911                    .into_iter()
19912                    .map(|p| ("tag".to_owned(), p.to_string()))
19913                    .collect::<Vec<(std::string::String, std::string::String)>>(),
19914            ),
19915            _ => local_var_req_builder.query(&[(
19916                "tag",
19917                &local_var_str
19918                    .into_iter()
19919                    .map(|p| p.to_string())
19920                    .collect::<Vec<String>>()
19921                    .join(",")
19922                    .to_string(),
19923            )]),
19924        };
19925    }
19926    if let Some(ref local_var_str) = tag__n {
19927        local_var_req_builder = match "multi" {
19928            "multi" => local_var_req_builder.query(
19929                &local_var_str
19930                    .into_iter()
19931                    .map(|p| ("tag__n".to_owned(), p.to_string()))
19932                    .collect::<Vec<(std::string::String, std::string::String)>>(),
19933            ),
19934            _ => local_var_req_builder.query(&[(
19935                "tag__n",
19936                &local_var_str
19937                    .into_iter()
19938                    .map(|p| p.to_string())
19939                    .collect::<Vec<String>>()
19940                    .join(",")
19941                    .to_string(),
19942            )]),
19943        };
19944    }
19945    if let Some(ref local_var_str) = tag_id {
19946        local_var_req_builder = match "multi" {
19947            "multi" => local_var_req_builder.query(
19948                &local_var_str
19949                    .into_iter()
19950                    .map(|p| ("tag_id".to_owned(), p.to_string()))
19951                    .collect::<Vec<(std::string::String, std::string::String)>>(),
19952            ),
19953            _ => local_var_req_builder.query(&[(
19954                "tag_id",
19955                &local_var_str
19956                    .into_iter()
19957                    .map(|p| p.to_string())
19958                    .collect::<Vec<String>>()
19959                    .join(",")
19960                    .to_string(),
19961            )]),
19962        };
19963    }
19964    if let Some(ref local_var_str) = tag_id__n {
19965        local_var_req_builder = match "multi" {
19966            "multi" => local_var_req_builder.query(
19967                &local_var_str
19968                    .into_iter()
19969                    .map(|p| ("tag_id__n".to_owned(), p.to_string()))
19970                    .collect::<Vec<(std::string::String, std::string::String)>>(),
19971            ),
19972            _ => local_var_req_builder.query(&[(
19973                "tag_id__n",
19974                &local_var_str
19975                    .into_iter()
19976                    .map(|p| p.to_string())
19977                    .collect::<Vec<String>>()
19978                    .join(",")
19979                    .to_string(),
19980            )]),
19981        };
19982    }
19983    if let Some(ref local_var_str) = termination_id {
19984        local_var_req_builder = match "multi" {
19985            "multi" => local_var_req_builder.query(
19986                &local_var_str
19987                    .into_iter()
19988                    .map(|p| ("termination_id".to_owned(), p.to_string()))
19989                    .collect::<Vec<(std::string::String, std::string::String)>>(),
19990            ),
19991            _ => local_var_req_builder.query(&[(
19992                "termination_id",
19993                &local_var_str
19994                    .into_iter()
19995                    .map(|p| p.to_string())
19996                    .collect::<Vec<String>>()
19997                    .join(",")
19998                    .to_string(),
19999            )]),
20000        };
20001    }
20002    if let Some(ref local_var_str) = termination_id__empty {
20003        local_var_req_builder =
20004            local_var_req_builder.query(&[("termination_id__empty", &local_var_str.to_string())]);
20005    }
20006    if let Some(ref local_var_str) = termination_id__gt {
20007        local_var_req_builder = match "multi" {
20008            "multi" => local_var_req_builder.query(
20009                &local_var_str
20010                    .into_iter()
20011                    .map(|p| ("termination_id__gt".to_owned(), p.to_string()))
20012                    .collect::<Vec<(std::string::String, std::string::String)>>(),
20013            ),
20014            _ => local_var_req_builder.query(&[(
20015                "termination_id__gt",
20016                &local_var_str
20017                    .into_iter()
20018                    .map(|p| p.to_string())
20019                    .collect::<Vec<String>>()
20020                    .join(",")
20021                    .to_string(),
20022            )]),
20023        };
20024    }
20025    if let Some(ref local_var_str) = termination_id__gte {
20026        local_var_req_builder = match "multi" {
20027            "multi" => local_var_req_builder.query(
20028                &local_var_str
20029                    .into_iter()
20030                    .map(|p| ("termination_id__gte".to_owned(), p.to_string()))
20031                    .collect::<Vec<(std::string::String, std::string::String)>>(),
20032            ),
20033            _ => local_var_req_builder.query(&[(
20034                "termination_id__gte",
20035                &local_var_str
20036                    .into_iter()
20037                    .map(|p| p.to_string())
20038                    .collect::<Vec<String>>()
20039                    .join(",")
20040                    .to_string(),
20041            )]),
20042        };
20043    }
20044    if let Some(ref local_var_str) = termination_id__lt {
20045        local_var_req_builder = match "multi" {
20046            "multi" => local_var_req_builder.query(
20047                &local_var_str
20048                    .into_iter()
20049                    .map(|p| ("termination_id__lt".to_owned(), p.to_string()))
20050                    .collect::<Vec<(std::string::String, std::string::String)>>(),
20051            ),
20052            _ => local_var_req_builder.query(&[(
20053                "termination_id__lt",
20054                &local_var_str
20055                    .into_iter()
20056                    .map(|p| p.to_string())
20057                    .collect::<Vec<String>>()
20058                    .join(",")
20059                    .to_string(),
20060            )]),
20061        };
20062    }
20063    if let Some(ref local_var_str) = termination_id__lte {
20064        local_var_req_builder = match "multi" {
20065            "multi" => local_var_req_builder.query(
20066                &local_var_str
20067                    .into_iter()
20068                    .map(|p| ("termination_id__lte".to_owned(), p.to_string()))
20069                    .collect::<Vec<(std::string::String, std::string::String)>>(),
20070            ),
20071            _ => local_var_req_builder.query(&[(
20072                "termination_id__lte",
20073                &local_var_str
20074                    .into_iter()
20075                    .map(|p| p.to_string())
20076                    .collect::<Vec<String>>()
20077                    .join(",")
20078                    .to_string(),
20079            )]),
20080        };
20081    }
20082    if let Some(ref local_var_str) = termination_id__n {
20083        local_var_req_builder = match "multi" {
20084            "multi" => local_var_req_builder.query(
20085                &local_var_str
20086                    .into_iter()
20087                    .map(|p| ("termination_id__n".to_owned(), p.to_string()))
20088                    .collect::<Vec<(std::string::String, std::string::String)>>(),
20089            ),
20090            _ => local_var_req_builder.query(&[(
20091                "termination_id__n",
20092                &local_var_str
20093                    .into_iter()
20094                    .map(|p| p.to_string())
20095                    .collect::<Vec<String>>()
20096                    .join(",")
20097                    .to_string(),
20098            )]),
20099        };
20100    }
20101    if let Some(ref local_var_str) = termination_type {
20102        local_var_req_builder = match "multi" {
20103            "multi" => local_var_req_builder.query(
20104                &local_var_str
20105                    .into_iter()
20106                    .map(|p| ("termination_type".to_owned(), p.to_string()))
20107                    .collect::<Vec<(std::string::String, std::string::String)>>(),
20108            ),
20109            _ => local_var_req_builder.query(&[(
20110                "termination_type",
20111                &local_var_str
20112                    .into_iter()
20113                    .map(|p| p.to_string())
20114                    .collect::<Vec<String>>()
20115                    .join(",")
20116                    .to_string(),
20117            )]),
20118        };
20119    }
20120    if let Some(ref local_var_str) = termination_type__n {
20121        local_var_req_builder = match "multi" {
20122            "multi" => local_var_req_builder.query(
20123                &local_var_str
20124                    .into_iter()
20125                    .map(|p| ("termination_type__n".to_owned(), p.to_string()))
20126                    .collect::<Vec<(std::string::String, std::string::String)>>(),
20127            ),
20128            _ => local_var_req_builder.query(&[(
20129                "termination_type__n",
20130                &local_var_str
20131                    .into_iter()
20132                    .map(|p| p.to_string())
20133                    .collect::<Vec<String>>()
20134                    .join(",")
20135                    .to_string(),
20136            )]),
20137        };
20138    }
20139    if let Some(ref local_var_str) = tunnel {
20140        local_var_req_builder = match "multi" {
20141            "multi" => local_var_req_builder.query(
20142                &local_var_str
20143                    .into_iter()
20144                    .map(|p| ("tunnel".to_owned(), p.to_string()))
20145                    .collect::<Vec<(std::string::String, std::string::String)>>(),
20146            ),
20147            _ => local_var_req_builder.query(&[(
20148                "tunnel",
20149                &local_var_str
20150                    .into_iter()
20151                    .map(|p| p.to_string())
20152                    .collect::<Vec<String>>()
20153                    .join(",")
20154                    .to_string(),
20155            )]),
20156        };
20157    }
20158    if let Some(ref local_var_str) = tunnel__n {
20159        local_var_req_builder = match "multi" {
20160            "multi" => local_var_req_builder.query(
20161                &local_var_str
20162                    .into_iter()
20163                    .map(|p| ("tunnel__n".to_owned(), p.to_string()))
20164                    .collect::<Vec<(std::string::String, std::string::String)>>(),
20165            ),
20166            _ => local_var_req_builder.query(&[(
20167                "tunnel__n",
20168                &local_var_str
20169                    .into_iter()
20170                    .map(|p| p.to_string())
20171                    .collect::<Vec<String>>()
20172                    .join(",")
20173                    .to_string(),
20174            )]),
20175        };
20176    }
20177    if let Some(ref local_var_str) = tunnel_id {
20178        local_var_req_builder = match "multi" {
20179            "multi" => local_var_req_builder.query(
20180                &local_var_str
20181                    .into_iter()
20182                    .map(|p| ("tunnel_id".to_owned(), p.to_string()))
20183                    .collect::<Vec<(std::string::String, std::string::String)>>(),
20184            ),
20185            _ => local_var_req_builder.query(&[(
20186                "tunnel_id",
20187                &local_var_str
20188                    .into_iter()
20189                    .map(|p| p.to_string())
20190                    .collect::<Vec<String>>()
20191                    .join(",")
20192                    .to_string(),
20193            )]),
20194        };
20195    }
20196    if let Some(ref local_var_str) = tunnel_id__n {
20197        local_var_req_builder = match "multi" {
20198            "multi" => local_var_req_builder.query(
20199                &local_var_str
20200                    .into_iter()
20201                    .map(|p| ("tunnel_id__n".to_owned(), p.to_string()))
20202                    .collect::<Vec<(std::string::String, std::string::String)>>(),
20203            ),
20204            _ => local_var_req_builder.query(&[(
20205                "tunnel_id__n",
20206                &local_var_str
20207                    .into_iter()
20208                    .map(|p| p.to_string())
20209                    .collect::<Vec<String>>()
20210                    .join(",")
20211                    .to_string(),
20212            )]),
20213        };
20214    }
20215    if let Some(ref local_var_str) = updated_by_request {
20216        local_var_req_builder =
20217            local_var_req_builder.query(&[("updated_by_request", &local_var_str.to_string())]);
20218    }
20219    if let Some(ref local_var_str) = vminterface {
20220        local_var_req_builder = match "multi" {
20221            "multi" => local_var_req_builder.query(
20222                &local_var_str
20223                    .into_iter()
20224                    .map(|p| ("vminterface".to_owned(), p.to_string()))
20225                    .collect::<Vec<(std::string::String, std::string::String)>>(),
20226            ),
20227            _ => local_var_req_builder.query(&[(
20228                "vminterface",
20229                &local_var_str
20230                    .into_iter()
20231                    .map(|p| p.to_string())
20232                    .collect::<Vec<String>>()
20233                    .join(",")
20234                    .to_string(),
20235            )]),
20236        };
20237    }
20238    if let Some(ref local_var_str) = vminterface__n {
20239        local_var_req_builder = match "multi" {
20240            "multi" => local_var_req_builder.query(
20241                &local_var_str
20242                    .into_iter()
20243                    .map(|p| ("vminterface__n".to_owned(), p.to_string()))
20244                    .collect::<Vec<(std::string::String, std::string::String)>>(),
20245            ),
20246            _ => local_var_req_builder.query(&[(
20247                "vminterface__n",
20248                &local_var_str
20249                    .into_iter()
20250                    .map(|p| p.to_string())
20251                    .collect::<Vec<String>>()
20252                    .join(",")
20253                    .to_string(),
20254            )]),
20255        };
20256    }
20257    if let Some(ref local_var_str) = vminterface_id {
20258        local_var_req_builder = match "multi" {
20259            "multi" => local_var_req_builder.query(
20260                &local_var_str
20261                    .into_iter()
20262                    .map(|p| ("vminterface_id".to_owned(), p.to_string()))
20263                    .collect::<Vec<(std::string::String, std::string::String)>>(),
20264            ),
20265            _ => local_var_req_builder.query(&[(
20266                "vminterface_id",
20267                &local_var_str
20268                    .into_iter()
20269                    .map(|p| p.to_string())
20270                    .collect::<Vec<String>>()
20271                    .join(",")
20272                    .to_string(),
20273            )]),
20274        };
20275    }
20276    if let Some(ref local_var_str) = vminterface_id__n {
20277        local_var_req_builder = match "multi" {
20278            "multi" => local_var_req_builder.query(
20279                &local_var_str
20280                    .into_iter()
20281                    .map(|p| ("vminterface_id__n".to_owned(), p.to_string()))
20282                    .collect::<Vec<(std::string::String, std::string::String)>>(),
20283            ),
20284            _ => local_var_req_builder.query(&[(
20285                "vminterface_id__n",
20286                &local_var_str
20287                    .into_iter()
20288                    .map(|p| p.to_string())
20289                    .collect::<Vec<String>>()
20290                    .join(",")
20291                    .to_string(),
20292            )]),
20293        };
20294    }
20295    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
20296        local_var_req_builder =
20297            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
20298    }
20299    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
20300        let local_var_key = local_var_apikey.key.clone();
20301        let local_var_value = match local_var_apikey.prefix {
20302            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
20303            None => local_var_key,
20304        };
20305        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
20306    };
20307
20308    let local_var_req = local_var_req_builder.build()?;
20309    let local_var_resp = local_var_client.execute(local_var_req).await?;
20310
20311    let local_var_status = local_var_resp.status();
20312    let local_var_content = local_var_resp.text().await?;
20313
20314    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
20315        serde_json::from_str(&local_var_content).map_err(Error::from)
20316    } else {
20317        let local_var_entity: Option<VpnTunnelTerminationsListError> =
20318            serde_json::from_str(&local_var_content).ok();
20319        let local_var_error = ResponseContent {
20320            status: local_var_status,
20321            content: local_var_content,
20322            entity: local_var_entity,
20323        };
20324        Err(Error::ResponseError(local_var_error))
20325    }
20326}
20327
20328/// Patch a tunnel termination object.
20329pub async fn vpn_tunnel_terminations_partial_update(
20330    configuration: &configuration::Configuration,
20331    id: i32,
20332    patched_writable_tunnel_termination_request: Option<
20333        crate::models::PatchedWritableTunnelTerminationRequest,
20334    >,
20335) -> Result<crate::models::TunnelTermination, Error<VpnTunnelTerminationsPartialUpdateError>> {
20336    let local_var_configuration = configuration;
20337
20338    let local_var_client = &local_var_configuration.client;
20339
20340    let local_var_uri_str = format!(
20341        "{}/api/vpn/tunnel-terminations/{id}/",
20342        local_var_configuration.base_path,
20343        id = id
20344    );
20345    let mut local_var_req_builder =
20346        local_var_client.request(reqwest::Method::PATCH, local_var_uri_str.as_str());
20347
20348    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
20349        local_var_req_builder =
20350            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
20351    }
20352    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
20353        let local_var_key = local_var_apikey.key.clone();
20354        let local_var_value = match local_var_apikey.prefix {
20355            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
20356            None => local_var_key,
20357        };
20358        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
20359    };
20360    local_var_req_builder =
20361        local_var_req_builder.json(&patched_writable_tunnel_termination_request);
20362
20363    let local_var_req = local_var_req_builder.build()?;
20364    let local_var_resp = local_var_client.execute(local_var_req).await?;
20365
20366    let local_var_status = local_var_resp.status();
20367    let local_var_content = local_var_resp.text().await?;
20368
20369    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
20370        serde_json::from_str(&local_var_content).map_err(Error::from)
20371    } else {
20372        let local_var_entity: Option<VpnTunnelTerminationsPartialUpdateError> =
20373            serde_json::from_str(&local_var_content).ok();
20374        let local_var_error = ResponseContent {
20375            status: local_var_status,
20376            content: local_var_content,
20377            entity: local_var_entity,
20378        };
20379        Err(Error::ResponseError(local_var_error))
20380    }
20381}
20382
20383/// Get a tunnel termination object.
20384pub async fn vpn_tunnel_terminations_retrieve(
20385    configuration: &configuration::Configuration,
20386    id: i32,
20387) -> Result<crate::models::TunnelTermination, Error<VpnTunnelTerminationsRetrieveError>> {
20388    let local_var_configuration = configuration;
20389
20390    let local_var_client = &local_var_configuration.client;
20391
20392    let local_var_uri_str = format!(
20393        "{}/api/vpn/tunnel-terminations/{id}/",
20394        local_var_configuration.base_path,
20395        id = id
20396    );
20397    let mut local_var_req_builder =
20398        local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
20399
20400    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
20401        local_var_req_builder =
20402            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
20403    }
20404    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
20405        let local_var_key = local_var_apikey.key.clone();
20406        let local_var_value = match local_var_apikey.prefix {
20407            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
20408            None => local_var_key,
20409        };
20410        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
20411    };
20412
20413    let local_var_req = local_var_req_builder.build()?;
20414    let local_var_resp = local_var_client.execute(local_var_req).await?;
20415
20416    let local_var_status = local_var_resp.status();
20417    let local_var_content = local_var_resp.text().await?;
20418
20419    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
20420        serde_json::from_str(&local_var_content).map_err(Error::from)
20421    } else {
20422        let local_var_entity: Option<VpnTunnelTerminationsRetrieveError> =
20423            serde_json::from_str(&local_var_content).ok();
20424        let local_var_error = ResponseContent {
20425            status: local_var_status,
20426            content: local_var_content,
20427            entity: local_var_entity,
20428        };
20429        Err(Error::ResponseError(local_var_error))
20430    }
20431}
20432
20433/// Put a tunnel termination object.
20434pub async fn vpn_tunnel_terminations_update(
20435    configuration: &configuration::Configuration,
20436    id: i32,
20437    writable_tunnel_termination_request: crate::models::WritableTunnelTerminationRequest,
20438) -> Result<crate::models::TunnelTermination, Error<VpnTunnelTerminationsUpdateError>> {
20439    let local_var_configuration = configuration;
20440
20441    let local_var_client = &local_var_configuration.client;
20442
20443    let local_var_uri_str = format!(
20444        "{}/api/vpn/tunnel-terminations/{id}/",
20445        local_var_configuration.base_path,
20446        id = id
20447    );
20448    let mut local_var_req_builder =
20449        local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());
20450
20451    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
20452        local_var_req_builder =
20453            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
20454    }
20455    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
20456        let local_var_key = local_var_apikey.key.clone();
20457        let local_var_value = match local_var_apikey.prefix {
20458            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
20459            None => local_var_key,
20460        };
20461        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
20462    };
20463    local_var_req_builder = local_var_req_builder.json(&writable_tunnel_termination_request);
20464
20465    let local_var_req = local_var_req_builder.build()?;
20466    let local_var_resp = local_var_client.execute(local_var_req).await?;
20467
20468    let local_var_status = local_var_resp.status();
20469    let local_var_content = local_var_resp.text().await?;
20470
20471    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
20472        serde_json::from_str(&local_var_content).map_err(Error::from)
20473    } else {
20474        let local_var_entity: Option<VpnTunnelTerminationsUpdateError> =
20475            serde_json::from_str(&local_var_content).ok();
20476        let local_var_error = ResponseContent {
20477            status: local_var_status,
20478            content: local_var_content,
20479            entity: local_var_entity,
20480        };
20481        Err(Error::ResponseError(local_var_error))
20482    }
20483}
20484
20485/// Delete a list of tunnel objects.
20486pub async fn vpn_tunnels_bulk_destroy(
20487    configuration: &configuration::Configuration,
20488    tunnel_request: Vec<crate::models::TunnelRequest>,
20489) -> Result<(), Error<VpnTunnelsBulkDestroyError>> {
20490    let local_var_configuration = configuration;
20491
20492    let local_var_client = &local_var_configuration.client;
20493
20494    let local_var_uri_str = format!("{}/api/vpn/tunnels/", local_var_configuration.base_path);
20495    let mut local_var_req_builder =
20496        local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());
20497
20498    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
20499        local_var_req_builder =
20500            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
20501    }
20502    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
20503        let local_var_key = local_var_apikey.key.clone();
20504        let local_var_value = match local_var_apikey.prefix {
20505            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
20506            None => local_var_key,
20507        };
20508        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
20509    };
20510    local_var_req_builder = local_var_req_builder.json(&tunnel_request);
20511
20512    let local_var_req = local_var_req_builder.build()?;
20513    let local_var_resp = local_var_client.execute(local_var_req).await?;
20514
20515    let local_var_status = local_var_resp.status();
20516    let local_var_content = local_var_resp.text().await?;
20517
20518    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
20519        Ok(())
20520    } else {
20521        let local_var_entity: Option<VpnTunnelsBulkDestroyError> =
20522            serde_json::from_str(&local_var_content).ok();
20523        let local_var_error = ResponseContent {
20524            status: local_var_status,
20525            content: local_var_content,
20526            entity: local_var_entity,
20527        };
20528        Err(Error::ResponseError(local_var_error))
20529    }
20530}
20531
20532/// Patch a list of tunnel objects.
20533pub async fn vpn_tunnels_bulk_partial_update(
20534    configuration: &configuration::Configuration,
20535    tunnel_request: Vec<crate::models::TunnelRequest>,
20536) -> Result<Vec<crate::models::Tunnel>, Error<VpnTunnelsBulkPartialUpdateError>> {
20537    let local_var_configuration = configuration;
20538
20539    let local_var_client = &local_var_configuration.client;
20540
20541    let local_var_uri_str = format!("{}/api/vpn/tunnels/", local_var_configuration.base_path);
20542    let mut local_var_req_builder =
20543        local_var_client.request(reqwest::Method::PATCH, local_var_uri_str.as_str());
20544
20545    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
20546        local_var_req_builder =
20547            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
20548    }
20549    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
20550        let local_var_key = local_var_apikey.key.clone();
20551        let local_var_value = match local_var_apikey.prefix {
20552            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
20553            None => local_var_key,
20554        };
20555        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
20556    };
20557    local_var_req_builder = local_var_req_builder.json(&tunnel_request);
20558
20559    let local_var_req = local_var_req_builder.build()?;
20560    let local_var_resp = local_var_client.execute(local_var_req).await?;
20561
20562    let local_var_status = local_var_resp.status();
20563    let local_var_content = local_var_resp.text().await?;
20564
20565    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
20566        serde_json::from_str(&local_var_content).map_err(Error::from)
20567    } else {
20568        let local_var_entity: Option<VpnTunnelsBulkPartialUpdateError> =
20569            serde_json::from_str(&local_var_content).ok();
20570        let local_var_error = ResponseContent {
20571            status: local_var_status,
20572            content: local_var_content,
20573            entity: local_var_entity,
20574        };
20575        Err(Error::ResponseError(local_var_error))
20576    }
20577}
20578
20579/// Put a list of tunnel objects.
20580pub async fn vpn_tunnels_bulk_update(
20581    configuration: &configuration::Configuration,
20582    tunnel_request: Vec<crate::models::TunnelRequest>,
20583) -> Result<Vec<crate::models::Tunnel>, Error<VpnTunnelsBulkUpdateError>> {
20584    let local_var_configuration = configuration;
20585
20586    let local_var_client = &local_var_configuration.client;
20587
20588    let local_var_uri_str = format!("{}/api/vpn/tunnels/", local_var_configuration.base_path);
20589    let mut local_var_req_builder =
20590        local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());
20591
20592    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
20593        local_var_req_builder =
20594            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
20595    }
20596    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
20597        let local_var_key = local_var_apikey.key.clone();
20598        let local_var_value = match local_var_apikey.prefix {
20599            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
20600            None => local_var_key,
20601        };
20602        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
20603    };
20604    local_var_req_builder = local_var_req_builder.json(&tunnel_request);
20605
20606    let local_var_req = local_var_req_builder.build()?;
20607    let local_var_resp = local_var_client.execute(local_var_req).await?;
20608
20609    let local_var_status = local_var_resp.status();
20610    let local_var_content = local_var_resp.text().await?;
20611
20612    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
20613        serde_json::from_str(&local_var_content).map_err(Error::from)
20614    } else {
20615        let local_var_entity: Option<VpnTunnelsBulkUpdateError> =
20616            serde_json::from_str(&local_var_content).ok();
20617        let local_var_error = ResponseContent {
20618            status: local_var_status,
20619            content: local_var_content,
20620            entity: local_var_entity,
20621        };
20622        Err(Error::ResponseError(local_var_error))
20623    }
20624}
20625
20626/// Post a list of tunnel objects.
20627pub async fn vpn_tunnels_create(
20628    configuration: &configuration::Configuration,
20629    vpn_tunnels_create_request: crate::models::VpnTunnelsCreateRequest,
20630) -> Result<crate::models::Tunnel, Error<VpnTunnelsCreateError>> {
20631    let local_var_configuration = configuration;
20632
20633    let local_var_client = &local_var_configuration.client;
20634
20635    let local_var_uri_str = format!("{}/api/vpn/tunnels/", local_var_configuration.base_path);
20636    let mut local_var_req_builder =
20637        local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
20638
20639    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
20640        local_var_req_builder =
20641            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
20642    }
20643    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
20644        let local_var_key = local_var_apikey.key.clone();
20645        let local_var_value = match local_var_apikey.prefix {
20646            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
20647            None => local_var_key,
20648        };
20649        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
20650    };
20651    local_var_req_builder = local_var_req_builder.json(&vpn_tunnels_create_request);
20652
20653    let local_var_req = local_var_req_builder.build()?;
20654    let local_var_resp = local_var_client.execute(local_var_req).await?;
20655
20656    let local_var_status = local_var_resp.status();
20657    let local_var_content = local_var_resp.text().await?;
20658
20659    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
20660        serde_json::from_str(&local_var_content).map_err(Error::from)
20661    } else {
20662        let local_var_entity: Option<VpnTunnelsCreateError> =
20663            serde_json::from_str(&local_var_content).ok();
20664        let local_var_error = ResponseContent {
20665            status: local_var_status,
20666            content: local_var_content,
20667            entity: local_var_entity,
20668        };
20669        Err(Error::ResponseError(local_var_error))
20670    }
20671}
20672
20673/// Delete a tunnel object.
20674pub async fn vpn_tunnels_destroy(
20675    configuration: &configuration::Configuration,
20676    id: i32,
20677) -> Result<(), Error<VpnTunnelsDestroyError>> {
20678    let local_var_configuration = configuration;
20679
20680    let local_var_client = &local_var_configuration.client;
20681
20682    let local_var_uri_str = format!(
20683        "{}/api/vpn/tunnels/{id}/",
20684        local_var_configuration.base_path,
20685        id = id
20686    );
20687    let mut local_var_req_builder =
20688        local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());
20689
20690    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
20691        local_var_req_builder =
20692            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
20693    }
20694    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
20695        let local_var_key = local_var_apikey.key.clone();
20696        let local_var_value = match local_var_apikey.prefix {
20697            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
20698            None => local_var_key,
20699        };
20700        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
20701    };
20702
20703    let local_var_req = local_var_req_builder.build()?;
20704    let local_var_resp = local_var_client.execute(local_var_req).await?;
20705
20706    let local_var_status = local_var_resp.status();
20707    let local_var_content = local_var_resp.text().await?;
20708
20709    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
20710        Ok(())
20711    } else {
20712        let local_var_entity: Option<VpnTunnelsDestroyError> =
20713            serde_json::from_str(&local_var_content).ok();
20714        let local_var_error = ResponseContent {
20715            status: local_var_status,
20716            content: local_var_content,
20717            entity: local_var_entity,
20718        };
20719        Err(Error::ResponseError(local_var_error))
20720    }
20721}
20722
20723/// Get a list of tunnel objects.
20724pub async fn vpn_tunnels_list(
20725    configuration: &configuration::Configuration,
20726    contact: Option<Vec<i32>>,
20727    contact__n: Option<Vec<i32>>,
20728    contact_group: Option<Vec<String>>,
20729    contact_group__n: Option<Vec<String>>,
20730    contact_role: Option<Vec<i32>>,
20731    contact_role__n: Option<Vec<i32>>,
20732    created: Option<Vec<String>>,
20733    created__empty: Option<Vec<String>>,
20734    created__gt: Option<Vec<String>>,
20735    created__gte: Option<Vec<String>>,
20736    created__lt: Option<Vec<String>>,
20737    created__lte: Option<Vec<String>>,
20738    created__n: Option<Vec<String>>,
20739    created_by_request: Option<&str>,
20740    description: Option<Vec<String>>,
20741    description__empty: Option<bool>,
20742    description__ic: Option<Vec<String>>,
20743    description__ie: Option<Vec<String>>,
20744    description__iew: Option<Vec<String>>,
20745    description__iregex: Option<Vec<String>>,
20746    description__isw: Option<Vec<String>>,
20747    description__n: Option<Vec<String>>,
20748    description__nic: Option<Vec<String>>,
20749    description__nie: Option<Vec<String>>,
20750    description__niew: Option<Vec<String>>,
20751    description__nisw: Option<Vec<String>>,
20752    description__regex: Option<Vec<String>>,
20753    encapsulation: Option<Vec<String>>,
20754    encapsulation__empty: Option<bool>,
20755    encapsulation__ic: Option<Vec<String>>,
20756    encapsulation__ie: Option<Vec<String>>,
20757    encapsulation__iew: Option<Vec<String>>,
20758    encapsulation__iregex: Option<Vec<String>>,
20759    encapsulation__isw: Option<Vec<String>>,
20760    encapsulation__n: Option<Vec<String>>,
20761    encapsulation__nic: Option<Vec<String>>,
20762    encapsulation__nie: Option<Vec<String>>,
20763    encapsulation__niew: Option<Vec<String>>,
20764    encapsulation__nisw: Option<Vec<String>>,
20765    encapsulation__regex: Option<Vec<String>>,
20766    group: Option<Vec<String>>,
20767    group__n: Option<Vec<String>>,
20768    group_id: Option<Vec<i32>>,
20769    group_id__n: Option<Vec<i32>>,
20770    id: Option<Vec<i32>>,
20771    id__empty: Option<bool>,
20772    id__gt: Option<Vec<i32>>,
20773    id__gte: Option<Vec<i32>>,
20774    id__lt: Option<Vec<i32>>,
20775    id__lte: Option<Vec<i32>>,
20776    id__n: Option<Vec<i32>>,
20777    ipsec_profile: Option<Vec<String>>,
20778    ipsec_profile__n: Option<Vec<String>>,
20779    ipsec_profile_id: Option<Vec<i32>>,
20780    ipsec_profile_id__n: Option<Vec<i32>>,
20781    last_updated: Option<Vec<String>>,
20782    last_updated__empty: Option<Vec<String>>,
20783    last_updated__gt: Option<Vec<String>>,
20784    last_updated__gte: Option<Vec<String>>,
20785    last_updated__lt: Option<Vec<String>>,
20786    last_updated__lte: Option<Vec<String>>,
20787    last_updated__n: Option<Vec<String>>,
20788    limit: Option<i32>,
20789    modified_by_request: Option<&str>,
20790    name: Option<Vec<String>>,
20791    name__empty: Option<bool>,
20792    name__ic: Option<Vec<String>>,
20793    name__ie: Option<Vec<String>>,
20794    name__iew: Option<Vec<String>>,
20795    name__iregex: Option<Vec<String>>,
20796    name__isw: Option<Vec<String>>,
20797    name__n: Option<Vec<String>>,
20798    name__nic: Option<Vec<String>>,
20799    name__nie: Option<Vec<String>>,
20800    name__niew: Option<Vec<String>>,
20801    name__nisw: Option<Vec<String>>,
20802    name__regex: Option<Vec<String>>,
20803    offset: Option<i32>,
20804    ordering: Option<&str>,
20805    owner: Option<Vec<String>>,
20806    owner__n: Option<Vec<String>>,
20807    owner_group: Option<Vec<String>>,
20808    owner_group__n: Option<Vec<String>>,
20809    owner_group_id: Option<Vec<i32>>,
20810    owner_group_id__n: Option<Vec<i32>>,
20811    owner_id: Option<Vec<i32>>,
20812    owner_id__n: Option<Vec<i32>>,
20813    q: Option<&str>,
20814    start: Option<i32>,
20815    status: Option<Vec<String>>,
20816    status__empty: Option<bool>,
20817    status__ic: Option<Vec<String>>,
20818    status__ie: Option<Vec<String>>,
20819    status__iew: Option<Vec<String>>,
20820    status__iregex: Option<Vec<String>>,
20821    status__isw: Option<Vec<String>>,
20822    status__n: Option<Vec<String>>,
20823    status__nic: Option<Vec<String>>,
20824    status__nie: Option<Vec<String>>,
20825    status__niew: Option<Vec<String>>,
20826    status__nisw: Option<Vec<String>>,
20827    status__regex: Option<Vec<String>>,
20828    tag: Option<Vec<String>>,
20829    tag__n: Option<Vec<String>>,
20830    tag_id: Option<Vec<i32>>,
20831    tag_id__n: Option<Vec<i32>>,
20832    tenant: Option<Vec<String>>,
20833    tenant__n: Option<Vec<String>>,
20834    tenant_group: Option<Vec<String>>,
20835    tenant_group__n: Option<Vec<String>>,
20836    tenant_group_id: Option<Vec<String>>,
20837    tenant_group_id__n: Option<Vec<String>>,
20838    tenant_id: Option<Vec<i32>>,
20839    tenant_id__n: Option<Vec<i32>>,
20840    tunnel_id: Option<Vec<i32>>,
20841    tunnel_id__empty: Option<bool>,
20842    tunnel_id__gt: Option<Vec<i32>>,
20843    tunnel_id__gte: Option<Vec<i32>>,
20844    tunnel_id__lt: Option<Vec<i32>>,
20845    tunnel_id__lte: Option<Vec<i32>>,
20846    tunnel_id__n: Option<Vec<i32>>,
20847    updated_by_request: Option<&str>,
20848) -> Result<crate::models::PaginatedTunnelList, Error<VpnTunnelsListError>> {
20849    let local_var_configuration = configuration;
20850
20851    let local_var_client = &local_var_configuration.client;
20852
20853    let local_var_uri_str = format!("{}/api/vpn/tunnels/", local_var_configuration.base_path);
20854    let mut local_var_req_builder =
20855        local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
20856
20857    if let Some(ref local_var_str) = contact {
20858        local_var_req_builder = match "multi" {
20859            "multi" => local_var_req_builder.query(
20860                &local_var_str
20861                    .into_iter()
20862                    .map(|p| ("contact".to_owned(), p.to_string()))
20863                    .collect::<Vec<(std::string::String, std::string::String)>>(),
20864            ),
20865            _ => local_var_req_builder.query(&[(
20866                "contact",
20867                &local_var_str
20868                    .into_iter()
20869                    .map(|p| p.to_string())
20870                    .collect::<Vec<String>>()
20871                    .join(",")
20872                    .to_string(),
20873            )]),
20874        };
20875    }
20876    if let Some(ref local_var_str) = contact__n {
20877        local_var_req_builder = match "multi" {
20878            "multi" => local_var_req_builder.query(
20879                &local_var_str
20880                    .into_iter()
20881                    .map(|p| ("contact__n".to_owned(), p.to_string()))
20882                    .collect::<Vec<(std::string::String, std::string::String)>>(),
20883            ),
20884            _ => local_var_req_builder.query(&[(
20885                "contact__n",
20886                &local_var_str
20887                    .into_iter()
20888                    .map(|p| p.to_string())
20889                    .collect::<Vec<String>>()
20890                    .join(",")
20891                    .to_string(),
20892            )]),
20893        };
20894    }
20895    if let Some(ref local_var_str) = contact_group {
20896        local_var_req_builder = match "multi" {
20897            "multi" => local_var_req_builder.query(
20898                &local_var_str
20899                    .into_iter()
20900                    .map(|p| ("contact_group".to_owned(), p.to_string()))
20901                    .collect::<Vec<(std::string::String, std::string::String)>>(),
20902            ),
20903            _ => local_var_req_builder.query(&[(
20904                "contact_group",
20905                &local_var_str
20906                    .into_iter()
20907                    .map(|p| p.to_string())
20908                    .collect::<Vec<String>>()
20909                    .join(",")
20910                    .to_string(),
20911            )]),
20912        };
20913    }
20914    if let Some(ref local_var_str) = contact_group__n {
20915        local_var_req_builder = match "multi" {
20916            "multi" => local_var_req_builder.query(
20917                &local_var_str
20918                    .into_iter()
20919                    .map(|p| ("contact_group__n".to_owned(), p.to_string()))
20920                    .collect::<Vec<(std::string::String, std::string::String)>>(),
20921            ),
20922            _ => local_var_req_builder.query(&[(
20923                "contact_group__n",
20924                &local_var_str
20925                    .into_iter()
20926                    .map(|p| p.to_string())
20927                    .collect::<Vec<String>>()
20928                    .join(",")
20929                    .to_string(),
20930            )]),
20931        };
20932    }
20933    if let Some(ref local_var_str) = contact_role {
20934        local_var_req_builder = match "multi" {
20935            "multi" => local_var_req_builder.query(
20936                &local_var_str
20937                    .into_iter()
20938                    .map(|p| ("contact_role".to_owned(), p.to_string()))
20939                    .collect::<Vec<(std::string::String, std::string::String)>>(),
20940            ),
20941            _ => local_var_req_builder.query(&[(
20942                "contact_role",
20943                &local_var_str
20944                    .into_iter()
20945                    .map(|p| p.to_string())
20946                    .collect::<Vec<String>>()
20947                    .join(",")
20948                    .to_string(),
20949            )]),
20950        };
20951    }
20952    if let Some(ref local_var_str) = contact_role__n {
20953        local_var_req_builder = match "multi" {
20954            "multi" => local_var_req_builder.query(
20955                &local_var_str
20956                    .into_iter()
20957                    .map(|p| ("contact_role__n".to_owned(), p.to_string()))
20958                    .collect::<Vec<(std::string::String, std::string::String)>>(),
20959            ),
20960            _ => local_var_req_builder.query(&[(
20961                "contact_role__n",
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) = created {
20972        local_var_req_builder = match "multi" {
20973            "multi" => local_var_req_builder.query(
20974                &local_var_str
20975                    .into_iter()
20976                    .map(|p| ("created".to_owned(), p.to_string()))
20977                    .collect::<Vec<(std::string::String, std::string::String)>>(),
20978            ),
20979            _ => local_var_req_builder.query(&[(
20980                "created",
20981                &local_var_str
20982                    .into_iter()
20983                    .map(|p| p.to_string())
20984                    .collect::<Vec<String>>()
20985                    .join(",")
20986                    .to_string(),
20987            )]),
20988        };
20989    }
20990    if let Some(ref local_var_str) = created__empty {
20991        local_var_req_builder = match "multi" {
20992            "multi" => local_var_req_builder.query(
20993                &local_var_str
20994                    .into_iter()
20995                    .map(|p| ("created__empty".to_owned(), p.to_string()))
20996                    .collect::<Vec<(std::string::String, std::string::String)>>(),
20997            ),
20998            _ => local_var_req_builder.query(&[(
20999                "created__empty",
21000                &local_var_str
21001                    .into_iter()
21002                    .map(|p| p.to_string())
21003                    .collect::<Vec<String>>()
21004                    .join(",")
21005                    .to_string(),
21006            )]),
21007        };
21008    }
21009    if let Some(ref local_var_str) = created__gt {
21010        local_var_req_builder = match "multi" {
21011            "multi" => local_var_req_builder.query(
21012                &local_var_str
21013                    .into_iter()
21014                    .map(|p| ("created__gt".to_owned(), p.to_string()))
21015                    .collect::<Vec<(std::string::String, std::string::String)>>(),
21016            ),
21017            _ => local_var_req_builder.query(&[(
21018                "created__gt",
21019                &local_var_str
21020                    .into_iter()
21021                    .map(|p| p.to_string())
21022                    .collect::<Vec<String>>()
21023                    .join(",")
21024                    .to_string(),
21025            )]),
21026        };
21027    }
21028    if let Some(ref local_var_str) = created__gte {
21029        local_var_req_builder = match "multi" {
21030            "multi" => local_var_req_builder.query(
21031                &local_var_str
21032                    .into_iter()
21033                    .map(|p| ("created__gte".to_owned(), p.to_string()))
21034                    .collect::<Vec<(std::string::String, std::string::String)>>(),
21035            ),
21036            _ => local_var_req_builder.query(&[(
21037                "created__gte",
21038                &local_var_str
21039                    .into_iter()
21040                    .map(|p| p.to_string())
21041                    .collect::<Vec<String>>()
21042                    .join(",")
21043                    .to_string(),
21044            )]),
21045        };
21046    }
21047    if let Some(ref local_var_str) = created__lt {
21048        local_var_req_builder = match "multi" {
21049            "multi" => local_var_req_builder.query(
21050                &local_var_str
21051                    .into_iter()
21052                    .map(|p| ("created__lt".to_owned(), p.to_string()))
21053                    .collect::<Vec<(std::string::String, std::string::String)>>(),
21054            ),
21055            _ => local_var_req_builder.query(&[(
21056                "created__lt",
21057                &local_var_str
21058                    .into_iter()
21059                    .map(|p| p.to_string())
21060                    .collect::<Vec<String>>()
21061                    .join(",")
21062                    .to_string(),
21063            )]),
21064        };
21065    }
21066    if let Some(ref local_var_str) = created__lte {
21067        local_var_req_builder = match "multi" {
21068            "multi" => local_var_req_builder.query(
21069                &local_var_str
21070                    .into_iter()
21071                    .map(|p| ("created__lte".to_owned(), p.to_string()))
21072                    .collect::<Vec<(std::string::String, std::string::String)>>(),
21073            ),
21074            _ => local_var_req_builder.query(&[(
21075                "created__lte",
21076                &local_var_str
21077                    .into_iter()
21078                    .map(|p| p.to_string())
21079                    .collect::<Vec<String>>()
21080                    .join(",")
21081                    .to_string(),
21082            )]),
21083        };
21084    }
21085    if let Some(ref local_var_str) = created__n {
21086        local_var_req_builder = match "multi" {
21087            "multi" => local_var_req_builder.query(
21088                &local_var_str
21089                    .into_iter()
21090                    .map(|p| ("created__n".to_owned(), p.to_string()))
21091                    .collect::<Vec<(std::string::String, std::string::String)>>(),
21092            ),
21093            _ => local_var_req_builder.query(&[(
21094                "created__n",
21095                &local_var_str
21096                    .into_iter()
21097                    .map(|p| p.to_string())
21098                    .collect::<Vec<String>>()
21099                    .join(",")
21100                    .to_string(),
21101            )]),
21102        };
21103    }
21104    if let Some(ref local_var_str) = created_by_request {
21105        local_var_req_builder =
21106            local_var_req_builder.query(&[("created_by_request", &local_var_str.to_string())]);
21107    }
21108    if let Some(ref local_var_str) = description {
21109        local_var_req_builder = match "multi" {
21110            "multi" => local_var_req_builder.query(
21111                &local_var_str
21112                    .into_iter()
21113                    .map(|p| ("description".to_owned(), p.to_string()))
21114                    .collect::<Vec<(std::string::String, std::string::String)>>(),
21115            ),
21116            _ => local_var_req_builder.query(&[(
21117                "description",
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) = description__empty {
21128        local_var_req_builder =
21129            local_var_req_builder.query(&[("description__empty", &local_var_str.to_string())]);
21130    }
21131    if let Some(ref local_var_str) = description__ic {
21132        local_var_req_builder = match "multi" {
21133            "multi" => local_var_req_builder.query(
21134                &local_var_str
21135                    .into_iter()
21136                    .map(|p| ("description__ic".to_owned(), p.to_string()))
21137                    .collect::<Vec<(std::string::String, std::string::String)>>(),
21138            ),
21139            _ => local_var_req_builder.query(&[(
21140                "description__ic",
21141                &local_var_str
21142                    .into_iter()
21143                    .map(|p| p.to_string())
21144                    .collect::<Vec<String>>()
21145                    .join(",")
21146                    .to_string(),
21147            )]),
21148        };
21149    }
21150    if let Some(ref local_var_str) = description__ie {
21151        local_var_req_builder = match "multi" {
21152            "multi" => local_var_req_builder.query(
21153                &local_var_str
21154                    .into_iter()
21155                    .map(|p| ("description__ie".to_owned(), p.to_string()))
21156                    .collect::<Vec<(std::string::String, std::string::String)>>(),
21157            ),
21158            _ => local_var_req_builder.query(&[(
21159                "description__ie",
21160                &local_var_str
21161                    .into_iter()
21162                    .map(|p| p.to_string())
21163                    .collect::<Vec<String>>()
21164                    .join(",")
21165                    .to_string(),
21166            )]),
21167        };
21168    }
21169    if let Some(ref local_var_str) = description__iew {
21170        local_var_req_builder = match "multi" {
21171            "multi" => local_var_req_builder.query(
21172                &local_var_str
21173                    .into_iter()
21174                    .map(|p| ("description__iew".to_owned(), p.to_string()))
21175                    .collect::<Vec<(std::string::String, std::string::String)>>(),
21176            ),
21177            _ => local_var_req_builder.query(&[(
21178                "description__iew",
21179                &local_var_str
21180                    .into_iter()
21181                    .map(|p| p.to_string())
21182                    .collect::<Vec<String>>()
21183                    .join(",")
21184                    .to_string(),
21185            )]),
21186        };
21187    }
21188    if let Some(ref local_var_str) = description__iregex {
21189        local_var_req_builder = match "multi" {
21190            "multi" => local_var_req_builder.query(
21191                &local_var_str
21192                    .into_iter()
21193                    .map(|p| ("description__iregex".to_owned(), p.to_string()))
21194                    .collect::<Vec<(std::string::String, std::string::String)>>(),
21195            ),
21196            _ => local_var_req_builder.query(&[(
21197                "description__iregex",
21198                &local_var_str
21199                    .into_iter()
21200                    .map(|p| p.to_string())
21201                    .collect::<Vec<String>>()
21202                    .join(",")
21203                    .to_string(),
21204            )]),
21205        };
21206    }
21207    if let Some(ref local_var_str) = description__isw {
21208        local_var_req_builder = match "multi" {
21209            "multi" => local_var_req_builder.query(
21210                &local_var_str
21211                    .into_iter()
21212                    .map(|p| ("description__isw".to_owned(), p.to_string()))
21213                    .collect::<Vec<(std::string::String, std::string::String)>>(),
21214            ),
21215            _ => local_var_req_builder.query(&[(
21216                "description__isw",
21217                &local_var_str
21218                    .into_iter()
21219                    .map(|p| p.to_string())
21220                    .collect::<Vec<String>>()
21221                    .join(",")
21222                    .to_string(),
21223            )]),
21224        };
21225    }
21226    if let Some(ref local_var_str) = description__n {
21227        local_var_req_builder = match "multi" {
21228            "multi" => local_var_req_builder.query(
21229                &local_var_str
21230                    .into_iter()
21231                    .map(|p| ("description__n".to_owned(), p.to_string()))
21232                    .collect::<Vec<(std::string::String, std::string::String)>>(),
21233            ),
21234            _ => local_var_req_builder.query(&[(
21235                "description__n",
21236                &local_var_str
21237                    .into_iter()
21238                    .map(|p| p.to_string())
21239                    .collect::<Vec<String>>()
21240                    .join(",")
21241                    .to_string(),
21242            )]),
21243        };
21244    }
21245    if let Some(ref local_var_str) = description__nic {
21246        local_var_req_builder = match "multi" {
21247            "multi" => local_var_req_builder.query(
21248                &local_var_str
21249                    .into_iter()
21250                    .map(|p| ("description__nic".to_owned(), p.to_string()))
21251                    .collect::<Vec<(std::string::String, std::string::String)>>(),
21252            ),
21253            _ => local_var_req_builder.query(&[(
21254                "description__nic",
21255                &local_var_str
21256                    .into_iter()
21257                    .map(|p| p.to_string())
21258                    .collect::<Vec<String>>()
21259                    .join(",")
21260                    .to_string(),
21261            )]),
21262        };
21263    }
21264    if let Some(ref local_var_str) = description__nie {
21265        local_var_req_builder = match "multi" {
21266            "multi" => local_var_req_builder.query(
21267                &local_var_str
21268                    .into_iter()
21269                    .map(|p| ("description__nie".to_owned(), p.to_string()))
21270                    .collect::<Vec<(std::string::String, std::string::String)>>(),
21271            ),
21272            _ => local_var_req_builder.query(&[(
21273                "description__nie",
21274                &local_var_str
21275                    .into_iter()
21276                    .map(|p| p.to_string())
21277                    .collect::<Vec<String>>()
21278                    .join(",")
21279                    .to_string(),
21280            )]),
21281        };
21282    }
21283    if let Some(ref local_var_str) = description__niew {
21284        local_var_req_builder = match "multi" {
21285            "multi" => local_var_req_builder.query(
21286                &local_var_str
21287                    .into_iter()
21288                    .map(|p| ("description__niew".to_owned(), p.to_string()))
21289                    .collect::<Vec<(std::string::String, std::string::String)>>(),
21290            ),
21291            _ => local_var_req_builder.query(&[(
21292                "description__niew",
21293                &local_var_str
21294                    .into_iter()
21295                    .map(|p| p.to_string())
21296                    .collect::<Vec<String>>()
21297                    .join(",")
21298                    .to_string(),
21299            )]),
21300        };
21301    }
21302    if let Some(ref local_var_str) = description__nisw {
21303        local_var_req_builder = match "multi" {
21304            "multi" => local_var_req_builder.query(
21305                &local_var_str
21306                    .into_iter()
21307                    .map(|p| ("description__nisw".to_owned(), p.to_string()))
21308                    .collect::<Vec<(std::string::String, std::string::String)>>(),
21309            ),
21310            _ => local_var_req_builder.query(&[(
21311                "description__nisw",
21312                &local_var_str
21313                    .into_iter()
21314                    .map(|p| p.to_string())
21315                    .collect::<Vec<String>>()
21316                    .join(",")
21317                    .to_string(),
21318            )]),
21319        };
21320    }
21321    if let Some(ref local_var_str) = description__regex {
21322        local_var_req_builder = match "multi" {
21323            "multi" => local_var_req_builder.query(
21324                &local_var_str
21325                    .into_iter()
21326                    .map(|p| ("description__regex".to_owned(), p.to_string()))
21327                    .collect::<Vec<(std::string::String, std::string::String)>>(),
21328            ),
21329            _ => local_var_req_builder.query(&[(
21330                "description__regex",
21331                &local_var_str
21332                    .into_iter()
21333                    .map(|p| p.to_string())
21334                    .collect::<Vec<String>>()
21335                    .join(",")
21336                    .to_string(),
21337            )]),
21338        };
21339    }
21340    if let Some(ref local_var_str) = encapsulation {
21341        local_var_req_builder = match "multi" {
21342            "multi" => local_var_req_builder.query(
21343                &local_var_str
21344                    .into_iter()
21345                    .map(|p| ("encapsulation".to_owned(), p.to_string()))
21346                    .collect::<Vec<(std::string::String, std::string::String)>>(),
21347            ),
21348            _ => local_var_req_builder.query(&[(
21349                "encapsulation",
21350                &local_var_str
21351                    .into_iter()
21352                    .map(|p| p.to_string())
21353                    .collect::<Vec<String>>()
21354                    .join(",")
21355                    .to_string(),
21356            )]),
21357        };
21358    }
21359    if let Some(ref local_var_str) = encapsulation__empty {
21360        local_var_req_builder =
21361            local_var_req_builder.query(&[("encapsulation__empty", &local_var_str.to_string())]);
21362    }
21363    if let Some(ref local_var_str) = encapsulation__ic {
21364        local_var_req_builder = match "multi" {
21365            "multi" => local_var_req_builder.query(
21366                &local_var_str
21367                    .into_iter()
21368                    .map(|p| ("encapsulation__ic".to_owned(), p.to_string()))
21369                    .collect::<Vec<(std::string::String, std::string::String)>>(),
21370            ),
21371            _ => local_var_req_builder.query(&[(
21372                "encapsulation__ic",
21373                &local_var_str
21374                    .into_iter()
21375                    .map(|p| p.to_string())
21376                    .collect::<Vec<String>>()
21377                    .join(",")
21378                    .to_string(),
21379            )]),
21380        };
21381    }
21382    if let Some(ref local_var_str) = encapsulation__ie {
21383        local_var_req_builder = match "multi" {
21384            "multi" => local_var_req_builder.query(
21385                &local_var_str
21386                    .into_iter()
21387                    .map(|p| ("encapsulation__ie".to_owned(), p.to_string()))
21388                    .collect::<Vec<(std::string::String, std::string::String)>>(),
21389            ),
21390            _ => local_var_req_builder.query(&[(
21391                "encapsulation__ie",
21392                &local_var_str
21393                    .into_iter()
21394                    .map(|p| p.to_string())
21395                    .collect::<Vec<String>>()
21396                    .join(",")
21397                    .to_string(),
21398            )]),
21399        };
21400    }
21401    if let Some(ref local_var_str) = encapsulation__iew {
21402        local_var_req_builder = match "multi" {
21403            "multi" => local_var_req_builder.query(
21404                &local_var_str
21405                    .into_iter()
21406                    .map(|p| ("encapsulation__iew".to_owned(), p.to_string()))
21407                    .collect::<Vec<(std::string::String, std::string::String)>>(),
21408            ),
21409            _ => local_var_req_builder.query(&[(
21410                "encapsulation__iew",
21411                &local_var_str
21412                    .into_iter()
21413                    .map(|p| p.to_string())
21414                    .collect::<Vec<String>>()
21415                    .join(",")
21416                    .to_string(),
21417            )]),
21418        };
21419    }
21420    if let Some(ref local_var_str) = encapsulation__iregex {
21421        local_var_req_builder = match "multi" {
21422            "multi" => local_var_req_builder.query(
21423                &local_var_str
21424                    .into_iter()
21425                    .map(|p| ("encapsulation__iregex".to_owned(), p.to_string()))
21426                    .collect::<Vec<(std::string::String, std::string::String)>>(),
21427            ),
21428            _ => local_var_req_builder.query(&[(
21429                "encapsulation__iregex",
21430                &local_var_str
21431                    .into_iter()
21432                    .map(|p| p.to_string())
21433                    .collect::<Vec<String>>()
21434                    .join(",")
21435                    .to_string(),
21436            )]),
21437        };
21438    }
21439    if let Some(ref local_var_str) = encapsulation__isw {
21440        local_var_req_builder = match "multi" {
21441            "multi" => local_var_req_builder.query(
21442                &local_var_str
21443                    .into_iter()
21444                    .map(|p| ("encapsulation__isw".to_owned(), p.to_string()))
21445                    .collect::<Vec<(std::string::String, std::string::String)>>(),
21446            ),
21447            _ => local_var_req_builder.query(&[(
21448                "encapsulation__isw",
21449                &local_var_str
21450                    .into_iter()
21451                    .map(|p| p.to_string())
21452                    .collect::<Vec<String>>()
21453                    .join(",")
21454                    .to_string(),
21455            )]),
21456        };
21457    }
21458    if let Some(ref local_var_str) = encapsulation__n {
21459        local_var_req_builder = match "multi" {
21460            "multi" => local_var_req_builder.query(
21461                &local_var_str
21462                    .into_iter()
21463                    .map(|p| ("encapsulation__n".to_owned(), p.to_string()))
21464                    .collect::<Vec<(std::string::String, std::string::String)>>(),
21465            ),
21466            _ => local_var_req_builder.query(&[(
21467                "encapsulation__n",
21468                &local_var_str
21469                    .into_iter()
21470                    .map(|p| p.to_string())
21471                    .collect::<Vec<String>>()
21472                    .join(",")
21473                    .to_string(),
21474            )]),
21475        };
21476    }
21477    if let Some(ref local_var_str) = encapsulation__nic {
21478        local_var_req_builder = match "multi" {
21479            "multi" => local_var_req_builder.query(
21480                &local_var_str
21481                    .into_iter()
21482                    .map(|p| ("encapsulation__nic".to_owned(), p.to_string()))
21483                    .collect::<Vec<(std::string::String, std::string::String)>>(),
21484            ),
21485            _ => local_var_req_builder.query(&[(
21486                "encapsulation__nic",
21487                &local_var_str
21488                    .into_iter()
21489                    .map(|p| p.to_string())
21490                    .collect::<Vec<String>>()
21491                    .join(",")
21492                    .to_string(),
21493            )]),
21494        };
21495    }
21496    if let Some(ref local_var_str) = encapsulation__nie {
21497        local_var_req_builder = match "multi" {
21498            "multi" => local_var_req_builder.query(
21499                &local_var_str
21500                    .into_iter()
21501                    .map(|p| ("encapsulation__nie".to_owned(), p.to_string()))
21502                    .collect::<Vec<(std::string::String, std::string::String)>>(),
21503            ),
21504            _ => local_var_req_builder.query(&[(
21505                "encapsulation__nie",
21506                &local_var_str
21507                    .into_iter()
21508                    .map(|p| p.to_string())
21509                    .collect::<Vec<String>>()
21510                    .join(",")
21511                    .to_string(),
21512            )]),
21513        };
21514    }
21515    if let Some(ref local_var_str) = encapsulation__niew {
21516        local_var_req_builder = match "multi" {
21517            "multi" => local_var_req_builder.query(
21518                &local_var_str
21519                    .into_iter()
21520                    .map(|p| ("encapsulation__niew".to_owned(), p.to_string()))
21521                    .collect::<Vec<(std::string::String, std::string::String)>>(),
21522            ),
21523            _ => local_var_req_builder.query(&[(
21524                "encapsulation__niew",
21525                &local_var_str
21526                    .into_iter()
21527                    .map(|p| p.to_string())
21528                    .collect::<Vec<String>>()
21529                    .join(",")
21530                    .to_string(),
21531            )]),
21532        };
21533    }
21534    if let Some(ref local_var_str) = encapsulation__nisw {
21535        local_var_req_builder = match "multi" {
21536            "multi" => local_var_req_builder.query(
21537                &local_var_str
21538                    .into_iter()
21539                    .map(|p| ("encapsulation__nisw".to_owned(), p.to_string()))
21540                    .collect::<Vec<(std::string::String, std::string::String)>>(),
21541            ),
21542            _ => local_var_req_builder.query(&[(
21543                "encapsulation__nisw",
21544                &local_var_str
21545                    .into_iter()
21546                    .map(|p| p.to_string())
21547                    .collect::<Vec<String>>()
21548                    .join(",")
21549                    .to_string(),
21550            )]),
21551        };
21552    }
21553    if let Some(ref local_var_str) = encapsulation__regex {
21554        local_var_req_builder = match "multi" {
21555            "multi" => local_var_req_builder.query(
21556                &local_var_str
21557                    .into_iter()
21558                    .map(|p| ("encapsulation__regex".to_owned(), p.to_string()))
21559                    .collect::<Vec<(std::string::String, std::string::String)>>(),
21560            ),
21561            _ => local_var_req_builder.query(&[(
21562                "encapsulation__regex",
21563                &local_var_str
21564                    .into_iter()
21565                    .map(|p| p.to_string())
21566                    .collect::<Vec<String>>()
21567                    .join(",")
21568                    .to_string(),
21569            )]),
21570        };
21571    }
21572    if let Some(ref local_var_str) = group {
21573        local_var_req_builder = match "multi" {
21574            "multi" => local_var_req_builder.query(
21575                &local_var_str
21576                    .into_iter()
21577                    .map(|p| ("group".to_owned(), p.to_string()))
21578                    .collect::<Vec<(std::string::String, std::string::String)>>(),
21579            ),
21580            _ => local_var_req_builder.query(&[(
21581                "group",
21582                &local_var_str
21583                    .into_iter()
21584                    .map(|p| p.to_string())
21585                    .collect::<Vec<String>>()
21586                    .join(",")
21587                    .to_string(),
21588            )]),
21589        };
21590    }
21591    if let Some(ref local_var_str) = group__n {
21592        local_var_req_builder = match "multi" {
21593            "multi" => local_var_req_builder.query(
21594                &local_var_str
21595                    .into_iter()
21596                    .map(|p| ("group__n".to_owned(), p.to_string()))
21597                    .collect::<Vec<(std::string::String, std::string::String)>>(),
21598            ),
21599            _ => local_var_req_builder.query(&[(
21600                "group__n",
21601                &local_var_str
21602                    .into_iter()
21603                    .map(|p| p.to_string())
21604                    .collect::<Vec<String>>()
21605                    .join(",")
21606                    .to_string(),
21607            )]),
21608        };
21609    }
21610    if let Some(ref local_var_str) = group_id {
21611        local_var_req_builder = match "multi" {
21612            "multi" => local_var_req_builder.query(
21613                &local_var_str
21614                    .into_iter()
21615                    .map(|p| ("group_id".to_owned(), p.to_string()))
21616                    .collect::<Vec<(std::string::String, std::string::String)>>(),
21617            ),
21618            _ => local_var_req_builder.query(&[(
21619                "group_id",
21620                &local_var_str
21621                    .into_iter()
21622                    .map(|p| p.to_string())
21623                    .collect::<Vec<String>>()
21624                    .join(",")
21625                    .to_string(),
21626            )]),
21627        };
21628    }
21629    if let Some(ref local_var_str) = group_id__n {
21630        local_var_req_builder = match "multi" {
21631            "multi" => local_var_req_builder.query(
21632                &local_var_str
21633                    .into_iter()
21634                    .map(|p| ("group_id__n".to_owned(), p.to_string()))
21635                    .collect::<Vec<(std::string::String, std::string::String)>>(),
21636            ),
21637            _ => local_var_req_builder.query(&[(
21638                "group_id__n",
21639                &local_var_str
21640                    .into_iter()
21641                    .map(|p| p.to_string())
21642                    .collect::<Vec<String>>()
21643                    .join(",")
21644                    .to_string(),
21645            )]),
21646        };
21647    }
21648    if let Some(ref local_var_str) = id {
21649        local_var_req_builder = match "multi" {
21650            "multi" => local_var_req_builder.query(
21651                &local_var_str
21652                    .into_iter()
21653                    .map(|p| ("id".to_owned(), p.to_string()))
21654                    .collect::<Vec<(std::string::String, std::string::String)>>(),
21655            ),
21656            _ => local_var_req_builder.query(&[(
21657                "id",
21658                &local_var_str
21659                    .into_iter()
21660                    .map(|p| p.to_string())
21661                    .collect::<Vec<String>>()
21662                    .join(",")
21663                    .to_string(),
21664            )]),
21665        };
21666    }
21667    if let Some(ref local_var_str) = id__empty {
21668        local_var_req_builder =
21669            local_var_req_builder.query(&[("id__empty", &local_var_str.to_string())]);
21670    }
21671    if let Some(ref local_var_str) = id__gt {
21672        local_var_req_builder = match "multi" {
21673            "multi" => local_var_req_builder.query(
21674                &local_var_str
21675                    .into_iter()
21676                    .map(|p| ("id__gt".to_owned(), p.to_string()))
21677                    .collect::<Vec<(std::string::String, std::string::String)>>(),
21678            ),
21679            _ => local_var_req_builder.query(&[(
21680                "id__gt",
21681                &local_var_str
21682                    .into_iter()
21683                    .map(|p| p.to_string())
21684                    .collect::<Vec<String>>()
21685                    .join(",")
21686                    .to_string(),
21687            )]),
21688        };
21689    }
21690    if let Some(ref local_var_str) = id__gte {
21691        local_var_req_builder = match "multi" {
21692            "multi" => local_var_req_builder.query(
21693                &local_var_str
21694                    .into_iter()
21695                    .map(|p| ("id__gte".to_owned(), p.to_string()))
21696                    .collect::<Vec<(std::string::String, std::string::String)>>(),
21697            ),
21698            _ => local_var_req_builder.query(&[(
21699                "id__gte",
21700                &local_var_str
21701                    .into_iter()
21702                    .map(|p| p.to_string())
21703                    .collect::<Vec<String>>()
21704                    .join(",")
21705                    .to_string(),
21706            )]),
21707        };
21708    }
21709    if let Some(ref local_var_str) = id__lt {
21710        local_var_req_builder = match "multi" {
21711            "multi" => local_var_req_builder.query(
21712                &local_var_str
21713                    .into_iter()
21714                    .map(|p| ("id__lt".to_owned(), p.to_string()))
21715                    .collect::<Vec<(std::string::String, std::string::String)>>(),
21716            ),
21717            _ => local_var_req_builder.query(&[(
21718                "id__lt",
21719                &local_var_str
21720                    .into_iter()
21721                    .map(|p| p.to_string())
21722                    .collect::<Vec<String>>()
21723                    .join(",")
21724                    .to_string(),
21725            )]),
21726        };
21727    }
21728    if let Some(ref local_var_str) = id__lte {
21729        local_var_req_builder = match "multi" {
21730            "multi" => local_var_req_builder.query(
21731                &local_var_str
21732                    .into_iter()
21733                    .map(|p| ("id__lte".to_owned(), p.to_string()))
21734                    .collect::<Vec<(std::string::String, std::string::String)>>(),
21735            ),
21736            _ => local_var_req_builder.query(&[(
21737                "id__lte",
21738                &local_var_str
21739                    .into_iter()
21740                    .map(|p| p.to_string())
21741                    .collect::<Vec<String>>()
21742                    .join(",")
21743                    .to_string(),
21744            )]),
21745        };
21746    }
21747    if let Some(ref local_var_str) = id__n {
21748        local_var_req_builder = match "multi" {
21749            "multi" => local_var_req_builder.query(
21750                &local_var_str
21751                    .into_iter()
21752                    .map(|p| ("id__n".to_owned(), p.to_string()))
21753                    .collect::<Vec<(std::string::String, std::string::String)>>(),
21754            ),
21755            _ => local_var_req_builder.query(&[(
21756                "id__n",
21757                &local_var_str
21758                    .into_iter()
21759                    .map(|p| p.to_string())
21760                    .collect::<Vec<String>>()
21761                    .join(",")
21762                    .to_string(),
21763            )]),
21764        };
21765    }
21766    if let Some(ref local_var_str) = ipsec_profile {
21767        local_var_req_builder = match "multi" {
21768            "multi" => local_var_req_builder.query(
21769                &local_var_str
21770                    .into_iter()
21771                    .map(|p| ("ipsec_profile".to_owned(), p.to_string()))
21772                    .collect::<Vec<(std::string::String, std::string::String)>>(),
21773            ),
21774            _ => local_var_req_builder.query(&[(
21775                "ipsec_profile",
21776                &local_var_str
21777                    .into_iter()
21778                    .map(|p| p.to_string())
21779                    .collect::<Vec<String>>()
21780                    .join(",")
21781                    .to_string(),
21782            )]),
21783        };
21784    }
21785    if let Some(ref local_var_str) = ipsec_profile__n {
21786        local_var_req_builder = match "multi" {
21787            "multi" => local_var_req_builder.query(
21788                &local_var_str
21789                    .into_iter()
21790                    .map(|p| ("ipsec_profile__n".to_owned(), p.to_string()))
21791                    .collect::<Vec<(std::string::String, std::string::String)>>(),
21792            ),
21793            _ => local_var_req_builder.query(&[(
21794                "ipsec_profile__n",
21795                &local_var_str
21796                    .into_iter()
21797                    .map(|p| p.to_string())
21798                    .collect::<Vec<String>>()
21799                    .join(",")
21800                    .to_string(),
21801            )]),
21802        };
21803    }
21804    if let Some(ref local_var_str) = ipsec_profile_id {
21805        local_var_req_builder = match "multi" {
21806            "multi" => local_var_req_builder.query(
21807                &local_var_str
21808                    .into_iter()
21809                    .map(|p| ("ipsec_profile_id".to_owned(), p.to_string()))
21810                    .collect::<Vec<(std::string::String, std::string::String)>>(),
21811            ),
21812            _ => local_var_req_builder.query(&[(
21813                "ipsec_profile_id",
21814                &local_var_str
21815                    .into_iter()
21816                    .map(|p| p.to_string())
21817                    .collect::<Vec<String>>()
21818                    .join(",")
21819                    .to_string(),
21820            )]),
21821        };
21822    }
21823    if let Some(ref local_var_str) = ipsec_profile_id__n {
21824        local_var_req_builder = match "multi" {
21825            "multi" => local_var_req_builder.query(
21826                &local_var_str
21827                    .into_iter()
21828                    .map(|p| ("ipsec_profile_id__n".to_owned(), p.to_string()))
21829                    .collect::<Vec<(std::string::String, std::string::String)>>(),
21830            ),
21831            _ => local_var_req_builder.query(&[(
21832                "ipsec_profile_id__n",
21833                &local_var_str
21834                    .into_iter()
21835                    .map(|p| p.to_string())
21836                    .collect::<Vec<String>>()
21837                    .join(",")
21838                    .to_string(),
21839            )]),
21840        };
21841    }
21842    if let Some(ref local_var_str) = last_updated {
21843        local_var_req_builder = match "multi" {
21844            "multi" => local_var_req_builder.query(
21845                &local_var_str
21846                    .into_iter()
21847                    .map(|p| ("last_updated".to_owned(), p.to_string()))
21848                    .collect::<Vec<(std::string::String, std::string::String)>>(),
21849            ),
21850            _ => local_var_req_builder.query(&[(
21851                "last_updated",
21852                &local_var_str
21853                    .into_iter()
21854                    .map(|p| p.to_string())
21855                    .collect::<Vec<String>>()
21856                    .join(",")
21857                    .to_string(),
21858            )]),
21859        };
21860    }
21861    if let Some(ref local_var_str) = last_updated__empty {
21862        local_var_req_builder = match "multi" {
21863            "multi" => local_var_req_builder.query(
21864                &local_var_str
21865                    .into_iter()
21866                    .map(|p| ("last_updated__empty".to_owned(), p.to_string()))
21867                    .collect::<Vec<(std::string::String, std::string::String)>>(),
21868            ),
21869            _ => local_var_req_builder.query(&[(
21870                "last_updated__empty",
21871                &local_var_str
21872                    .into_iter()
21873                    .map(|p| p.to_string())
21874                    .collect::<Vec<String>>()
21875                    .join(",")
21876                    .to_string(),
21877            )]),
21878        };
21879    }
21880    if let Some(ref local_var_str) = last_updated__gt {
21881        local_var_req_builder = match "multi" {
21882            "multi" => local_var_req_builder.query(
21883                &local_var_str
21884                    .into_iter()
21885                    .map(|p| ("last_updated__gt".to_owned(), p.to_string()))
21886                    .collect::<Vec<(std::string::String, std::string::String)>>(),
21887            ),
21888            _ => local_var_req_builder.query(&[(
21889                "last_updated__gt",
21890                &local_var_str
21891                    .into_iter()
21892                    .map(|p| p.to_string())
21893                    .collect::<Vec<String>>()
21894                    .join(",")
21895                    .to_string(),
21896            )]),
21897        };
21898    }
21899    if let Some(ref local_var_str) = last_updated__gte {
21900        local_var_req_builder = match "multi" {
21901            "multi" => local_var_req_builder.query(
21902                &local_var_str
21903                    .into_iter()
21904                    .map(|p| ("last_updated__gte".to_owned(), p.to_string()))
21905                    .collect::<Vec<(std::string::String, std::string::String)>>(),
21906            ),
21907            _ => local_var_req_builder.query(&[(
21908                "last_updated__gte",
21909                &local_var_str
21910                    .into_iter()
21911                    .map(|p| p.to_string())
21912                    .collect::<Vec<String>>()
21913                    .join(",")
21914                    .to_string(),
21915            )]),
21916        };
21917    }
21918    if let Some(ref local_var_str) = last_updated__lt {
21919        local_var_req_builder = match "multi" {
21920            "multi" => local_var_req_builder.query(
21921                &local_var_str
21922                    .into_iter()
21923                    .map(|p| ("last_updated__lt".to_owned(), p.to_string()))
21924                    .collect::<Vec<(std::string::String, std::string::String)>>(),
21925            ),
21926            _ => local_var_req_builder.query(&[(
21927                "last_updated__lt",
21928                &local_var_str
21929                    .into_iter()
21930                    .map(|p| p.to_string())
21931                    .collect::<Vec<String>>()
21932                    .join(",")
21933                    .to_string(),
21934            )]),
21935        };
21936    }
21937    if let Some(ref local_var_str) = last_updated__lte {
21938        local_var_req_builder = match "multi" {
21939            "multi" => local_var_req_builder.query(
21940                &local_var_str
21941                    .into_iter()
21942                    .map(|p| ("last_updated__lte".to_owned(), p.to_string()))
21943                    .collect::<Vec<(std::string::String, std::string::String)>>(),
21944            ),
21945            _ => local_var_req_builder.query(&[(
21946                "last_updated__lte",
21947                &local_var_str
21948                    .into_iter()
21949                    .map(|p| p.to_string())
21950                    .collect::<Vec<String>>()
21951                    .join(",")
21952                    .to_string(),
21953            )]),
21954        };
21955    }
21956    if let Some(ref local_var_str) = last_updated__n {
21957        local_var_req_builder = match "multi" {
21958            "multi" => local_var_req_builder.query(
21959                &local_var_str
21960                    .into_iter()
21961                    .map(|p| ("last_updated__n".to_owned(), p.to_string()))
21962                    .collect::<Vec<(std::string::String, std::string::String)>>(),
21963            ),
21964            _ => local_var_req_builder.query(&[(
21965                "last_updated__n",
21966                &local_var_str
21967                    .into_iter()
21968                    .map(|p| p.to_string())
21969                    .collect::<Vec<String>>()
21970                    .join(",")
21971                    .to_string(),
21972            )]),
21973        };
21974    }
21975    if let Some(ref local_var_str) = limit {
21976        local_var_req_builder =
21977            local_var_req_builder.query(&[("limit", &local_var_str.to_string())]);
21978    }
21979    if let Some(ref local_var_str) = modified_by_request {
21980        local_var_req_builder =
21981            local_var_req_builder.query(&[("modified_by_request", &local_var_str.to_string())]);
21982    }
21983    if let Some(ref local_var_str) = name {
21984        local_var_req_builder = match "multi" {
21985            "multi" => local_var_req_builder.query(
21986                &local_var_str
21987                    .into_iter()
21988                    .map(|p| ("name".to_owned(), p.to_string()))
21989                    .collect::<Vec<(std::string::String, std::string::String)>>(),
21990            ),
21991            _ => local_var_req_builder.query(&[(
21992                "name",
21993                &local_var_str
21994                    .into_iter()
21995                    .map(|p| p.to_string())
21996                    .collect::<Vec<String>>()
21997                    .join(",")
21998                    .to_string(),
21999            )]),
22000        };
22001    }
22002    if let Some(ref local_var_str) = name__empty {
22003        local_var_req_builder =
22004            local_var_req_builder.query(&[("name__empty", &local_var_str.to_string())]);
22005    }
22006    if let Some(ref local_var_str) = name__ic {
22007        local_var_req_builder = match "multi" {
22008            "multi" => local_var_req_builder.query(
22009                &local_var_str
22010                    .into_iter()
22011                    .map(|p| ("name__ic".to_owned(), p.to_string()))
22012                    .collect::<Vec<(std::string::String, std::string::String)>>(),
22013            ),
22014            _ => local_var_req_builder.query(&[(
22015                "name__ic",
22016                &local_var_str
22017                    .into_iter()
22018                    .map(|p| p.to_string())
22019                    .collect::<Vec<String>>()
22020                    .join(",")
22021                    .to_string(),
22022            )]),
22023        };
22024    }
22025    if let Some(ref local_var_str) = name__ie {
22026        local_var_req_builder = match "multi" {
22027            "multi" => local_var_req_builder.query(
22028                &local_var_str
22029                    .into_iter()
22030                    .map(|p| ("name__ie".to_owned(), p.to_string()))
22031                    .collect::<Vec<(std::string::String, std::string::String)>>(),
22032            ),
22033            _ => local_var_req_builder.query(&[(
22034                "name__ie",
22035                &local_var_str
22036                    .into_iter()
22037                    .map(|p| p.to_string())
22038                    .collect::<Vec<String>>()
22039                    .join(",")
22040                    .to_string(),
22041            )]),
22042        };
22043    }
22044    if let Some(ref local_var_str) = name__iew {
22045        local_var_req_builder = match "multi" {
22046            "multi" => local_var_req_builder.query(
22047                &local_var_str
22048                    .into_iter()
22049                    .map(|p| ("name__iew".to_owned(), p.to_string()))
22050                    .collect::<Vec<(std::string::String, std::string::String)>>(),
22051            ),
22052            _ => local_var_req_builder.query(&[(
22053                "name__iew",
22054                &local_var_str
22055                    .into_iter()
22056                    .map(|p| p.to_string())
22057                    .collect::<Vec<String>>()
22058                    .join(",")
22059                    .to_string(),
22060            )]),
22061        };
22062    }
22063    if let Some(ref local_var_str) = name__iregex {
22064        local_var_req_builder = match "multi" {
22065            "multi" => local_var_req_builder.query(
22066                &local_var_str
22067                    .into_iter()
22068                    .map(|p| ("name__iregex".to_owned(), p.to_string()))
22069                    .collect::<Vec<(std::string::String, std::string::String)>>(),
22070            ),
22071            _ => local_var_req_builder.query(&[(
22072                "name__iregex",
22073                &local_var_str
22074                    .into_iter()
22075                    .map(|p| p.to_string())
22076                    .collect::<Vec<String>>()
22077                    .join(",")
22078                    .to_string(),
22079            )]),
22080        };
22081    }
22082    if let Some(ref local_var_str) = name__isw {
22083        local_var_req_builder = match "multi" {
22084            "multi" => local_var_req_builder.query(
22085                &local_var_str
22086                    .into_iter()
22087                    .map(|p| ("name__isw".to_owned(), p.to_string()))
22088                    .collect::<Vec<(std::string::String, std::string::String)>>(),
22089            ),
22090            _ => local_var_req_builder.query(&[(
22091                "name__isw",
22092                &local_var_str
22093                    .into_iter()
22094                    .map(|p| p.to_string())
22095                    .collect::<Vec<String>>()
22096                    .join(",")
22097                    .to_string(),
22098            )]),
22099        };
22100    }
22101    if let Some(ref local_var_str) = name__n {
22102        local_var_req_builder = match "multi" {
22103            "multi" => local_var_req_builder.query(
22104                &local_var_str
22105                    .into_iter()
22106                    .map(|p| ("name__n".to_owned(), p.to_string()))
22107                    .collect::<Vec<(std::string::String, std::string::String)>>(),
22108            ),
22109            _ => local_var_req_builder.query(&[(
22110                "name__n",
22111                &local_var_str
22112                    .into_iter()
22113                    .map(|p| p.to_string())
22114                    .collect::<Vec<String>>()
22115                    .join(",")
22116                    .to_string(),
22117            )]),
22118        };
22119    }
22120    if let Some(ref local_var_str) = name__nic {
22121        local_var_req_builder = match "multi" {
22122            "multi" => local_var_req_builder.query(
22123                &local_var_str
22124                    .into_iter()
22125                    .map(|p| ("name__nic".to_owned(), p.to_string()))
22126                    .collect::<Vec<(std::string::String, std::string::String)>>(),
22127            ),
22128            _ => local_var_req_builder.query(&[(
22129                "name__nic",
22130                &local_var_str
22131                    .into_iter()
22132                    .map(|p| p.to_string())
22133                    .collect::<Vec<String>>()
22134                    .join(",")
22135                    .to_string(),
22136            )]),
22137        };
22138    }
22139    if let Some(ref local_var_str) = name__nie {
22140        local_var_req_builder = match "multi" {
22141            "multi" => local_var_req_builder.query(
22142                &local_var_str
22143                    .into_iter()
22144                    .map(|p| ("name__nie".to_owned(), p.to_string()))
22145                    .collect::<Vec<(std::string::String, std::string::String)>>(),
22146            ),
22147            _ => local_var_req_builder.query(&[(
22148                "name__nie",
22149                &local_var_str
22150                    .into_iter()
22151                    .map(|p| p.to_string())
22152                    .collect::<Vec<String>>()
22153                    .join(",")
22154                    .to_string(),
22155            )]),
22156        };
22157    }
22158    if let Some(ref local_var_str) = name__niew {
22159        local_var_req_builder = match "multi" {
22160            "multi" => local_var_req_builder.query(
22161                &local_var_str
22162                    .into_iter()
22163                    .map(|p| ("name__niew".to_owned(), p.to_string()))
22164                    .collect::<Vec<(std::string::String, std::string::String)>>(),
22165            ),
22166            _ => local_var_req_builder.query(&[(
22167                "name__niew",
22168                &local_var_str
22169                    .into_iter()
22170                    .map(|p| p.to_string())
22171                    .collect::<Vec<String>>()
22172                    .join(",")
22173                    .to_string(),
22174            )]),
22175        };
22176    }
22177    if let Some(ref local_var_str) = name__nisw {
22178        local_var_req_builder = match "multi" {
22179            "multi" => local_var_req_builder.query(
22180                &local_var_str
22181                    .into_iter()
22182                    .map(|p| ("name__nisw".to_owned(), p.to_string()))
22183                    .collect::<Vec<(std::string::String, std::string::String)>>(),
22184            ),
22185            _ => local_var_req_builder.query(&[(
22186                "name__nisw",
22187                &local_var_str
22188                    .into_iter()
22189                    .map(|p| p.to_string())
22190                    .collect::<Vec<String>>()
22191                    .join(",")
22192                    .to_string(),
22193            )]),
22194        };
22195    }
22196    if let Some(ref local_var_str) = name__regex {
22197        local_var_req_builder = match "multi" {
22198            "multi" => local_var_req_builder.query(
22199                &local_var_str
22200                    .into_iter()
22201                    .map(|p| ("name__regex".to_owned(), p.to_string()))
22202                    .collect::<Vec<(std::string::String, std::string::String)>>(),
22203            ),
22204            _ => local_var_req_builder.query(&[(
22205                "name__regex",
22206                &local_var_str
22207                    .into_iter()
22208                    .map(|p| p.to_string())
22209                    .collect::<Vec<String>>()
22210                    .join(",")
22211                    .to_string(),
22212            )]),
22213        };
22214    }
22215    if let Some(ref local_var_str) = offset {
22216        local_var_req_builder =
22217            local_var_req_builder.query(&[("offset", &local_var_str.to_string())]);
22218    }
22219    if let Some(ref local_var_str) = ordering {
22220        local_var_req_builder =
22221            local_var_req_builder.query(&[("ordering", &local_var_str.to_string())]);
22222    }
22223    if let Some(ref local_var_str) = owner {
22224        local_var_req_builder = match "multi" {
22225            "multi" => local_var_req_builder.query(
22226                &local_var_str
22227                    .into_iter()
22228                    .map(|p| ("owner".to_owned(), p.to_string()))
22229                    .collect::<Vec<(std::string::String, std::string::String)>>(),
22230            ),
22231            _ => local_var_req_builder.query(&[(
22232                "owner",
22233                &local_var_str
22234                    .into_iter()
22235                    .map(|p| p.to_string())
22236                    .collect::<Vec<String>>()
22237                    .join(",")
22238                    .to_string(),
22239            )]),
22240        };
22241    }
22242    if let Some(ref local_var_str) = owner__n {
22243        local_var_req_builder = match "multi" {
22244            "multi" => local_var_req_builder.query(
22245                &local_var_str
22246                    .into_iter()
22247                    .map(|p| ("owner__n".to_owned(), p.to_string()))
22248                    .collect::<Vec<(std::string::String, std::string::String)>>(),
22249            ),
22250            _ => local_var_req_builder.query(&[(
22251                "owner__n",
22252                &local_var_str
22253                    .into_iter()
22254                    .map(|p| p.to_string())
22255                    .collect::<Vec<String>>()
22256                    .join(",")
22257                    .to_string(),
22258            )]),
22259        };
22260    }
22261    if let Some(ref local_var_str) = owner_group {
22262        local_var_req_builder = match "multi" {
22263            "multi" => local_var_req_builder.query(
22264                &local_var_str
22265                    .into_iter()
22266                    .map(|p| ("owner_group".to_owned(), p.to_string()))
22267                    .collect::<Vec<(std::string::String, std::string::String)>>(),
22268            ),
22269            _ => local_var_req_builder.query(&[(
22270                "owner_group",
22271                &local_var_str
22272                    .into_iter()
22273                    .map(|p| p.to_string())
22274                    .collect::<Vec<String>>()
22275                    .join(",")
22276                    .to_string(),
22277            )]),
22278        };
22279    }
22280    if let Some(ref local_var_str) = owner_group__n {
22281        local_var_req_builder = match "multi" {
22282            "multi" => local_var_req_builder.query(
22283                &local_var_str
22284                    .into_iter()
22285                    .map(|p| ("owner_group__n".to_owned(), p.to_string()))
22286                    .collect::<Vec<(std::string::String, std::string::String)>>(),
22287            ),
22288            _ => local_var_req_builder.query(&[(
22289                "owner_group__n",
22290                &local_var_str
22291                    .into_iter()
22292                    .map(|p| p.to_string())
22293                    .collect::<Vec<String>>()
22294                    .join(",")
22295                    .to_string(),
22296            )]),
22297        };
22298    }
22299    if let Some(ref local_var_str) = owner_group_id {
22300        local_var_req_builder = match "multi" {
22301            "multi" => local_var_req_builder.query(
22302                &local_var_str
22303                    .into_iter()
22304                    .map(|p| ("owner_group_id".to_owned(), p.to_string()))
22305                    .collect::<Vec<(std::string::String, std::string::String)>>(),
22306            ),
22307            _ => local_var_req_builder.query(&[(
22308                "owner_group_id",
22309                &local_var_str
22310                    .into_iter()
22311                    .map(|p| p.to_string())
22312                    .collect::<Vec<String>>()
22313                    .join(",")
22314                    .to_string(),
22315            )]),
22316        };
22317    }
22318    if let Some(ref local_var_str) = owner_group_id__n {
22319        local_var_req_builder = match "multi" {
22320            "multi" => local_var_req_builder.query(
22321                &local_var_str
22322                    .into_iter()
22323                    .map(|p| ("owner_group_id__n".to_owned(), p.to_string()))
22324                    .collect::<Vec<(std::string::String, std::string::String)>>(),
22325            ),
22326            _ => local_var_req_builder.query(&[(
22327                "owner_group_id__n",
22328                &local_var_str
22329                    .into_iter()
22330                    .map(|p| p.to_string())
22331                    .collect::<Vec<String>>()
22332                    .join(",")
22333                    .to_string(),
22334            )]),
22335        };
22336    }
22337    if let Some(ref local_var_str) = owner_id {
22338        local_var_req_builder = match "multi" {
22339            "multi" => local_var_req_builder.query(
22340                &local_var_str
22341                    .into_iter()
22342                    .map(|p| ("owner_id".to_owned(), p.to_string()))
22343                    .collect::<Vec<(std::string::String, std::string::String)>>(),
22344            ),
22345            _ => local_var_req_builder.query(&[(
22346                "owner_id",
22347                &local_var_str
22348                    .into_iter()
22349                    .map(|p| p.to_string())
22350                    .collect::<Vec<String>>()
22351                    .join(",")
22352                    .to_string(),
22353            )]),
22354        };
22355    }
22356    if let Some(ref local_var_str) = owner_id__n {
22357        local_var_req_builder = match "multi" {
22358            "multi" => local_var_req_builder.query(
22359                &local_var_str
22360                    .into_iter()
22361                    .map(|p| ("owner_id__n".to_owned(), p.to_string()))
22362                    .collect::<Vec<(std::string::String, std::string::String)>>(),
22363            ),
22364            _ => local_var_req_builder.query(&[(
22365                "owner_id__n",
22366                &local_var_str
22367                    .into_iter()
22368                    .map(|p| p.to_string())
22369                    .collect::<Vec<String>>()
22370                    .join(",")
22371                    .to_string(),
22372            )]),
22373        };
22374    }
22375    if let Some(ref local_var_str) = q {
22376        local_var_req_builder = local_var_req_builder.query(&[("q", &local_var_str.to_string())]);
22377    }
22378    if let Some(ref local_var_str) = start {
22379        local_var_req_builder =
22380            local_var_req_builder.query(&[("start", &local_var_str.to_string())]);
22381    }
22382    if let Some(ref local_var_str) = status {
22383        local_var_req_builder = match "multi" {
22384            "multi" => local_var_req_builder.query(
22385                &local_var_str
22386                    .into_iter()
22387                    .map(|p| ("status".to_owned(), p.to_string()))
22388                    .collect::<Vec<(std::string::String, std::string::String)>>(),
22389            ),
22390            _ => local_var_req_builder.query(&[(
22391                "status",
22392                &local_var_str
22393                    .into_iter()
22394                    .map(|p| p.to_string())
22395                    .collect::<Vec<String>>()
22396                    .join(",")
22397                    .to_string(),
22398            )]),
22399        };
22400    }
22401    if let Some(ref local_var_str) = status__empty {
22402        local_var_req_builder =
22403            local_var_req_builder.query(&[("status__empty", &local_var_str.to_string())]);
22404    }
22405    if let Some(ref local_var_str) = status__ic {
22406        local_var_req_builder = match "multi" {
22407            "multi" => local_var_req_builder.query(
22408                &local_var_str
22409                    .into_iter()
22410                    .map(|p| ("status__ic".to_owned(), p.to_string()))
22411                    .collect::<Vec<(std::string::String, std::string::String)>>(),
22412            ),
22413            _ => local_var_req_builder.query(&[(
22414                "status__ic",
22415                &local_var_str
22416                    .into_iter()
22417                    .map(|p| p.to_string())
22418                    .collect::<Vec<String>>()
22419                    .join(",")
22420                    .to_string(),
22421            )]),
22422        };
22423    }
22424    if let Some(ref local_var_str) = status__ie {
22425        local_var_req_builder = match "multi" {
22426            "multi" => local_var_req_builder.query(
22427                &local_var_str
22428                    .into_iter()
22429                    .map(|p| ("status__ie".to_owned(), p.to_string()))
22430                    .collect::<Vec<(std::string::String, std::string::String)>>(),
22431            ),
22432            _ => local_var_req_builder.query(&[(
22433                "status__ie",
22434                &local_var_str
22435                    .into_iter()
22436                    .map(|p| p.to_string())
22437                    .collect::<Vec<String>>()
22438                    .join(",")
22439                    .to_string(),
22440            )]),
22441        };
22442    }
22443    if let Some(ref local_var_str) = status__iew {
22444        local_var_req_builder = match "multi" {
22445            "multi" => local_var_req_builder.query(
22446                &local_var_str
22447                    .into_iter()
22448                    .map(|p| ("status__iew".to_owned(), p.to_string()))
22449                    .collect::<Vec<(std::string::String, std::string::String)>>(),
22450            ),
22451            _ => local_var_req_builder.query(&[(
22452                "status__iew",
22453                &local_var_str
22454                    .into_iter()
22455                    .map(|p| p.to_string())
22456                    .collect::<Vec<String>>()
22457                    .join(",")
22458                    .to_string(),
22459            )]),
22460        };
22461    }
22462    if let Some(ref local_var_str) = status__iregex {
22463        local_var_req_builder = match "multi" {
22464            "multi" => local_var_req_builder.query(
22465                &local_var_str
22466                    .into_iter()
22467                    .map(|p| ("status__iregex".to_owned(), p.to_string()))
22468                    .collect::<Vec<(std::string::String, std::string::String)>>(),
22469            ),
22470            _ => local_var_req_builder.query(&[(
22471                "status__iregex",
22472                &local_var_str
22473                    .into_iter()
22474                    .map(|p| p.to_string())
22475                    .collect::<Vec<String>>()
22476                    .join(",")
22477                    .to_string(),
22478            )]),
22479        };
22480    }
22481    if let Some(ref local_var_str) = status__isw {
22482        local_var_req_builder = match "multi" {
22483            "multi" => local_var_req_builder.query(
22484                &local_var_str
22485                    .into_iter()
22486                    .map(|p| ("status__isw".to_owned(), p.to_string()))
22487                    .collect::<Vec<(std::string::String, std::string::String)>>(),
22488            ),
22489            _ => local_var_req_builder.query(&[(
22490                "status__isw",
22491                &local_var_str
22492                    .into_iter()
22493                    .map(|p| p.to_string())
22494                    .collect::<Vec<String>>()
22495                    .join(",")
22496                    .to_string(),
22497            )]),
22498        };
22499    }
22500    if let Some(ref local_var_str) = status__n {
22501        local_var_req_builder = match "multi" {
22502            "multi" => local_var_req_builder.query(
22503                &local_var_str
22504                    .into_iter()
22505                    .map(|p| ("status__n".to_owned(), p.to_string()))
22506                    .collect::<Vec<(std::string::String, std::string::String)>>(),
22507            ),
22508            _ => local_var_req_builder.query(&[(
22509                "status__n",
22510                &local_var_str
22511                    .into_iter()
22512                    .map(|p| p.to_string())
22513                    .collect::<Vec<String>>()
22514                    .join(",")
22515                    .to_string(),
22516            )]),
22517        };
22518    }
22519    if let Some(ref local_var_str) = status__nic {
22520        local_var_req_builder = match "multi" {
22521            "multi" => local_var_req_builder.query(
22522                &local_var_str
22523                    .into_iter()
22524                    .map(|p| ("status__nic".to_owned(), p.to_string()))
22525                    .collect::<Vec<(std::string::String, std::string::String)>>(),
22526            ),
22527            _ => local_var_req_builder.query(&[(
22528                "status__nic",
22529                &local_var_str
22530                    .into_iter()
22531                    .map(|p| p.to_string())
22532                    .collect::<Vec<String>>()
22533                    .join(",")
22534                    .to_string(),
22535            )]),
22536        };
22537    }
22538    if let Some(ref local_var_str) = status__nie {
22539        local_var_req_builder = match "multi" {
22540            "multi" => local_var_req_builder.query(
22541                &local_var_str
22542                    .into_iter()
22543                    .map(|p| ("status__nie".to_owned(), p.to_string()))
22544                    .collect::<Vec<(std::string::String, std::string::String)>>(),
22545            ),
22546            _ => local_var_req_builder.query(&[(
22547                "status__nie",
22548                &local_var_str
22549                    .into_iter()
22550                    .map(|p| p.to_string())
22551                    .collect::<Vec<String>>()
22552                    .join(",")
22553                    .to_string(),
22554            )]),
22555        };
22556    }
22557    if let Some(ref local_var_str) = status__niew {
22558        local_var_req_builder = match "multi" {
22559            "multi" => local_var_req_builder.query(
22560                &local_var_str
22561                    .into_iter()
22562                    .map(|p| ("status__niew".to_owned(), p.to_string()))
22563                    .collect::<Vec<(std::string::String, std::string::String)>>(),
22564            ),
22565            _ => local_var_req_builder.query(&[(
22566                "status__niew",
22567                &local_var_str
22568                    .into_iter()
22569                    .map(|p| p.to_string())
22570                    .collect::<Vec<String>>()
22571                    .join(",")
22572                    .to_string(),
22573            )]),
22574        };
22575    }
22576    if let Some(ref local_var_str) = status__nisw {
22577        local_var_req_builder = match "multi" {
22578            "multi" => local_var_req_builder.query(
22579                &local_var_str
22580                    .into_iter()
22581                    .map(|p| ("status__nisw".to_owned(), p.to_string()))
22582                    .collect::<Vec<(std::string::String, std::string::String)>>(),
22583            ),
22584            _ => local_var_req_builder.query(&[(
22585                "status__nisw",
22586                &local_var_str
22587                    .into_iter()
22588                    .map(|p| p.to_string())
22589                    .collect::<Vec<String>>()
22590                    .join(",")
22591                    .to_string(),
22592            )]),
22593        };
22594    }
22595    if let Some(ref local_var_str) = status__regex {
22596        local_var_req_builder = match "multi" {
22597            "multi" => local_var_req_builder.query(
22598                &local_var_str
22599                    .into_iter()
22600                    .map(|p| ("status__regex".to_owned(), p.to_string()))
22601                    .collect::<Vec<(std::string::String, std::string::String)>>(),
22602            ),
22603            _ => local_var_req_builder.query(&[(
22604                "status__regex",
22605                &local_var_str
22606                    .into_iter()
22607                    .map(|p| p.to_string())
22608                    .collect::<Vec<String>>()
22609                    .join(",")
22610                    .to_string(),
22611            )]),
22612        };
22613    }
22614    if let Some(ref local_var_str) = tag {
22615        local_var_req_builder = match "multi" {
22616            "multi" => local_var_req_builder.query(
22617                &local_var_str
22618                    .into_iter()
22619                    .map(|p| ("tag".to_owned(), p.to_string()))
22620                    .collect::<Vec<(std::string::String, std::string::String)>>(),
22621            ),
22622            _ => local_var_req_builder.query(&[(
22623                "tag",
22624                &local_var_str
22625                    .into_iter()
22626                    .map(|p| p.to_string())
22627                    .collect::<Vec<String>>()
22628                    .join(",")
22629                    .to_string(),
22630            )]),
22631        };
22632    }
22633    if let Some(ref local_var_str) = tag__n {
22634        local_var_req_builder = match "multi" {
22635            "multi" => local_var_req_builder.query(
22636                &local_var_str
22637                    .into_iter()
22638                    .map(|p| ("tag__n".to_owned(), p.to_string()))
22639                    .collect::<Vec<(std::string::String, std::string::String)>>(),
22640            ),
22641            _ => local_var_req_builder.query(&[(
22642                "tag__n",
22643                &local_var_str
22644                    .into_iter()
22645                    .map(|p| p.to_string())
22646                    .collect::<Vec<String>>()
22647                    .join(",")
22648                    .to_string(),
22649            )]),
22650        };
22651    }
22652    if let Some(ref local_var_str) = tag_id {
22653        local_var_req_builder = match "multi" {
22654            "multi" => local_var_req_builder.query(
22655                &local_var_str
22656                    .into_iter()
22657                    .map(|p| ("tag_id".to_owned(), p.to_string()))
22658                    .collect::<Vec<(std::string::String, std::string::String)>>(),
22659            ),
22660            _ => local_var_req_builder.query(&[(
22661                "tag_id",
22662                &local_var_str
22663                    .into_iter()
22664                    .map(|p| p.to_string())
22665                    .collect::<Vec<String>>()
22666                    .join(",")
22667                    .to_string(),
22668            )]),
22669        };
22670    }
22671    if let Some(ref local_var_str) = tag_id__n {
22672        local_var_req_builder = match "multi" {
22673            "multi" => local_var_req_builder.query(
22674                &local_var_str
22675                    .into_iter()
22676                    .map(|p| ("tag_id__n".to_owned(), p.to_string()))
22677                    .collect::<Vec<(std::string::String, std::string::String)>>(),
22678            ),
22679            _ => local_var_req_builder.query(&[(
22680                "tag_id__n",
22681                &local_var_str
22682                    .into_iter()
22683                    .map(|p| p.to_string())
22684                    .collect::<Vec<String>>()
22685                    .join(",")
22686                    .to_string(),
22687            )]),
22688        };
22689    }
22690    if let Some(ref local_var_str) = tenant {
22691        local_var_req_builder = match "multi" {
22692            "multi" => local_var_req_builder.query(
22693                &local_var_str
22694                    .into_iter()
22695                    .map(|p| ("tenant".to_owned(), p.to_string()))
22696                    .collect::<Vec<(std::string::String, std::string::String)>>(),
22697            ),
22698            _ => local_var_req_builder.query(&[(
22699                "tenant",
22700                &local_var_str
22701                    .into_iter()
22702                    .map(|p| p.to_string())
22703                    .collect::<Vec<String>>()
22704                    .join(",")
22705                    .to_string(),
22706            )]),
22707        };
22708    }
22709    if let Some(ref local_var_str) = tenant__n {
22710        local_var_req_builder = match "multi" {
22711            "multi" => local_var_req_builder.query(
22712                &local_var_str
22713                    .into_iter()
22714                    .map(|p| ("tenant__n".to_owned(), p.to_string()))
22715                    .collect::<Vec<(std::string::String, std::string::String)>>(),
22716            ),
22717            _ => local_var_req_builder.query(&[(
22718                "tenant__n",
22719                &local_var_str
22720                    .into_iter()
22721                    .map(|p| p.to_string())
22722                    .collect::<Vec<String>>()
22723                    .join(",")
22724                    .to_string(),
22725            )]),
22726        };
22727    }
22728    if let Some(ref local_var_str) = tenant_group {
22729        local_var_req_builder = match "multi" {
22730            "multi" => local_var_req_builder.query(
22731                &local_var_str
22732                    .into_iter()
22733                    .map(|p| ("tenant_group".to_owned(), p.to_string()))
22734                    .collect::<Vec<(std::string::String, std::string::String)>>(),
22735            ),
22736            _ => local_var_req_builder.query(&[(
22737                "tenant_group",
22738                &local_var_str
22739                    .into_iter()
22740                    .map(|p| p.to_string())
22741                    .collect::<Vec<String>>()
22742                    .join(",")
22743                    .to_string(),
22744            )]),
22745        };
22746    }
22747    if let Some(ref local_var_str) = tenant_group__n {
22748        local_var_req_builder = match "multi" {
22749            "multi" => local_var_req_builder.query(
22750                &local_var_str
22751                    .into_iter()
22752                    .map(|p| ("tenant_group__n".to_owned(), p.to_string()))
22753                    .collect::<Vec<(std::string::String, std::string::String)>>(),
22754            ),
22755            _ => local_var_req_builder.query(&[(
22756                "tenant_group__n",
22757                &local_var_str
22758                    .into_iter()
22759                    .map(|p| p.to_string())
22760                    .collect::<Vec<String>>()
22761                    .join(",")
22762                    .to_string(),
22763            )]),
22764        };
22765    }
22766    if let Some(ref local_var_str) = tenant_group_id {
22767        local_var_req_builder = match "multi" {
22768            "multi" => local_var_req_builder.query(
22769                &local_var_str
22770                    .into_iter()
22771                    .map(|p| ("tenant_group_id".to_owned(), p.to_string()))
22772                    .collect::<Vec<(std::string::String, std::string::String)>>(),
22773            ),
22774            _ => local_var_req_builder.query(&[(
22775                "tenant_group_id",
22776                &local_var_str
22777                    .into_iter()
22778                    .map(|p| p.to_string())
22779                    .collect::<Vec<String>>()
22780                    .join(",")
22781                    .to_string(),
22782            )]),
22783        };
22784    }
22785    if let Some(ref local_var_str) = tenant_group_id__n {
22786        local_var_req_builder = match "multi" {
22787            "multi" => local_var_req_builder.query(
22788                &local_var_str
22789                    .into_iter()
22790                    .map(|p| ("tenant_group_id__n".to_owned(), p.to_string()))
22791                    .collect::<Vec<(std::string::String, std::string::String)>>(),
22792            ),
22793            _ => local_var_req_builder.query(&[(
22794                "tenant_group_id__n",
22795                &local_var_str
22796                    .into_iter()
22797                    .map(|p| p.to_string())
22798                    .collect::<Vec<String>>()
22799                    .join(",")
22800                    .to_string(),
22801            )]),
22802        };
22803    }
22804    if let Some(ref local_var_str) = tenant_id {
22805        local_var_req_builder = match "multi" {
22806            "multi" => local_var_req_builder.query(
22807                &local_var_str
22808                    .into_iter()
22809                    .map(|p| ("tenant_id".to_owned(), p.to_string()))
22810                    .collect::<Vec<(std::string::String, std::string::String)>>(),
22811            ),
22812            _ => local_var_req_builder.query(&[(
22813                "tenant_id",
22814                &local_var_str
22815                    .into_iter()
22816                    .map(|p| p.to_string())
22817                    .collect::<Vec<String>>()
22818                    .join(",")
22819                    .to_string(),
22820            )]),
22821        };
22822    }
22823    if let Some(ref local_var_str) = tenant_id__n {
22824        local_var_req_builder = match "multi" {
22825            "multi" => local_var_req_builder.query(
22826                &local_var_str
22827                    .into_iter()
22828                    .map(|p| ("tenant_id__n".to_owned(), p.to_string()))
22829                    .collect::<Vec<(std::string::String, std::string::String)>>(),
22830            ),
22831            _ => local_var_req_builder.query(&[(
22832                "tenant_id__n",
22833                &local_var_str
22834                    .into_iter()
22835                    .map(|p| p.to_string())
22836                    .collect::<Vec<String>>()
22837                    .join(",")
22838                    .to_string(),
22839            )]),
22840        };
22841    }
22842    if let Some(ref local_var_str) = tunnel_id {
22843        local_var_req_builder = match "multi" {
22844            "multi" => local_var_req_builder.query(
22845                &local_var_str
22846                    .into_iter()
22847                    .map(|p| ("tunnel_id".to_owned(), p.to_string()))
22848                    .collect::<Vec<(std::string::String, std::string::String)>>(),
22849            ),
22850            _ => local_var_req_builder.query(&[(
22851                "tunnel_id",
22852                &local_var_str
22853                    .into_iter()
22854                    .map(|p| p.to_string())
22855                    .collect::<Vec<String>>()
22856                    .join(",")
22857                    .to_string(),
22858            )]),
22859        };
22860    }
22861    if let Some(ref local_var_str) = tunnel_id__empty {
22862        local_var_req_builder =
22863            local_var_req_builder.query(&[("tunnel_id__empty", &local_var_str.to_string())]);
22864    }
22865    if let Some(ref local_var_str) = tunnel_id__gt {
22866        local_var_req_builder = match "multi" {
22867            "multi" => local_var_req_builder.query(
22868                &local_var_str
22869                    .into_iter()
22870                    .map(|p| ("tunnel_id__gt".to_owned(), p.to_string()))
22871                    .collect::<Vec<(std::string::String, std::string::String)>>(),
22872            ),
22873            _ => local_var_req_builder.query(&[(
22874                "tunnel_id__gt",
22875                &local_var_str
22876                    .into_iter()
22877                    .map(|p| p.to_string())
22878                    .collect::<Vec<String>>()
22879                    .join(",")
22880                    .to_string(),
22881            )]),
22882        };
22883    }
22884    if let Some(ref local_var_str) = tunnel_id__gte {
22885        local_var_req_builder = match "multi" {
22886            "multi" => local_var_req_builder.query(
22887                &local_var_str
22888                    .into_iter()
22889                    .map(|p| ("tunnel_id__gte".to_owned(), p.to_string()))
22890                    .collect::<Vec<(std::string::String, std::string::String)>>(),
22891            ),
22892            _ => local_var_req_builder.query(&[(
22893                "tunnel_id__gte",
22894                &local_var_str
22895                    .into_iter()
22896                    .map(|p| p.to_string())
22897                    .collect::<Vec<String>>()
22898                    .join(",")
22899                    .to_string(),
22900            )]),
22901        };
22902    }
22903    if let Some(ref local_var_str) = tunnel_id__lt {
22904        local_var_req_builder = match "multi" {
22905            "multi" => local_var_req_builder.query(
22906                &local_var_str
22907                    .into_iter()
22908                    .map(|p| ("tunnel_id__lt".to_owned(), p.to_string()))
22909                    .collect::<Vec<(std::string::String, std::string::String)>>(),
22910            ),
22911            _ => local_var_req_builder.query(&[(
22912                "tunnel_id__lt",
22913                &local_var_str
22914                    .into_iter()
22915                    .map(|p| p.to_string())
22916                    .collect::<Vec<String>>()
22917                    .join(",")
22918                    .to_string(),
22919            )]),
22920        };
22921    }
22922    if let Some(ref local_var_str) = tunnel_id__lte {
22923        local_var_req_builder = match "multi" {
22924            "multi" => local_var_req_builder.query(
22925                &local_var_str
22926                    .into_iter()
22927                    .map(|p| ("tunnel_id__lte".to_owned(), p.to_string()))
22928                    .collect::<Vec<(std::string::String, std::string::String)>>(),
22929            ),
22930            _ => local_var_req_builder.query(&[(
22931                "tunnel_id__lte",
22932                &local_var_str
22933                    .into_iter()
22934                    .map(|p| p.to_string())
22935                    .collect::<Vec<String>>()
22936                    .join(",")
22937                    .to_string(),
22938            )]),
22939        };
22940    }
22941    if let Some(ref local_var_str) = tunnel_id__n {
22942        local_var_req_builder = match "multi" {
22943            "multi" => local_var_req_builder.query(
22944                &local_var_str
22945                    .into_iter()
22946                    .map(|p| ("tunnel_id__n".to_owned(), p.to_string()))
22947                    .collect::<Vec<(std::string::String, std::string::String)>>(),
22948            ),
22949            _ => local_var_req_builder.query(&[(
22950                "tunnel_id__n",
22951                &local_var_str
22952                    .into_iter()
22953                    .map(|p| p.to_string())
22954                    .collect::<Vec<String>>()
22955                    .join(",")
22956                    .to_string(),
22957            )]),
22958        };
22959    }
22960    if let Some(ref local_var_str) = updated_by_request {
22961        local_var_req_builder =
22962            local_var_req_builder.query(&[("updated_by_request", &local_var_str.to_string())]);
22963    }
22964    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
22965        local_var_req_builder =
22966            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
22967    }
22968    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
22969        let local_var_key = local_var_apikey.key.clone();
22970        let local_var_value = match local_var_apikey.prefix {
22971            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
22972            None => local_var_key,
22973        };
22974        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
22975    };
22976
22977    let local_var_req = local_var_req_builder.build()?;
22978    let local_var_resp = local_var_client.execute(local_var_req).await?;
22979
22980    let local_var_status = local_var_resp.status();
22981    let local_var_content = local_var_resp.text().await?;
22982
22983    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
22984        serde_json::from_str(&local_var_content).map_err(Error::from)
22985    } else {
22986        let local_var_entity: Option<VpnTunnelsListError> =
22987            serde_json::from_str(&local_var_content).ok();
22988        let local_var_error = ResponseContent {
22989            status: local_var_status,
22990            content: local_var_content,
22991            entity: local_var_entity,
22992        };
22993        Err(Error::ResponseError(local_var_error))
22994    }
22995}
22996
22997/// Patch a tunnel object.
22998pub async fn vpn_tunnels_partial_update(
22999    configuration: &configuration::Configuration,
23000    id: i32,
23001    patched_writable_tunnel_request: Option<crate::models::PatchedWritableTunnelRequest>,
23002) -> Result<crate::models::Tunnel, Error<VpnTunnelsPartialUpdateError>> {
23003    let local_var_configuration = configuration;
23004
23005    let local_var_client = &local_var_configuration.client;
23006
23007    let local_var_uri_str = format!(
23008        "{}/api/vpn/tunnels/{id}/",
23009        local_var_configuration.base_path,
23010        id = id
23011    );
23012    let mut local_var_req_builder =
23013        local_var_client.request(reqwest::Method::PATCH, local_var_uri_str.as_str());
23014
23015    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
23016        local_var_req_builder =
23017            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
23018    }
23019    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
23020        let local_var_key = local_var_apikey.key.clone();
23021        let local_var_value = match local_var_apikey.prefix {
23022            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
23023            None => local_var_key,
23024        };
23025        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
23026    };
23027    local_var_req_builder = local_var_req_builder.json(&patched_writable_tunnel_request);
23028
23029    let local_var_req = local_var_req_builder.build()?;
23030    let local_var_resp = local_var_client.execute(local_var_req).await?;
23031
23032    let local_var_status = local_var_resp.status();
23033    let local_var_content = local_var_resp.text().await?;
23034
23035    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
23036        serde_json::from_str(&local_var_content).map_err(Error::from)
23037    } else {
23038        let local_var_entity: Option<VpnTunnelsPartialUpdateError> =
23039            serde_json::from_str(&local_var_content).ok();
23040        let local_var_error = ResponseContent {
23041            status: local_var_status,
23042            content: local_var_content,
23043            entity: local_var_entity,
23044        };
23045        Err(Error::ResponseError(local_var_error))
23046    }
23047}
23048
23049/// Get a tunnel object.
23050pub async fn vpn_tunnels_retrieve(
23051    configuration: &configuration::Configuration,
23052    id: i32,
23053) -> Result<crate::models::Tunnel, Error<VpnTunnelsRetrieveError>> {
23054    let local_var_configuration = configuration;
23055
23056    let local_var_client = &local_var_configuration.client;
23057
23058    let local_var_uri_str = format!(
23059        "{}/api/vpn/tunnels/{id}/",
23060        local_var_configuration.base_path,
23061        id = id
23062    );
23063    let mut local_var_req_builder =
23064        local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
23065
23066    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
23067        local_var_req_builder =
23068            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
23069    }
23070    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
23071        let local_var_key = local_var_apikey.key.clone();
23072        let local_var_value = match local_var_apikey.prefix {
23073            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
23074            None => local_var_key,
23075        };
23076        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
23077    };
23078
23079    let local_var_req = local_var_req_builder.build()?;
23080    let local_var_resp = local_var_client.execute(local_var_req).await?;
23081
23082    let local_var_status = local_var_resp.status();
23083    let local_var_content = local_var_resp.text().await?;
23084
23085    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
23086        serde_json::from_str(&local_var_content).map_err(Error::from)
23087    } else {
23088        let local_var_entity: Option<VpnTunnelsRetrieveError> =
23089            serde_json::from_str(&local_var_content).ok();
23090        let local_var_error = ResponseContent {
23091            status: local_var_status,
23092            content: local_var_content,
23093            entity: local_var_entity,
23094        };
23095        Err(Error::ResponseError(local_var_error))
23096    }
23097}
23098
23099/// Put a tunnel object.
23100pub async fn vpn_tunnels_update(
23101    configuration: &configuration::Configuration,
23102    id: i32,
23103    writable_tunnel_request: crate::models::WritableTunnelRequest,
23104) -> Result<crate::models::Tunnel, Error<VpnTunnelsUpdateError>> {
23105    let local_var_configuration = configuration;
23106
23107    let local_var_client = &local_var_configuration.client;
23108
23109    let local_var_uri_str = format!(
23110        "{}/api/vpn/tunnels/{id}/",
23111        local_var_configuration.base_path,
23112        id = id
23113    );
23114    let mut local_var_req_builder =
23115        local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());
23116
23117    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
23118        local_var_req_builder =
23119            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
23120    }
23121    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
23122        let local_var_key = local_var_apikey.key.clone();
23123        let local_var_value = match local_var_apikey.prefix {
23124            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
23125            None => local_var_key,
23126        };
23127        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
23128    };
23129    local_var_req_builder = local_var_req_builder.json(&writable_tunnel_request);
23130
23131    let local_var_req = local_var_req_builder.build()?;
23132    let local_var_resp = local_var_client.execute(local_var_req).await?;
23133
23134    let local_var_status = local_var_resp.status();
23135    let local_var_content = local_var_resp.text().await?;
23136
23137    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
23138        serde_json::from_str(&local_var_content).map_err(Error::from)
23139    } else {
23140        let local_var_entity: Option<VpnTunnelsUpdateError> =
23141            serde_json::from_str(&local_var_content).ok();
23142        let local_var_error = ResponseContent {
23143            status: local_var_status,
23144            content: local_var_content,
23145            entity: local_var_entity,
23146        };
23147        Err(Error::ResponseError(local_var_error))
23148    }
23149}
netbox_openapi/apis/vpn_api.rs

netbox_openapi/apis/
vpn_api.rs
