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.5.9-Docker-4.0.2 (4.5)
7 *
8 * Generated by: https://openapi-generator.tech
9 */
10
11use reqwest;
12
13use super::{Error, configuration};
14use crate::apis::ResponseContent;
15
16/// struct for typed errors of method [`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    tag: Option<Vec<String>>,
990    tag__n: Option<Vec<String>>,
991    tag_id: Option<Vec<i32>>,
992    tag_id__n: Option<Vec<i32>>,
993    updated_by_request: Option<&str>,
994    version: Option<Vec<i32>>,
995    version__ic: Option<Vec<i32>>,
996    version__ie: Option<Vec<i32>>,
997    version__iew: Option<Vec<i32>>,
998    version__iregex: Option<Vec<i32>>,
999    version__isw: Option<Vec<i32>>,
1000    version__n: Option<Vec<i32>>,
1001    version__nic: Option<Vec<i32>>,
1002    version__nie: Option<Vec<i32>>,
1003    version__niew: Option<Vec<i32>>,
1004    version__nisw: Option<Vec<i32>>,
1005    version__regex: Option<Vec<i32>>,
1006) -> Result<crate::models::PaginatedIkePolicyList, Error<VpnIkePoliciesListError>> {
1007    let local_var_configuration = configuration;
1008
1009    let local_var_client = &local_var_configuration.client;
1010
1011    let local_var_uri_str = format!(
1012        "{}/api/vpn/ike-policies/",
1013        local_var_configuration.base_path
1014    );
1015    let mut local_var_req_builder =
1016        local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
1017
1018    if let Some(ref local_var_str) = created {
1019        local_var_req_builder = match "multi" {
1020            "multi" => local_var_req_builder.query(
1021                &local_var_str
1022                    .into_iter()
1023                    .map(|p| ("created".to_owned(), p.to_string()))
1024                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1025            ),
1026            _ => local_var_req_builder.query(&[(
1027                "created",
1028                &local_var_str
1029                    .into_iter()
1030                    .map(|p| p.to_string())
1031                    .collect::<Vec<String>>()
1032                    .join(",")
1033                    .to_string(),
1034            )]),
1035        };
1036    }
1037    if let Some(ref local_var_str) = created__empty {
1038        local_var_req_builder = match "multi" {
1039            "multi" => local_var_req_builder.query(
1040                &local_var_str
1041                    .into_iter()
1042                    .map(|p| ("created__empty".to_owned(), p.to_string()))
1043                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1044            ),
1045            _ => local_var_req_builder.query(&[(
1046                "created__empty",
1047                &local_var_str
1048                    .into_iter()
1049                    .map(|p| p.to_string())
1050                    .collect::<Vec<String>>()
1051                    .join(",")
1052                    .to_string(),
1053            )]),
1054        };
1055    }
1056    if let Some(ref local_var_str) = created__gt {
1057        local_var_req_builder = match "multi" {
1058            "multi" => local_var_req_builder.query(
1059                &local_var_str
1060                    .into_iter()
1061                    .map(|p| ("created__gt".to_owned(), p.to_string()))
1062                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1063            ),
1064            _ => local_var_req_builder.query(&[(
1065                "created__gt",
1066                &local_var_str
1067                    .into_iter()
1068                    .map(|p| p.to_string())
1069                    .collect::<Vec<String>>()
1070                    .join(",")
1071                    .to_string(),
1072            )]),
1073        };
1074    }
1075    if let Some(ref local_var_str) = created__gte {
1076        local_var_req_builder = match "multi" {
1077            "multi" => local_var_req_builder.query(
1078                &local_var_str
1079                    .into_iter()
1080                    .map(|p| ("created__gte".to_owned(), p.to_string()))
1081                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1082            ),
1083            _ => local_var_req_builder.query(&[(
1084                "created__gte",
1085                &local_var_str
1086                    .into_iter()
1087                    .map(|p| p.to_string())
1088                    .collect::<Vec<String>>()
1089                    .join(",")
1090                    .to_string(),
1091            )]),
1092        };
1093    }
1094    if let Some(ref local_var_str) = created__lt {
1095        local_var_req_builder = match "multi" {
1096            "multi" => local_var_req_builder.query(
1097                &local_var_str
1098                    .into_iter()
1099                    .map(|p| ("created__lt".to_owned(), p.to_string()))
1100                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1101            ),
1102            _ => local_var_req_builder.query(&[(
1103                "created__lt",
1104                &local_var_str
1105                    .into_iter()
1106                    .map(|p| p.to_string())
1107                    .collect::<Vec<String>>()
1108                    .join(",")
1109                    .to_string(),
1110            )]),
1111        };
1112    }
1113    if let Some(ref local_var_str) = created__lte {
1114        local_var_req_builder = match "multi" {
1115            "multi" => local_var_req_builder.query(
1116                &local_var_str
1117                    .into_iter()
1118                    .map(|p| ("created__lte".to_owned(), p.to_string()))
1119                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1120            ),
1121            _ => local_var_req_builder.query(&[(
1122                "created__lte",
1123                &local_var_str
1124                    .into_iter()
1125                    .map(|p| p.to_string())
1126                    .collect::<Vec<String>>()
1127                    .join(",")
1128                    .to_string(),
1129            )]),
1130        };
1131    }
1132    if let Some(ref local_var_str) = created__n {
1133        local_var_req_builder = match "multi" {
1134            "multi" => local_var_req_builder.query(
1135                &local_var_str
1136                    .into_iter()
1137                    .map(|p| ("created__n".to_owned(), p.to_string()))
1138                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1139            ),
1140            _ => local_var_req_builder.query(&[(
1141                "created__n",
1142                &local_var_str
1143                    .into_iter()
1144                    .map(|p| p.to_string())
1145                    .collect::<Vec<String>>()
1146                    .join(",")
1147                    .to_string(),
1148            )]),
1149        };
1150    }
1151    if let Some(ref local_var_str) = created_by_request {
1152        local_var_req_builder =
1153            local_var_req_builder.query(&[("created_by_request", &local_var_str.to_string())]);
1154    }
1155    if let Some(ref local_var_str) = description {
1156        local_var_req_builder = match "multi" {
1157            "multi" => local_var_req_builder.query(
1158                &local_var_str
1159                    .into_iter()
1160                    .map(|p| ("description".to_owned(), p.to_string()))
1161                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1162            ),
1163            _ => local_var_req_builder.query(&[(
1164                "description",
1165                &local_var_str
1166                    .into_iter()
1167                    .map(|p| p.to_string())
1168                    .collect::<Vec<String>>()
1169                    .join(",")
1170                    .to_string(),
1171            )]),
1172        };
1173    }
1174    if let Some(ref local_var_str) = description__empty {
1175        local_var_req_builder =
1176            local_var_req_builder.query(&[("description__empty", &local_var_str.to_string())]);
1177    }
1178    if let Some(ref local_var_str) = description__ic {
1179        local_var_req_builder = match "multi" {
1180            "multi" => local_var_req_builder.query(
1181                &local_var_str
1182                    .into_iter()
1183                    .map(|p| ("description__ic".to_owned(), p.to_string()))
1184                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1185            ),
1186            _ => local_var_req_builder.query(&[(
1187                "description__ic",
1188                &local_var_str
1189                    .into_iter()
1190                    .map(|p| p.to_string())
1191                    .collect::<Vec<String>>()
1192                    .join(",")
1193                    .to_string(),
1194            )]),
1195        };
1196    }
1197    if let Some(ref local_var_str) = description__ie {
1198        local_var_req_builder = match "multi" {
1199            "multi" => local_var_req_builder.query(
1200                &local_var_str
1201                    .into_iter()
1202                    .map(|p| ("description__ie".to_owned(), p.to_string()))
1203                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1204            ),
1205            _ => local_var_req_builder.query(&[(
1206                "description__ie",
1207                &local_var_str
1208                    .into_iter()
1209                    .map(|p| p.to_string())
1210                    .collect::<Vec<String>>()
1211                    .join(",")
1212                    .to_string(),
1213            )]),
1214        };
1215    }
1216    if let Some(ref local_var_str) = description__iew {
1217        local_var_req_builder = match "multi" {
1218            "multi" => local_var_req_builder.query(
1219                &local_var_str
1220                    .into_iter()
1221                    .map(|p| ("description__iew".to_owned(), p.to_string()))
1222                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1223            ),
1224            _ => local_var_req_builder.query(&[(
1225                "description__iew",
1226                &local_var_str
1227                    .into_iter()
1228                    .map(|p| p.to_string())
1229                    .collect::<Vec<String>>()
1230                    .join(",")
1231                    .to_string(),
1232            )]),
1233        };
1234    }
1235    if let Some(ref local_var_str) = description__iregex {
1236        local_var_req_builder = match "multi" {
1237            "multi" => local_var_req_builder.query(
1238                &local_var_str
1239                    .into_iter()
1240                    .map(|p| ("description__iregex".to_owned(), p.to_string()))
1241                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1242            ),
1243            _ => local_var_req_builder.query(&[(
1244                "description__iregex",
1245                &local_var_str
1246                    .into_iter()
1247                    .map(|p| p.to_string())
1248                    .collect::<Vec<String>>()
1249                    .join(",")
1250                    .to_string(),
1251            )]),
1252        };
1253    }
1254    if let Some(ref local_var_str) = description__isw {
1255        local_var_req_builder = match "multi" {
1256            "multi" => local_var_req_builder.query(
1257                &local_var_str
1258                    .into_iter()
1259                    .map(|p| ("description__isw".to_owned(), p.to_string()))
1260                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1261            ),
1262            _ => local_var_req_builder.query(&[(
1263                "description__isw",
1264                &local_var_str
1265                    .into_iter()
1266                    .map(|p| p.to_string())
1267                    .collect::<Vec<String>>()
1268                    .join(",")
1269                    .to_string(),
1270            )]),
1271        };
1272    }
1273    if let Some(ref local_var_str) = description__n {
1274        local_var_req_builder = match "multi" {
1275            "multi" => local_var_req_builder.query(
1276                &local_var_str
1277                    .into_iter()
1278                    .map(|p| ("description__n".to_owned(), p.to_string()))
1279                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1280            ),
1281            _ => local_var_req_builder.query(&[(
1282                "description__n",
1283                &local_var_str
1284                    .into_iter()
1285                    .map(|p| p.to_string())
1286                    .collect::<Vec<String>>()
1287                    .join(",")
1288                    .to_string(),
1289            )]),
1290        };
1291    }
1292    if let Some(ref local_var_str) = description__nic {
1293        local_var_req_builder = match "multi" {
1294            "multi" => local_var_req_builder.query(
1295                &local_var_str
1296                    .into_iter()
1297                    .map(|p| ("description__nic".to_owned(), p.to_string()))
1298                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1299            ),
1300            _ => local_var_req_builder.query(&[(
1301                "description__nic",
1302                &local_var_str
1303                    .into_iter()
1304                    .map(|p| p.to_string())
1305                    .collect::<Vec<String>>()
1306                    .join(",")
1307                    .to_string(),
1308            )]),
1309        };
1310    }
1311    if let Some(ref local_var_str) = description__nie {
1312        local_var_req_builder = match "multi" {
1313            "multi" => local_var_req_builder.query(
1314                &local_var_str
1315                    .into_iter()
1316                    .map(|p| ("description__nie".to_owned(), p.to_string()))
1317                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1318            ),
1319            _ => local_var_req_builder.query(&[(
1320                "description__nie",
1321                &local_var_str
1322                    .into_iter()
1323                    .map(|p| p.to_string())
1324                    .collect::<Vec<String>>()
1325                    .join(",")
1326                    .to_string(),
1327            )]),
1328        };
1329    }
1330    if let Some(ref local_var_str) = description__niew {
1331        local_var_req_builder = match "multi" {
1332            "multi" => local_var_req_builder.query(
1333                &local_var_str
1334                    .into_iter()
1335                    .map(|p| ("description__niew".to_owned(), p.to_string()))
1336                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1337            ),
1338            _ => local_var_req_builder.query(&[(
1339                "description__niew",
1340                &local_var_str
1341                    .into_iter()
1342                    .map(|p| p.to_string())
1343                    .collect::<Vec<String>>()
1344                    .join(",")
1345                    .to_string(),
1346            )]),
1347        };
1348    }
1349    if let Some(ref local_var_str) = description__nisw {
1350        local_var_req_builder = match "multi" {
1351            "multi" => local_var_req_builder.query(
1352                &local_var_str
1353                    .into_iter()
1354                    .map(|p| ("description__nisw".to_owned(), p.to_string()))
1355                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1356            ),
1357            _ => local_var_req_builder.query(&[(
1358                "description__nisw",
1359                &local_var_str
1360                    .into_iter()
1361                    .map(|p| p.to_string())
1362                    .collect::<Vec<String>>()
1363                    .join(",")
1364                    .to_string(),
1365            )]),
1366        };
1367    }
1368    if let Some(ref local_var_str) = description__regex {
1369        local_var_req_builder = match "multi" {
1370            "multi" => local_var_req_builder.query(
1371                &local_var_str
1372                    .into_iter()
1373                    .map(|p| ("description__regex".to_owned(), p.to_string()))
1374                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1375            ),
1376            _ => local_var_req_builder.query(&[(
1377                "description__regex",
1378                &local_var_str
1379                    .into_iter()
1380                    .map(|p| p.to_string())
1381                    .collect::<Vec<String>>()
1382                    .join(",")
1383                    .to_string(),
1384            )]),
1385        };
1386    }
1387    if let Some(ref local_var_str) = id {
1388        local_var_req_builder = match "multi" {
1389            "multi" => local_var_req_builder.query(
1390                &local_var_str
1391                    .into_iter()
1392                    .map(|p| ("id".to_owned(), p.to_string()))
1393                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1394            ),
1395            _ => local_var_req_builder.query(&[(
1396                "id",
1397                &local_var_str
1398                    .into_iter()
1399                    .map(|p| p.to_string())
1400                    .collect::<Vec<String>>()
1401                    .join(",")
1402                    .to_string(),
1403            )]),
1404        };
1405    }
1406    if let Some(ref local_var_str) = id__empty {
1407        local_var_req_builder =
1408            local_var_req_builder.query(&[("id__empty", &local_var_str.to_string())]);
1409    }
1410    if let Some(ref local_var_str) = id__gt {
1411        local_var_req_builder = match "multi" {
1412            "multi" => local_var_req_builder.query(
1413                &local_var_str
1414                    .into_iter()
1415                    .map(|p| ("id__gt".to_owned(), p.to_string()))
1416                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1417            ),
1418            _ => local_var_req_builder.query(&[(
1419                "id__gt",
1420                &local_var_str
1421                    .into_iter()
1422                    .map(|p| p.to_string())
1423                    .collect::<Vec<String>>()
1424                    .join(",")
1425                    .to_string(),
1426            )]),
1427        };
1428    }
1429    if let Some(ref local_var_str) = id__gte {
1430        local_var_req_builder = match "multi" {
1431            "multi" => local_var_req_builder.query(
1432                &local_var_str
1433                    .into_iter()
1434                    .map(|p| ("id__gte".to_owned(), p.to_string()))
1435                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1436            ),
1437            _ => local_var_req_builder.query(&[(
1438                "id__gte",
1439                &local_var_str
1440                    .into_iter()
1441                    .map(|p| p.to_string())
1442                    .collect::<Vec<String>>()
1443                    .join(",")
1444                    .to_string(),
1445            )]),
1446        };
1447    }
1448    if let Some(ref local_var_str) = id__lt {
1449        local_var_req_builder = match "multi" {
1450            "multi" => local_var_req_builder.query(
1451                &local_var_str
1452                    .into_iter()
1453                    .map(|p| ("id__lt".to_owned(), p.to_string()))
1454                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1455            ),
1456            _ => local_var_req_builder.query(&[(
1457                "id__lt",
1458                &local_var_str
1459                    .into_iter()
1460                    .map(|p| p.to_string())
1461                    .collect::<Vec<String>>()
1462                    .join(",")
1463                    .to_string(),
1464            )]),
1465        };
1466    }
1467    if let Some(ref local_var_str) = id__lte {
1468        local_var_req_builder = match "multi" {
1469            "multi" => local_var_req_builder.query(
1470                &local_var_str
1471                    .into_iter()
1472                    .map(|p| ("id__lte".to_owned(), p.to_string()))
1473                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1474            ),
1475            _ => local_var_req_builder.query(&[(
1476                "id__lte",
1477                &local_var_str
1478                    .into_iter()
1479                    .map(|p| p.to_string())
1480                    .collect::<Vec<String>>()
1481                    .join(",")
1482                    .to_string(),
1483            )]),
1484        };
1485    }
1486    if let Some(ref local_var_str) = id__n {
1487        local_var_req_builder = match "multi" {
1488            "multi" => local_var_req_builder.query(
1489                &local_var_str
1490                    .into_iter()
1491                    .map(|p| ("id__n".to_owned(), p.to_string()))
1492                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1493            ),
1494            _ => local_var_req_builder.query(&[(
1495                "id__n",
1496                &local_var_str
1497                    .into_iter()
1498                    .map(|p| p.to_string())
1499                    .collect::<Vec<String>>()
1500                    .join(",")
1501                    .to_string(),
1502            )]),
1503        };
1504    }
1505    if let Some(ref local_var_str) = ike_proposal {
1506        local_var_req_builder = match "multi" {
1507            "multi" => local_var_req_builder.query(
1508                &local_var_str
1509                    .into_iter()
1510                    .map(|p| ("ike_proposal".to_owned(), p.to_string()))
1511                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1512            ),
1513            _ => local_var_req_builder.query(&[(
1514                "ike_proposal",
1515                &local_var_str
1516                    .into_iter()
1517                    .map(|p| p.to_string())
1518                    .collect::<Vec<String>>()
1519                    .join(",")
1520                    .to_string(),
1521            )]),
1522        };
1523    }
1524    if let Some(ref local_var_str) = ike_proposal__n {
1525        local_var_req_builder = match "multi" {
1526            "multi" => local_var_req_builder.query(
1527                &local_var_str
1528                    .into_iter()
1529                    .map(|p| ("ike_proposal__n".to_owned(), p.to_string()))
1530                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1531            ),
1532            _ => local_var_req_builder.query(&[(
1533                "ike_proposal__n",
1534                &local_var_str
1535                    .into_iter()
1536                    .map(|p| p.to_string())
1537                    .collect::<Vec<String>>()
1538                    .join(",")
1539                    .to_string(),
1540            )]),
1541        };
1542    }
1543    if let Some(ref local_var_str) = ike_proposal_id {
1544        local_var_req_builder = match "multi" {
1545            "multi" => local_var_req_builder.query(
1546                &local_var_str
1547                    .into_iter()
1548                    .map(|p| ("ike_proposal_id".to_owned(), p.to_string()))
1549                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1550            ),
1551            _ => local_var_req_builder.query(&[(
1552                "ike_proposal_id",
1553                &local_var_str
1554                    .into_iter()
1555                    .map(|p| p.to_string())
1556                    .collect::<Vec<String>>()
1557                    .join(",")
1558                    .to_string(),
1559            )]),
1560        };
1561    }
1562    if let Some(ref local_var_str) = ike_proposal_id__n {
1563        local_var_req_builder = match "multi" {
1564            "multi" => local_var_req_builder.query(
1565                &local_var_str
1566                    .into_iter()
1567                    .map(|p| ("ike_proposal_id__n".to_owned(), p.to_string()))
1568                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1569            ),
1570            _ => local_var_req_builder.query(&[(
1571                "ike_proposal_id__n",
1572                &local_var_str
1573                    .into_iter()
1574                    .map(|p| p.to_string())
1575                    .collect::<Vec<String>>()
1576                    .join(",")
1577                    .to_string(),
1578            )]),
1579        };
1580    }
1581    if let Some(ref local_var_str) = last_updated {
1582        local_var_req_builder = match "multi" {
1583            "multi" => local_var_req_builder.query(
1584                &local_var_str
1585                    .into_iter()
1586                    .map(|p| ("last_updated".to_owned(), p.to_string()))
1587                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1588            ),
1589            _ => local_var_req_builder.query(&[(
1590                "last_updated",
1591                &local_var_str
1592                    .into_iter()
1593                    .map(|p| p.to_string())
1594                    .collect::<Vec<String>>()
1595                    .join(",")
1596                    .to_string(),
1597            )]),
1598        };
1599    }
1600    if let Some(ref local_var_str) = last_updated__empty {
1601        local_var_req_builder = match "multi" {
1602            "multi" => local_var_req_builder.query(
1603                &local_var_str
1604                    .into_iter()
1605                    .map(|p| ("last_updated__empty".to_owned(), p.to_string()))
1606                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1607            ),
1608            _ => local_var_req_builder.query(&[(
1609                "last_updated__empty",
1610                &local_var_str
1611                    .into_iter()
1612                    .map(|p| p.to_string())
1613                    .collect::<Vec<String>>()
1614                    .join(",")
1615                    .to_string(),
1616            )]),
1617        };
1618    }
1619    if let Some(ref local_var_str) = last_updated__gt {
1620        local_var_req_builder = match "multi" {
1621            "multi" => local_var_req_builder.query(
1622                &local_var_str
1623                    .into_iter()
1624                    .map(|p| ("last_updated__gt".to_owned(), p.to_string()))
1625                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1626            ),
1627            _ => local_var_req_builder.query(&[(
1628                "last_updated__gt",
1629                &local_var_str
1630                    .into_iter()
1631                    .map(|p| p.to_string())
1632                    .collect::<Vec<String>>()
1633                    .join(",")
1634                    .to_string(),
1635            )]),
1636        };
1637    }
1638    if let Some(ref local_var_str) = last_updated__gte {
1639        local_var_req_builder = match "multi" {
1640            "multi" => local_var_req_builder.query(
1641                &local_var_str
1642                    .into_iter()
1643                    .map(|p| ("last_updated__gte".to_owned(), p.to_string()))
1644                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1645            ),
1646            _ => local_var_req_builder.query(&[(
1647                "last_updated__gte",
1648                &local_var_str
1649                    .into_iter()
1650                    .map(|p| p.to_string())
1651                    .collect::<Vec<String>>()
1652                    .join(",")
1653                    .to_string(),
1654            )]),
1655        };
1656    }
1657    if let Some(ref local_var_str) = last_updated__lt {
1658        local_var_req_builder = match "multi" {
1659            "multi" => local_var_req_builder.query(
1660                &local_var_str
1661                    .into_iter()
1662                    .map(|p| ("last_updated__lt".to_owned(), p.to_string()))
1663                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1664            ),
1665            _ => local_var_req_builder.query(&[(
1666                "last_updated__lt",
1667                &local_var_str
1668                    .into_iter()
1669                    .map(|p| p.to_string())
1670                    .collect::<Vec<String>>()
1671                    .join(",")
1672                    .to_string(),
1673            )]),
1674        };
1675    }
1676    if let Some(ref local_var_str) = last_updated__lte {
1677        local_var_req_builder = match "multi" {
1678            "multi" => local_var_req_builder.query(
1679                &local_var_str
1680                    .into_iter()
1681                    .map(|p| ("last_updated__lte".to_owned(), p.to_string()))
1682                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1683            ),
1684            _ => local_var_req_builder.query(&[(
1685                "last_updated__lte",
1686                &local_var_str
1687                    .into_iter()
1688                    .map(|p| p.to_string())
1689                    .collect::<Vec<String>>()
1690                    .join(",")
1691                    .to_string(),
1692            )]),
1693        };
1694    }
1695    if let Some(ref local_var_str) = last_updated__n {
1696        local_var_req_builder = match "multi" {
1697            "multi" => local_var_req_builder.query(
1698                &local_var_str
1699                    .into_iter()
1700                    .map(|p| ("last_updated__n".to_owned(), p.to_string()))
1701                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1702            ),
1703            _ => local_var_req_builder.query(&[(
1704                "last_updated__n",
1705                &local_var_str
1706                    .into_iter()
1707                    .map(|p| p.to_string())
1708                    .collect::<Vec<String>>()
1709                    .join(",")
1710                    .to_string(),
1711            )]),
1712        };
1713    }
1714    if let Some(ref local_var_str) = limit {
1715        local_var_req_builder =
1716            local_var_req_builder.query(&[("limit", &local_var_str.to_string())]);
1717    }
1718    if let Some(ref local_var_str) = mode {
1719        local_var_req_builder = match "multi" {
1720            "multi" => local_var_req_builder.query(
1721                &local_var_str
1722                    .into_iter()
1723                    .map(|p| ("mode".to_owned(), p.to_string()))
1724                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1725            ),
1726            _ => local_var_req_builder.query(&[(
1727                "mode",
1728                &local_var_str
1729                    .into_iter()
1730                    .map(|p| p.to_string())
1731                    .collect::<Vec<String>>()
1732                    .join(",")
1733                    .to_string(),
1734            )]),
1735        };
1736    }
1737    if let Some(ref local_var_str) = mode__empty {
1738        local_var_req_builder =
1739            local_var_req_builder.query(&[("mode__empty", &local_var_str.to_string())]);
1740    }
1741    if let Some(ref local_var_str) = mode__ic {
1742        local_var_req_builder = match "multi" {
1743            "multi" => local_var_req_builder.query(
1744                &local_var_str
1745                    .into_iter()
1746                    .map(|p| ("mode__ic".to_owned(), p.to_string()))
1747                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1748            ),
1749            _ => local_var_req_builder.query(&[(
1750                "mode__ic",
1751                &local_var_str
1752                    .into_iter()
1753                    .map(|p| p.to_string())
1754                    .collect::<Vec<String>>()
1755                    .join(",")
1756                    .to_string(),
1757            )]),
1758        };
1759    }
1760    if let Some(ref local_var_str) = mode__ie {
1761        local_var_req_builder = match "multi" {
1762            "multi" => local_var_req_builder.query(
1763                &local_var_str
1764                    .into_iter()
1765                    .map(|p| ("mode__ie".to_owned(), p.to_string()))
1766                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1767            ),
1768            _ => local_var_req_builder.query(&[(
1769                "mode__ie",
1770                &local_var_str
1771                    .into_iter()
1772                    .map(|p| p.to_string())
1773                    .collect::<Vec<String>>()
1774                    .join(",")
1775                    .to_string(),
1776            )]),
1777        };
1778    }
1779    if let Some(ref local_var_str) = mode__iew {
1780        local_var_req_builder = match "multi" {
1781            "multi" => local_var_req_builder.query(
1782                &local_var_str
1783                    .into_iter()
1784                    .map(|p| ("mode__iew".to_owned(), p.to_string()))
1785                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1786            ),
1787            _ => local_var_req_builder.query(&[(
1788                "mode__iew",
1789                &local_var_str
1790                    .into_iter()
1791                    .map(|p| p.to_string())
1792                    .collect::<Vec<String>>()
1793                    .join(",")
1794                    .to_string(),
1795            )]),
1796        };
1797    }
1798    if let Some(ref local_var_str) = mode__iregex {
1799        local_var_req_builder = match "multi" {
1800            "multi" => local_var_req_builder.query(
1801                &local_var_str
1802                    .into_iter()
1803                    .map(|p| ("mode__iregex".to_owned(), p.to_string()))
1804                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1805            ),
1806            _ => local_var_req_builder.query(&[(
1807                "mode__iregex",
1808                &local_var_str
1809                    .into_iter()
1810                    .map(|p| p.to_string())
1811                    .collect::<Vec<String>>()
1812                    .join(",")
1813                    .to_string(),
1814            )]),
1815        };
1816    }
1817    if let Some(ref local_var_str) = mode__isw {
1818        local_var_req_builder = match "multi" {
1819            "multi" => local_var_req_builder.query(
1820                &local_var_str
1821                    .into_iter()
1822                    .map(|p| ("mode__isw".to_owned(), p.to_string()))
1823                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1824            ),
1825            _ => local_var_req_builder.query(&[(
1826                "mode__isw",
1827                &local_var_str
1828                    .into_iter()
1829                    .map(|p| p.to_string())
1830                    .collect::<Vec<String>>()
1831                    .join(",")
1832                    .to_string(),
1833            )]),
1834        };
1835    }
1836    if let Some(ref local_var_str) = mode__n {
1837        local_var_req_builder = match "multi" {
1838            "multi" => local_var_req_builder.query(
1839                &local_var_str
1840                    .into_iter()
1841                    .map(|p| ("mode__n".to_owned(), p.to_string()))
1842                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1843            ),
1844            _ => local_var_req_builder.query(&[(
1845                "mode__n",
1846                &local_var_str
1847                    .into_iter()
1848                    .map(|p| p.to_string())
1849                    .collect::<Vec<String>>()
1850                    .join(",")
1851                    .to_string(),
1852            )]),
1853        };
1854    }
1855    if let Some(ref local_var_str) = mode__nic {
1856        local_var_req_builder = match "multi" {
1857            "multi" => local_var_req_builder.query(
1858                &local_var_str
1859                    .into_iter()
1860                    .map(|p| ("mode__nic".to_owned(), p.to_string()))
1861                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1862            ),
1863            _ => local_var_req_builder.query(&[(
1864                "mode__nic",
1865                &local_var_str
1866                    .into_iter()
1867                    .map(|p| p.to_string())
1868                    .collect::<Vec<String>>()
1869                    .join(",")
1870                    .to_string(),
1871            )]),
1872        };
1873    }
1874    if let Some(ref local_var_str) = mode__nie {
1875        local_var_req_builder = match "multi" {
1876            "multi" => local_var_req_builder.query(
1877                &local_var_str
1878                    .into_iter()
1879                    .map(|p| ("mode__nie".to_owned(), p.to_string()))
1880                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1881            ),
1882            _ => local_var_req_builder.query(&[(
1883                "mode__nie",
1884                &local_var_str
1885                    .into_iter()
1886                    .map(|p| p.to_string())
1887                    .collect::<Vec<String>>()
1888                    .join(",")
1889                    .to_string(),
1890            )]),
1891        };
1892    }
1893    if let Some(ref local_var_str) = mode__niew {
1894        local_var_req_builder = match "multi" {
1895            "multi" => local_var_req_builder.query(
1896                &local_var_str
1897                    .into_iter()
1898                    .map(|p| ("mode__niew".to_owned(), p.to_string()))
1899                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1900            ),
1901            _ => local_var_req_builder.query(&[(
1902                "mode__niew",
1903                &local_var_str
1904                    .into_iter()
1905                    .map(|p| p.to_string())
1906                    .collect::<Vec<String>>()
1907                    .join(",")
1908                    .to_string(),
1909            )]),
1910        };
1911    }
1912    if let Some(ref local_var_str) = mode__nisw {
1913        local_var_req_builder = match "multi" {
1914            "multi" => local_var_req_builder.query(
1915                &local_var_str
1916                    .into_iter()
1917                    .map(|p| ("mode__nisw".to_owned(), p.to_string()))
1918                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1919            ),
1920            _ => local_var_req_builder.query(&[(
1921                "mode__nisw",
1922                &local_var_str
1923                    .into_iter()
1924                    .map(|p| p.to_string())
1925                    .collect::<Vec<String>>()
1926                    .join(",")
1927                    .to_string(),
1928            )]),
1929        };
1930    }
1931    if let Some(ref local_var_str) = mode__regex {
1932        local_var_req_builder = match "multi" {
1933            "multi" => local_var_req_builder.query(
1934                &local_var_str
1935                    .into_iter()
1936                    .map(|p| ("mode__regex".to_owned(), p.to_string()))
1937                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1938            ),
1939            _ => local_var_req_builder.query(&[(
1940                "mode__regex",
1941                &local_var_str
1942                    .into_iter()
1943                    .map(|p| p.to_string())
1944                    .collect::<Vec<String>>()
1945                    .join(",")
1946                    .to_string(),
1947            )]),
1948        };
1949    }
1950    if let Some(ref local_var_str) = modified_by_request {
1951        local_var_req_builder =
1952            local_var_req_builder.query(&[("modified_by_request", &local_var_str.to_string())]);
1953    }
1954    if let Some(ref local_var_str) = name {
1955        local_var_req_builder = match "multi" {
1956            "multi" => local_var_req_builder.query(
1957                &local_var_str
1958                    .into_iter()
1959                    .map(|p| ("name".to_owned(), p.to_string()))
1960                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1961            ),
1962            _ => local_var_req_builder.query(&[(
1963                "name",
1964                &local_var_str
1965                    .into_iter()
1966                    .map(|p| p.to_string())
1967                    .collect::<Vec<String>>()
1968                    .join(",")
1969                    .to_string(),
1970            )]),
1971        };
1972    }
1973    if let Some(ref local_var_str) = name__empty {
1974        local_var_req_builder =
1975            local_var_req_builder.query(&[("name__empty", &local_var_str.to_string())]);
1976    }
1977    if let Some(ref local_var_str) = name__ic {
1978        local_var_req_builder = match "multi" {
1979            "multi" => local_var_req_builder.query(
1980                &local_var_str
1981                    .into_iter()
1982                    .map(|p| ("name__ic".to_owned(), p.to_string()))
1983                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1984            ),
1985            _ => local_var_req_builder.query(&[(
1986                "name__ic",
1987                &local_var_str
1988                    .into_iter()
1989                    .map(|p| p.to_string())
1990                    .collect::<Vec<String>>()
1991                    .join(",")
1992                    .to_string(),
1993            )]),
1994        };
1995    }
1996    if let Some(ref local_var_str) = name__ie {
1997        local_var_req_builder = match "multi" {
1998            "multi" => local_var_req_builder.query(
1999                &local_var_str
2000                    .into_iter()
2001                    .map(|p| ("name__ie".to_owned(), p.to_string()))
2002                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2003            ),
2004            _ => local_var_req_builder.query(&[(
2005                "name__ie",
2006                &local_var_str
2007                    .into_iter()
2008                    .map(|p| p.to_string())
2009                    .collect::<Vec<String>>()
2010                    .join(",")
2011                    .to_string(),
2012            )]),
2013        };
2014    }
2015    if let Some(ref local_var_str) = name__iew {
2016        local_var_req_builder = match "multi" {
2017            "multi" => local_var_req_builder.query(
2018                &local_var_str
2019                    .into_iter()
2020                    .map(|p| ("name__iew".to_owned(), p.to_string()))
2021                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2022            ),
2023            _ => local_var_req_builder.query(&[(
2024                "name__iew",
2025                &local_var_str
2026                    .into_iter()
2027                    .map(|p| p.to_string())
2028                    .collect::<Vec<String>>()
2029                    .join(",")
2030                    .to_string(),
2031            )]),
2032        };
2033    }
2034    if let Some(ref local_var_str) = name__iregex {
2035        local_var_req_builder = match "multi" {
2036            "multi" => local_var_req_builder.query(
2037                &local_var_str
2038                    .into_iter()
2039                    .map(|p| ("name__iregex".to_owned(), p.to_string()))
2040                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2041            ),
2042            _ => local_var_req_builder.query(&[(
2043                "name__iregex",
2044                &local_var_str
2045                    .into_iter()
2046                    .map(|p| p.to_string())
2047                    .collect::<Vec<String>>()
2048                    .join(",")
2049                    .to_string(),
2050            )]),
2051        };
2052    }
2053    if let Some(ref local_var_str) = name__isw {
2054        local_var_req_builder = match "multi" {
2055            "multi" => local_var_req_builder.query(
2056                &local_var_str
2057                    .into_iter()
2058                    .map(|p| ("name__isw".to_owned(), p.to_string()))
2059                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2060            ),
2061            _ => local_var_req_builder.query(&[(
2062                "name__isw",
2063                &local_var_str
2064                    .into_iter()
2065                    .map(|p| p.to_string())
2066                    .collect::<Vec<String>>()
2067                    .join(",")
2068                    .to_string(),
2069            )]),
2070        };
2071    }
2072    if let Some(ref local_var_str) = name__n {
2073        local_var_req_builder = match "multi" {
2074            "multi" => local_var_req_builder.query(
2075                &local_var_str
2076                    .into_iter()
2077                    .map(|p| ("name__n".to_owned(), p.to_string()))
2078                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2079            ),
2080            _ => local_var_req_builder.query(&[(
2081                "name__n",
2082                &local_var_str
2083                    .into_iter()
2084                    .map(|p| p.to_string())
2085                    .collect::<Vec<String>>()
2086                    .join(",")
2087                    .to_string(),
2088            )]),
2089        };
2090    }
2091    if let Some(ref local_var_str) = name__nic {
2092        local_var_req_builder = match "multi" {
2093            "multi" => local_var_req_builder.query(
2094                &local_var_str
2095                    .into_iter()
2096                    .map(|p| ("name__nic".to_owned(), p.to_string()))
2097                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2098            ),
2099            _ => local_var_req_builder.query(&[(
2100                "name__nic",
2101                &local_var_str
2102                    .into_iter()
2103                    .map(|p| p.to_string())
2104                    .collect::<Vec<String>>()
2105                    .join(",")
2106                    .to_string(),
2107            )]),
2108        };
2109    }
2110    if let Some(ref local_var_str) = name__nie {
2111        local_var_req_builder = match "multi" {
2112            "multi" => local_var_req_builder.query(
2113                &local_var_str
2114                    .into_iter()
2115                    .map(|p| ("name__nie".to_owned(), p.to_string()))
2116                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2117            ),
2118            _ => local_var_req_builder.query(&[(
2119                "name__nie",
2120                &local_var_str
2121                    .into_iter()
2122                    .map(|p| p.to_string())
2123                    .collect::<Vec<String>>()
2124                    .join(",")
2125                    .to_string(),
2126            )]),
2127        };
2128    }
2129    if let Some(ref local_var_str) = name__niew {
2130        local_var_req_builder = match "multi" {
2131            "multi" => local_var_req_builder.query(
2132                &local_var_str
2133                    .into_iter()
2134                    .map(|p| ("name__niew".to_owned(), p.to_string()))
2135                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2136            ),
2137            _ => local_var_req_builder.query(&[(
2138                "name__niew",
2139                &local_var_str
2140                    .into_iter()
2141                    .map(|p| p.to_string())
2142                    .collect::<Vec<String>>()
2143                    .join(",")
2144                    .to_string(),
2145            )]),
2146        };
2147    }
2148    if let Some(ref local_var_str) = name__nisw {
2149        local_var_req_builder = match "multi" {
2150            "multi" => local_var_req_builder.query(
2151                &local_var_str
2152                    .into_iter()
2153                    .map(|p| ("name__nisw".to_owned(), p.to_string()))
2154                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2155            ),
2156            _ => local_var_req_builder.query(&[(
2157                "name__nisw",
2158                &local_var_str
2159                    .into_iter()
2160                    .map(|p| p.to_string())
2161                    .collect::<Vec<String>>()
2162                    .join(",")
2163                    .to_string(),
2164            )]),
2165        };
2166    }
2167    if let Some(ref local_var_str) = name__regex {
2168        local_var_req_builder = match "multi" {
2169            "multi" => local_var_req_builder.query(
2170                &local_var_str
2171                    .into_iter()
2172                    .map(|p| ("name__regex".to_owned(), p.to_string()))
2173                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2174            ),
2175            _ => local_var_req_builder.query(&[(
2176                "name__regex",
2177                &local_var_str
2178                    .into_iter()
2179                    .map(|p| p.to_string())
2180                    .collect::<Vec<String>>()
2181                    .join(",")
2182                    .to_string(),
2183            )]),
2184        };
2185    }
2186    if let Some(ref local_var_str) = offset {
2187        local_var_req_builder =
2188            local_var_req_builder.query(&[("offset", &local_var_str.to_string())]);
2189    }
2190    if let Some(ref local_var_str) = ordering {
2191        local_var_req_builder =
2192            local_var_req_builder.query(&[("ordering", &local_var_str.to_string())]);
2193    }
2194    if let Some(ref local_var_str) = owner {
2195        local_var_req_builder = match "multi" {
2196            "multi" => local_var_req_builder.query(
2197                &local_var_str
2198                    .into_iter()
2199                    .map(|p| ("owner".to_owned(), p.to_string()))
2200                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2201            ),
2202            _ => local_var_req_builder.query(&[(
2203                "owner",
2204                &local_var_str
2205                    .into_iter()
2206                    .map(|p| p.to_string())
2207                    .collect::<Vec<String>>()
2208                    .join(",")
2209                    .to_string(),
2210            )]),
2211        };
2212    }
2213    if let Some(ref local_var_str) = owner__n {
2214        local_var_req_builder = match "multi" {
2215            "multi" => local_var_req_builder.query(
2216                &local_var_str
2217                    .into_iter()
2218                    .map(|p| ("owner__n".to_owned(), p.to_string()))
2219                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2220            ),
2221            _ => local_var_req_builder.query(&[(
2222                "owner__n",
2223                &local_var_str
2224                    .into_iter()
2225                    .map(|p| p.to_string())
2226                    .collect::<Vec<String>>()
2227                    .join(",")
2228                    .to_string(),
2229            )]),
2230        };
2231    }
2232    if let Some(ref local_var_str) = owner_group {
2233        local_var_req_builder = match "multi" {
2234            "multi" => local_var_req_builder.query(
2235                &local_var_str
2236                    .into_iter()
2237                    .map(|p| ("owner_group".to_owned(), p.to_string()))
2238                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2239            ),
2240            _ => local_var_req_builder.query(&[(
2241                "owner_group",
2242                &local_var_str
2243                    .into_iter()
2244                    .map(|p| p.to_string())
2245                    .collect::<Vec<String>>()
2246                    .join(",")
2247                    .to_string(),
2248            )]),
2249        };
2250    }
2251    if let Some(ref local_var_str) = owner_group__n {
2252        local_var_req_builder = match "multi" {
2253            "multi" => local_var_req_builder.query(
2254                &local_var_str
2255                    .into_iter()
2256                    .map(|p| ("owner_group__n".to_owned(), p.to_string()))
2257                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2258            ),
2259            _ => local_var_req_builder.query(&[(
2260                "owner_group__n",
2261                &local_var_str
2262                    .into_iter()
2263                    .map(|p| p.to_string())
2264                    .collect::<Vec<String>>()
2265                    .join(",")
2266                    .to_string(),
2267            )]),
2268        };
2269    }
2270    if let Some(ref local_var_str) = owner_group_id {
2271        local_var_req_builder = match "multi" {
2272            "multi" => local_var_req_builder.query(
2273                &local_var_str
2274                    .into_iter()
2275                    .map(|p| ("owner_group_id".to_owned(), p.to_string()))
2276                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2277            ),
2278            _ => local_var_req_builder.query(&[(
2279                "owner_group_id",
2280                &local_var_str
2281                    .into_iter()
2282                    .map(|p| p.to_string())
2283                    .collect::<Vec<String>>()
2284                    .join(",")
2285                    .to_string(),
2286            )]),
2287        };
2288    }
2289    if let Some(ref local_var_str) = owner_group_id__n {
2290        local_var_req_builder = match "multi" {
2291            "multi" => local_var_req_builder.query(
2292                &local_var_str
2293                    .into_iter()
2294                    .map(|p| ("owner_group_id__n".to_owned(), p.to_string()))
2295                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2296            ),
2297            _ => local_var_req_builder.query(&[(
2298                "owner_group_id__n",
2299                &local_var_str
2300                    .into_iter()
2301                    .map(|p| p.to_string())
2302                    .collect::<Vec<String>>()
2303                    .join(",")
2304                    .to_string(),
2305            )]),
2306        };
2307    }
2308    if let Some(ref local_var_str) = owner_id {
2309        local_var_req_builder = match "multi" {
2310            "multi" => local_var_req_builder.query(
2311                &local_var_str
2312                    .into_iter()
2313                    .map(|p| ("owner_id".to_owned(), p.to_string()))
2314                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2315            ),
2316            _ => local_var_req_builder.query(&[(
2317                "owner_id",
2318                &local_var_str
2319                    .into_iter()
2320                    .map(|p| p.to_string())
2321                    .collect::<Vec<String>>()
2322                    .join(",")
2323                    .to_string(),
2324            )]),
2325        };
2326    }
2327    if let Some(ref local_var_str) = owner_id__n {
2328        local_var_req_builder = match "multi" {
2329            "multi" => local_var_req_builder.query(
2330                &local_var_str
2331                    .into_iter()
2332                    .map(|p| ("owner_id__n".to_owned(), p.to_string()))
2333                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2334            ),
2335            _ => local_var_req_builder.query(&[(
2336                "owner_id__n",
2337                &local_var_str
2338                    .into_iter()
2339                    .map(|p| p.to_string())
2340                    .collect::<Vec<String>>()
2341                    .join(",")
2342                    .to_string(),
2343            )]),
2344        };
2345    }
2346    if let Some(ref local_var_str) = preshared_key {
2347        local_var_req_builder =
2348            local_var_req_builder.query(&[("preshared_key", &local_var_str.to_string())]);
2349    }
2350    if let Some(ref local_var_str) = preshared_key__ic {
2351        local_var_req_builder =
2352            local_var_req_builder.query(&[("preshared_key__ic", &local_var_str.to_string())]);
2353    }
2354    if let Some(ref local_var_str) = preshared_key__ie {
2355        local_var_req_builder =
2356            local_var_req_builder.query(&[("preshared_key__ie", &local_var_str.to_string())]);
2357    }
2358    if let Some(ref local_var_str) = preshared_key__iew {
2359        local_var_req_builder =
2360            local_var_req_builder.query(&[("preshared_key__iew", &local_var_str.to_string())]);
2361    }
2362    if let Some(ref local_var_str) = preshared_key__iregex {
2363        local_var_req_builder =
2364            local_var_req_builder.query(&[("preshared_key__iregex", &local_var_str.to_string())]);
2365    }
2366    if let Some(ref local_var_str) = preshared_key__isw {
2367        local_var_req_builder =
2368            local_var_req_builder.query(&[("preshared_key__isw", &local_var_str.to_string())]);
2369    }
2370    if let Some(ref local_var_str) = preshared_key__n {
2371        local_var_req_builder =
2372            local_var_req_builder.query(&[("preshared_key__n", &local_var_str.to_string())]);
2373    }
2374    if let Some(ref local_var_str) = preshared_key__nic {
2375        local_var_req_builder =
2376            local_var_req_builder.query(&[("preshared_key__nic", &local_var_str.to_string())]);
2377    }
2378    if let Some(ref local_var_str) = preshared_key__nie {
2379        local_var_req_builder =
2380            local_var_req_builder.query(&[("preshared_key__nie", &local_var_str.to_string())]);
2381    }
2382    if let Some(ref local_var_str) = preshared_key__niew {
2383        local_var_req_builder =
2384            local_var_req_builder.query(&[("preshared_key__niew", &local_var_str.to_string())]);
2385    }
2386    if let Some(ref local_var_str) = preshared_key__nisw {
2387        local_var_req_builder =
2388            local_var_req_builder.query(&[("preshared_key__nisw", &local_var_str.to_string())]);
2389    }
2390    if let Some(ref local_var_str) = preshared_key__regex {
2391        local_var_req_builder =
2392            local_var_req_builder.query(&[("preshared_key__regex", &local_var_str.to_string())]);
2393    }
2394    if let Some(ref local_var_str) = q {
2395        local_var_req_builder = local_var_req_builder.query(&[("q", &local_var_str.to_string())]);
2396    }
2397    if let Some(ref local_var_str) = tag {
2398        local_var_req_builder = match "multi" {
2399            "multi" => local_var_req_builder.query(
2400                &local_var_str
2401                    .into_iter()
2402                    .map(|p| ("tag".to_owned(), p.to_string()))
2403                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2404            ),
2405            _ => local_var_req_builder.query(&[(
2406                "tag",
2407                &local_var_str
2408                    .into_iter()
2409                    .map(|p| p.to_string())
2410                    .collect::<Vec<String>>()
2411                    .join(",")
2412                    .to_string(),
2413            )]),
2414        };
2415    }
2416    if let Some(ref local_var_str) = tag__n {
2417        local_var_req_builder = match "multi" {
2418            "multi" => local_var_req_builder.query(
2419                &local_var_str
2420                    .into_iter()
2421                    .map(|p| ("tag__n".to_owned(), p.to_string()))
2422                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2423            ),
2424            _ => local_var_req_builder.query(&[(
2425                "tag__n",
2426                &local_var_str
2427                    .into_iter()
2428                    .map(|p| p.to_string())
2429                    .collect::<Vec<String>>()
2430                    .join(",")
2431                    .to_string(),
2432            )]),
2433        };
2434    }
2435    if let Some(ref local_var_str) = tag_id {
2436        local_var_req_builder = match "multi" {
2437            "multi" => local_var_req_builder.query(
2438                &local_var_str
2439                    .into_iter()
2440                    .map(|p| ("tag_id".to_owned(), p.to_string()))
2441                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2442            ),
2443            _ => local_var_req_builder.query(&[(
2444                "tag_id",
2445                &local_var_str
2446                    .into_iter()
2447                    .map(|p| p.to_string())
2448                    .collect::<Vec<String>>()
2449                    .join(",")
2450                    .to_string(),
2451            )]),
2452        };
2453    }
2454    if let Some(ref local_var_str) = tag_id__n {
2455        local_var_req_builder = match "multi" {
2456            "multi" => local_var_req_builder.query(
2457                &local_var_str
2458                    .into_iter()
2459                    .map(|p| ("tag_id__n".to_owned(), p.to_string()))
2460                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2461            ),
2462            _ => local_var_req_builder.query(&[(
2463                "tag_id__n",
2464                &local_var_str
2465                    .into_iter()
2466                    .map(|p| p.to_string())
2467                    .collect::<Vec<String>>()
2468                    .join(",")
2469                    .to_string(),
2470            )]),
2471        };
2472    }
2473    if let Some(ref local_var_str) = updated_by_request {
2474        local_var_req_builder =
2475            local_var_req_builder.query(&[("updated_by_request", &local_var_str.to_string())]);
2476    }
2477    if let Some(ref local_var_str) = version {
2478        local_var_req_builder = match "multi" {
2479            "multi" => local_var_req_builder.query(
2480                &local_var_str
2481                    .into_iter()
2482                    .map(|p| ("version".to_owned(), p.to_string()))
2483                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2484            ),
2485            _ => local_var_req_builder.query(&[(
2486                "version",
2487                &local_var_str
2488                    .into_iter()
2489                    .map(|p| p.to_string())
2490                    .collect::<Vec<String>>()
2491                    .join(",")
2492                    .to_string(),
2493            )]),
2494        };
2495    }
2496    if let Some(ref local_var_str) = version__ic {
2497        local_var_req_builder = match "multi" {
2498            "multi" => local_var_req_builder.query(
2499                &local_var_str
2500                    .into_iter()
2501                    .map(|p| ("version__ic".to_owned(), p.to_string()))
2502                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2503            ),
2504            _ => local_var_req_builder.query(&[(
2505                "version__ic",
2506                &local_var_str
2507                    .into_iter()
2508                    .map(|p| p.to_string())
2509                    .collect::<Vec<String>>()
2510                    .join(",")
2511                    .to_string(),
2512            )]),
2513        };
2514    }
2515    if let Some(ref local_var_str) = version__ie {
2516        local_var_req_builder = match "multi" {
2517            "multi" => local_var_req_builder.query(
2518                &local_var_str
2519                    .into_iter()
2520                    .map(|p| ("version__ie".to_owned(), p.to_string()))
2521                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2522            ),
2523            _ => local_var_req_builder.query(&[(
2524                "version__ie",
2525                &local_var_str
2526                    .into_iter()
2527                    .map(|p| p.to_string())
2528                    .collect::<Vec<String>>()
2529                    .join(",")
2530                    .to_string(),
2531            )]),
2532        };
2533    }
2534    if let Some(ref local_var_str) = version__iew {
2535        local_var_req_builder = match "multi" {
2536            "multi" => local_var_req_builder.query(
2537                &local_var_str
2538                    .into_iter()
2539                    .map(|p| ("version__iew".to_owned(), p.to_string()))
2540                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2541            ),
2542            _ => local_var_req_builder.query(&[(
2543                "version__iew",
2544                &local_var_str
2545                    .into_iter()
2546                    .map(|p| p.to_string())
2547                    .collect::<Vec<String>>()
2548                    .join(",")
2549                    .to_string(),
2550            )]),
2551        };
2552    }
2553    if let Some(ref local_var_str) = version__iregex {
2554        local_var_req_builder = match "multi" {
2555            "multi" => local_var_req_builder.query(
2556                &local_var_str
2557                    .into_iter()
2558                    .map(|p| ("version__iregex".to_owned(), p.to_string()))
2559                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2560            ),
2561            _ => local_var_req_builder.query(&[(
2562                "version__iregex",
2563                &local_var_str
2564                    .into_iter()
2565                    .map(|p| p.to_string())
2566                    .collect::<Vec<String>>()
2567                    .join(",")
2568                    .to_string(),
2569            )]),
2570        };
2571    }
2572    if let Some(ref local_var_str) = version__isw {
2573        local_var_req_builder = match "multi" {
2574            "multi" => local_var_req_builder.query(
2575                &local_var_str
2576                    .into_iter()
2577                    .map(|p| ("version__isw".to_owned(), p.to_string()))
2578                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2579            ),
2580            _ => local_var_req_builder.query(&[(
2581                "version__isw",
2582                &local_var_str
2583                    .into_iter()
2584                    .map(|p| p.to_string())
2585                    .collect::<Vec<String>>()
2586                    .join(",")
2587                    .to_string(),
2588            )]),
2589        };
2590    }
2591    if let Some(ref local_var_str) = version__n {
2592        local_var_req_builder = match "multi" {
2593            "multi" => local_var_req_builder.query(
2594                &local_var_str
2595                    .into_iter()
2596                    .map(|p| ("version__n".to_owned(), p.to_string()))
2597                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2598            ),
2599            _ => local_var_req_builder.query(&[(
2600                "version__n",
2601                &local_var_str
2602                    .into_iter()
2603                    .map(|p| p.to_string())
2604                    .collect::<Vec<String>>()
2605                    .join(",")
2606                    .to_string(),
2607            )]),
2608        };
2609    }
2610    if let Some(ref local_var_str) = version__nic {
2611        local_var_req_builder = match "multi" {
2612            "multi" => local_var_req_builder.query(
2613                &local_var_str
2614                    .into_iter()
2615                    .map(|p| ("version__nic".to_owned(), p.to_string()))
2616                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2617            ),
2618            _ => local_var_req_builder.query(&[(
2619                "version__nic",
2620                &local_var_str
2621                    .into_iter()
2622                    .map(|p| p.to_string())
2623                    .collect::<Vec<String>>()
2624                    .join(",")
2625                    .to_string(),
2626            )]),
2627        };
2628    }
2629    if let Some(ref local_var_str) = version__nie {
2630        local_var_req_builder = match "multi" {
2631            "multi" => local_var_req_builder.query(
2632                &local_var_str
2633                    .into_iter()
2634                    .map(|p| ("version__nie".to_owned(), p.to_string()))
2635                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2636            ),
2637            _ => local_var_req_builder.query(&[(
2638                "version__nie",
2639                &local_var_str
2640                    .into_iter()
2641                    .map(|p| p.to_string())
2642                    .collect::<Vec<String>>()
2643                    .join(",")
2644                    .to_string(),
2645            )]),
2646        };
2647    }
2648    if let Some(ref local_var_str) = version__niew {
2649        local_var_req_builder = match "multi" {
2650            "multi" => local_var_req_builder.query(
2651                &local_var_str
2652                    .into_iter()
2653                    .map(|p| ("version__niew".to_owned(), p.to_string()))
2654                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2655            ),
2656            _ => local_var_req_builder.query(&[(
2657                "version__niew",
2658                &local_var_str
2659                    .into_iter()
2660                    .map(|p| p.to_string())
2661                    .collect::<Vec<String>>()
2662                    .join(",")
2663                    .to_string(),
2664            )]),
2665        };
2666    }
2667    if let Some(ref local_var_str) = version__nisw {
2668        local_var_req_builder = match "multi" {
2669            "multi" => local_var_req_builder.query(
2670                &local_var_str
2671                    .into_iter()
2672                    .map(|p| ("version__nisw".to_owned(), p.to_string()))
2673                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2674            ),
2675            _ => local_var_req_builder.query(&[(
2676                "version__nisw",
2677                &local_var_str
2678                    .into_iter()
2679                    .map(|p| p.to_string())
2680                    .collect::<Vec<String>>()
2681                    .join(",")
2682                    .to_string(),
2683            )]),
2684        };
2685    }
2686    if let Some(ref local_var_str) = version__regex {
2687        local_var_req_builder = match "multi" {
2688            "multi" => local_var_req_builder.query(
2689                &local_var_str
2690                    .into_iter()
2691                    .map(|p| ("version__regex".to_owned(), p.to_string()))
2692                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2693            ),
2694            _ => local_var_req_builder.query(&[(
2695                "version__regex",
2696                &local_var_str
2697                    .into_iter()
2698                    .map(|p| p.to_string())
2699                    .collect::<Vec<String>>()
2700                    .join(",")
2701                    .to_string(),
2702            )]),
2703        };
2704    }
2705    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
2706        local_var_req_builder =
2707            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
2708    }
2709    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
2710        let local_var_key = local_var_apikey.key.clone();
2711        let local_var_value = match local_var_apikey.prefix {
2712            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
2713            None => local_var_key,
2714        };
2715        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
2716    };
2717
2718    let local_var_req = local_var_req_builder.build()?;
2719    let local_var_resp = local_var_client.execute(local_var_req).await?;
2720
2721    let local_var_status = local_var_resp.status();
2722    let local_var_content = local_var_resp.text().await?;
2723
2724    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
2725        serde_json::from_str(&local_var_content).map_err(Error::from)
2726    } else {
2727        let local_var_entity: Option<VpnIkePoliciesListError> =
2728            serde_json::from_str(&local_var_content).ok();
2729        let local_var_error = ResponseContent {
2730            status: local_var_status,
2731            content: local_var_content,
2732            entity: local_var_entity,
2733        };
2734        Err(Error::ResponseError(local_var_error))
2735    }
2736}
2737
2738/// Patch a IKE policy object.
2739pub async fn vpn_ike_policies_partial_update(
2740    configuration: &configuration::Configuration,
2741    id: i32,
2742    patched_writable_ike_policy_request: Option<crate::models::PatchedWritableIkePolicyRequest>,
2743) -> Result<crate::models::IkePolicy, Error<VpnIkePoliciesPartialUpdateError>> {
2744    let local_var_configuration = configuration;
2745
2746    let local_var_client = &local_var_configuration.client;
2747
2748    let local_var_uri_str = format!(
2749        "{}/api/vpn/ike-policies/{id}/",
2750        local_var_configuration.base_path,
2751        id = id
2752    );
2753    let mut local_var_req_builder =
2754        local_var_client.request(reqwest::Method::PATCH, local_var_uri_str.as_str());
2755
2756    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
2757        local_var_req_builder =
2758            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
2759    }
2760    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
2761        let local_var_key = local_var_apikey.key.clone();
2762        let local_var_value = match local_var_apikey.prefix {
2763            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
2764            None => local_var_key,
2765        };
2766        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
2767    };
2768    local_var_req_builder = local_var_req_builder.json(&patched_writable_ike_policy_request);
2769
2770    let local_var_req = local_var_req_builder.build()?;
2771    let local_var_resp = local_var_client.execute(local_var_req).await?;
2772
2773    let local_var_status = local_var_resp.status();
2774    let local_var_content = local_var_resp.text().await?;
2775
2776    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
2777        serde_json::from_str(&local_var_content).map_err(Error::from)
2778    } else {
2779        let local_var_entity: Option<VpnIkePoliciesPartialUpdateError> =
2780            serde_json::from_str(&local_var_content).ok();
2781        let local_var_error = ResponseContent {
2782            status: local_var_status,
2783            content: local_var_content,
2784            entity: local_var_entity,
2785        };
2786        Err(Error::ResponseError(local_var_error))
2787    }
2788}
2789
2790/// Get a IKE policy object.
2791pub async fn vpn_ike_policies_retrieve(
2792    configuration: &configuration::Configuration,
2793    id: i32,
2794) -> Result<crate::models::IkePolicy, Error<VpnIkePoliciesRetrieveError>> {
2795    let local_var_configuration = configuration;
2796
2797    let local_var_client = &local_var_configuration.client;
2798
2799    let local_var_uri_str = format!(
2800        "{}/api/vpn/ike-policies/{id}/",
2801        local_var_configuration.base_path,
2802        id = id
2803    );
2804    let mut local_var_req_builder =
2805        local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
2806
2807    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
2808        local_var_req_builder =
2809            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
2810    }
2811    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
2812        let local_var_key = local_var_apikey.key.clone();
2813        let local_var_value = match local_var_apikey.prefix {
2814            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
2815            None => local_var_key,
2816        };
2817        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
2818    };
2819
2820    let local_var_req = local_var_req_builder.build()?;
2821    let local_var_resp = local_var_client.execute(local_var_req).await?;
2822
2823    let local_var_status = local_var_resp.status();
2824    let local_var_content = local_var_resp.text().await?;
2825
2826    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
2827        serde_json::from_str(&local_var_content).map_err(Error::from)
2828    } else {
2829        let local_var_entity: Option<VpnIkePoliciesRetrieveError> =
2830            serde_json::from_str(&local_var_content).ok();
2831        let local_var_error = ResponseContent {
2832            status: local_var_status,
2833            content: local_var_content,
2834            entity: local_var_entity,
2835        };
2836        Err(Error::ResponseError(local_var_error))
2837    }
2838}
2839
2840/// Put a IKE policy object.
2841pub async fn vpn_ike_policies_update(
2842    configuration: &configuration::Configuration,
2843    id: i32,
2844    writable_ike_policy_request: crate::models::WritableIkePolicyRequest,
2845) -> Result<crate::models::IkePolicy, Error<VpnIkePoliciesUpdateError>> {
2846    let local_var_configuration = configuration;
2847
2848    let local_var_client = &local_var_configuration.client;
2849
2850    let local_var_uri_str = format!(
2851        "{}/api/vpn/ike-policies/{id}/",
2852        local_var_configuration.base_path,
2853        id = id
2854    );
2855    let mut local_var_req_builder =
2856        local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());
2857
2858    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
2859        local_var_req_builder =
2860            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
2861    }
2862    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
2863        let local_var_key = local_var_apikey.key.clone();
2864        let local_var_value = match local_var_apikey.prefix {
2865            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
2866            None => local_var_key,
2867        };
2868        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
2869    };
2870    local_var_req_builder = local_var_req_builder.json(&writable_ike_policy_request);
2871
2872    let local_var_req = local_var_req_builder.build()?;
2873    let local_var_resp = local_var_client.execute(local_var_req).await?;
2874
2875    let local_var_status = local_var_resp.status();
2876    let local_var_content = local_var_resp.text().await?;
2877
2878    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
2879        serde_json::from_str(&local_var_content).map_err(Error::from)
2880    } else {
2881        let local_var_entity: Option<VpnIkePoliciesUpdateError> =
2882            serde_json::from_str(&local_var_content).ok();
2883        let local_var_error = ResponseContent {
2884            status: local_var_status,
2885            content: local_var_content,
2886            entity: local_var_entity,
2887        };
2888        Err(Error::ResponseError(local_var_error))
2889    }
2890}
2891
2892/// Delete a list of IKE proposal objects.
2893pub async fn vpn_ike_proposals_bulk_destroy(
2894    configuration: &configuration::Configuration,
2895    ike_proposal_request: Vec<crate::models::IkeProposalRequest>,
2896) -> Result<(), Error<VpnIkeProposalsBulkDestroyError>> {
2897    let local_var_configuration = configuration;
2898
2899    let local_var_client = &local_var_configuration.client;
2900
2901    let local_var_uri_str = format!(
2902        "{}/api/vpn/ike-proposals/",
2903        local_var_configuration.base_path
2904    );
2905    let mut local_var_req_builder =
2906        local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());
2907
2908    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
2909        local_var_req_builder =
2910            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
2911    }
2912    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
2913        let local_var_key = local_var_apikey.key.clone();
2914        let local_var_value = match local_var_apikey.prefix {
2915            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
2916            None => local_var_key,
2917        };
2918        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
2919    };
2920    local_var_req_builder = local_var_req_builder.json(&ike_proposal_request);
2921
2922    let local_var_req = local_var_req_builder.build()?;
2923    let local_var_resp = local_var_client.execute(local_var_req).await?;
2924
2925    let local_var_status = local_var_resp.status();
2926    let local_var_content = local_var_resp.text().await?;
2927
2928    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
2929        Ok(())
2930    } else {
2931        let local_var_entity: Option<VpnIkeProposalsBulkDestroyError> =
2932            serde_json::from_str(&local_var_content).ok();
2933        let local_var_error = ResponseContent {
2934            status: local_var_status,
2935            content: local_var_content,
2936            entity: local_var_entity,
2937        };
2938        Err(Error::ResponseError(local_var_error))
2939    }
2940}
2941
2942/// Patch a list of IKE proposal objects.
2943pub async fn vpn_ike_proposals_bulk_partial_update(
2944    configuration: &configuration::Configuration,
2945    ike_proposal_request: Vec<crate::models::IkeProposalRequest>,
2946) -> Result<Vec<crate::models::IkeProposal>, Error<VpnIkeProposalsBulkPartialUpdateError>> {
2947    let local_var_configuration = configuration;
2948
2949    let local_var_client = &local_var_configuration.client;
2950
2951    let local_var_uri_str = format!(
2952        "{}/api/vpn/ike-proposals/",
2953        local_var_configuration.base_path
2954    );
2955    let mut local_var_req_builder =
2956        local_var_client.request(reqwest::Method::PATCH, local_var_uri_str.as_str());
2957
2958    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
2959        local_var_req_builder =
2960            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
2961    }
2962    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
2963        let local_var_key = local_var_apikey.key.clone();
2964        let local_var_value = match local_var_apikey.prefix {
2965            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
2966            None => local_var_key,
2967        };
2968        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
2969    };
2970    local_var_req_builder = local_var_req_builder.json(&ike_proposal_request);
2971
2972    let local_var_req = local_var_req_builder.build()?;
2973    let local_var_resp = local_var_client.execute(local_var_req).await?;
2974
2975    let local_var_status = local_var_resp.status();
2976    let local_var_content = local_var_resp.text().await?;
2977
2978    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
2979        serde_json::from_str(&local_var_content).map_err(Error::from)
2980    } else {
2981        let local_var_entity: Option<VpnIkeProposalsBulkPartialUpdateError> =
2982            serde_json::from_str(&local_var_content).ok();
2983        let local_var_error = ResponseContent {
2984            status: local_var_status,
2985            content: local_var_content,
2986            entity: local_var_entity,
2987        };
2988        Err(Error::ResponseError(local_var_error))
2989    }
2990}
2991
2992/// Put a list of IKE proposal objects.
2993pub async fn vpn_ike_proposals_bulk_update(
2994    configuration: &configuration::Configuration,
2995    ike_proposal_request: Vec<crate::models::IkeProposalRequest>,
2996) -> Result<Vec<crate::models::IkeProposal>, Error<VpnIkeProposalsBulkUpdateError>> {
2997    let local_var_configuration = configuration;
2998
2999    let local_var_client = &local_var_configuration.client;
3000
3001    let local_var_uri_str = format!(
3002        "{}/api/vpn/ike-proposals/",
3003        local_var_configuration.base_path
3004    );
3005    let mut local_var_req_builder =
3006        local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());
3007
3008    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
3009        local_var_req_builder =
3010            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
3011    }
3012    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
3013        let local_var_key = local_var_apikey.key.clone();
3014        let local_var_value = match local_var_apikey.prefix {
3015            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
3016            None => local_var_key,
3017        };
3018        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
3019    };
3020    local_var_req_builder = local_var_req_builder.json(&ike_proposal_request);
3021
3022    let local_var_req = local_var_req_builder.build()?;
3023    let local_var_resp = local_var_client.execute(local_var_req).await?;
3024
3025    let local_var_status = local_var_resp.status();
3026    let local_var_content = local_var_resp.text().await?;
3027
3028    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
3029        serde_json::from_str(&local_var_content).map_err(Error::from)
3030    } else {
3031        let local_var_entity: Option<VpnIkeProposalsBulkUpdateError> =
3032            serde_json::from_str(&local_var_content).ok();
3033        let local_var_error = ResponseContent {
3034            status: local_var_status,
3035            content: local_var_content,
3036            entity: local_var_entity,
3037        };
3038        Err(Error::ResponseError(local_var_error))
3039    }
3040}
3041
3042/// Post a list of IKE proposal objects.
3043pub async fn vpn_ike_proposals_create(
3044    configuration: &configuration::Configuration,
3045    vpn_ike_proposals_create_request: crate::models::VpnIkeProposalsCreateRequest,
3046) -> Result<crate::models::IkeProposal, Error<VpnIkeProposalsCreateError>> {
3047    let local_var_configuration = configuration;
3048
3049    let local_var_client = &local_var_configuration.client;
3050
3051    let local_var_uri_str = format!(
3052        "{}/api/vpn/ike-proposals/",
3053        local_var_configuration.base_path
3054    );
3055    let mut local_var_req_builder =
3056        local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
3057
3058    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
3059        local_var_req_builder =
3060            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
3061    }
3062    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
3063        let local_var_key = local_var_apikey.key.clone();
3064        let local_var_value = match local_var_apikey.prefix {
3065            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
3066            None => local_var_key,
3067        };
3068        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
3069    };
3070    local_var_req_builder = local_var_req_builder.json(&vpn_ike_proposals_create_request);
3071
3072    let local_var_req = local_var_req_builder.build()?;
3073    let local_var_resp = local_var_client.execute(local_var_req).await?;
3074
3075    let local_var_status = local_var_resp.status();
3076    let local_var_content = local_var_resp.text().await?;
3077
3078    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
3079        serde_json::from_str(&local_var_content).map_err(Error::from)
3080    } else {
3081        let local_var_entity: Option<VpnIkeProposalsCreateError> =
3082            serde_json::from_str(&local_var_content).ok();
3083        let local_var_error = ResponseContent {
3084            status: local_var_status,
3085            content: local_var_content,
3086            entity: local_var_entity,
3087        };
3088        Err(Error::ResponseError(local_var_error))
3089    }
3090}
3091
3092/// Delete a IKE proposal object.
3093pub async fn vpn_ike_proposals_destroy(
3094    configuration: &configuration::Configuration,
3095    id: i32,
3096) -> Result<(), Error<VpnIkeProposalsDestroyError>> {
3097    let local_var_configuration = configuration;
3098
3099    let local_var_client = &local_var_configuration.client;
3100
3101    let local_var_uri_str = format!(
3102        "{}/api/vpn/ike-proposals/{id}/",
3103        local_var_configuration.base_path,
3104        id = id
3105    );
3106    let mut local_var_req_builder =
3107        local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());
3108
3109    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
3110        local_var_req_builder =
3111            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
3112    }
3113    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
3114        let local_var_key = local_var_apikey.key.clone();
3115        let local_var_value = match local_var_apikey.prefix {
3116            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
3117            None => local_var_key,
3118        };
3119        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
3120    };
3121
3122    let local_var_req = local_var_req_builder.build()?;
3123    let local_var_resp = local_var_client.execute(local_var_req).await?;
3124
3125    let local_var_status = local_var_resp.status();
3126    let local_var_content = local_var_resp.text().await?;
3127
3128    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
3129        Ok(())
3130    } else {
3131        let local_var_entity: Option<VpnIkeProposalsDestroyError> =
3132            serde_json::from_str(&local_var_content).ok();
3133        let local_var_error = ResponseContent {
3134            status: local_var_status,
3135            content: local_var_content,
3136            entity: local_var_entity,
3137        };
3138        Err(Error::ResponseError(local_var_error))
3139    }
3140}
3141
3142/// Get a list of IKE proposal objects.
3143pub async fn vpn_ike_proposals_list(
3144    configuration: &configuration::Configuration,
3145    authentication_algorithm: Option<Vec<String>>,
3146    authentication_algorithm__empty: Option<bool>,
3147    authentication_algorithm__ic: Option<Vec<String>>,
3148    authentication_algorithm__ie: Option<Vec<String>>,
3149    authentication_algorithm__iew: Option<Vec<String>>,
3150    authentication_algorithm__iregex: Option<Vec<String>>,
3151    authentication_algorithm__isw: Option<Vec<String>>,
3152    authentication_algorithm__n: Option<Vec<String>>,
3153    authentication_algorithm__nic: Option<Vec<String>>,
3154    authentication_algorithm__nie: Option<Vec<String>>,
3155    authentication_algorithm__niew: Option<Vec<String>>,
3156    authentication_algorithm__nisw: Option<Vec<String>>,
3157    authentication_algorithm__regex: Option<Vec<String>>,
3158    authentication_method: Option<Vec<String>>,
3159    authentication_method__empty: Option<bool>,
3160    authentication_method__ic: Option<Vec<String>>,
3161    authentication_method__ie: Option<Vec<String>>,
3162    authentication_method__iew: Option<Vec<String>>,
3163    authentication_method__iregex: Option<Vec<String>>,
3164    authentication_method__isw: Option<Vec<String>>,
3165    authentication_method__n: Option<Vec<String>>,
3166    authentication_method__nic: Option<Vec<String>>,
3167    authentication_method__nie: Option<Vec<String>>,
3168    authentication_method__niew: Option<Vec<String>>,
3169    authentication_method__nisw: Option<Vec<String>>,
3170    authentication_method__regex: Option<Vec<String>>,
3171    created: Option<Vec<String>>,
3172    created__empty: Option<Vec<String>>,
3173    created__gt: Option<Vec<String>>,
3174    created__gte: Option<Vec<String>>,
3175    created__lt: Option<Vec<String>>,
3176    created__lte: Option<Vec<String>>,
3177    created__n: Option<Vec<String>>,
3178    created_by_request: Option<&str>,
3179    description: Option<Vec<String>>,
3180    description__empty: Option<bool>,
3181    description__ic: Option<Vec<String>>,
3182    description__ie: Option<Vec<String>>,
3183    description__iew: Option<Vec<String>>,
3184    description__iregex: Option<Vec<String>>,
3185    description__isw: Option<Vec<String>>,
3186    description__n: Option<Vec<String>>,
3187    description__nic: Option<Vec<String>>,
3188    description__nie: Option<Vec<String>>,
3189    description__niew: Option<Vec<String>>,
3190    description__nisw: Option<Vec<String>>,
3191    description__regex: Option<Vec<String>>,
3192    encryption_algorithm: Option<Vec<String>>,
3193    encryption_algorithm__empty: Option<bool>,
3194    encryption_algorithm__ic: Option<Vec<String>>,
3195    encryption_algorithm__ie: Option<Vec<String>>,
3196    encryption_algorithm__iew: Option<Vec<String>>,
3197    encryption_algorithm__iregex: Option<Vec<String>>,
3198    encryption_algorithm__isw: Option<Vec<String>>,
3199    encryption_algorithm__n: Option<Vec<String>>,
3200    encryption_algorithm__nic: Option<Vec<String>>,
3201    encryption_algorithm__nie: Option<Vec<String>>,
3202    encryption_algorithm__niew: Option<Vec<String>>,
3203    encryption_algorithm__nisw: Option<Vec<String>>,
3204    encryption_algorithm__regex: Option<Vec<String>>,
3205    group: Option<Vec<i32>>,
3206    group__ic: Option<Vec<i32>>,
3207    group__ie: Option<Vec<i32>>,
3208    group__iew: Option<Vec<i32>>,
3209    group__iregex: Option<Vec<i32>>,
3210    group__isw: Option<Vec<i32>>,
3211    group__n: Option<Vec<i32>>,
3212    group__nic: Option<Vec<i32>>,
3213    group__nie: Option<Vec<i32>>,
3214    group__niew: Option<Vec<i32>>,
3215    group__nisw: Option<Vec<i32>>,
3216    group__regex: Option<Vec<i32>>,
3217    id: Option<Vec<i32>>,
3218    id__empty: Option<bool>,
3219    id__gt: Option<Vec<i32>>,
3220    id__gte: Option<Vec<i32>>,
3221    id__lt: Option<Vec<i32>>,
3222    id__lte: Option<Vec<i32>>,
3223    id__n: Option<Vec<i32>>,
3224    ike_policy: Option<Vec<String>>,
3225    ike_policy__n: Option<Vec<String>>,
3226    ike_policy_id: Option<Vec<i32>>,
3227    ike_policy_id__n: Option<Vec<i32>>,
3228    last_updated: Option<Vec<String>>,
3229    last_updated__empty: Option<Vec<String>>,
3230    last_updated__gt: Option<Vec<String>>,
3231    last_updated__gte: Option<Vec<String>>,
3232    last_updated__lt: Option<Vec<String>>,
3233    last_updated__lte: Option<Vec<String>>,
3234    last_updated__n: Option<Vec<String>>,
3235    limit: Option<i32>,
3236    modified_by_request: Option<&str>,
3237    name: Option<Vec<String>>,
3238    name__empty: Option<bool>,
3239    name__ic: Option<Vec<String>>,
3240    name__ie: Option<Vec<String>>,
3241    name__iew: Option<Vec<String>>,
3242    name__iregex: Option<Vec<String>>,
3243    name__isw: Option<Vec<String>>,
3244    name__n: Option<Vec<String>>,
3245    name__nic: Option<Vec<String>>,
3246    name__nie: Option<Vec<String>>,
3247    name__niew: Option<Vec<String>>,
3248    name__nisw: Option<Vec<String>>,
3249    name__regex: Option<Vec<String>>,
3250    offset: Option<i32>,
3251    ordering: Option<&str>,
3252    owner: Option<Vec<String>>,
3253    owner__n: Option<Vec<String>>,
3254    owner_group: Option<Vec<String>>,
3255    owner_group__n: Option<Vec<String>>,
3256    owner_group_id: Option<Vec<i32>>,
3257    owner_group_id__n: Option<Vec<i32>>,
3258    owner_id: Option<Vec<i32>>,
3259    owner_id__n: Option<Vec<i32>>,
3260    q: Option<&str>,
3261    sa_lifetime: Option<Vec<i32>>,
3262    sa_lifetime__empty: Option<bool>,
3263    sa_lifetime__gt: Option<Vec<i32>>,
3264    sa_lifetime__gte: Option<Vec<i32>>,
3265    sa_lifetime__lt: Option<Vec<i32>>,
3266    sa_lifetime__lte: Option<Vec<i32>>,
3267    sa_lifetime__n: Option<Vec<i32>>,
3268    tag: Option<Vec<String>>,
3269    tag__n: Option<Vec<String>>,
3270    tag_id: Option<Vec<i32>>,
3271    tag_id__n: Option<Vec<i32>>,
3272    updated_by_request: Option<&str>,
3273) -> Result<crate::models::PaginatedIkeProposalList, Error<VpnIkeProposalsListError>> {
3274    let local_var_configuration = configuration;
3275
3276    let local_var_client = &local_var_configuration.client;
3277
3278    let local_var_uri_str = format!(
3279        "{}/api/vpn/ike-proposals/",
3280        local_var_configuration.base_path
3281    );
3282    let mut local_var_req_builder =
3283        local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
3284
3285    if let Some(ref local_var_str) = authentication_algorithm {
3286        local_var_req_builder = match "multi" {
3287            "multi" => local_var_req_builder.query(
3288                &local_var_str
3289                    .into_iter()
3290                    .map(|p| ("authentication_algorithm".to_owned(), p.to_string()))
3291                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3292            ),
3293            _ => local_var_req_builder.query(&[(
3294                "authentication_algorithm",
3295                &local_var_str
3296                    .into_iter()
3297                    .map(|p| p.to_string())
3298                    .collect::<Vec<String>>()
3299                    .join(",")
3300                    .to_string(),
3301            )]),
3302        };
3303    }
3304    if let Some(ref local_var_str) = authentication_algorithm__empty {
3305        local_var_req_builder = local_var_req_builder.query(&[(
3306            "authentication_algorithm__empty",
3307            &local_var_str.to_string(),
3308        )]);
3309    }
3310    if let Some(ref local_var_str) = authentication_algorithm__ic {
3311        local_var_req_builder = match "multi" {
3312            "multi" => local_var_req_builder.query(
3313                &local_var_str
3314                    .into_iter()
3315                    .map(|p| ("authentication_algorithm__ic".to_owned(), p.to_string()))
3316                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3317            ),
3318            _ => local_var_req_builder.query(&[(
3319                "authentication_algorithm__ic",
3320                &local_var_str
3321                    .into_iter()
3322                    .map(|p| p.to_string())
3323                    .collect::<Vec<String>>()
3324                    .join(",")
3325                    .to_string(),
3326            )]),
3327        };
3328    }
3329    if let Some(ref local_var_str) = authentication_algorithm__ie {
3330        local_var_req_builder = match "multi" {
3331            "multi" => local_var_req_builder.query(
3332                &local_var_str
3333                    .into_iter()
3334                    .map(|p| ("authentication_algorithm__ie".to_owned(), p.to_string()))
3335                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3336            ),
3337            _ => local_var_req_builder.query(&[(
3338                "authentication_algorithm__ie",
3339                &local_var_str
3340                    .into_iter()
3341                    .map(|p| p.to_string())
3342                    .collect::<Vec<String>>()
3343                    .join(",")
3344                    .to_string(),
3345            )]),
3346        };
3347    }
3348    if let Some(ref local_var_str) = authentication_algorithm__iew {
3349        local_var_req_builder = match "multi" {
3350            "multi" => local_var_req_builder.query(
3351                &local_var_str
3352                    .into_iter()
3353                    .map(|p| ("authentication_algorithm__iew".to_owned(), p.to_string()))
3354                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3355            ),
3356            _ => local_var_req_builder.query(&[(
3357                "authentication_algorithm__iew",
3358                &local_var_str
3359                    .into_iter()
3360                    .map(|p| p.to_string())
3361                    .collect::<Vec<String>>()
3362                    .join(",")
3363                    .to_string(),
3364            )]),
3365        };
3366    }
3367    if let Some(ref local_var_str) = authentication_algorithm__iregex {
3368        local_var_req_builder = match "multi" {
3369            "multi" => local_var_req_builder.query(
3370                &local_var_str
3371                    .into_iter()
3372                    .map(|p| ("authentication_algorithm__iregex".to_owned(), p.to_string()))
3373                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3374            ),
3375            _ => local_var_req_builder.query(&[(
3376                "authentication_algorithm__iregex",
3377                &local_var_str
3378                    .into_iter()
3379                    .map(|p| p.to_string())
3380                    .collect::<Vec<String>>()
3381                    .join(",")
3382                    .to_string(),
3383            )]),
3384        };
3385    }
3386    if let Some(ref local_var_str) = authentication_algorithm__isw {
3387        local_var_req_builder = match "multi" {
3388            "multi" => local_var_req_builder.query(
3389                &local_var_str
3390                    .into_iter()
3391                    .map(|p| ("authentication_algorithm__isw".to_owned(), p.to_string()))
3392                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3393            ),
3394            _ => local_var_req_builder.query(&[(
3395                "authentication_algorithm__isw",
3396                &local_var_str
3397                    .into_iter()
3398                    .map(|p| p.to_string())
3399                    .collect::<Vec<String>>()
3400                    .join(",")
3401                    .to_string(),
3402            )]),
3403        };
3404    }
3405    if let Some(ref local_var_str) = authentication_algorithm__n {
3406        local_var_req_builder = match "multi" {
3407            "multi" => local_var_req_builder.query(
3408                &local_var_str
3409                    .into_iter()
3410                    .map(|p| ("authentication_algorithm__n".to_owned(), p.to_string()))
3411                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3412            ),
3413            _ => local_var_req_builder.query(&[(
3414                "authentication_algorithm__n",
3415                &local_var_str
3416                    .into_iter()
3417                    .map(|p| p.to_string())
3418                    .collect::<Vec<String>>()
3419                    .join(",")
3420                    .to_string(),
3421            )]),
3422        };
3423    }
3424    if let Some(ref local_var_str) = authentication_algorithm__nic {
3425        local_var_req_builder = match "multi" {
3426            "multi" => local_var_req_builder.query(
3427                &local_var_str
3428                    .into_iter()
3429                    .map(|p| ("authentication_algorithm__nic".to_owned(), p.to_string()))
3430                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3431            ),
3432            _ => local_var_req_builder.query(&[(
3433                "authentication_algorithm__nic",
3434                &local_var_str
3435                    .into_iter()
3436                    .map(|p| p.to_string())
3437                    .collect::<Vec<String>>()
3438                    .join(",")
3439                    .to_string(),
3440            )]),
3441        };
3442    }
3443    if let Some(ref local_var_str) = authentication_algorithm__nie {
3444        local_var_req_builder = match "multi" {
3445            "multi" => local_var_req_builder.query(
3446                &local_var_str
3447                    .into_iter()
3448                    .map(|p| ("authentication_algorithm__nie".to_owned(), p.to_string()))
3449                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3450            ),
3451            _ => local_var_req_builder.query(&[(
3452                "authentication_algorithm__nie",
3453                &local_var_str
3454                    .into_iter()
3455                    .map(|p| p.to_string())
3456                    .collect::<Vec<String>>()
3457                    .join(",")
3458                    .to_string(),
3459            )]),
3460        };
3461    }
3462    if let Some(ref local_var_str) = authentication_algorithm__niew {
3463        local_var_req_builder = match "multi" {
3464            "multi" => local_var_req_builder.query(
3465                &local_var_str
3466                    .into_iter()
3467                    .map(|p| ("authentication_algorithm__niew".to_owned(), p.to_string()))
3468                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3469            ),
3470            _ => local_var_req_builder.query(&[(
3471                "authentication_algorithm__niew",
3472                &local_var_str
3473                    .into_iter()
3474                    .map(|p| p.to_string())
3475                    .collect::<Vec<String>>()
3476                    .join(",")
3477                    .to_string(),
3478            )]),
3479        };
3480    }
3481    if let Some(ref local_var_str) = authentication_algorithm__nisw {
3482        local_var_req_builder = match "multi" {
3483            "multi" => local_var_req_builder.query(
3484                &local_var_str
3485                    .into_iter()
3486                    .map(|p| ("authentication_algorithm__nisw".to_owned(), p.to_string()))
3487                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3488            ),
3489            _ => local_var_req_builder.query(&[(
3490                "authentication_algorithm__nisw",
3491                &local_var_str
3492                    .into_iter()
3493                    .map(|p| p.to_string())
3494                    .collect::<Vec<String>>()
3495                    .join(",")
3496                    .to_string(),
3497            )]),
3498        };
3499    }
3500    if let Some(ref local_var_str) = authentication_algorithm__regex {
3501        local_var_req_builder = match "multi" {
3502            "multi" => local_var_req_builder.query(
3503                &local_var_str
3504                    .into_iter()
3505                    .map(|p| ("authentication_algorithm__regex".to_owned(), p.to_string()))
3506                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3507            ),
3508            _ => local_var_req_builder.query(&[(
3509                "authentication_algorithm__regex",
3510                &local_var_str
3511                    .into_iter()
3512                    .map(|p| p.to_string())
3513                    .collect::<Vec<String>>()
3514                    .join(",")
3515                    .to_string(),
3516            )]),
3517        };
3518    }
3519    if let Some(ref local_var_str) = authentication_method {
3520        local_var_req_builder = match "multi" {
3521            "multi" => local_var_req_builder.query(
3522                &local_var_str
3523                    .into_iter()
3524                    .map(|p| ("authentication_method".to_owned(), p.to_string()))
3525                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3526            ),
3527            _ => local_var_req_builder.query(&[(
3528                "authentication_method",
3529                &local_var_str
3530                    .into_iter()
3531                    .map(|p| p.to_string())
3532                    .collect::<Vec<String>>()
3533                    .join(",")
3534                    .to_string(),
3535            )]),
3536        };
3537    }
3538    if let Some(ref local_var_str) = authentication_method__empty {
3539        local_var_req_builder = local_var_req_builder
3540            .query(&[("authentication_method__empty", &local_var_str.to_string())]);
3541    }
3542    if let Some(ref local_var_str) = authentication_method__ic {
3543        local_var_req_builder = match "multi" {
3544            "multi" => local_var_req_builder.query(
3545                &local_var_str
3546                    .into_iter()
3547                    .map(|p| ("authentication_method__ic".to_owned(), p.to_string()))
3548                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3549            ),
3550            _ => local_var_req_builder.query(&[(
3551                "authentication_method__ic",
3552                &local_var_str
3553                    .into_iter()
3554                    .map(|p| p.to_string())
3555                    .collect::<Vec<String>>()
3556                    .join(",")
3557                    .to_string(),
3558            )]),
3559        };
3560    }
3561    if let Some(ref local_var_str) = authentication_method__ie {
3562        local_var_req_builder = match "multi" {
3563            "multi" => local_var_req_builder.query(
3564                &local_var_str
3565                    .into_iter()
3566                    .map(|p| ("authentication_method__ie".to_owned(), p.to_string()))
3567                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3568            ),
3569            _ => local_var_req_builder.query(&[(
3570                "authentication_method__ie",
3571                &local_var_str
3572                    .into_iter()
3573                    .map(|p| p.to_string())
3574                    .collect::<Vec<String>>()
3575                    .join(",")
3576                    .to_string(),
3577            )]),
3578        };
3579    }
3580    if let Some(ref local_var_str) = authentication_method__iew {
3581        local_var_req_builder = match "multi" {
3582            "multi" => local_var_req_builder.query(
3583                &local_var_str
3584                    .into_iter()
3585                    .map(|p| ("authentication_method__iew".to_owned(), p.to_string()))
3586                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3587            ),
3588            _ => local_var_req_builder.query(&[(
3589                "authentication_method__iew",
3590                &local_var_str
3591                    .into_iter()
3592                    .map(|p| p.to_string())
3593                    .collect::<Vec<String>>()
3594                    .join(",")
3595                    .to_string(),
3596            )]),
3597        };
3598    }
3599    if let Some(ref local_var_str) = authentication_method__iregex {
3600        local_var_req_builder = match "multi" {
3601            "multi" => local_var_req_builder.query(
3602                &local_var_str
3603                    .into_iter()
3604                    .map(|p| ("authentication_method__iregex".to_owned(), p.to_string()))
3605                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3606            ),
3607            _ => local_var_req_builder.query(&[(
3608                "authentication_method__iregex",
3609                &local_var_str
3610                    .into_iter()
3611                    .map(|p| p.to_string())
3612                    .collect::<Vec<String>>()
3613                    .join(",")
3614                    .to_string(),
3615            )]),
3616        };
3617    }
3618    if let Some(ref local_var_str) = authentication_method__isw {
3619        local_var_req_builder = match "multi" {
3620            "multi" => local_var_req_builder.query(
3621                &local_var_str
3622                    .into_iter()
3623                    .map(|p| ("authentication_method__isw".to_owned(), p.to_string()))
3624                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3625            ),
3626            _ => local_var_req_builder.query(&[(
3627                "authentication_method__isw",
3628                &local_var_str
3629                    .into_iter()
3630                    .map(|p| p.to_string())
3631                    .collect::<Vec<String>>()
3632                    .join(",")
3633                    .to_string(),
3634            )]),
3635        };
3636    }
3637    if let Some(ref local_var_str) = authentication_method__n {
3638        local_var_req_builder = match "multi" {
3639            "multi" => local_var_req_builder.query(
3640                &local_var_str
3641                    .into_iter()
3642                    .map(|p| ("authentication_method__n".to_owned(), p.to_string()))
3643                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3644            ),
3645            _ => local_var_req_builder.query(&[(
3646                "authentication_method__n",
3647                &local_var_str
3648                    .into_iter()
3649                    .map(|p| p.to_string())
3650                    .collect::<Vec<String>>()
3651                    .join(",")
3652                    .to_string(),
3653            )]),
3654        };
3655    }
3656    if let Some(ref local_var_str) = authentication_method__nic {
3657        local_var_req_builder = match "multi" {
3658            "multi" => local_var_req_builder.query(
3659                &local_var_str
3660                    .into_iter()
3661                    .map(|p| ("authentication_method__nic".to_owned(), p.to_string()))
3662                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3663            ),
3664            _ => local_var_req_builder.query(&[(
3665                "authentication_method__nic",
3666                &local_var_str
3667                    .into_iter()
3668                    .map(|p| p.to_string())
3669                    .collect::<Vec<String>>()
3670                    .join(",")
3671                    .to_string(),
3672            )]),
3673        };
3674    }
3675    if let Some(ref local_var_str) = authentication_method__nie {
3676        local_var_req_builder = match "multi" {
3677            "multi" => local_var_req_builder.query(
3678                &local_var_str
3679                    .into_iter()
3680                    .map(|p| ("authentication_method__nie".to_owned(), p.to_string()))
3681                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3682            ),
3683            _ => local_var_req_builder.query(&[(
3684                "authentication_method__nie",
3685                &local_var_str
3686                    .into_iter()
3687                    .map(|p| p.to_string())
3688                    .collect::<Vec<String>>()
3689                    .join(",")
3690                    .to_string(),
3691            )]),
3692        };
3693    }
3694    if let Some(ref local_var_str) = authentication_method__niew {
3695        local_var_req_builder = match "multi" {
3696            "multi" => local_var_req_builder.query(
3697                &local_var_str
3698                    .into_iter()
3699                    .map(|p| ("authentication_method__niew".to_owned(), p.to_string()))
3700                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3701            ),
3702            _ => local_var_req_builder.query(&[(
3703                "authentication_method__niew",
3704                &local_var_str
3705                    .into_iter()
3706                    .map(|p| p.to_string())
3707                    .collect::<Vec<String>>()
3708                    .join(",")
3709                    .to_string(),
3710            )]),
3711        };
3712    }
3713    if let Some(ref local_var_str) = authentication_method__nisw {
3714        local_var_req_builder = match "multi" {
3715            "multi" => local_var_req_builder.query(
3716                &local_var_str
3717                    .into_iter()
3718                    .map(|p| ("authentication_method__nisw".to_owned(), p.to_string()))
3719                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3720            ),
3721            _ => local_var_req_builder.query(&[(
3722                "authentication_method__nisw",
3723                &local_var_str
3724                    .into_iter()
3725                    .map(|p| p.to_string())
3726                    .collect::<Vec<String>>()
3727                    .join(",")
3728                    .to_string(),
3729            )]),
3730        };
3731    }
3732    if let Some(ref local_var_str) = authentication_method__regex {
3733        local_var_req_builder = match "multi" {
3734            "multi" => local_var_req_builder.query(
3735                &local_var_str
3736                    .into_iter()
3737                    .map(|p| ("authentication_method__regex".to_owned(), p.to_string()))
3738                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3739            ),
3740            _ => local_var_req_builder.query(&[(
3741                "authentication_method__regex",
3742                &local_var_str
3743                    .into_iter()
3744                    .map(|p| p.to_string())
3745                    .collect::<Vec<String>>()
3746                    .join(",")
3747                    .to_string(),
3748            )]),
3749        };
3750    }
3751    if let Some(ref local_var_str) = created {
3752        local_var_req_builder = match "multi" {
3753            "multi" => local_var_req_builder.query(
3754                &local_var_str
3755                    .into_iter()
3756                    .map(|p| ("created".to_owned(), p.to_string()))
3757                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3758            ),
3759            _ => local_var_req_builder.query(&[(
3760                "created",
3761                &local_var_str
3762                    .into_iter()
3763                    .map(|p| p.to_string())
3764                    .collect::<Vec<String>>()
3765                    .join(",")
3766                    .to_string(),
3767            )]),
3768        };
3769    }
3770    if let Some(ref local_var_str) = created__empty {
3771        local_var_req_builder = match "multi" {
3772            "multi" => local_var_req_builder.query(
3773                &local_var_str
3774                    .into_iter()
3775                    .map(|p| ("created__empty".to_owned(), p.to_string()))
3776                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3777            ),
3778            _ => local_var_req_builder.query(&[(
3779                "created__empty",
3780                &local_var_str
3781                    .into_iter()
3782                    .map(|p| p.to_string())
3783                    .collect::<Vec<String>>()
3784                    .join(",")
3785                    .to_string(),
3786            )]),
3787        };
3788    }
3789    if let Some(ref local_var_str) = created__gt {
3790        local_var_req_builder = match "multi" {
3791            "multi" => local_var_req_builder.query(
3792                &local_var_str
3793                    .into_iter()
3794                    .map(|p| ("created__gt".to_owned(), p.to_string()))
3795                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3796            ),
3797            _ => local_var_req_builder.query(&[(
3798                "created__gt",
3799                &local_var_str
3800                    .into_iter()
3801                    .map(|p| p.to_string())
3802                    .collect::<Vec<String>>()
3803                    .join(",")
3804                    .to_string(),
3805            )]),
3806        };
3807    }
3808    if let Some(ref local_var_str) = created__gte {
3809        local_var_req_builder = match "multi" {
3810            "multi" => local_var_req_builder.query(
3811                &local_var_str
3812                    .into_iter()
3813                    .map(|p| ("created__gte".to_owned(), p.to_string()))
3814                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3815            ),
3816            _ => local_var_req_builder.query(&[(
3817                "created__gte",
3818                &local_var_str
3819                    .into_iter()
3820                    .map(|p| p.to_string())
3821                    .collect::<Vec<String>>()
3822                    .join(",")
3823                    .to_string(),
3824            )]),
3825        };
3826    }
3827    if let Some(ref local_var_str) = created__lt {
3828        local_var_req_builder = match "multi" {
3829            "multi" => local_var_req_builder.query(
3830                &local_var_str
3831                    .into_iter()
3832                    .map(|p| ("created__lt".to_owned(), p.to_string()))
3833                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3834            ),
3835            _ => local_var_req_builder.query(&[(
3836                "created__lt",
3837                &local_var_str
3838                    .into_iter()
3839                    .map(|p| p.to_string())
3840                    .collect::<Vec<String>>()
3841                    .join(",")
3842                    .to_string(),
3843            )]),
3844        };
3845    }
3846    if let Some(ref local_var_str) = created__lte {
3847        local_var_req_builder = match "multi" {
3848            "multi" => local_var_req_builder.query(
3849                &local_var_str
3850                    .into_iter()
3851                    .map(|p| ("created__lte".to_owned(), p.to_string()))
3852                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3853            ),
3854            _ => local_var_req_builder.query(&[(
3855                "created__lte",
3856                &local_var_str
3857                    .into_iter()
3858                    .map(|p| p.to_string())
3859                    .collect::<Vec<String>>()
3860                    .join(",")
3861                    .to_string(),
3862            )]),
3863        };
3864    }
3865    if let Some(ref local_var_str) = created__n {
3866        local_var_req_builder = match "multi" {
3867            "multi" => local_var_req_builder.query(
3868                &local_var_str
3869                    .into_iter()
3870                    .map(|p| ("created__n".to_owned(), p.to_string()))
3871                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3872            ),
3873            _ => local_var_req_builder.query(&[(
3874                "created__n",
3875                &local_var_str
3876                    .into_iter()
3877                    .map(|p| p.to_string())
3878                    .collect::<Vec<String>>()
3879                    .join(",")
3880                    .to_string(),
3881            )]),
3882        };
3883    }
3884    if let Some(ref local_var_str) = created_by_request {
3885        local_var_req_builder =
3886            local_var_req_builder.query(&[("created_by_request", &local_var_str.to_string())]);
3887    }
3888    if let Some(ref local_var_str) = description {
3889        local_var_req_builder = match "multi" {
3890            "multi" => local_var_req_builder.query(
3891                &local_var_str
3892                    .into_iter()
3893                    .map(|p| ("description".to_owned(), p.to_string()))
3894                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3895            ),
3896            _ => local_var_req_builder.query(&[(
3897                "description",
3898                &local_var_str
3899                    .into_iter()
3900                    .map(|p| p.to_string())
3901                    .collect::<Vec<String>>()
3902                    .join(",")
3903                    .to_string(),
3904            )]),
3905        };
3906    }
3907    if let Some(ref local_var_str) = description__empty {
3908        local_var_req_builder =
3909            local_var_req_builder.query(&[("description__empty", &local_var_str.to_string())]);
3910    }
3911    if let Some(ref local_var_str) = description__ic {
3912        local_var_req_builder = match "multi" {
3913            "multi" => local_var_req_builder.query(
3914                &local_var_str
3915                    .into_iter()
3916                    .map(|p| ("description__ic".to_owned(), p.to_string()))
3917                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3918            ),
3919            _ => local_var_req_builder.query(&[(
3920                "description__ic",
3921                &local_var_str
3922                    .into_iter()
3923                    .map(|p| p.to_string())
3924                    .collect::<Vec<String>>()
3925                    .join(",")
3926                    .to_string(),
3927            )]),
3928        };
3929    }
3930    if let Some(ref local_var_str) = description__ie {
3931        local_var_req_builder = match "multi" {
3932            "multi" => local_var_req_builder.query(
3933                &local_var_str
3934                    .into_iter()
3935                    .map(|p| ("description__ie".to_owned(), p.to_string()))
3936                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3937            ),
3938            _ => local_var_req_builder.query(&[(
3939                "description__ie",
3940                &local_var_str
3941                    .into_iter()
3942                    .map(|p| p.to_string())
3943                    .collect::<Vec<String>>()
3944                    .join(",")
3945                    .to_string(),
3946            )]),
3947        };
3948    }
3949    if let Some(ref local_var_str) = description__iew {
3950        local_var_req_builder = match "multi" {
3951            "multi" => local_var_req_builder.query(
3952                &local_var_str
3953                    .into_iter()
3954                    .map(|p| ("description__iew".to_owned(), p.to_string()))
3955                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3956            ),
3957            _ => local_var_req_builder.query(&[(
3958                "description__iew",
3959                &local_var_str
3960                    .into_iter()
3961                    .map(|p| p.to_string())
3962                    .collect::<Vec<String>>()
3963                    .join(",")
3964                    .to_string(),
3965            )]),
3966        };
3967    }
3968    if let Some(ref local_var_str) = description__iregex {
3969        local_var_req_builder = match "multi" {
3970            "multi" => local_var_req_builder.query(
3971                &local_var_str
3972                    .into_iter()
3973                    .map(|p| ("description__iregex".to_owned(), p.to_string()))
3974                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3975            ),
3976            _ => local_var_req_builder.query(&[(
3977                "description__iregex",
3978                &local_var_str
3979                    .into_iter()
3980                    .map(|p| p.to_string())
3981                    .collect::<Vec<String>>()
3982                    .join(",")
3983                    .to_string(),
3984            )]),
3985        };
3986    }
3987    if let Some(ref local_var_str) = description__isw {
3988        local_var_req_builder = match "multi" {
3989            "multi" => local_var_req_builder.query(
3990                &local_var_str
3991                    .into_iter()
3992                    .map(|p| ("description__isw".to_owned(), p.to_string()))
3993                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3994            ),
3995            _ => local_var_req_builder.query(&[(
3996                "description__isw",
3997                &local_var_str
3998                    .into_iter()
3999                    .map(|p| p.to_string())
4000                    .collect::<Vec<String>>()
4001                    .join(",")
4002                    .to_string(),
4003            )]),
4004        };
4005    }
4006    if let Some(ref local_var_str) = description__n {
4007        local_var_req_builder = match "multi" {
4008            "multi" => local_var_req_builder.query(
4009                &local_var_str
4010                    .into_iter()
4011                    .map(|p| ("description__n".to_owned(), p.to_string()))
4012                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4013            ),
4014            _ => local_var_req_builder.query(&[(
4015                "description__n",
4016                &local_var_str
4017                    .into_iter()
4018                    .map(|p| p.to_string())
4019                    .collect::<Vec<String>>()
4020                    .join(",")
4021                    .to_string(),
4022            )]),
4023        };
4024    }
4025    if let Some(ref local_var_str) = description__nic {
4026        local_var_req_builder = match "multi" {
4027            "multi" => local_var_req_builder.query(
4028                &local_var_str
4029                    .into_iter()
4030                    .map(|p| ("description__nic".to_owned(), p.to_string()))
4031                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4032            ),
4033            _ => local_var_req_builder.query(&[(
4034                "description__nic",
4035                &local_var_str
4036                    .into_iter()
4037                    .map(|p| p.to_string())
4038                    .collect::<Vec<String>>()
4039                    .join(",")
4040                    .to_string(),
4041            )]),
4042        };
4043    }
4044    if let Some(ref local_var_str) = description__nie {
4045        local_var_req_builder = match "multi" {
4046            "multi" => local_var_req_builder.query(
4047                &local_var_str
4048                    .into_iter()
4049                    .map(|p| ("description__nie".to_owned(), p.to_string()))
4050                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4051            ),
4052            _ => local_var_req_builder.query(&[(
4053                "description__nie",
4054                &local_var_str
4055                    .into_iter()
4056                    .map(|p| p.to_string())
4057                    .collect::<Vec<String>>()
4058                    .join(",")
4059                    .to_string(),
4060            )]),
4061        };
4062    }
4063    if let Some(ref local_var_str) = description__niew {
4064        local_var_req_builder = match "multi" {
4065            "multi" => local_var_req_builder.query(
4066                &local_var_str
4067                    .into_iter()
4068                    .map(|p| ("description__niew".to_owned(), p.to_string()))
4069                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4070            ),
4071            _ => local_var_req_builder.query(&[(
4072                "description__niew",
4073                &local_var_str
4074                    .into_iter()
4075                    .map(|p| p.to_string())
4076                    .collect::<Vec<String>>()
4077                    .join(",")
4078                    .to_string(),
4079            )]),
4080        };
4081    }
4082    if let Some(ref local_var_str) = description__nisw {
4083        local_var_req_builder = match "multi" {
4084            "multi" => local_var_req_builder.query(
4085                &local_var_str
4086                    .into_iter()
4087                    .map(|p| ("description__nisw".to_owned(), p.to_string()))
4088                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4089            ),
4090            _ => local_var_req_builder.query(&[(
4091                "description__nisw",
4092                &local_var_str
4093                    .into_iter()
4094                    .map(|p| p.to_string())
4095                    .collect::<Vec<String>>()
4096                    .join(",")
4097                    .to_string(),
4098            )]),
4099        };
4100    }
4101    if let Some(ref local_var_str) = description__regex {
4102        local_var_req_builder = match "multi" {
4103            "multi" => local_var_req_builder.query(
4104                &local_var_str
4105                    .into_iter()
4106                    .map(|p| ("description__regex".to_owned(), p.to_string()))
4107                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4108            ),
4109            _ => local_var_req_builder.query(&[(
4110                "description__regex",
4111                &local_var_str
4112                    .into_iter()
4113                    .map(|p| p.to_string())
4114                    .collect::<Vec<String>>()
4115                    .join(",")
4116                    .to_string(),
4117            )]),
4118        };
4119    }
4120    if let Some(ref local_var_str) = encryption_algorithm {
4121        local_var_req_builder = match "multi" {
4122            "multi" => local_var_req_builder.query(
4123                &local_var_str
4124                    .into_iter()
4125                    .map(|p| ("encryption_algorithm".to_owned(), p.to_string()))
4126                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4127            ),
4128            _ => local_var_req_builder.query(&[(
4129                "encryption_algorithm",
4130                &local_var_str
4131                    .into_iter()
4132                    .map(|p| p.to_string())
4133                    .collect::<Vec<String>>()
4134                    .join(",")
4135                    .to_string(),
4136            )]),
4137        };
4138    }
4139    if let Some(ref local_var_str) = encryption_algorithm__empty {
4140        local_var_req_builder = local_var_req_builder
4141            .query(&[("encryption_algorithm__empty", &local_var_str.to_string())]);
4142    }
4143    if let Some(ref local_var_str) = encryption_algorithm__ic {
4144        local_var_req_builder = match "multi" {
4145            "multi" => local_var_req_builder.query(
4146                &local_var_str
4147                    .into_iter()
4148                    .map(|p| ("encryption_algorithm__ic".to_owned(), p.to_string()))
4149                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4150            ),
4151            _ => local_var_req_builder.query(&[(
4152                "encryption_algorithm__ic",
4153                &local_var_str
4154                    .into_iter()
4155                    .map(|p| p.to_string())
4156                    .collect::<Vec<String>>()
4157                    .join(",")
4158                    .to_string(),
4159            )]),
4160        };
4161    }
4162    if let Some(ref local_var_str) = encryption_algorithm__ie {
4163        local_var_req_builder = match "multi" {
4164            "multi" => local_var_req_builder.query(
4165                &local_var_str
4166                    .into_iter()
4167                    .map(|p| ("encryption_algorithm__ie".to_owned(), p.to_string()))
4168                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4169            ),
4170            _ => local_var_req_builder.query(&[(
4171                "encryption_algorithm__ie",
4172                &local_var_str
4173                    .into_iter()
4174                    .map(|p| p.to_string())
4175                    .collect::<Vec<String>>()
4176                    .join(",")
4177                    .to_string(),
4178            )]),
4179        };
4180    }
4181    if let Some(ref local_var_str) = encryption_algorithm__iew {
4182        local_var_req_builder = match "multi" {
4183            "multi" => local_var_req_builder.query(
4184                &local_var_str
4185                    .into_iter()
4186                    .map(|p| ("encryption_algorithm__iew".to_owned(), p.to_string()))
4187                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4188            ),
4189            _ => local_var_req_builder.query(&[(
4190                "encryption_algorithm__iew",
4191                &local_var_str
4192                    .into_iter()
4193                    .map(|p| p.to_string())
4194                    .collect::<Vec<String>>()
4195                    .join(",")
4196                    .to_string(),
4197            )]),
4198        };
4199    }
4200    if let Some(ref local_var_str) = encryption_algorithm__iregex {
4201        local_var_req_builder = match "multi" {
4202            "multi" => local_var_req_builder.query(
4203                &local_var_str
4204                    .into_iter()
4205                    .map(|p| ("encryption_algorithm__iregex".to_owned(), p.to_string()))
4206                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4207            ),
4208            _ => local_var_req_builder.query(&[(
4209                "encryption_algorithm__iregex",
4210                &local_var_str
4211                    .into_iter()
4212                    .map(|p| p.to_string())
4213                    .collect::<Vec<String>>()
4214                    .join(",")
4215                    .to_string(),
4216            )]),
4217        };
4218    }
4219    if let Some(ref local_var_str) = encryption_algorithm__isw {
4220        local_var_req_builder = match "multi" {
4221            "multi" => local_var_req_builder.query(
4222                &local_var_str
4223                    .into_iter()
4224                    .map(|p| ("encryption_algorithm__isw".to_owned(), p.to_string()))
4225                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4226            ),
4227            _ => local_var_req_builder.query(&[(
4228                "encryption_algorithm__isw",
4229                &local_var_str
4230                    .into_iter()
4231                    .map(|p| p.to_string())
4232                    .collect::<Vec<String>>()
4233                    .join(",")
4234                    .to_string(),
4235            )]),
4236        };
4237    }
4238    if let Some(ref local_var_str) = encryption_algorithm__n {
4239        local_var_req_builder = match "multi" {
4240            "multi" => local_var_req_builder.query(
4241                &local_var_str
4242                    .into_iter()
4243                    .map(|p| ("encryption_algorithm__n".to_owned(), p.to_string()))
4244                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4245            ),
4246            _ => local_var_req_builder.query(&[(
4247                "encryption_algorithm__n",
4248                &local_var_str
4249                    .into_iter()
4250                    .map(|p| p.to_string())
4251                    .collect::<Vec<String>>()
4252                    .join(",")
4253                    .to_string(),
4254            )]),
4255        };
4256    }
4257    if let Some(ref local_var_str) = encryption_algorithm__nic {
4258        local_var_req_builder = match "multi" {
4259            "multi" => local_var_req_builder.query(
4260                &local_var_str
4261                    .into_iter()
4262                    .map(|p| ("encryption_algorithm__nic".to_owned(), p.to_string()))
4263                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4264            ),
4265            _ => local_var_req_builder.query(&[(
4266                "encryption_algorithm__nic",
4267                &local_var_str
4268                    .into_iter()
4269                    .map(|p| p.to_string())
4270                    .collect::<Vec<String>>()
4271                    .join(",")
4272                    .to_string(),
4273            )]),
4274        };
4275    }
4276    if let Some(ref local_var_str) = encryption_algorithm__nie {
4277        local_var_req_builder = match "multi" {
4278            "multi" => local_var_req_builder.query(
4279                &local_var_str
4280                    .into_iter()
4281                    .map(|p| ("encryption_algorithm__nie".to_owned(), p.to_string()))
4282                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4283            ),
4284            _ => local_var_req_builder.query(&[(
4285                "encryption_algorithm__nie",
4286                &local_var_str
4287                    .into_iter()
4288                    .map(|p| p.to_string())
4289                    .collect::<Vec<String>>()
4290                    .join(",")
4291                    .to_string(),
4292            )]),
4293        };
4294    }
4295    if let Some(ref local_var_str) = encryption_algorithm__niew {
4296        local_var_req_builder = match "multi" {
4297            "multi" => local_var_req_builder.query(
4298                &local_var_str
4299                    .into_iter()
4300                    .map(|p| ("encryption_algorithm__niew".to_owned(), p.to_string()))
4301                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4302            ),
4303            _ => local_var_req_builder.query(&[(
4304                "encryption_algorithm__niew",
4305                &local_var_str
4306                    .into_iter()
4307                    .map(|p| p.to_string())
4308                    .collect::<Vec<String>>()
4309                    .join(",")
4310                    .to_string(),
4311            )]),
4312        };
4313    }
4314    if let Some(ref local_var_str) = encryption_algorithm__nisw {
4315        local_var_req_builder = match "multi" {
4316            "multi" => local_var_req_builder.query(
4317                &local_var_str
4318                    .into_iter()
4319                    .map(|p| ("encryption_algorithm__nisw".to_owned(), p.to_string()))
4320                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4321            ),
4322            _ => local_var_req_builder.query(&[(
4323                "encryption_algorithm__nisw",
4324                &local_var_str
4325                    .into_iter()
4326                    .map(|p| p.to_string())
4327                    .collect::<Vec<String>>()
4328                    .join(",")
4329                    .to_string(),
4330            )]),
4331        };
4332    }
4333    if let Some(ref local_var_str) = encryption_algorithm__regex {
4334        local_var_req_builder = match "multi" {
4335            "multi" => local_var_req_builder.query(
4336                &local_var_str
4337                    .into_iter()
4338                    .map(|p| ("encryption_algorithm__regex".to_owned(), p.to_string()))
4339                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4340            ),
4341            _ => local_var_req_builder.query(&[(
4342                "encryption_algorithm__regex",
4343                &local_var_str
4344                    .into_iter()
4345                    .map(|p| p.to_string())
4346                    .collect::<Vec<String>>()
4347                    .join(",")
4348                    .to_string(),
4349            )]),
4350        };
4351    }
4352    if let Some(ref local_var_str) = group {
4353        local_var_req_builder = match "multi" {
4354            "multi" => local_var_req_builder.query(
4355                &local_var_str
4356                    .into_iter()
4357                    .map(|p| ("group".to_owned(), p.to_string()))
4358                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4359            ),
4360            _ => local_var_req_builder.query(&[(
4361                "group",
4362                &local_var_str
4363                    .into_iter()
4364                    .map(|p| p.to_string())
4365                    .collect::<Vec<String>>()
4366                    .join(",")
4367                    .to_string(),
4368            )]),
4369        };
4370    }
4371    if let Some(ref local_var_str) = group__ic {
4372        local_var_req_builder = match "multi" {
4373            "multi" => local_var_req_builder.query(
4374                &local_var_str
4375                    .into_iter()
4376                    .map(|p| ("group__ic".to_owned(), p.to_string()))
4377                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4378            ),
4379            _ => local_var_req_builder.query(&[(
4380                "group__ic",
4381                &local_var_str
4382                    .into_iter()
4383                    .map(|p| p.to_string())
4384                    .collect::<Vec<String>>()
4385                    .join(",")
4386                    .to_string(),
4387            )]),
4388        };
4389    }
4390    if let Some(ref local_var_str) = group__ie {
4391        local_var_req_builder = match "multi" {
4392            "multi" => local_var_req_builder.query(
4393                &local_var_str
4394                    .into_iter()
4395                    .map(|p| ("group__ie".to_owned(), p.to_string()))
4396                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4397            ),
4398            _ => local_var_req_builder.query(&[(
4399                "group__ie",
4400                &local_var_str
4401                    .into_iter()
4402                    .map(|p| p.to_string())
4403                    .collect::<Vec<String>>()
4404                    .join(",")
4405                    .to_string(),
4406            )]),
4407        };
4408    }
4409    if let Some(ref local_var_str) = group__iew {
4410        local_var_req_builder = match "multi" {
4411            "multi" => local_var_req_builder.query(
4412                &local_var_str
4413                    .into_iter()
4414                    .map(|p| ("group__iew".to_owned(), p.to_string()))
4415                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4416            ),
4417            _ => local_var_req_builder.query(&[(
4418                "group__iew",
4419                &local_var_str
4420                    .into_iter()
4421                    .map(|p| p.to_string())
4422                    .collect::<Vec<String>>()
4423                    .join(",")
4424                    .to_string(),
4425            )]),
4426        };
4427    }
4428    if let Some(ref local_var_str) = group__iregex {
4429        local_var_req_builder = match "multi" {
4430            "multi" => local_var_req_builder.query(
4431                &local_var_str
4432                    .into_iter()
4433                    .map(|p| ("group__iregex".to_owned(), p.to_string()))
4434                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4435            ),
4436            _ => local_var_req_builder.query(&[(
4437                "group__iregex",
4438                &local_var_str
4439                    .into_iter()
4440                    .map(|p| p.to_string())
4441                    .collect::<Vec<String>>()
4442                    .join(",")
4443                    .to_string(),
4444            )]),
4445        };
4446    }
4447    if let Some(ref local_var_str) = group__isw {
4448        local_var_req_builder = match "multi" {
4449            "multi" => local_var_req_builder.query(
4450                &local_var_str
4451                    .into_iter()
4452                    .map(|p| ("group__isw".to_owned(), p.to_string()))
4453                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4454            ),
4455            _ => local_var_req_builder.query(&[(
4456                "group__isw",
4457                &local_var_str
4458                    .into_iter()
4459                    .map(|p| p.to_string())
4460                    .collect::<Vec<String>>()
4461                    .join(",")
4462                    .to_string(),
4463            )]),
4464        };
4465    }
4466    if let Some(ref local_var_str) = group__n {
4467        local_var_req_builder = match "multi" {
4468            "multi" => local_var_req_builder.query(
4469                &local_var_str
4470                    .into_iter()
4471                    .map(|p| ("group__n".to_owned(), p.to_string()))
4472                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4473            ),
4474            _ => local_var_req_builder.query(&[(
4475                "group__n",
4476                &local_var_str
4477                    .into_iter()
4478                    .map(|p| p.to_string())
4479                    .collect::<Vec<String>>()
4480                    .join(",")
4481                    .to_string(),
4482            )]),
4483        };
4484    }
4485    if let Some(ref local_var_str) = group__nic {
4486        local_var_req_builder = match "multi" {
4487            "multi" => local_var_req_builder.query(
4488                &local_var_str
4489                    .into_iter()
4490                    .map(|p| ("group__nic".to_owned(), p.to_string()))
4491                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4492            ),
4493            _ => local_var_req_builder.query(&[(
4494                "group__nic",
4495                &local_var_str
4496                    .into_iter()
4497                    .map(|p| p.to_string())
4498                    .collect::<Vec<String>>()
4499                    .join(",")
4500                    .to_string(),
4501            )]),
4502        };
4503    }
4504    if let Some(ref local_var_str) = group__nie {
4505        local_var_req_builder = match "multi" {
4506            "multi" => local_var_req_builder.query(
4507                &local_var_str
4508                    .into_iter()
4509                    .map(|p| ("group__nie".to_owned(), p.to_string()))
4510                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4511            ),
4512            _ => local_var_req_builder.query(&[(
4513                "group__nie",
4514                &local_var_str
4515                    .into_iter()
4516                    .map(|p| p.to_string())
4517                    .collect::<Vec<String>>()
4518                    .join(",")
4519                    .to_string(),
4520            )]),
4521        };
4522    }
4523    if let Some(ref local_var_str) = group__niew {
4524        local_var_req_builder = match "multi" {
4525            "multi" => local_var_req_builder.query(
4526                &local_var_str
4527                    .into_iter()
4528                    .map(|p| ("group__niew".to_owned(), p.to_string()))
4529                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4530            ),
4531            _ => local_var_req_builder.query(&[(
4532                "group__niew",
4533                &local_var_str
4534                    .into_iter()
4535                    .map(|p| p.to_string())
4536                    .collect::<Vec<String>>()
4537                    .join(",")
4538                    .to_string(),
4539            )]),
4540        };
4541    }
4542    if let Some(ref local_var_str) = group__nisw {
4543        local_var_req_builder = match "multi" {
4544            "multi" => local_var_req_builder.query(
4545                &local_var_str
4546                    .into_iter()
4547                    .map(|p| ("group__nisw".to_owned(), p.to_string()))
4548                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4549            ),
4550            _ => local_var_req_builder.query(&[(
4551                "group__nisw",
4552                &local_var_str
4553                    .into_iter()
4554                    .map(|p| p.to_string())
4555                    .collect::<Vec<String>>()
4556                    .join(",")
4557                    .to_string(),
4558            )]),
4559        };
4560    }
4561    if let Some(ref local_var_str) = group__regex {
4562        local_var_req_builder = match "multi" {
4563            "multi" => local_var_req_builder.query(
4564                &local_var_str
4565                    .into_iter()
4566                    .map(|p| ("group__regex".to_owned(), p.to_string()))
4567                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4568            ),
4569            _ => local_var_req_builder.query(&[(
4570                "group__regex",
4571                &local_var_str
4572                    .into_iter()
4573                    .map(|p| p.to_string())
4574                    .collect::<Vec<String>>()
4575                    .join(",")
4576                    .to_string(),
4577            )]),
4578        };
4579    }
4580    if let Some(ref local_var_str) = id {
4581        local_var_req_builder = match "multi" {
4582            "multi" => local_var_req_builder.query(
4583                &local_var_str
4584                    .into_iter()
4585                    .map(|p| ("id".to_owned(), p.to_string()))
4586                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4587            ),
4588            _ => local_var_req_builder.query(&[(
4589                "id",
4590                &local_var_str
4591                    .into_iter()
4592                    .map(|p| p.to_string())
4593                    .collect::<Vec<String>>()
4594                    .join(",")
4595                    .to_string(),
4596            )]),
4597        };
4598    }
4599    if let Some(ref local_var_str) = id__empty {
4600        local_var_req_builder =
4601            local_var_req_builder.query(&[("id__empty", &local_var_str.to_string())]);
4602    }
4603    if let Some(ref local_var_str) = id__gt {
4604        local_var_req_builder = match "multi" {
4605            "multi" => local_var_req_builder.query(
4606                &local_var_str
4607                    .into_iter()
4608                    .map(|p| ("id__gt".to_owned(), p.to_string()))
4609                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4610            ),
4611            _ => local_var_req_builder.query(&[(
4612                "id__gt",
4613                &local_var_str
4614                    .into_iter()
4615                    .map(|p| p.to_string())
4616                    .collect::<Vec<String>>()
4617                    .join(",")
4618                    .to_string(),
4619            )]),
4620        };
4621    }
4622    if let Some(ref local_var_str) = id__gte {
4623        local_var_req_builder = match "multi" {
4624            "multi" => local_var_req_builder.query(
4625                &local_var_str
4626                    .into_iter()
4627                    .map(|p| ("id__gte".to_owned(), p.to_string()))
4628                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4629            ),
4630            _ => local_var_req_builder.query(&[(
4631                "id__gte",
4632                &local_var_str
4633                    .into_iter()
4634                    .map(|p| p.to_string())
4635                    .collect::<Vec<String>>()
4636                    .join(",")
4637                    .to_string(),
4638            )]),
4639        };
4640    }
4641    if let Some(ref local_var_str) = id__lt {
4642        local_var_req_builder = match "multi" {
4643            "multi" => local_var_req_builder.query(
4644                &local_var_str
4645                    .into_iter()
4646                    .map(|p| ("id__lt".to_owned(), p.to_string()))
4647                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4648            ),
4649            _ => local_var_req_builder.query(&[(
4650                "id__lt",
4651                &local_var_str
4652                    .into_iter()
4653                    .map(|p| p.to_string())
4654                    .collect::<Vec<String>>()
4655                    .join(",")
4656                    .to_string(),
4657            )]),
4658        };
4659    }
4660    if let Some(ref local_var_str) = id__lte {
4661        local_var_req_builder = match "multi" {
4662            "multi" => local_var_req_builder.query(
4663                &local_var_str
4664                    .into_iter()
4665                    .map(|p| ("id__lte".to_owned(), p.to_string()))
4666                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4667            ),
4668            _ => local_var_req_builder.query(&[(
4669                "id__lte",
4670                &local_var_str
4671                    .into_iter()
4672                    .map(|p| p.to_string())
4673                    .collect::<Vec<String>>()
4674                    .join(",")
4675                    .to_string(),
4676            )]),
4677        };
4678    }
4679    if let Some(ref local_var_str) = id__n {
4680        local_var_req_builder = match "multi" {
4681            "multi" => local_var_req_builder.query(
4682                &local_var_str
4683                    .into_iter()
4684                    .map(|p| ("id__n".to_owned(), p.to_string()))
4685                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4686            ),
4687            _ => local_var_req_builder.query(&[(
4688                "id__n",
4689                &local_var_str
4690                    .into_iter()
4691                    .map(|p| p.to_string())
4692                    .collect::<Vec<String>>()
4693                    .join(",")
4694                    .to_string(),
4695            )]),
4696        };
4697    }
4698    if let Some(ref local_var_str) = ike_policy {
4699        local_var_req_builder = match "multi" {
4700            "multi" => local_var_req_builder.query(
4701                &local_var_str
4702                    .into_iter()
4703                    .map(|p| ("ike_policy".to_owned(), p.to_string()))
4704                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4705            ),
4706            _ => local_var_req_builder.query(&[(
4707                "ike_policy",
4708                &local_var_str
4709                    .into_iter()
4710                    .map(|p| p.to_string())
4711                    .collect::<Vec<String>>()
4712                    .join(",")
4713                    .to_string(),
4714            )]),
4715        };
4716    }
4717    if let Some(ref local_var_str) = ike_policy__n {
4718        local_var_req_builder = match "multi" {
4719            "multi" => local_var_req_builder.query(
4720                &local_var_str
4721                    .into_iter()
4722                    .map(|p| ("ike_policy__n".to_owned(), p.to_string()))
4723                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4724            ),
4725            _ => local_var_req_builder.query(&[(
4726                "ike_policy__n",
4727                &local_var_str
4728                    .into_iter()
4729                    .map(|p| p.to_string())
4730                    .collect::<Vec<String>>()
4731                    .join(",")
4732                    .to_string(),
4733            )]),
4734        };
4735    }
4736    if let Some(ref local_var_str) = ike_policy_id {
4737        local_var_req_builder = match "multi" {
4738            "multi" => local_var_req_builder.query(
4739                &local_var_str
4740                    .into_iter()
4741                    .map(|p| ("ike_policy_id".to_owned(), p.to_string()))
4742                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4743            ),
4744            _ => local_var_req_builder.query(&[(
4745                "ike_policy_id",
4746                &local_var_str
4747                    .into_iter()
4748                    .map(|p| p.to_string())
4749                    .collect::<Vec<String>>()
4750                    .join(",")
4751                    .to_string(),
4752            )]),
4753        };
4754    }
4755    if let Some(ref local_var_str) = ike_policy_id__n {
4756        local_var_req_builder = match "multi" {
4757            "multi" => local_var_req_builder.query(
4758                &local_var_str
4759                    .into_iter()
4760                    .map(|p| ("ike_policy_id__n".to_owned(), p.to_string()))
4761                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4762            ),
4763            _ => local_var_req_builder.query(&[(
4764                "ike_policy_id__n",
4765                &local_var_str
4766                    .into_iter()
4767                    .map(|p| p.to_string())
4768                    .collect::<Vec<String>>()
4769                    .join(",")
4770                    .to_string(),
4771            )]),
4772        };
4773    }
4774    if let Some(ref local_var_str) = last_updated {
4775        local_var_req_builder = match "multi" {
4776            "multi" => local_var_req_builder.query(
4777                &local_var_str
4778                    .into_iter()
4779                    .map(|p| ("last_updated".to_owned(), p.to_string()))
4780                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4781            ),
4782            _ => local_var_req_builder.query(&[(
4783                "last_updated",
4784                &local_var_str
4785                    .into_iter()
4786                    .map(|p| p.to_string())
4787                    .collect::<Vec<String>>()
4788                    .join(",")
4789                    .to_string(),
4790            )]),
4791        };
4792    }
4793    if let Some(ref local_var_str) = last_updated__empty {
4794        local_var_req_builder = match "multi" {
4795            "multi" => local_var_req_builder.query(
4796                &local_var_str
4797                    .into_iter()
4798                    .map(|p| ("last_updated__empty".to_owned(), p.to_string()))
4799                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4800            ),
4801            _ => local_var_req_builder.query(&[(
4802                "last_updated__empty",
4803                &local_var_str
4804                    .into_iter()
4805                    .map(|p| p.to_string())
4806                    .collect::<Vec<String>>()
4807                    .join(",")
4808                    .to_string(),
4809            )]),
4810        };
4811    }
4812    if let Some(ref local_var_str) = last_updated__gt {
4813        local_var_req_builder = match "multi" {
4814            "multi" => local_var_req_builder.query(
4815                &local_var_str
4816                    .into_iter()
4817                    .map(|p| ("last_updated__gt".to_owned(), p.to_string()))
4818                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4819            ),
4820            _ => local_var_req_builder.query(&[(
4821                "last_updated__gt",
4822                &local_var_str
4823                    .into_iter()
4824                    .map(|p| p.to_string())
4825                    .collect::<Vec<String>>()
4826                    .join(",")
4827                    .to_string(),
4828            )]),
4829        };
4830    }
4831    if let Some(ref local_var_str) = last_updated__gte {
4832        local_var_req_builder = match "multi" {
4833            "multi" => local_var_req_builder.query(
4834                &local_var_str
4835                    .into_iter()
4836                    .map(|p| ("last_updated__gte".to_owned(), p.to_string()))
4837                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4838            ),
4839            _ => local_var_req_builder.query(&[(
4840                "last_updated__gte",
4841                &local_var_str
4842                    .into_iter()
4843                    .map(|p| p.to_string())
4844                    .collect::<Vec<String>>()
4845                    .join(",")
4846                    .to_string(),
4847            )]),
4848        };
4849    }
4850    if let Some(ref local_var_str) = last_updated__lt {
4851        local_var_req_builder = match "multi" {
4852            "multi" => local_var_req_builder.query(
4853                &local_var_str
4854                    .into_iter()
4855                    .map(|p| ("last_updated__lt".to_owned(), p.to_string()))
4856                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4857            ),
4858            _ => local_var_req_builder.query(&[(
4859                "last_updated__lt",
4860                &local_var_str
4861                    .into_iter()
4862                    .map(|p| p.to_string())
4863                    .collect::<Vec<String>>()
4864                    .join(",")
4865                    .to_string(),
4866            )]),
4867        };
4868    }
4869    if let Some(ref local_var_str) = last_updated__lte {
4870        local_var_req_builder = match "multi" {
4871            "multi" => local_var_req_builder.query(
4872                &local_var_str
4873                    .into_iter()
4874                    .map(|p| ("last_updated__lte".to_owned(), p.to_string()))
4875                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4876            ),
4877            _ => local_var_req_builder.query(&[(
4878                "last_updated__lte",
4879                &local_var_str
4880                    .into_iter()
4881                    .map(|p| p.to_string())
4882                    .collect::<Vec<String>>()
4883                    .join(",")
4884                    .to_string(),
4885            )]),
4886        };
4887    }
4888    if let Some(ref local_var_str) = last_updated__n {
4889        local_var_req_builder = match "multi" {
4890            "multi" => local_var_req_builder.query(
4891                &local_var_str
4892                    .into_iter()
4893                    .map(|p| ("last_updated__n".to_owned(), p.to_string()))
4894                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4895            ),
4896            _ => local_var_req_builder.query(&[(
4897                "last_updated__n",
4898                &local_var_str
4899                    .into_iter()
4900                    .map(|p| p.to_string())
4901                    .collect::<Vec<String>>()
4902                    .join(",")
4903                    .to_string(),
4904            )]),
4905        };
4906    }
4907    if let Some(ref local_var_str) = limit {
4908        local_var_req_builder =
4909            local_var_req_builder.query(&[("limit", &local_var_str.to_string())]);
4910    }
4911    if let Some(ref local_var_str) = modified_by_request {
4912        local_var_req_builder =
4913            local_var_req_builder.query(&[("modified_by_request", &local_var_str.to_string())]);
4914    }
4915    if let Some(ref local_var_str) = name {
4916        local_var_req_builder = match "multi" {
4917            "multi" => local_var_req_builder.query(
4918                &local_var_str
4919                    .into_iter()
4920                    .map(|p| ("name".to_owned(), p.to_string()))
4921                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4922            ),
4923            _ => local_var_req_builder.query(&[(
4924                "name",
4925                &local_var_str
4926                    .into_iter()
4927                    .map(|p| p.to_string())
4928                    .collect::<Vec<String>>()
4929                    .join(",")
4930                    .to_string(),
4931            )]),
4932        };
4933    }
4934    if let Some(ref local_var_str) = name__empty {
4935        local_var_req_builder =
4936            local_var_req_builder.query(&[("name__empty", &local_var_str.to_string())]);
4937    }
4938    if let Some(ref local_var_str) = name__ic {
4939        local_var_req_builder = match "multi" {
4940            "multi" => local_var_req_builder.query(
4941                &local_var_str
4942                    .into_iter()
4943                    .map(|p| ("name__ic".to_owned(), p.to_string()))
4944                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4945            ),
4946            _ => local_var_req_builder.query(&[(
4947                "name__ic",
4948                &local_var_str
4949                    .into_iter()
4950                    .map(|p| p.to_string())
4951                    .collect::<Vec<String>>()
4952                    .join(",")
4953                    .to_string(),
4954            )]),
4955        };
4956    }
4957    if let Some(ref local_var_str) = name__ie {
4958        local_var_req_builder = match "multi" {
4959            "multi" => local_var_req_builder.query(
4960                &local_var_str
4961                    .into_iter()
4962                    .map(|p| ("name__ie".to_owned(), p.to_string()))
4963                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4964            ),
4965            _ => local_var_req_builder.query(&[(
4966                "name__ie",
4967                &local_var_str
4968                    .into_iter()
4969                    .map(|p| p.to_string())
4970                    .collect::<Vec<String>>()
4971                    .join(",")
4972                    .to_string(),
4973            )]),
4974        };
4975    }
4976    if let Some(ref local_var_str) = name__iew {
4977        local_var_req_builder = match "multi" {
4978            "multi" => local_var_req_builder.query(
4979                &local_var_str
4980                    .into_iter()
4981                    .map(|p| ("name__iew".to_owned(), p.to_string()))
4982                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4983            ),
4984            _ => local_var_req_builder.query(&[(
4985                "name__iew",
4986                &local_var_str
4987                    .into_iter()
4988                    .map(|p| p.to_string())
4989                    .collect::<Vec<String>>()
4990                    .join(",")
4991                    .to_string(),
4992            )]),
4993        };
4994    }
4995    if let Some(ref local_var_str) = name__iregex {
4996        local_var_req_builder = match "multi" {
4997            "multi" => local_var_req_builder.query(
4998                &local_var_str
4999                    .into_iter()
5000                    .map(|p| ("name__iregex".to_owned(), p.to_string()))
5001                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5002            ),
5003            _ => local_var_req_builder.query(&[(
5004                "name__iregex",
5005                &local_var_str
5006                    .into_iter()
5007                    .map(|p| p.to_string())
5008                    .collect::<Vec<String>>()
5009                    .join(",")
5010                    .to_string(),
5011            )]),
5012        };
5013    }
5014    if let Some(ref local_var_str) = name__isw {
5015        local_var_req_builder = match "multi" {
5016            "multi" => local_var_req_builder.query(
5017                &local_var_str
5018                    .into_iter()
5019                    .map(|p| ("name__isw".to_owned(), p.to_string()))
5020                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5021            ),
5022            _ => local_var_req_builder.query(&[(
5023                "name__isw",
5024                &local_var_str
5025                    .into_iter()
5026                    .map(|p| p.to_string())
5027                    .collect::<Vec<String>>()
5028                    .join(",")
5029                    .to_string(),
5030            )]),
5031        };
5032    }
5033    if let Some(ref local_var_str) = name__n {
5034        local_var_req_builder = match "multi" {
5035            "multi" => local_var_req_builder.query(
5036                &local_var_str
5037                    .into_iter()
5038                    .map(|p| ("name__n".to_owned(), p.to_string()))
5039                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5040            ),
5041            _ => local_var_req_builder.query(&[(
5042                "name__n",
5043                &local_var_str
5044                    .into_iter()
5045                    .map(|p| p.to_string())
5046                    .collect::<Vec<String>>()
5047                    .join(",")
5048                    .to_string(),
5049            )]),
5050        };
5051    }
5052    if let Some(ref local_var_str) = name__nic {
5053        local_var_req_builder = match "multi" {
5054            "multi" => local_var_req_builder.query(
5055                &local_var_str
5056                    .into_iter()
5057                    .map(|p| ("name__nic".to_owned(), p.to_string()))
5058                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5059            ),
5060            _ => local_var_req_builder.query(&[(
5061                "name__nic",
5062                &local_var_str
5063                    .into_iter()
5064                    .map(|p| p.to_string())
5065                    .collect::<Vec<String>>()
5066                    .join(",")
5067                    .to_string(),
5068            )]),
5069        };
5070    }
5071    if let Some(ref local_var_str) = name__nie {
5072        local_var_req_builder = match "multi" {
5073            "multi" => local_var_req_builder.query(
5074                &local_var_str
5075                    .into_iter()
5076                    .map(|p| ("name__nie".to_owned(), p.to_string()))
5077                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5078            ),
5079            _ => local_var_req_builder.query(&[(
5080                "name__nie",
5081                &local_var_str
5082                    .into_iter()
5083                    .map(|p| p.to_string())
5084                    .collect::<Vec<String>>()
5085                    .join(",")
5086                    .to_string(),
5087            )]),
5088        };
5089    }
5090    if let Some(ref local_var_str) = name__niew {
5091        local_var_req_builder = match "multi" {
5092            "multi" => local_var_req_builder.query(
5093                &local_var_str
5094                    .into_iter()
5095                    .map(|p| ("name__niew".to_owned(), p.to_string()))
5096                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5097            ),
5098            _ => local_var_req_builder.query(&[(
5099                "name__niew",
5100                &local_var_str
5101                    .into_iter()
5102                    .map(|p| p.to_string())
5103                    .collect::<Vec<String>>()
5104                    .join(",")
5105                    .to_string(),
5106            )]),
5107        };
5108    }
5109    if let Some(ref local_var_str) = name__nisw {
5110        local_var_req_builder = match "multi" {
5111            "multi" => local_var_req_builder.query(
5112                &local_var_str
5113                    .into_iter()
5114                    .map(|p| ("name__nisw".to_owned(), p.to_string()))
5115                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5116            ),
5117            _ => local_var_req_builder.query(&[(
5118                "name__nisw",
5119                &local_var_str
5120                    .into_iter()
5121                    .map(|p| p.to_string())
5122                    .collect::<Vec<String>>()
5123                    .join(",")
5124                    .to_string(),
5125            )]),
5126        };
5127    }
5128    if let Some(ref local_var_str) = name__regex {
5129        local_var_req_builder = match "multi" {
5130            "multi" => local_var_req_builder.query(
5131                &local_var_str
5132                    .into_iter()
5133                    .map(|p| ("name__regex".to_owned(), p.to_string()))
5134                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5135            ),
5136            _ => local_var_req_builder.query(&[(
5137                "name__regex",
5138                &local_var_str
5139                    .into_iter()
5140                    .map(|p| p.to_string())
5141                    .collect::<Vec<String>>()
5142                    .join(",")
5143                    .to_string(),
5144            )]),
5145        };
5146    }
5147    if let Some(ref local_var_str) = offset {
5148        local_var_req_builder =
5149            local_var_req_builder.query(&[("offset", &local_var_str.to_string())]);
5150    }
5151    if let Some(ref local_var_str) = ordering {
5152        local_var_req_builder =
5153            local_var_req_builder.query(&[("ordering", &local_var_str.to_string())]);
5154    }
5155    if let Some(ref local_var_str) = owner {
5156        local_var_req_builder = match "multi" {
5157            "multi" => local_var_req_builder.query(
5158                &local_var_str
5159                    .into_iter()
5160                    .map(|p| ("owner".to_owned(), p.to_string()))
5161                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5162            ),
5163            _ => local_var_req_builder.query(&[(
5164                "owner",
5165                &local_var_str
5166                    .into_iter()
5167                    .map(|p| p.to_string())
5168                    .collect::<Vec<String>>()
5169                    .join(",")
5170                    .to_string(),
5171            )]),
5172        };
5173    }
5174    if let Some(ref local_var_str) = owner__n {
5175        local_var_req_builder = match "multi" {
5176            "multi" => local_var_req_builder.query(
5177                &local_var_str
5178                    .into_iter()
5179                    .map(|p| ("owner__n".to_owned(), p.to_string()))
5180                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5181            ),
5182            _ => local_var_req_builder.query(&[(
5183                "owner__n",
5184                &local_var_str
5185                    .into_iter()
5186                    .map(|p| p.to_string())
5187                    .collect::<Vec<String>>()
5188                    .join(",")
5189                    .to_string(),
5190            )]),
5191        };
5192    }
5193    if let Some(ref local_var_str) = owner_group {
5194        local_var_req_builder = match "multi" {
5195            "multi" => local_var_req_builder.query(
5196                &local_var_str
5197                    .into_iter()
5198                    .map(|p| ("owner_group".to_owned(), p.to_string()))
5199                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5200            ),
5201            _ => local_var_req_builder.query(&[(
5202                "owner_group",
5203                &local_var_str
5204                    .into_iter()
5205                    .map(|p| p.to_string())
5206                    .collect::<Vec<String>>()
5207                    .join(",")
5208                    .to_string(),
5209            )]),
5210        };
5211    }
5212    if let Some(ref local_var_str) = owner_group__n {
5213        local_var_req_builder = match "multi" {
5214            "multi" => local_var_req_builder.query(
5215                &local_var_str
5216                    .into_iter()
5217                    .map(|p| ("owner_group__n".to_owned(), p.to_string()))
5218                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5219            ),
5220            _ => local_var_req_builder.query(&[(
5221                "owner_group__n",
5222                &local_var_str
5223                    .into_iter()
5224                    .map(|p| p.to_string())
5225                    .collect::<Vec<String>>()
5226                    .join(",")
5227                    .to_string(),
5228            )]),
5229        };
5230    }
5231    if let Some(ref local_var_str) = owner_group_id {
5232        local_var_req_builder = match "multi" {
5233            "multi" => local_var_req_builder.query(
5234                &local_var_str
5235                    .into_iter()
5236                    .map(|p| ("owner_group_id".to_owned(), p.to_string()))
5237                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5238            ),
5239            _ => local_var_req_builder.query(&[(
5240                "owner_group_id",
5241                &local_var_str
5242                    .into_iter()
5243                    .map(|p| p.to_string())
5244                    .collect::<Vec<String>>()
5245                    .join(",")
5246                    .to_string(),
5247            )]),
5248        };
5249    }
5250    if let Some(ref local_var_str) = owner_group_id__n {
5251        local_var_req_builder = match "multi" {
5252            "multi" => local_var_req_builder.query(
5253                &local_var_str
5254                    .into_iter()
5255                    .map(|p| ("owner_group_id__n".to_owned(), p.to_string()))
5256                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5257            ),
5258            _ => local_var_req_builder.query(&[(
5259                "owner_group_id__n",
5260                &local_var_str
5261                    .into_iter()
5262                    .map(|p| p.to_string())
5263                    .collect::<Vec<String>>()
5264                    .join(",")
5265                    .to_string(),
5266            )]),
5267        };
5268    }
5269    if let Some(ref local_var_str) = owner_id {
5270        local_var_req_builder = match "multi" {
5271            "multi" => local_var_req_builder.query(
5272                &local_var_str
5273                    .into_iter()
5274                    .map(|p| ("owner_id".to_owned(), p.to_string()))
5275                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5276            ),
5277            _ => local_var_req_builder.query(&[(
5278                "owner_id",
5279                &local_var_str
5280                    .into_iter()
5281                    .map(|p| p.to_string())
5282                    .collect::<Vec<String>>()
5283                    .join(",")
5284                    .to_string(),
5285            )]),
5286        };
5287    }
5288    if let Some(ref local_var_str) = owner_id__n {
5289        local_var_req_builder = match "multi" {
5290            "multi" => local_var_req_builder.query(
5291                &local_var_str
5292                    .into_iter()
5293                    .map(|p| ("owner_id__n".to_owned(), p.to_string()))
5294                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5295            ),
5296            _ => local_var_req_builder.query(&[(
5297                "owner_id__n",
5298                &local_var_str
5299                    .into_iter()
5300                    .map(|p| p.to_string())
5301                    .collect::<Vec<String>>()
5302                    .join(",")
5303                    .to_string(),
5304            )]),
5305        };
5306    }
5307    if let Some(ref local_var_str) = q {
5308        local_var_req_builder = local_var_req_builder.query(&[("q", &local_var_str.to_string())]);
5309    }
5310    if let Some(ref local_var_str) = sa_lifetime {
5311        local_var_req_builder = match "multi" {
5312            "multi" => local_var_req_builder.query(
5313                &local_var_str
5314                    .into_iter()
5315                    .map(|p| ("sa_lifetime".to_owned(), p.to_string()))
5316                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5317            ),
5318            _ => local_var_req_builder.query(&[(
5319                "sa_lifetime",
5320                &local_var_str
5321                    .into_iter()
5322                    .map(|p| p.to_string())
5323                    .collect::<Vec<String>>()
5324                    .join(",")
5325                    .to_string(),
5326            )]),
5327        };
5328    }
5329    if let Some(ref local_var_str) = sa_lifetime__empty {
5330        local_var_req_builder =
5331            local_var_req_builder.query(&[("sa_lifetime__empty", &local_var_str.to_string())]);
5332    }
5333    if let Some(ref local_var_str) = sa_lifetime__gt {
5334        local_var_req_builder = match "multi" {
5335            "multi" => local_var_req_builder.query(
5336                &local_var_str
5337                    .into_iter()
5338                    .map(|p| ("sa_lifetime__gt".to_owned(), p.to_string()))
5339                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5340            ),
5341            _ => local_var_req_builder.query(&[(
5342                "sa_lifetime__gt",
5343                &local_var_str
5344                    .into_iter()
5345                    .map(|p| p.to_string())
5346                    .collect::<Vec<String>>()
5347                    .join(",")
5348                    .to_string(),
5349            )]),
5350        };
5351    }
5352    if let Some(ref local_var_str) = sa_lifetime__gte {
5353        local_var_req_builder = match "multi" {
5354            "multi" => local_var_req_builder.query(
5355                &local_var_str
5356                    .into_iter()
5357                    .map(|p| ("sa_lifetime__gte".to_owned(), p.to_string()))
5358                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5359            ),
5360            _ => local_var_req_builder.query(&[(
5361                "sa_lifetime__gte",
5362                &local_var_str
5363                    .into_iter()
5364                    .map(|p| p.to_string())
5365                    .collect::<Vec<String>>()
5366                    .join(",")
5367                    .to_string(),
5368            )]),
5369        };
5370    }
5371    if let Some(ref local_var_str) = sa_lifetime__lt {
5372        local_var_req_builder = match "multi" {
5373            "multi" => local_var_req_builder.query(
5374                &local_var_str
5375                    .into_iter()
5376                    .map(|p| ("sa_lifetime__lt".to_owned(), p.to_string()))
5377                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5378            ),
5379            _ => local_var_req_builder.query(&[(
5380                "sa_lifetime__lt",
5381                &local_var_str
5382                    .into_iter()
5383                    .map(|p| p.to_string())
5384                    .collect::<Vec<String>>()
5385                    .join(",")
5386                    .to_string(),
5387            )]),
5388        };
5389    }
5390    if let Some(ref local_var_str) = sa_lifetime__lte {
5391        local_var_req_builder = match "multi" {
5392            "multi" => local_var_req_builder.query(
5393                &local_var_str
5394                    .into_iter()
5395                    .map(|p| ("sa_lifetime__lte".to_owned(), p.to_string()))
5396                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5397            ),
5398            _ => local_var_req_builder.query(&[(
5399                "sa_lifetime__lte",
5400                &local_var_str
5401                    .into_iter()
5402                    .map(|p| p.to_string())
5403                    .collect::<Vec<String>>()
5404                    .join(",")
5405                    .to_string(),
5406            )]),
5407        };
5408    }
5409    if let Some(ref local_var_str) = sa_lifetime__n {
5410        local_var_req_builder = match "multi" {
5411            "multi" => local_var_req_builder.query(
5412                &local_var_str
5413                    .into_iter()
5414                    .map(|p| ("sa_lifetime__n".to_owned(), p.to_string()))
5415                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5416            ),
5417            _ => local_var_req_builder.query(&[(
5418                "sa_lifetime__n",
5419                &local_var_str
5420                    .into_iter()
5421                    .map(|p| p.to_string())
5422                    .collect::<Vec<String>>()
5423                    .join(",")
5424                    .to_string(),
5425            )]),
5426        };
5427    }
5428    if let Some(ref local_var_str) = tag {
5429        local_var_req_builder = match "multi" {
5430            "multi" => local_var_req_builder.query(
5431                &local_var_str
5432                    .into_iter()
5433                    .map(|p| ("tag".to_owned(), p.to_string()))
5434                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5435            ),
5436            _ => local_var_req_builder.query(&[(
5437                "tag",
5438                &local_var_str
5439                    .into_iter()
5440                    .map(|p| p.to_string())
5441                    .collect::<Vec<String>>()
5442                    .join(",")
5443                    .to_string(),
5444            )]),
5445        };
5446    }
5447    if let Some(ref local_var_str) = tag__n {
5448        local_var_req_builder = match "multi" {
5449            "multi" => local_var_req_builder.query(
5450                &local_var_str
5451                    .into_iter()
5452                    .map(|p| ("tag__n".to_owned(), p.to_string()))
5453                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5454            ),
5455            _ => local_var_req_builder.query(&[(
5456                "tag__n",
5457                &local_var_str
5458                    .into_iter()
5459                    .map(|p| p.to_string())
5460                    .collect::<Vec<String>>()
5461                    .join(",")
5462                    .to_string(),
5463            )]),
5464        };
5465    }
5466    if let Some(ref local_var_str) = tag_id {
5467        local_var_req_builder = match "multi" {
5468            "multi" => local_var_req_builder.query(
5469                &local_var_str
5470                    .into_iter()
5471                    .map(|p| ("tag_id".to_owned(), p.to_string()))
5472                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5473            ),
5474            _ => local_var_req_builder.query(&[(
5475                "tag_id",
5476                &local_var_str
5477                    .into_iter()
5478                    .map(|p| p.to_string())
5479                    .collect::<Vec<String>>()
5480                    .join(",")
5481                    .to_string(),
5482            )]),
5483        };
5484    }
5485    if let Some(ref local_var_str) = tag_id__n {
5486        local_var_req_builder = match "multi" {
5487            "multi" => local_var_req_builder.query(
5488                &local_var_str
5489                    .into_iter()
5490                    .map(|p| ("tag_id__n".to_owned(), p.to_string()))
5491                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5492            ),
5493            _ => local_var_req_builder.query(&[(
5494                "tag_id__n",
5495                &local_var_str
5496                    .into_iter()
5497                    .map(|p| p.to_string())
5498                    .collect::<Vec<String>>()
5499                    .join(",")
5500                    .to_string(),
5501            )]),
5502        };
5503    }
5504    if let Some(ref local_var_str) = updated_by_request {
5505        local_var_req_builder =
5506            local_var_req_builder.query(&[("updated_by_request", &local_var_str.to_string())]);
5507    }
5508    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
5509        local_var_req_builder =
5510            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
5511    }
5512    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
5513        let local_var_key = local_var_apikey.key.clone();
5514        let local_var_value = match local_var_apikey.prefix {
5515            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
5516            None => local_var_key,
5517        };
5518        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
5519    };
5520
5521    let local_var_req = local_var_req_builder.build()?;
5522    let local_var_resp = local_var_client.execute(local_var_req).await?;
5523
5524    let local_var_status = local_var_resp.status();
5525    let local_var_content = local_var_resp.text().await?;
5526
5527    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
5528        serde_json::from_str(&local_var_content).map_err(Error::from)
5529    } else {
5530        let local_var_entity: Option<VpnIkeProposalsListError> =
5531            serde_json::from_str(&local_var_content).ok();
5532        let local_var_error = ResponseContent {
5533            status: local_var_status,
5534            content: local_var_content,
5535            entity: local_var_entity,
5536        };
5537        Err(Error::ResponseError(local_var_error))
5538    }
5539}
5540
5541/// Patch a IKE proposal object.
5542pub async fn vpn_ike_proposals_partial_update(
5543    configuration: &configuration::Configuration,
5544    id: i32,
5545    patched_writable_ike_proposal_request: Option<crate::models::PatchedWritableIkeProposalRequest>,
5546) -> Result<crate::models::IkeProposal, Error<VpnIkeProposalsPartialUpdateError>> {
5547    let local_var_configuration = configuration;
5548
5549    let local_var_client = &local_var_configuration.client;
5550
5551    let local_var_uri_str = format!(
5552        "{}/api/vpn/ike-proposals/{id}/",
5553        local_var_configuration.base_path,
5554        id = id
5555    );
5556    let mut local_var_req_builder =
5557        local_var_client.request(reqwest::Method::PATCH, local_var_uri_str.as_str());
5558
5559    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
5560        local_var_req_builder =
5561            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
5562    }
5563    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
5564        let local_var_key = local_var_apikey.key.clone();
5565        let local_var_value = match local_var_apikey.prefix {
5566            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
5567            None => local_var_key,
5568        };
5569        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
5570    };
5571    local_var_req_builder = local_var_req_builder.json(&patched_writable_ike_proposal_request);
5572
5573    let local_var_req = local_var_req_builder.build()?;
5574    let local_var_resp = local_var_client.execute(local_var_req).await?;
5575
5576    let local_var_status = local_var_resp.status();
5577    let local_var_content = local_var_resp.text().await?;
5578
5579    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
5580        serde_json::from_str(&local_var_content).map_err(Error::from)
5581    } else {
5582        let local_var_entity: Option<VpnIkeProposalsPartialUpdateError> =
5583            serde_json::from_str(&local_var_content).ok();
5584        let local_var_error = ResponseContent {
5585            status: local_var_status,
5586            content: local_var_content,
5587            entity: local_var_entity,
5588        };
5589        Err(Error::ResponseError(local_var_error))
5590    }
5591}
5592
5593/// Get a IKE proposal object.
5594pub async fn vpn_ike_proposals_retrieve(
5595    configuration: &configuration::Configuration,
5596    id: i32,
5597) -> Result<crate::models::IkeProposal, Error<VpnIkeProposalsRetrieveError>> {
5598    let local_var_configuration = configuration;
5599
5600    let local_var_client = &local_var_configuration.client;
5601
5602    let local_var_uri_str = format!(
5603        "{}/api/vpn/ike-proposals/{id}/",
5604        local_var_configuration.base_path,
5605        id = id
5606    );
5607    let mut local_var_req_builder =
5608        local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
5609
5610    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
5611        local_var_req_builder =
5612            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
5613    }
5614    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
5615        let local_var_key = local_var_apikey.key.clone();
5616        let local_var_value = match local_var_apikey.prefix {
5617            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
5618            None => local_var_key,
5619        };
5620        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
5621    };
5622
5623    let local_var_req = local_var_req_builder.build()?;
5624    let local_var_resp = local_var_client.execute(local_var_req).await?;
5625
5626    let local_var_status = local_var_resp.status();
5627    let local_var_content = local_var_resp.text().await?;
5628
5629    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
5630        serde_json::from_str(&local_var_content).map_err(Error::from)
5631    } else {
5632        let local_var_entity: Option<VpnIkeProposalsRetrieveError> =
5633            serde_json::from_str(&local_var_content).ok();
5634        let local_var_error = ResponseContent {
5635            status: local_var_status,
5636            content: local_var_content,
5637            entity: local_var_entity,
5638        };
5639        Err(Error::ResponseError(local_var_error))
5640    }
5641}
5642
5643/// Put a IKE proposal object.
5644pub async fn vpn_ike_proposals_update(
5645    configuration: &configuration::Configuration,
5646    id: i32,
5647    writable_ike_proposal_request: crate::models::WritableIkeProposalRequest,
5648) -> Result<crate::models::IkeProposal, Error<VpnIkeProposalsUpdateError>> {
5649    let local_var_configuration = configuration;
5650
5651    let local_var_client = &local_var_configuration.client;
5652
5653    let local_var_uri_str = format!(
5654        "{}/api/vpn/ike-proposals/{id}/",
5655        local_var_configuration.base_path,
5656        id = id
5657    );
5658    let mut local_var_req_builder =
5659        local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());
5660
5661    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
5662        local_var_req_builder =
5663            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
5664    }
5665    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
5666        let local_var_key = local_var_apikey.key.clone();
5667        let local_var_value = match local_var_apikey.prefix {
5668            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
5669            None => local_var_key,
5670        };
5671        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
5672    };
5673    local_var_req_builder = local_var_req_builder.json(&writable_ike_proposal_request);
5674
5675    let local_var_req = local_var_req_builder.build()?;
5676    let local_var_resp = local_var_client.execute(local_var_req).await?;
5677
5678    let local_var_status = local_var_resp.status();
5679    let local_var_content = local_var_resp.text().await?;
5680
5681    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
5682        serde_json::from_str(&local_var_content).map_err(Error::from)
5683    } else {
5684        let local_var_entity: Option<VpnIkeProposalsUpdateError> =
5685            serde_json::from_str(&local_var_content).ok();
5686        let local_var_error = ResponseContent {
5687            status: local_var_status,
5688            content: local_var_content,
5689            entity: local_var_entity,
5690        };
5691        Err(Error::ResponseError(local_var_error))
5692    }
5693}
5694
5695/// Delete a list of IPSec policy objects.
5696pub async fn vpn_ipsec_policies_bulk_destroy(
5697    configuration: &configuration::Configuration,
5698    ip_sec_policy_request: Vec<crate::models::IpSecPolicyRequest>,
5699) -> Result<(), Error<VpnIpsecPoliciesBulkDestroyError>> {
5700    let local_var_configuration = configuration;
5701
5702    let local_var_client = &local_var_configuration.client;
5703
5704    let local_var_uri_str = format!(
5705        "{}/api/vpn/ipsec-policies/",
5706        local_var_configuration.base_path
5707    );
5708    let mut local_var_req_builder =
5709        local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());
5710
5711    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
5712        local_var_req_builder =
5713            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
5714    }
5715    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
5716        let local_var_key = local_var_apikey.key.clone();
5717        let local_var_value = match local_var_apikey.prefix {
5718            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
5719            None => local_var_key,
5720        };
5721        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
5722    };
5723    local_var_req_builder = local_var_req_builder.json(&ip_sec_policy_request);
5724
5725    let local_var_req = local_var_req_builder.build()?;
5726    let local_var_resp = local_var_client.execute(local_var_req).await?;
5727
5728    let local_var_status = local_var_resp.status();
5729    let local_var_content = local_var_resp.text().await?;
5730
5731    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
5732        Ok(())
5733    } else {
5734        let local_var_entity: Option<VpnIpsecPoliciesBulkDestroyError> =
5735            serde_json::from_str(&local_var_content).ok();
5736        let local_var_error = ResponseContent {
5737            status: local_var_status,
5738            content: local_var_content,
5739            entity: local_var_entity,
5740        };
5741        Err(Error::ResponseError(local_var_error))
5742    }
5743}
5744
5745/// Patch a list of IPSec policy objects.
5746pub async fn vpn_ipsec_policies_bulk_partial_update(
5747    configuration: &configuration::Configuration,
5748    ip_sec_policy_request: Vec<crate::models::IpSecPolicyRequest>,
5749) -> Result<Vec<crate::models::IpSecPolicy>, Error<VpnIpsecPoliciesBulkPartialUpdateError>> {
5750    let local_var_configuration = configuration;
5751
5752    let local_var_client = &local_var_configuration.client;
5753
5754    let local_var_uri_str = format!(
5755        "{}/api/vpn/ipsec-policies/",
5756        local_var_configuration.base_path
5757    );
5758    let mut local_var_req_builder =
5759        local_var_client.request(reqwest::Method::PATCH, local_var_uri_str.as_str());
5760
5761    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
5762        local_var_req_builder =
5763            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
5764    }
5765    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
5766        let local_var_key = local_var_apikey.key.clone();
5767        let local_var_value = match local_var_apikey.prefix {
5768            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
5769            None => local_var_key,
5770        };
5771        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
5772    };
5773    local_var_req_builder = local_var_req_builder.json(&ip_sec_policy_request);
5774
5775    let local_var_req = local_var_req_builder.build()?;
5776    let local_var_resp = local_var_client.execute(local_var_req).await?;
5777
5778    let local_var_status = local_var_resp.status();
5779    let local_var_content = local_var_resp.text().await?;
5780
5781    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
5782        serde_json::from_str(&local_var_content).map_err(Error::from)
5783    } else {
5784        let local_var_entity: Option<VpnIpsecPoliciesBulkPartialUpdateError> =
5785            serde_json::from_str(&local_var_content).ok();
5786        let local_var_error = ResponseContent {
5787            status: local_var_status,
5788            content: local_var_content,
5789            entity: local_var_entity,
5790        };
5791        Err(Error::ResponseError(local_var_error))
5792    }
5793}
5794
5795/// Put a list of IPSec policy objects.
5796pub async fn vpn_ipsec_policies_bulk_update(
5797    configuration: &configuration::Configuration,
5798    ip_sec_policy_request: Vec<crate::models::IpSecPolicyRequest>,
5799) -> Result<Vec<crate::models::IpSecPolicy>, Error<VpnIpsecPoliciesBulkUpdateError>> {
5800    let local_var_configuration = configuration;
5801
5802    let local_var_client = &local_var_configuration.client;
5803
5804    let local_var_uri_str = format!(
5805        "{}/api/vpn/ipsec-policies/",
5806        local_var_configuration.base_path
5807    );
5808    let mut local_var_req_builder =
5809        local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());
5810
5811    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
5812        local_var_req_builder =
5813            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
5814    }
5815    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
5816        let local_var_key = local_var_apikey.key.clone();
5817        let local_var_value = match local_var_apikey.prefix {
5818            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
5819            None => local_var_key,
5820        };
5821        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
5822    };
5823    local_var_req_builder = local_var_req_builder.json(&ip_sec_policy_request);
5824
5825    let local_var_req = local_var_req_builder.build()?;
5826    let local_var_resp = local_var_client.execute(local_var_req).await?;
5827
5828    let local_var_status = local_var_resp.status();
5829    let local_var_content = local_var_resp.text().await?;
5830
5831    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
5832        serde_json::from_str(&local_var_content).map_err(Error::from)
5833    } else {
5834        let local_var_entity: Option<VpnIpsecPoliciesBulkUpdateError> =
5835            serde_json::from_str(&local_var_content).ok();
5836        let local_var_error = ResponseContent {
5837            status: local_var_status,
5838            content: local_var_content,
5839            entity: local_var_entity,
5840        };
5841        Err(Error::ResponseError(local_var_error))
5842    }
5843}
5844
5845/// Post a list of IPSec policy objects.
5846pub async fn vpn_ipsec_policies_create(
5847    configuration: &configuration::Configuration,
5848    vpn_ipsec_policies_create_request: crate::models::VpnIpsecPoliciesCreateRequest,
5849) -> Result<crate::models::IpSecPolicy, Error<VpnIpsecPoliciesCreateError>> {
5850    let local_var_configuration = configuration;
5851
5852    let local_var_client = &local_var_configuration.client;
5853
5854    let local_var_uri_str = format!(
5855        "{}/api/vpn/ipsec-policies/",
5856        local_var_configuration.base_path
5857    );
5858    let mut local_var_req_builder =
5859        local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
5860
5861    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
5862        local_var_req_builder =
5863            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
5864    }
5865    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
5866        let local_var_key = local_var_apikey.key.clone();
5867        let local_var_value = match local_var_apikey.prefix {
5868            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
5869            None => local_var_key,
5870        };
5871        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
5872    };
5873    local_var_req_builder = local_var_req_builder.json(&vpn_ipsec_policies_create_request);
5874
5875    let local_var_req = local_var_req_builder.build()?;
5876    let local_var_resp = local_var_client.execute(local_var_req).await?;
5877
5878    let local_var_status = local_var_resp.status();
5879    let local_var_content = local_var_resp.text().await?;
5880
5881    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
5882        serde_json::from_str(&local_var_content).map_err(Error::from)
5883    } else {
5884        let local_var_entity: Option<VpnIpsecPoliciesCreateError> =
5885            serde_json::from_str(&local_var_content).ok();
5886        let local_var_error = ResponseContent {
5887            status: local_var_status,
5888            content: local_var_content,
5889            entity: local_var_entity,
5890        };
5891        Err(Error::ResponseError(local_var_error))
5892    }
5893}
5894
5895/// Delete a IPSec policy object.
5896pub async fn vpn_ipsec_policies_destroy(
5897    configuration: &configuration::Configuration,
5898    id: i32,
5899) -> Result<(), Error<VpnIpsecPoliciesDestroyError>> {
5900    let local_var_configuration = configuration;
5901
5902    let local_var_client = &local_var_configuration.client;
5903
5904    let local_var_uri_str = format!(
5905        "{}/api/vpn/ipsec-policies/{id}/",
5906        local_var_configuration.base_path,
5907        id = id
5908    );
5909    let mut local_var_req_builder =
5910        local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());
5911
5912    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
5913        local_var_req_builder =
5914            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
5915    }
5916    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
5917        let local_var_key = local_var_apikey.key.clone();
5918        let local_var_value = match local_var_apikey.prefix {
5919            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
5920            None => local_var_key,
5921        };
5922        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
5923    };
5924
5925    let local_var_req = local_var_req_builder.build()?;
5926    let local_var_resp = local_var_client.execute(local_var_req).await?;
5927
5928    let local_var_status = local_var_resp.status();
5929    let local_var_content = local_var_resp.text().await?;
5930
5931    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
5932        Ok(())
5933    } else {
5934        let local_var_entity: Option<VpnIpsecPoliciesDestroyError> =
5935            serde_json::from_str(&local_var_content).ok();
5936        let local_var_error = ResponseContent {
5937            status: local_var_status,
5938            content: local_var_content,
5939            entity: local_var_entity,
5940        };
5941        Err(Error::ResponseError(local_var_error))
5942    }
5943}
5944
5945/// Get a list of IPSec policy objects.
5946pub async fn vpn_ipsec_policies_list(
5947    configuration: &configuration::Configuration,
5948    created: Option<Vec<String>>,
5949    created__empty: Option<Vec<String>>,
5950    created__gt: Option<Vec<String>>,
5951    created__gte: Option<Vec<String>>,
5952    created__lt: Option<Vec<String>>,
5953    created__lte: Option<Vec<String>>,
5954    created__n: Option<Vec<String>>,
5955    created_by_request: Option<&str>,
5956    description: Option<Vec<String>>,
5957    description__empty: Option<bool>,
5958    description__ic: Option<Vec<String>>,
5959    description__ie: Option<Vec<String>>,
5960    description__iew: Option<Vec<String>>,
5961    description__iregex: Option<Vec<String>>,
5962    description__isw: Option<Vec<String>>,
5963    description__n: Option<Vec<String>>,
5964    description__nic: Option<Vec<String>>,
5965    description__nie: Option<Vec<String>>,
5966    description__niew: Option<Vec<String>>,
5967    description__nisw: Option<Vec<String>>,
5968    description__regex: Option<Vec<String>>,
5969    id: Option<Vec<i32>>,
5970    id__empty: Option<bool>,
5971    id__gt: Option<Vec<i32>>,
5972    id__gte: Option<Vec<i32>>,
5973    id__lt: Option<Vec<i32>>,
5974    id__lte: Option<Vec<i32>>,
5975    id__n: Option<Vec<i32>>,
5976    ipsec_proposal: Option<Vec<String>>,
5977    ipsec_proposal__n: Option<Vec<String>>,
5978    ipsec_proposal_id: Option<Vec<i32>>,
5979    ipsec_proposal_id__n: Option<Vec<i32>>,
5980    last_updated: Option<Vec<String>>,
5981    last_updated__empty: Option<Vec<String>>,
5982    last_updated__gt: Option<Vec<String>>,
5983    last_updated__gte: Option<Vec<String>>,
5984    last_updated__lt: Option<Vec<String>>,
5985    last_updated__lte: Option<Vec<String>>,
5986    last_updated__n: Option<Vec<String>>,
5987    limit: Option<i32>,
5988    modified_by_request: Option<&str>,
5989    name: Option<Vec<String>>,
5990    name__empty: Option<bool>,
5991    name__ic: Option<Vec<String>>,
5992    name__ie: Option<Vec<String>>,
5993    name__iew: Option<Vec<String>>,
5994    name__iregex: Option<Vec<String>>,
5995    name__isw: Option<Vec<String>>,
5996    name__n: Option<Vec<String>>,
5997    name__nic: Option<Vec<String>>,
5998    name__nie: Option<Vec<String>>,
5999    name__niew: Option<Vec<String>>,
6000    name__nisw: Option<Vec<String>>,
6001    name__regex: Option<Vec<String>>,
6002    offset: Option<i32>,
6003    ordering: Option<&str>,
6004    owner: Option<Vec<String>>,
6005    owner__n: Option<Vec<String>>,
6006    owner_group: Option<Vec<String>>,
6007    owner_group__n: Option<Vec<String>>,
6008    owner_group_id: Option<Vec<i32>>,
6009    owner_group_id__n: Option<Vec<i32>>,
6010    owner_id: Option<Vec<i32>>,
6011    owner_id__n: Option<Vec<i32>>,
6012    pfs_group: Option<Vec<i32>>,
6013    pfs_group__ic: Option<Vec<i32>>,
6014    pfs_group__ie: Option<Vec<i32>>,
6015    pfs_group__iew: Option<Vec<i32>>,
6016    pfs_group__iregex: Option<Vec<i32>>,
6017    pfs_group__isw: Option<Vec<i32>>,
6018    pfs_group__n: Option<Vec<i32>>,
6019    pfs_group__nic: Option<Vec<i32>>,
6020    pfs_group__nie: Option<Vec<i32>>,
6021    pfs_group__niew: Option<Vec<i32>>,
6022    pfs_group__nisw: Option<Vec<i32>>,
6023    pfs_group__regex: Option<Vec<i32>>,
6024    q: Option<&str>,
6025    tag: Option<Vec<String>>,
6026    tag__n: Option<Vec<String>>,
6027    tag_id: Option<Vec<i32>>,
6028    tag_id__n: Option<Vec<i32>>,
6029    updated_by_request: Option<&str>,
6030) -> Result<crate::models::PaginatedIpSecPolicyList, Error<VpnIpsecPoliciesListError>> {
6031    let local_var_configuration = configuration;
6032
6033    let local_var_client = &local_var_configuration.client;
6034
6035    let local_var_uri_str = format!(
6036        "{}/api/vpn/ipsec-policies/",
6037        local_var_configuration.base_path
6038    );
6039    let mut local_var_req_builder =
6040        local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
6041
6042    if let Some(ref local_var_str) = created {
6043        local_var_req_builder = match "multi" {
6044            "multi" => local_var_req_builder.query(
6045                &local_var_str
6046                    .into_iter()
6047                    .map(|p| ("created".to_owned(), p.to_string()))
6048                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6049            ),
6050            _ => local_var_req_builder.query(&[(
6051                "created",
6052                &local_var_str
6053                    .into_iter()
6054                    .map(|p| p.to_string())
6055                    .collect::<Vec<String>>()
6056                    .join(",")
6057                    .to_string(),
6058            )]),
6059        };
6060    }
6061    if let Some(ref local_var_str) = created__empty {
6062        local_var_req_builder = match "multi" {
6063            "multi" => local_var_req_builder.query(
6064                &local_var_str
6065                    .into_iter()
6066                    .map(|p| ("created__empty".to_owned(), p.to_string()))
6067                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6068            ),
6069            _ => local_var_req_builder.query(&[(
6070                "created__empty",
6071                &local_var_str
6072                    .into_iter()
6073                    .map(|p| p.to_string())
6074                    .collect::<Vec<String>>()
6075                    .join(",")
6076                    .to_string(),
6077            )]),
6078        };
6079    }
6080    if let Some(ref local_var_str) = created__gt {
6081        local_var_req_builder = match "multi" {
6082            "multi" => local_var_req_builder.query(
6083                &local_var_str
6084                    .into_iter()
6085                    .map(|p| ("created__gt".to_owned(), p.to_string()))
6086                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6087            ),
6088            _ => local_var_req_builder.query(&[(
6089                "created__gt",
6090                &local_var_str
6091                    .into_iter()
6092                    .map(|p| p.to_string())
6093                    .collect::<Vec<String>>()
6094                    .join(",")
6095                    .to_string(),
6096            )]),
6097        };
6098    }
6099    if let Some(ref local_var_str) = created__gte {
6100        local_var_req_builder = match "multi" {
6101            "multi" => local_var_req_builder.query(
6102                &local_var_str
6103                    .into_iter()
6104                    .map(|p| ("created__gte".to_owned(), p.to_string()))
6105                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6106            ),
6107            _ => local_var_req_builder.query(&[(
6108                "created__gte",
6109                &local_var_str
6110                    .into_iter()
6111                    .map(|p| p.to_string())
6112                    .collect::<Vec<String>>()
6113                    .join(",")
6114                    .to_string(),
6115            )]),
6116        };
6117    }
6118    if let Some(ref local_var_str) = created__lt {
6119        local_var_req_builder = match "multi" {
6120            "multi" => local_var_req_builder.query(
6121                &local_var_str
6122                    .into_iter()
6123                    .map(|p| ("created__lt".to_owned(), p.to_string()))
6124                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6125            ),
6126            _ => local_var_req_builder.query(&[(
6127                "created__lt",
6128                &local_var_str
6129                    .into_iter()
6130                    .map(|p| p.to_string())
6131                    .collect::<Vec<String>>()
6132                    .join(",")
6133                    .to_string(),
6134            )]),
6135        };
6136    }
6137    if let Some(ref local_var_str) = created__lte {
6138        local_var_req_builder = match "multi" {
6139            "multi" => local_var_req_builder.query(
6140                &local_var_str
6141                    .into_iter()
6142                    .map(|p| ("created__lte".to_owned(), p.to_string()))
6143                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6144            ),
6145            _ => local_var_req_builder.query(&[(
6146                "created__lte",
6147                &local_var_str
6148                    .into_iter()
6149                    .map(|p| p.to_string())
6150                    .collect::<Vec<String>>()
6151                    .join(",")
6152                    .to_string(),
6153            )]),
6154        };
6155    }
6156    if let Some(ref local_var_str) = created__n {
6157        local_var_req_builder = match "multi" {
6158            "multi" => local_var_req_builder.query(
6159                &local_var_str
6160                    .into_iter()
6161                    .map(|p| ("created__n".to_owned(), p.to_string()))
6162                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6163            ),
6164            _ => local_var_req_builder.query(&[(
6165                "created__n",
6166                &local_var_str
6167                    .into_iter()
6168                    .map(|p| p.to_string())
6169                    .collect::<Vec<String>>()
6170                    .join(",")
6171                    .to_string(),
6172            )]),
6173        };
6174    }
6175    if let Some(ref local_var_str) = created_by_request {
6176        local_var_req_builder =
6177            local_var_req_builder.query(&[("created_by_request", &local_var_str.to_string())]);
6178    }
6179    if let Some(ref local_var_str) = description {
6180        local_var_req_builder = match "multi" {
6181            "multi" => local_var_req_builder.query(
6182                &local_var_str
6183                    .into_iter()
6184                    .map(|p| ("description".to_owned(), p.to_string()))
6185                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6186            ),
6187            _ => local_var_req_builder.query(&[(
6188                "description",
6189                &local_var_str
6190                    .into_iter()
6191                    .map(|p| p.to_string())
6192                    .collect::<Vec<String>>()
6193                    .join(",")
6194                    .to_string(),
6195            )]),
6196        };
6197    }
6198    if let Some(ref local_var_str) = description__empty {
6199        local_var_req_builder =
6200            local_var_req_builder.query(&[("description__empty", &local_var_str.to_string())]);
6201    }
6202    if let Some(ref local_var_str) = description__ic {
6203        local_var_req_builder = match "multi" {
6204            "multi" => local_var_req_builder.query(
6205                &local_var_str
6206                    .into_iter()
6207                    .map(|p| ("description__ic".to_owned(), p.to_string()))
6208                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6209            ),
6210            _ => local_var_req_builder.query(&[(
6211                "description__ic",
6212                &local_var_str
6213                    .into_iter()
6214                    .map(|p| p.to_string())
6215                    .collect::<Vec<String>>()
6216                    .join(",")
6217                    .to_string(),
6218            )]),
6219        };
6220    }
6221    if let Some(ref local_var_str) = description__ie {
6222        local_var_req_builder = match "multi" {
6223            "multi" => local_var_req_builder.query(
6224                &local_var_str
6225                    .into_iter()
6226                    .map(|p| ("description__ie".to_owned(), p.to_string()))
6227                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6228            ),
6229            _ => local_var_req_builder.query(&[(
6230                "description__ie",
6231                &local_var_str
6232                    .into_iter()
6233                    .map(|p| p.to_string())
6234                    .collect::<Vec<String>>()
6235                    .join(",")
6236                    .to_string(),
6237            )]),
6238        };
6239    }
6240    if let Some(ref local_var_str) = description__iew {
6241        local_var_req_builder = match "multi" {
6242            "multi" => local_var_req_builder.query(
6243                &local_var_str
6244                    .into_iter()
6245                    .map(|p| ("description__iew".to_owned(), p.to_string()))
6246                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6247            ),
6248            _ => local_var_req_builder.query(&[(
6249                "description__iew",
6250                &local_var_str
6251                    .into_iter()
6252                    .map(|p| p.to_string())
6253                    .collect::<Vec<String>>()
6254                    .join(",")
6255                    .to_string(),
6256            )]),
6257        };
6258    }
6259    if let Some(ref local_var_str) = description__iregex {
6260        local_var_req_builder = match "multi" {
6261            "multi" => local_var_req_builder.query(
6262                &local_var_str
6263                    .into_iter()
6264                    .map(|p| ("description__iregex".to_owned(), p.to_string()))
6265                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6266            ),
6267            _ => local_var_req_builder.query(&[(
6268                "description__iregex",
6269                &local_var_str
6270                    .into_iter()
6271                    .map(|p| p.to_string())
6272                    .collect::<Vec<String>>()
6273                    .join(",")
6274                    .to_string(),
6275            )]),
6276        };
6277    }
6278    if let Some(ref local_var_str) = description__isw {
6279        local_var_req_builder = match "multi" {
6280            "multi" => local_var_req_builder.query(
6281                &local_var_str
6282                    .into_iter()
6283                    .map(|p| ("description__isw".to_owned(), p.to_string()))
6284                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6285            ),
6286            _ => local_var_req_builder.query(&[(
6287                "description__isw",
6288                &local_var_str
6289                    .into_iter()
6290                    .map(|p| p.to_string())
6291                    .collect::<Vec<String>>()
6292                    .join(",")
6293                    .to_string(),
6294            )]),
6295        };
6296    }
6297    if let Some(ref local_var_str) = description__n {
6298        local_var_req_builder = match "multi" {
6299            "multi" => local_var_req_builder.query(
6300                &local_var_str
6301                    .into_iter()
6302                    .map(|p| ("description__n".to_owned(), p.to_string()))
6303                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6304            ),
6305            _ => local_var_req_builder.query(&[(
6306                "description__n",
6307                &local_var_str
6308                    .into_iter()
6309                    .map(|p| p.to_string())
6310                    .collect::<Vec<String>>()
6311                    .join(",")
6312                    .to_string(),
6313            )]),
6314        };
6315    }
6316    if let Some(ref local_var_str) = description__nic {
6317        local_var_req_builder = match "multi" {
6318            "multi" => local_var_req_builder.query(
6319                &local_var_str
6320                    .into_iter()
6321                    .map(|p| ("description__nic".to_owned(), p.to_string()))
6322                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6323            ),
6324            _ => local_var_req_builder.query(&[(
6325                "description__nic",
6326                &local_var_str
6327                    .into_iter()
6328                    .map(|p| p.to_string())
6329                    .collect::<Vec<String>>()
6330                    .join(",")
6331                    .to_string(),
6332            )]),
6333        };
6334    }
6335    if let Some(ref local_var_str) = description__nie {
6336        local_var_req_builder = match "multi" {
6337            "multi" => local_var_req_builder.query(
6338                &local_var_str
6339                    .into_iter()
6340                    .map(|p| ("description__nie".to_owned(), p.to_string()))
6341                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6342            ),
6343            _ => local_var_req_builder.query(&[(
6344                "description__nie",
6345                &local_var_str
6346                    .into_iter()
6347                    .map(|p| p.to_string())
6348                    .collect::<Vec<String>>()
6349                    .join(",")
6350                    .to_string(),
6351            )]),
6352        };
6353    }
6354    if let Some(ref local_var_str) = description__niew {
6355        local_var_req_builder = match "multi" {
6356            "multi" => local_var_req_builder.query(
6357                &local_var_str
6358                    .into_iter()
6359                    .map(|p| ("description__niew".to_owned(), p.to_string()))
6360                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6361            ),
6362            _ => local_var_req_builder.query(&[(
6363                "description__niew",
6364                &local_var_str
6365                    .into_iter()
6366                    .map(|p| p.to_string())
6367                    .collect::<Vec<String>>()
6368                    .join(",")
6369                    .to_string(),
6370            )]),
6371        };
6372    }
6373    if let Some(ref local_var_str) = description__nisw {
6374        local_var_req_builder = match "multi" {
6375            "multi" => local_var_req_builder.query(
6376                &local_var_str
6377                    .into_iter()
6378                    .map(|p| ("description__nisw".to_owned(), p.to_string()))
6379                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6380            ),
6381            _ => local_var_req_builder.query(&[(
6382                "description__nisw",
6383                &local_var_str
6384                    .into_iter()
6385                    .map(|p| p.to_string())
6386                    .collect::<Vec<String>>()
6387                    .join(",")
6388                    .to_string(),
6389            )]),
6390        };
6391    }
6392    if let Some(ref local_var_str) = description__regex {
6393        local_var_req_builder = match "multi" {
6394            "multi" => local_var_req_builder.query(
6395                &local_var_str
6396                    .into_iter()
6397                    .map(|p| ("description__regex".to_owned(), p.to_string()))
6398                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6399            ),
6400            _ => local_var_req_builder.query(&[(
6401                "description__regex",
6402                &local_var_str
6403                    .into_iter()
6404                    .map(|p| p.to_string())
6405                    .collect::<Vec<String>>()
6406                    .join(",")
6407                    .to_string(),
6408            )]),
6409        };
6410    }
6411    if let Some(ref local_var_str) = id {
6412        local_var_req_builder = match "multi" {
6413            "multi" => local_var_req_builder.query(
6414                &local_var_str
6415                    .into_iter()
6416                    .map(|p| ("id".to_owned(), p.to_string()))
6417                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6418            ),
6419            _ => local_var_req_builder.query(&[(
6420                "id",
6421                &local_var_str
6422                    .into_iter()
6423                    .map(|p| p.to_string())
6424                    .collect::<Vec<String>>()
6425                    .join(",")
6426                    .to_string(),
6427            )]),
6428        };
6429    }
6430    if let Some(ref local_var_str) = id__empty {
6431        local_var_req_builder =
6432            local_var_req_builder.query(&[("id__empty", &local_var_str.to_string())]);
6433    }
6434    if let Some(ref local_var_str) = id__gt {
6435        local_var_req_builder = match "multi" {
6436            "multi" => local_var_req_builder.query(
6437                &local_var_str
6438                    .into_iter()
6439                    .map(|p| ("id__gt".to_owned(), p.to_string()))
6440                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6441            ),
6442            _ => local_var_req_builder.query(&[(
6443                "id__gt",
6444                &local_var_str
6445                    .into_iter()
6446                    .map(|p| p.to_string())
6447                    .collect::<Vec<String>>()
6448                    .join(",")
6449                    .to_string(),
6450            )]),
6451        };
6452    }
6453    if let Some(ref local_var_str) = id__gte {
6454        local_var_req_builder = match "multi" {
6455            "multi" => local_var_req_builder.query(
6456                &local_var_str
6457                    .into_iter()
6458                    .map(|p| ("id__gte".to_owned(), p.to_string()))
6459                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6460            ),
6461            _ => local_var_req_builder.query(&[(
6462                "id__gte",
6463                &local_var_str
6464                    .into_iter()
6465                    .map(|p| p.to_string())
6466                    .collect::<Vec<String>>()
6467                    .join(",")
6468                    .to_string(),
6469            )]),
6470        };
6471    }
6472    if let Some(ref local_var_str) = id__lt {
6473        local_var_req_builder = match "multi" {
6474            "multi" => local_var_req_builder.query(
6475                &local_var_str
6476                    .into_iter()
6477                    .map(|p| ("id__lt".to_owned(), p.to_string()))
6478                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6479            ),
6480            _ => local_var_req_builder.query(&[(
6481                "id__lt",
6482                &local_var_str
6483                    .into_iter()
6484                    .map(|p| p.to_string())
6485                    .collect::<Vec<String>>()
6486                    .join(",")
6487                    .to_string(),
6488            )]),
6489        };
6490    }
6491    if let Some(ref local_var_str) = id__lte {
6492        local_var_req_builder = match "multi" {
6493            "multi" => local_var_req_builder.query(
6494                &local_var_str
6495                    .into_iter()
6496                    .map(|p| ("id__lte".to_owned(), p.to_string()))
6497                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6498            ),
6499            _ => local_var_req_builder.query(&[(
6500                "id__lte",
6501                &local_var_str
6502                    .into_iter()
6503                    .map(|p| p.to_string())
6504                    .collect::<Vec<String>>()
6505                    .join(",")
6506                    .to_string(),
6507            )]),
6508        };
6509    }
6510    if let Some(ref local_var_str) = id__n {
6511        local_var_req_builder = match "multi" {
6512            "multi" => local_var_req_builder.query(
6513                &local_var_str
6514                    .into_iter()
6515                    .map(|p| ("id__n".to_owned(), p.to_string()))
6516                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6517            ),
6518            _ => local_var_req_builder.query(&[(
6519                "id__n",
6520                &local_var_str
6521                    .into_iter()
6522                    .map(|p| p.to_string())
6523                    .collect::<Vec<String>>()
6524                    .join(",")
6525                    .to_string(),
6526            )]),
6527        };
6528    }
6529    if let Some(ref local_var_str) = ipsec_proposal {
6530        local_var_req_builder = match "multi" {
6531            "multi" => local_var_req_builder.query(
6532                &local_var_str
6533                    .into_iter()
6534                    .map(|p| ("ipsec_proposal".to_owned(), p.to_string()))
6535                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6536            ),
6537            _ => local_var_req_builder.query(&[(
6538                "ipsec_proposal",
6539                &local_var_str
6540                    .into_iter()
6541                    .map(|p| p.to_string())
6542                    .collect::<Vec<String>>()
6543                    .join(",")
6544                    .to_string(),
6545            )]),
6546        };
6547    }
6548    if let Some(ref local_var_str) = ipsec_proposal__n {
6549        local_var_req_builder = match "multi" {
6550            "multi" => local_var_req_builder.query(
6551                &local_var_str
6552                    .into_iter()
6553                    .map(|p| ("ipsec_proposal__n".to_owned(), p.to_string()))
6554                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6555            ),
6556            _ => local_var_req_builder.query(&[(
6557                "ipsec_proposal__n",
6558                &local_var_str
6559                    .into_iter()
6560                    .map(|p| p.to_string())
6561                    .collect::<Vec<String>>()
6562                    .join(",")
6563                    .to_string(),
6564            )]),
6565        };
6566    }
6567    if let Some(ref local_var_str) = ipsec_proposal_id {
6568        local_var_req_builder = match "multi" {
6569            "multi" => local_var_req_builder.query(
6570                &local_var_str
6571                    .into_iter()
6572                    .map(|p| ("ipsec_proposal_id".to_owned(), p.to_string()))
6573                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6574            ),
6575            _ => local_var_req_builder.query(&[(
6576                "ipsec_proposal_id",
6577                &local_var_str
6578                    .into_iter()
6579                    .map(|p| p.to_string())
6580                    .collect::<Vec<String>>()
6581                    .join(",")
6582                    .to_string(),
6583            )]),
6584        };
6585    }
6586    if let Some(ref local_var_str) = ipsec_proposal_id__n {
6587        local_var_req_builder = match "multi" {
6588            "multi" => local_var_req_builder.query(
6589                &local_var_str
6590                    .into_iter()
6591                    .map(|p| ("ipsec_proposal_id__n".to_owned(), p.to_string()))
6592                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6593            ),
6594            _ => local_var_req_builder.query(&[(
6595                "ipsec_proposal_id__n",
6596                &local_var_str
6597                    .into_iter()
6598                    .map(|p| p.to_string())
6599                    .collect::<Vec<String>>()
6600                    .join(",")
6601                    .to_string(),
6602            )]),
6603        };
6604    }
6605    if let Some(ref local_var_str) = last_updated {
6606        local_var_req_builder = match "multi" {
6607            "multi" => local_var_req_builder.query(
6608                &local_var_str
6609                    .into_iter()
6610                    .map(|p| ("last_updated".to_owned(), p.to_string()))
6611                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6612            ),
6613            _ => local_var_req_builder.query(&[(
6614                "last_updated",
6615                &local_var_str
6616                    .into_iter()
6617                    .map(|p| p.to_string())
6618                    .collect::<Vec<String>>()
6619                    .join(",")
6620                    .to_string(),
6621            )]),
6622        };
6623    }
6624    if let Some(ref local_var_str) = last_updated__empty {
6625        local_var_req_builder = match "multi" {
6626            "multi" => local_var_req_builder.query(
6627                &local_var_str
6628                    .into_iter()
6629                    .map(|p| ("last_updated__empty".to_owned(), p.to_string()))
6630                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6631            ),
6632            _ => local_var_req_builder.query(&[(
6633                "last_updated__empty",
6634                &local_var_str
6635                    .into_iter()
6636                    .map(|p| p.to_string())
6637                    .collect::<Vec<String>>()
6638                    .join(",")
6639                    .to_string(),
6640            )]),
6641        };
6642    }
6643    if let Some(ref local_var_str) = last_updated__gt {
6644        local_var_req_builder = match "multi" {
6645            "multi" => local_var_req_builder.query(
6646                &local_var_str
6647                    .into_iter()
6648                    .map(|p| ("last_updated__gt".to_owned(), p.to_string()))
6649                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6650            ),
6651            _ => local_var_req_builder.query(&[(
6652                "last_updated__gt",
6653                &local_var_str
6654                    .into_iter()
6655                    .map(|p| p.to_string())
6656                    .collect::<Vec<String>>()
6657                    .join(",")
6658                    .to_string(),
6659            )]),
6660        };
6661    }
6662    if let Some(ref local_var_str) = last_updated__gte {
6663        local_var_req_builder = match "multi" {
6664            "multi" => local_var_req_builder.query(
6665                &local_var_str
6666                    .into_iter()
6667                    .map(|p| ("last_updated__gte".to_owned(), p.to_string()))
6668                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6669            ),
6670            _ => local_var_req_builder.query(&[(
6671                "last_updated__gte",
6672                &local_var_str
6673                    .into_iter()
6674                    .map(|p| p.to_string())
6675                    .collect::<Vec<String>>()
6676                    .join(",")
6677                    .to_string(),
6678            )]),
6679        };
6680    }
6681    if let Some(ref local_var_str) = last_updated__lt {
6682        local_var_req_builder = match "multi" {
6683            "multi" => local_var_req_builder.query(
6684                &local_var_str
6685                    .into_iter()
6686                    .map(|p| ("last_updated__lt".to_owned(), p.to_string()))
6687                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6688            ),
6689            _ => local_var_req_builder.query(&[(
6690                "last_updated__lt",
6691                &local_var_str
6692                    .into_iter()
6693                    .map(|p| p.to_string())
6694                    .collect::<Vec<String>>()
6695                    .join(",")
6696                    .to_string(),
6697            )]),
6698        };
6699    }
6700    if let Some(ref local_var_str) = last_updated__lte {
6701        local_var_req_builder = match "multi" {
6702            "multi" => local_var_req_builder.query(
6703                &local_var_str
6704                    .into_iter()
6705                    .map(|p| ("last_updated__lte".to_owned(), p.to_string()))
6706                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6707            ),
6708            _ => local_var_req_builder.query(&[(
6709                "last_updated__lte",
6710                &local_var_str
6711                    .into_iter()
6712                    .map(|p| p.to_string())
6713                    .collect::<Vec<String>>()
6714                    .join(",")
6715                    .to_string(),
6716            )]),
6717        };
6718    }
6719    if let Some(ref local_var_str) = last_updated__n {
6720        local_var_req_builder = match "multi" {
6721            "multi" => local_var_req_builder.query(
6722                &local_var_str
6723                    .into_iter()
6724                    .map(|p| ("last_updated__n".to_owned(), p.to_string()))
6725                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6726            ),
6727            _ => local_var_req_builder.query(&[(
6728                "last_updated__n",
6729                &local_var_str
6730                    .into_iter()
6731                    .map(|p| p.to_string())
6732                    .collect::<Vec<String>>()
6733                    .join(",")
6734                    .to_string(),
6735            )]),
6736        };
6737    }
6738    if let Some(ref local_var_str) = limit {
6739        local_var_req_builder =
6740            local_var_req_builder.query(&[("limit", &local_var_str.to_string())]);
6741    }
6742    if let Some(ref local_var_str) = modified_by_request {
6743        local_var_req_builder =
6744            local_var_req_builder.query(&[("modified_by_request", &local_var_str.to_string())]);
6745    }
6746    if let Some(ref local_var_str) = name {
6747        local_var_req_builder = match "multi" {
6748            "multi" => local_var_req_builder.query(
6749                &local_var_str
6750                    .into_iter()
6751                    .map(|p| ("name".to_owned(), p.to_string()))
6752                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6753            ),
6754            _ => local_var_req_builder.query(&[(
6755                "name",
6756                &local_var_str
6757                    .into_iter()
6758                    .map(|p| p.to_string())
6759                    .collect::<Vec<String>>()
6760                    .join(",")
6761                    .to_string(),
6762            )]),
6763        };
6764    }
6765    if let Some(ref local_var_str) = name__empty {
6766        local_var_req_builder =
6767            local_var_req_builder.query(&[("name__empty", &local_var_str.to_string())]);
6768    }
6769    if let Some(ref local_var_str) = name__ic {
6770        local_var_req_builder = match "multi" {
6771            "multi" => local_var_req_builder.query(
6772                &local_var_str
6773                    .into_iter()
6774                    .map(|p| ("name__ic".to_owned(), p.to_string()))
6775                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6776            ),
6777            _ => local_var_req_builder.query(&[(
6778                "name__ic",
6779                &local_var_str
6780                    .into_iter()
6781                    .map(|p| p.to_string())
6782                    .collect::<Vec<String>>()
6783                    .join(",")
6784                    .to_string(),
6785            )]),
6786        };
6787    }
6788    if let Some(ref local_var_str) = name__ie {
6789        local_var_req_builder = match "multi" {
6790            "multi" => local_var_req_builder.query(
6791                &local_var_str
6792                    .into_iter()
6793                    .map(|p| ("name__ie".to_owned(), p.to_string()))
6794                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6795            ),
6796            _ => local_var_req_builder.query(&[(
6797                "name__ie",
6798                &local_var_str
6799                    .into_iter()
6800                    .map(|p| p.to_string())
6801                    .collect::<Vec<String>>()
6802                    .join(",")
6803                    .to_string(),
6804            )]),
6805        };
6806    }
6807    if let Some(ref local_var_str) = name__iew {
6808        local_var_req_builder = match "multi" {
6809            "multi" => local_var_req_builder.query(
6810                &local_var_str
6811                    .into_iter()
6812                    .map(|p| ("name__iew".to_owned(), p.to_string()))
6813                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6814            ),
6815            _ => local_var_req_builder.query(&[(
6816                "name__iew",
6817                &local_var_str
6818                    .into_iter()
6819                    .map(|p| p.to_string())
6820                    .collect::<Vec<String>>()
6821                    .join(",")
6822                    .to_string(),
6823            )]),
6824        };
6825    }
6826    if let Some(ref local_var_str) = name__iregex {
6827        local_var_req_builder = match "multi" {
6828            "multi" => local_var_req_builder.query(
6829                &local_var_str
6830                    .into_iter()
6831                    .map(|p| ("name__iregex".to_owned(), p.to_string()))
6832                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6833            ),
6834            _ => local_var_req_builder.query(&[(
6835                "name__iregex",
6836                &local_var_str
6837                    .into_iter()
6838                    .map(|p| p.to_string())
6839                    .collect::<Vec<String>>()
6840                    .join(",")
6841                    .to_string(),
6842            )]),
6843        };
6844    }
6845    if let Some(ref local_var_str) = name__isw {
6846        local_var_req_builder = match "multi" {
6847            "multi" => local_var_req_builder.query(
6848                &local_var_str
6849                    .into_iter()
6850                    .map(|p| ("name__isw".to_owned(), p.to_string()))
6851                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6852            ),
6853            _ => local_var_req_builder.query(&[(
6854                "name__isw",
6855                &local_var_str
6856                    .into_iter()
6857                    .map(|p| p.to_string())
6858                    .collect::<Vec<String>>()
6859                    .join(",")
6860                    .to_string(),
6861            )]),
6862        };
6863    }
6864    if let Some(ref local_var_str) = name__n {
6865        local_var_req_builder = match "multi" {
6866            "multi" => local_var_req_builder.query(
6867                &local_var_str
6868                    .into_iter()
6869                    .map(|p| ("name__n".to_owned(), p.to_string()))
6870                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6871            ),
6872            _ => local_var_req_builder.query(&[(
6873                "name__n",
6874                &local_var_str
6875                    .into_iter()
6876                    .map(|p| p.to_string())
6877                    .collect::<Vec<String>>()
6878                    .join(",")
6879                    .to_string(),
6880            )]),
6881        };
6882    }
6883    if let Some(ref local_var_str) = name__nic {
6884        local_var_req_builder = match "multi" {
6885            "multi" => local_var_req_builder.query(
6886                &local_var_str
6887                    .into_iter()
6888                    .map(|p| ("name__nic".to_owned(), p.to_string()))
6889                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6890            ),
6891            _ => local_var_req_builder.query(&[(
6892                "name__nic",
6893                &local_var_str
6894                    .into_iter()
6895                    .map(|p| p.to_string())
6896                    .collect::<Vec<String>>()
6897                    .join(",")
6898                    .to_string(),
6899            )]),
6900        };
6901    }
6902    if let Some(ref local_var_str) = name__nie {
6903        local_var_req_builder = match "multi" {
6904            "multi" => local_var_req_builder.query(
6905                &local_var_str
6906                    .into_iter()
6907                    .map(|p| ("name__nie".to_owned(), p.to_string()))
6908                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6909            ),
6910            _ => local_var_req_builder.query(&[(
6911                "name__nie",
6912                &local_var_str
6913                    .into_iter()
6914                    .map(|p| p.to_string())
6915                    .collect::<Vec<String>>()
6916                    .join(",")
6917                    .to_string(),
6918            )]),
6919        };
6920    }
6921    if let Some(ref local_var_str) = name__niew {
6922        local_var_req_builder = match "multi" {
6923            "multi" => local_var_req_builder.query(
6924                &local_var_str
6925                    .into_iter()
6926                    .map(|p| ("name__niew".to_owned(), p.to_string()))
6927                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6928            ),
6929            _ => local_var_req_builder.query(&[(
6930                "name__niew",
6931                &local_var_str
6932                    .into_iter()
6933                    .map(|p| p.to_string())
6934                    .collect::<Vec<String>>()
6935                    .join(",")
6936                    .to_string(),
6937            )]),
6938        };
6939    }
6940    if let Some(ref local_var_str) = name__nisw {
6941        local_var_req_builder = match "multi" {
6942            "multi" => local_var_req_builder.query(
6943                &local_var_str
6944                    .into_iter()
6945                    .map(|p| ("name__nisw".to_owned(), p.to_string()))
6946                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6947            ),
6948            _ => local_var_req_builder.query(&[(
6949                "name__nisw",
6950                &local_var_str
6951                    .into_iter()
6952                    .map(|p| p.to_string())
6953                    .collect::<Vec<String>>()
6954                    .join(",")
6955                    .to_string(),
6956            )]),
6957        };
6958    }
6959    if let Some(ref local_var_str) = name__regex {
6960        local_var_req_builder = match "multi" {
6961            "multi" => local_var_req_builder.query(
6962                &local_var_str
6963                    .into_iter()
6964                    .map(|p| ("name__regex".to_owned(), p.to_string()))
6965                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6966            ),
6967            _ => local_var_req_builder.query(&[(
6968                "name__regex",
6969                &local_var_str
6970                    .into_iter()
6971                    .map(|p| p.to_string())
6972                    .collect::<Vec<String>>()
6973                    .join(",")
6974                    .to_string(),
6975            )]),
6976        };
6977    }
6978    if let Some(ref local_var_str) = offset {
6979        local_var_req_builder =
6980            local_var_req_builder.query(&[("offset", &local_var_str.to_string())]);
6981    }
6982    if let Some(ref local_var_str) = ordering {
6983        local_var_req_builder =
6984            local_var_req_builder.query(&[("ordering", &local_var_str.to_string())]);
6985    }
6986    if let Some(ref local_var_str) = owner {
6987        local_var_req_builder = match "multi" {
6988            "multi" => local_var_req_builder.query(
6989                &local_var_str
6990                    .into_iter()
6991                    .map(|p| ("owner".to_owned(), p.to_string()))
6992                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6993            ),
6994            _ => local_var_req_builder.query(&[(
6995                "owner",
6996                &local_var_str
6997                    .into_iter()
6998                    .map(|p| p.to_string())
6999                    .collect::<Vec<String>>()
7000                    .join(",")
7001                    .to_string(),
7002            )]),
7003        };
7004    }
7005    if let Some(ref local_var_str) = owner__n {
7006        local_var_req_builder = match "multi" {
7007            "multi" => local_var_req_builder.query(
7008                &local_var_str
7009                    .into_iter()
7010                    .map(|p| ("owner__n".to_owned(), p.to_string()))
7011                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7012            ),
7013            _ => local_var_req_builder.query(&[(
7014                "owner__n",
7015                &local_var_str
7016                    .into_iter()
7017                    .map(|p| p.to_string())
7018                    .collect::<Vec<String>>()
7019                    .join(",")
7020                    .to_string(),
7021            )]),
7022        };
7023    }
7024    if let Some(ref local_var_str) = owner_group {
7025        local_var_req_builder = match "multi" {
7026            "multi" => local_var_req_builder.query(
7027                &local_var_str
7028                    .into_iter()
7029                    .map(|p| ("owner_group".to_owned(), p.to_string()))
7030                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7031            ),
7032            _ => local_var_req_builder.query(&[(
7033                "owner_group",
7034                &local_var_str
7035                    .into_iter()
7036                    .map(|p| p.to_string())
7037                    .collect::<Vec<String>>()
7038                    .join(",")
7039                    .to_string(),
7040            )]),
7041        };
7042    }
7043    if let Some(ref local_var_str) = owner_group__n {
7044        local_var_req_builder = match "multi" {
7045            "multi" => local_var_req_builder.query(
7046                &local_var_str
7047                    .into_iter()
7048                    .map(|p| ("owner_group__n".to_owned(), p.to_string()))
7049                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7050            ),
7051            _ => local_var_req_builder.query(&[(
7052                "owner_group__n",
7053                &local_var_str
7054                    .into_iter()
7055                    .map(|p| p.to_string())
7056                    .collect::<Vec<String>>()
7057                    .join(",")
7058                    .to_string(),
7059            )]),
7060        };
7061    }
7062    if let Some(ref local_var_str) = owner_group_id {
7063        local_var_req_builder = match "multi" {
7064            "multi" => local_var_req_builder.query(
7065                &local_var_str
7066                    .into_iter()
7067                    .map(|p| ("owner_group_id".to_owned(), p.to_string()))
7068                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7069            ),
7070            _ => local_var_req_builder.query(&[(
7071                "owner_group_id",
7072                &local_var_str
7073                    .into_iter()
7074                    .map(|p| p.to_string())
7075                    .collect::<Vec<String>>()
7076                    .join(",")
7077                    .to_string(),
7078            )]),
7079        };
7080    }
7081    if let Some(ref local_var_str) = owner_group_id__n {
7082        local_var_req_builder = match "multi" {
7083            "multi" => local_var_req_builder.query(
7084                &local_var_str
7085                    .into_iter()
7086                    .map(|p| ("owner_group_id__n".to_owned(), p.to_string()))
7087                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7088            ),
7089            _ => local_var_req_builder.query(&[(
7090                "owner_group_id__n",
7091                &local_var_str
7092                    .into_iter()
7093                    .map(|p| p.to_string())
7094                    .collect::<Vec<String>>()
7095                    .join(",")
7096                    .to_string(),
7097            )]),
7098        };
7099    }
7100    if let Some(ref local_var_str) = owner_id {
7101        local_var_req_builder = match "multi" {
7102            "multi" => local_var_req_builder.query(
7103                &local_var_str
7104                    .into_iter()
7105                    .map(|p| ("owner_id".to_owned(), p.to_string()))
7106                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7107            ),
7108            _ => local_var_req_builder.query(&[(
7109                "owner_id",
7110                &local_var_str
7111                    .into_iter()
7112                    .map(|p| p.to_string())
7113                    .collect::<Vec<String>>()
7114                    .join(",")
7115                    .to_string(),
7116            )]),
7117        };
7118    }
7119    if let Some(ref local_var_str) = owner_id__n {
7120        local_var_req_builder = match "multi" {
7121            "multi" => local_var_req_builder.query(
7122                &local_var_str
7123                    .into_iter()
7124                    .map(|p| ("owner_id__n".to_owned(), p.to_string()))
7125                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7126            ),
7127            _ => local_var_req_builder.query(&[(
7128                "owner_id__n",
7129                &local_var_str
7130                    .into_iter()
7131                    .map(|p| p.to_string())
7132                    .collect::<Vec<String>>()
7133                    .join(",")
7134                    .to_string(),
7135            )]),
7136        };
7137    }
7138    if let Some(ref local_var_str) = pfs_group {
7139        local_var_req_builder = match "multi" {
7140            "multi" => local_var_req_builder.query(
7141                &local_var_str
7142                    .into_iter()
7143                    .map(|p| ("pfs_group".to_owned(), p.to_string()))
7144                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7145            ),
7146            _ => local_var_req_builder.query(&[(
7147                "pfs_group",
7148                &local_var_str
7149                    .into_iter()
7150                    .map(|p| p.to_string())
7151                    .collect::<Vec<String>>()
7152                    .join(",")
7153                    .to_string(),
7154            )]),
7155        };
7156    }
7157    if let Some(ref local_var_str) = pfs_group__ic {
7158        local_var_req_builder = match "multi" {
7159            "multi" => local_var_req_builder.query(
7160                &local_var_str
7161                    .into_iter()
7162                    .map(|p| ("pfs_group__ic".to_owned(), p.to_string()))
7163                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7164            ),
7165            _ => local_var_req_builder.query(&[(
7166                "pfs_group__ic",
7167                &local_var_str
7168                    .into_iter()
7169                    .map(|p| p.to_string())
7170                    .collect::<Vec<String>>()
7171                    .join(",")
7172                    .to_string(),
7173            )]),
7174        };
7175    }
7176    if let Some(ref local_var_str) = pfs_group__ie {
7177        local_var_req_builder = match "multi" {
7178            "multi" => local_var_req_builder.query(
7179                &local_var_str
7180                    .into_iter()
7181                    .map(|p| ("pfs_group__ie".to_owned(), p.to_string()))
7182                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7183            ),
7184            _ => local_var_req_builder.query(&[(
7185                "pfs_group__ie",
7186                &local_var_str
7187                    .into_iter()
7188                    .map(|p| p.to_string())
7189                    .collect::<Vec<String>>()
7190                    .join(",")
7191                    .to_string(),
7192            )]),
7193        };
7194    }
7195    if let Some(ref local_var_str) = pfs_group__iew {
7196        local_var_req_builder = match "multi" {
7197            "multi" => local_var_req_builder.query(
7198                &local_var_str
7199                    .into_iter()
7200                    .map(|p| ("pfs_group__iew".to_owned(), p.to_string()))
7201                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7202            ),
7203            _ => local_var_req_builder.query(&[(
7204                "pfs_group__iew",
7205                &local_var_str
7206                    .into_iter()
7207                    .map(|p| p.to_string())
7208                    .collect::<Vec<String>>()
7209                    .join(",")
7210                    .to_string(),
7211            )]),
7212        };
7213    }
7214    if let Some(ref local_var_str) = pfs_group__iregex {
7215        local_var_req_builder = match "multi" {
7216            "multi" => local_var_req_builder.query(
7217                &local_var_str
7218                    .into_iter()
7219                    .map(|p| ("pfs_group__iregex".to_owned(), p.to_string()))
7220                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7221            ),
7222            _ => local_var_req_builder.query(&[(
7223                "pfs_group__iregex",
7224                &local_var_str
7225                    .into_iter()
7226                    .map(|p| p.to_string())
7227                    .collect::<Vec<String>>()
7228                    .join(",")
7229                    .to_string(),
7230            )]),
7231        };
7232    }
7233    if let Some(ref local_var_str) = pfs_group__isw {
7234        local_var_req_builder = match "multi" {
7235            "multi" => local_var_req_builder.query(
7236                &local_var_str
7237                    .into_iter()
7238                    .map(|p| ("pfs_group__isw".to_owned(), p.to_string()))
7239                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7240            ),
7241            _ => local_var_req_builder.query(&[(
7242                "pfs_group__isw",
7243                &local_var_str
7244                    .into_iter()
7245                    .map(|p| p.to_string())
7246                    .collect::<Vec<String>>()
7247                    .join(",")
7248                    .to_string(),
7249            )]),
7250        };
7251    }
7252    if let Some(ref local_var_str) = pfs_group__n {
7253        local_var_req_builder = match "multi" {
7254            "multi" => local_var_req_builder.query(
7255                &local_var_str
7256                    .into_iter()
7257                    .map(|p| ("pfs_group__n".to_owned(), p.to_string()))
7258                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7259            ),
7260            _ => local_var_req_builder.query(&[(
7261                "pfs_group__n",
7262                &local_var_str
7263                    .into_iter()
7264                    .map(|p| p.to_string())
7265                    .collect::<Vec<String>>()
7266                    .join(",")
7267                    .to_string(),
7268            )]),
7269        };
7270    }
7271    if let Some(ref local_var_str) = pfs_group__nic {
7272        local_var_req_builder = match "multi" {
7273            "multi" => local_var_req_builder.query(
7274                &local_var_str
7275                    .into_iter()
7276                    .map(|p| ("pfs_group__nic".to_owned(), p.to_string()))
7277                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7278            ),
7279            _ => local_var_req_builder.query(&[(
7280                "pfs_group__nic",
7281                &local_var_str
7282                    .into_iter()
7283                    .map(|p| p.to_string())
7284                    .collect::<Vec<String>>()
7285                    .join(",")
7286                    .to_string(),
7287            )]),
7288        };
7289    }
7290    if let Some(ref local_var_str) = pfs_group__nie {
7291        local_var_req_builder = match "multi" {
7292            "multi" => local_var_req_builder.query(
7293                &local_var_str
7294                    .into_iter()
7295                    .map(|p| ("pfs_group__nie".to_owned(), p.to_string()))
7296                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7297            ),
7298            _ => local_var_req_builder.query(&[(
7299                "pfs_group__nie",
7300                &local_var_str
7301                    .into_iter()
7302                    .map(|p| p.to_string())
7303                    .collect::<Vec<String>>()
7304                    .join(",")
7305                    .to_string(),
7306            )]),
7307        };
7308    }
7309    if let Some(ref local_var_str) = pfs_group__niew {
7310        local_var_req_builder = match "multi" {
7311            "multi" => local_var_req_builder.query(
7312                &local_var_str
7313                    .into_iter()
7314                    .map(|p| ("pfs_group__niew".to_owned(), p.to_string()))
7315                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7316            ),
7317            _ => local_var_req_builder.query(&[(
7318                "pfs_group__niew",
7319                &local_var_str
7320                    .into_iter()
7321                    .map(|p| p.to_string())
7322                    .collect::<Vec<String>>()
7323                    .join(",")
7324                    .to_string(),
7325            )]),
7326        };
7327    }
7328    if let Some(ref local_var_str) = pfs_group__nisw {
7329        local_var_req_builder = match "multi" {
7330            "multi" => local_var_req_builder.query(
7331                &local_var_str
7332                    .into_iter()
7333                    .map(|p| ("pfs_group__nisw".to_owned(), p.to_string()))
7334                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7335            ),
7336            _ => local_var_req_builder.query(&[(
7337                "pfs_group__nisw",
7338                &local_var_str
7339                    .into_iter()
7340                    .map(|p| p.to_string())
7341                    .collect::<Vec<String>>()
7342                    .join(",")
7343                    .to_string(),
7344            )]),
7345        };
7346    }
7347    if let Some(ref local_var_str) = pfs_group__regex {
7348        local_var_req_builder = match "multi" {
7349            "multi" => local_var_req_builder.query(
7350                &local_var_str
7351                    .into_iter()
7352                    .map(|p| ("pfs_group__regex".to_owned(), p.to_string()))
7353                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7354            ),
7355            _ => local_var_req_builder.query(&[(
7356                "pfs_group__regex",
7357                &local_var_str
7358                    .into_iter()
7359                    .map(|p| p.to_string())
7360                    .collect::<Vec<String>>()
7361                    .join(",")
7362                    .to_string(),
7363            )]),
7364        };
7365    }
7366    if let Some(ref local_var_str) = q {
7367        local_var_req_builder = local_var_req_builder.query(&[("q", &local_var_str.to_string())]);
7368    }
7369    if let Some(ref local_var_str) = tag {
7370        local_var_req_builder = match "multi" {
7371            "multi" => local_var_req_builder.query(
7372                &local_var_str
7373                    .into_iter()
7374                    .map(|p| ("tag".to_owned(), p.to_string()))
7375                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7376            ),
7377            _ => local_var_req_builder.query(&[(
7378                "tag",
7379                &local_var_str
7380                    .into_iter()
7381                    .map(|p| p.to_string())
7382                    .collect::<Vec<String>>()
7383                    .join(",")
7384                    .to_string(),
7385            )]),
7386        };
7387    }
7388    if let Some(ref local_var_str) = tag__n {
7389        local_var_req_builder = match "multi" {
7390            "multi" => local_var_req_builder.query(
7391                &local_var_str
7392                    .into_iter()
7393                    .map(|p| ("tag__n".to_owned(), p.to_string()))
7394                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7395            ),
7396            _ => local_var_req_builder.query(&[(
7397                "tag__n",
7398                &local_var_str
7399                    .into_iter()
7400                    .map(|p| p.to_string())
7401                    .collect::<Vec<String>>()
7402                    .join(",")
7403                    .to_string(),
7404            )]),
7405        };
7406    }
7407    if let Some(ref local_var_str) = tag_id {
7408        local_var_req_builder = match "multi" {
7409            "multi" => local_var_req_builder.query(
7410                &local_var_str
7411                    .into_iter()
7412                    .map(|p| ("tag_id".to_owned(), p.to_string()))
7413                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7414            ),
7415            _ => local_var_req_builder.query(&[(
7416                "tag_id",
7417                &local_var_str
7418                    .into_iter()
7419                    .map(|p| p.to_string())
7420                    .collect::<Vec<String>>()
7421                    .join(",")
7422                    .to_string(),
7423            )]),
7424        };
7425    }
7426    if let Some(ref local_var_str) = tag_id__n {
7427        local_var_req_builder = match "multi" {
7428            "multi" => local_var_req_builder.query(
7429                &local_var_str
7430                    .into_iter()
7431                    .map(|p| ("tag_id__n".to_owned(), p.to_string()))
7432                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7433            ),
7434            _ => local_var_req_builder.query(&[(
7435                "tag_id__n",
7436                &local_var_str
7437                    .into_iter()
7438                    .map(|p| p.to_string())
7439                    .collect::<Vec<String>>()
7440                    .join(",")
7441                    .to_string(),
7442            )]),
7443        };
7444    }
7445    if let Some(ref local_var_str) = updated_by_request {
7446        local_var_req_builder =
7447            local_var_req_builder.query(&[("updated_by_request", &local_var_str.to_string())]);
7448    }
7449    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
7450        local_var_req_builder =
7451            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
7452    }
7453    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
7454        let local_var_key = local_var_apikey.key.clone();
7455        let local_var_value = match local_var_apikey.prefix {
7456            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
7457            None => local_var_key,
7458        };
7459        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
7460    };
7461
7462    let local_var_req = local_var_req_builder.build()?;
7463    let local_var_resp = local_var_client.execute(local_var_req).await?;
7464
7465    let local_var_status = local_var_resp.status();
7466    let local_var_content = local_var_resp.text().await?;
7467
7468    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
7469        serde_json::from_str(&local_var_content).map_err(Error::from)
7470    } else {
7471        let local_var_entity: Option<VpnIpsecPoliciesListError> =
7472            serde_json::from_str(&local_var_content).ok();
7473        let local_var_error = ResponseContent {
7474            status: local_var_status,
7475            content: local_var_content,
7476            entity: local_var_entity,
7477        };
7478        Err(Error::ResponseError(local_var_error))
7479    }
7480}
7481
7482/// Patch a IPSec policy object.
7483pub async fn vpn_ipsec_policies_partial_update(
7484    configuration: &configuration::Configuration,
7485    id: i32,
7486    patched_writable_ip_sec_policy_request: Option<
7487        crate::models::PatchedWritableIpSecPolicyRequest,
7488    >,
7489) -> Result<crate::models::IpSecPolicy, Error<VpnIpsecPoliciesPartialUpdateError>> {
7490    let local_var_configuration = configuration;
7491
7492    let local_var_client = &local_var_configuration.client;
7493
7494    let local_var_uri_str = format!(
7495        "{}/api/vpn/ipsec-policies/{id}/",
7496        local_var_configuration.base_path,
7497        id = id
7498    );
7499    let mut local_var_req_builder =
7500        local_var_client.request(reqwest::Method::PATCH, local_var_uri_str.as_str());
7501
7502    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
7503        local_var_req_builder =
7504            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
7505    }
7506    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
7507        let local_var_key = local_var_apikey.key.clone();
7508        let local_var_value = match local_var_apikey.prefix {
7509            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
7510            None => local_var_key,
7511        };
7512        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
7513    };
7514    local_var_req_builder = local_var_req_builder.json(&patched_writable_ip_sec_policy_request);
7515
7516    let local_var_req = local_var_req_builder.build()?;
7517    let local_var_resp = local_var_client.execute(local_var_req).await?;
7518
7519    let local_var_status = local_var_resp.status();
7520    let local_var_content = local_var_resp.text().await?;
7521
7522    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
7523        serde_json::from_str(&local_var_content).map_err(Error::from)
7524    } else {
7525        let local_var_entity: Option<VpnIpsecPoliciesPartialUpdateError> =
7526            serde_json::from_str(&local_var_content).ok();
7527        let local_var_error = ResponseContent {
7528            status: local_var_status,
7529            content: local_var_content,
7530            entity: local_var_entity,
7531        };
7532        Err(Error::ResponseError(local_var_error))
7533    }
7534}
7535
7536/// Get a IPSec policy object.
7537pub async fn vpn_ipsec_policies_retrieve(
7538    configuration: &configuration::Configuration,
7539    id: i32,
7540) -> Result<crate::models::IpSecPolicy, Error<VpnIpsecPoliciesRetrieveError>> {
7541    let local_var_configuration = configuration;
7542
7543    let local_var_client = &local_var_configuration.client;
7544
7545    let local_var_uri_str = format!(
7546        "{}/api/vpn/ipsec-policies/{id}/",
7547        local_var_configuration.base_path,
7548        id = id
7549    );
7550    let mut local_var_req_builder =
7551        local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
7552
7553    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
7554        local_var_req_builder =
7555            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
7556    }
7557    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
7558        let local_var_key = local_var_apikey.key.clone();
7559        let local_var_value = match local_var_apikey.prefix {
7560            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
7561            None => local_var_key,
7562        };
7563        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
7564    };
7565
7566    let local_var_req = local_var_req_builder.build()?;
7567    let local_var_resp = local_var_client.execute(local_var_req).await?;
7568
7569    let local_var_status = local_var_resp.status();
7570    let local_var_content = local_var_resp.text().await?;
7571
7572    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
7573        serde_json::from_str(&local_var_content).map_err(Error::from)
7574    } else {
7575        let local_var_entity: Option<VpnIpsecPoliciesRetrieveError> =
7576            serde_json::from_str(&local_var_content).ok();
7577        let local_var_error = ResponseContent {
7578            status: local_var_status,
7579            content: local_var_content,
7580            entity: local_var_entity,
7581        };
7582        Err(Error::ResponseError(local_var_error))
7583    }
7584}
7585
7586/// Put a IPSec policy object.
7587pub async fn vpn_ipsec_policies_update(
7588    configuration: &configuration::Configuration,
7589    id: i32,
7590    writable_ip_sec_policy_request: crate::models::WritableIpSecPolicyRequest,
7591) -> Result<crate::models::IpSecPolicy, Error<VpnIpsecPoliciesUpdateError>> {
7592    let local_var_configuration = configuration;
7593
7594    let local_var_client = &local_var_configuration.client;
7595
7596    let local_var_uri_str = format!(
7597        "{}/api/vpn/ipsec-policies/{id}/",
7598        local_var_configuration.base_path,
7599        id = id
7600    );
7601    let mut local_var_req_builder =
7602        local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());
7603
7604    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
7605        local_var_req_builder =
7606            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
7607    }
7608    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
7609        let local_var_key = local_var_apikey.key.clone();
7610        let local_var_value = match local_var_apikey.prefix {
7611            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
7612            None => local_var_key,
7613        };
7614        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
7615    };
7616    local_var_req_builder = local_var_req_builder.json(&writable_ip_sec_policy_request);
7617
7618    let local_var_req = local_var_req_builder.build()?;
7619    let local_var_resp = local_var_client.execute(local_var_req).await?;
7620
7621    let local_var_status = local_var_resp.status();
7622    let local_var_content = local_var_resp.text().await?;
7623
7624    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
7625        serde_json::from_str(&local_var_content).map_err(Error::from)
7626    } else {
7627        let local_var_entity: Option<VpnIpsecPoliciesUpdateError> =
7628            serde_json::from_str(&local_var_content).ok();
7629        let local_var_error = ResponseContent {
7630            status: local_var_status,
7631            content: local_var_content,
7632            entity: local_var_entity,
7633        };
7634        Err(Error::ResponseError(local_var_error))
7635    }
7636}
7637
7638/// Delete a list of IPSec profile objects.
7639pub async fn vpn_ipsec_profiles_bulk_destroy(
7640    configuration: &configuration::Configuration,
7641    ip_sec_profile_request: Vec<crate::models::IpSecProfileRequest>,
7642) -> Result<(), Error<VpnIpsecProfilesBulkDestroyError>> {
7643    let local_var_configuration = configuration;
7644
7645    let local_var_client = &local_var_configuration.client;
7646
7647    let local_var_uri_str = format!(
7648        "{}/api/vpn/ipsec-profiles/",
7649        local_var_configuration.base_path
7650    );
7651    let mut local_var_req_builder =
7652        local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());
7653
7654    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
7655        local_var_req_builder =
7656            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
7657    }
7658    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
7659        let local_var_key = local_var_apikey.key.clone();
7660        let local_var_value = match local_var_apikey.prefix {
7661            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
7662            None => local_var_key,
7663        };
7664        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
7665    };
7666    local_var_req_builder = local_var_req_builder.json(&ip_sec_profile_request);
7667
7668    let local_var_req = local_var_req_builder.build()?;
7669    let local_var_resp = local_var_client.execute(local_var_req).await?;
7670
7671    let local_var_status = local_var_resp.status();
7672    let local_var_content = local_var_resp.text().await?;
7673
7674    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
7675        Ok(())
7676    } else {
7677        let local_var_entity: Option<VpnIpsecProfilesBulkDestroyError> =
7678            serde_json::from_str(&local_var_content).ok();
7679        let local_var_error = ResponseContent {
7680            status: local_var_status,
7681            content: local_var_content,
7682            entity: local_var_entity,
7683        };
7684        Err(Error::ResponseError(local_var_error))
7685    }
7686}
7687
7688/// Patch a list of IPSec profile objects.
7689pub async fn vpn_ipsec_profiles_bulk_partial_update(
7690    configuration: &configuration::Configuration,
7691    ip_sec_profile_request: Vec<crate::models::IpSecProfileRequest>,
7692) -> Result<Vec<crate::models::IpSecProfile>, Error<VpnIpsecProfilesBulkPartialUpdateError>> {
7693    let local_var_configuration = configuration;
7694
7695    let local_var_client = &local_var_configuration.client;
7696
7697    let local_var_uri_str = format!(
7698        "{}/api/vpn/ipsec-profiles/",
7699        local_var_configuration.base_path
7700    );
7701    let mut local_var_req_builder =
7702        local_var_client.request(reqwest::Method::PATCH, local_var_uri_str.as_str());
7703
7704    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
7705        local_var_req_builder =
7706            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
7707    }
7708    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
7709        let local_var_key = local_var_apikey.key.clone();
7710        let local_var_value = match local_var_apikey.prefix {
7711            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
7712            None => local_var_key,
7713        };
7714        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
7715    };
7716    local_var_req_builder = local_var_req_builder.json(&ip_sec_profile_request);
7717
7718    let local_var_req = local_var_req_builder.build()?;
7719    let local_var_resp = local_var_client.execute(local_var_req).await?;
7720
7721    let local_var_status = local_var_resp.status();
7722    let local_var_content = local_var_resp.text().await?;
7723
7724    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
7725        serde_json::from_str(&local_var_content).map_err(Error::from)
7726    } else {
7727        let local_var_entity: Option<VpnIpsecProfilesBulkPartialUpdateError> =
7728            serde_json::from_str(&local_var_content).ok();
7729        let local_var_error = ResponseContent {
7730            status: local_var_status,
7731            content: local_var_content,
7732            entity: local_var_entity,
7733        };
7734        Err(Error::ResponseError(local_var_error))
7735    }
7736}
7737
7738/// Put a list of IPSec profile objects.
7739pub async fn vpn_ipsec_profiles_bulk_update(
7740    configuration: &configuration::Configuration,
7741    ip_sec_profile_request: Vec<crate::models::IpSecProfileRequest>,
7742) -> Result<Vec<crate::models::IpSecProfile>, Error<VpnIpsecProfilesBulkUpdateError>> {
7743    let local_var_configuration = configuration;
7744
7745    let local_var_client = &local_var_configuration.client;
7746
7747    let local_var_uri_str = format!(
7748        "{}/api/vpn/ipsec-profiles/",
7749        local_var_configuration.base_path
7750    );
7751    let mut local_var_req_builder =
7752        local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());
7753
7754    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
7755        local_var_req_builder =
7756            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
7757    }
7758    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
7759        let local_var_key = local_var_apikey.key.clone();
7760        let local_var_value = match local_var_apikey.prefix {
7761            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
7762            None => local_var_key,
7763        };
7764        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
7765    };
7766    local_var_req_builder = local_var_req_builder.json(&ip_sec_profile_request);
7767
7768    let local_var_req = local_var_req_builder.build()?;
7769    let local_var_resp = local_var_client.execute(local_var_req).await?;
7770
7771    let local_var_status = local_var_resp.status();
7772    let local_var_content = local_var_resp.text().await?;
7773
7774    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
7775        serde_json::from_str(&local_var_content).map_err(Error::from)
7776    } else {
7777        let local_var_entity: Option<VpnIpsecProfilesBulkUpdateError> =
7778            serde_json::from_str(&local_var_content).ok();
7779        let local_var_error = ResponseContent {
7780            status: local_var_status,
7781            content: local_var_content,
7782            entity: local_var_entity,
7783        };
7784        Err(Error::ResponseError(local_var_error))
7785    }
7786}
7787
7788/// Post a list of IPSec profile objects.
7789pub async fn vpn_ipsec_profiles_create(
7790    configuration: &configuration::Configuration,
7791    vpn_ipsec_profiles_create_request: crate::models::VpnIpsecProfilesCreateRequest,
7792) -> Result<crate::models::IpSecProfile, Error<VpnIpsecProfilesCreateError>> {
7793    let local_var_configuration = configuration;
7794
7795    let local_var_client = &local_var_configuration.client;
7796
7797    let local_var_uri_str = format!(
7798        "{}/api/vpn/ipsec-profiles/",
7799        local_var_configuration.base_path
7800    );
7801    let mut local_var_req_builder =
7802        local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
7803
7804    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
7805        local_var_req_builder =
7806            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
7807    }
7808    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
7809        let local_var_key = local_var_apikey.key.clone();
7810        let local_var_value = match local_var_apikey.prefix {
7811            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
7812            None => local_var_key,
7813        };
7814        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
7815    };
7816    local_var_req_builder = local_var_req_builder.json(&vpn_ipsec_profiles_create_request);
7817
7818    let local_var_req = local_var_req_builder.build()?;
7819    let local_var_resp = local_var_client.execute(local_var_req).await?;
7820
7821    let local_var_status = local_var_resp.status();
7822    let local_var_content = local_var_resp.text().await?;
7823
7824    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
7825        serde_json::from_str(&local_var_content).map_err(Error::from)
7826    } else {
7827        let local_var_entity: Option<VpnIpsecProfilesCreateError> =
7828            serde_json::from_str(&local_var_content).ok();
7829        let local_var_error = ResponseContent {
7830            status: local_var_status,
7831            content: local_var_content,
7832            entity: local_var_entity,
7833        };
7834        Err(Error::ResponseError(local_var_error))
7835    }
7836}
7837
7838/// Delete a IPSec profile object.
7839pub async fn vpn_ipsec_profiles_destroy(
7840    configuration: &configuration::Configuration,
7841    id: i32,
7842) -> Result<(), Error<VpnIpsecProfilesDestroyError>> {
7843    let local_var_configuration = configuration;
7844
7845    let local_var_client = &local_var_configuration.client;
7846
7847    let local_var_uri_str = format!(
7848        "{}/api/vpn/ipsec-profiles/{id}/",
7849        local_var_configuration.base_path,
7850        id = id
7851    );
7852    let mut local_var_req_builder =
7853        local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());
7854
7855    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
7856        local_var_req_builder =
7857            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
7858    }
7859    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
7860        let local_var_key = local_var_apikey.key.clone();
7861        let local_var_value = match local_var_apikey.prefix {
7862            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
7863            None => local_var_key,
7864        };
7865        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
7866    };
7867
7868    let local_var_req = local_var_req_builder.build()?;
7869    let local_var_resp = local_var_client.execute(local_var_req).await?;
7870
7871    let local_var_status = local_var_resp.status();
7872    let local_var_content = local_var_resp.text().await?;
7873
7874    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
7875        Ok(())
7876    } else {
7877        let local_var_entity: Option<VpnIpsecProfilesDestroyError> =
7878            serde_json::from_str(&local_var_content).ok();
7879        let local_var_error = ResponseContent {
7880            status: local_var_status,
7881            content: local_var_content,
7882            entity: local_var_entity,
7883        };
7884        Err(Error::ResponseError(local_var_error))
7885    }
7886}
7887
7888/// Get a list of IPSec profile objects.
7889pub async fn vpn_ipsec_profiles_list(
7890    configuration: &configuration::Configuration,
7891    created: Option<Vec<String>>,
7892    created__empty: Option<Vec<String>>,
7893    created__gt: Option<Vec<String>>,
7894    created__gte: Option<Vec<String>>,
7895    created__lt: Option<Vec<String>>,
7896    created__lte: Option<Vec<String>>,
7897    created__n: Option<Vec<String>>,
7898    created_by_request: Option<&str>,
7899    description: Option<Vec<String>>,
7900    description__empty: Option<bool>,
7901    description__ic: Option<Vec<String>>,
7902    description__ie: Option<Vec<String>>,
7903    description__iew: Option<Vec<String>>,
7904    description__iregex: Option<Vec<String>>,
7905    description__isw: Option<Vec<String>>,
7906    description__n: Option<Vec<String>>,
7907    description__nic: Option<Vec<String>>,
7908    description__nie: Option<Vec<String>>,
7909    description__niew: Option<Vec<String>>,
7910    description__nisw: Option<Vec<String>>,
7911    description__regex: Option<Vec<String>>,
7912    id: Option<Vec<i32>>,
7913    id__empty: Option<bool>,
7914    id__gt: Option<Vec<i32>>,
7915    id__gte: Option<Vec<i32>>,
7916    id__lt: Option<Vec<i32>>,
7917    id__lte: Option<Vec<i32>>,
7918    id__n: Option<Vec<i32>>,
7919    ike_policy: Option<Vec<String>>,
7920    ike_policy__n: Option<Vec<String>>,
7921    ike_policy_id: Option<Vec<i32>>,
7922    ike_policy_id__n: Option<Vec<i32>>,
7923    ipsec_policy: Option<Vec<String>>,
7924    ipsec_policy__n: Option<Vec<String>>,
7925    ipsec_policy_id: Option<Vec<i32>>,
7926    ipsec_policy_id__n: Option<Vec<i32>>,
7927    last_updated: Option<Vec<String>>,
7928    last_updated__empty: Option<Vec<String>>,
7929    last_updated__gt: Option<Vec<String>>,
7930    last_updated__gte: Option<Vec<String>>,
7931    last_updated__lt: Option<Vec<String>>,
7932    last_updated__lte: Option<Vec<String>>,
7933    last_updated__n: Option<Vec<String>>,
7934    limit: Option<i32>,
7935    mode: Option<Vec<String>>,
7936    mode__empty: Option<bool>,
7937    mode__ic: Option<Vec<String>>,
7938    mode__ie: Option<Vec<String>>,
7939    mode__iew: Option<Vec<String>>,
7940    mode__iregex: Option<Vec<String>>,
7941    mode__isw: Option<Vec<String>>,
7942    mode__n: Option<Vec<String>>,
7943    mode__nic: Option<Vec<String>>,
7944    mode__nie: Option<Vec<String>>,
7945    mode__niew: Option<Vec<String>>,
7946    mode__nisw: Option<Vec<String>>,
7947    mode__regex: Option<Vec<String>>,
7948    modified_by_request: Option<&str>,
7949    name: Option<Vec<String>>,
7950    name__empty: Option<bool>,
7951    name__ic: Option<Vec<String>>,
7952    name__ie: Option<Vec<String>>,
7953    name__iew: Option<Vec<String>>,
7954    name__iregex: Option<Vec<String>>,
7955    name__isw: Option<Vec<String>>,
7956    name__n: Option<Vec<String>>,
7957    name__nic: Option<Vec<String>>,
7958    name__nie: Option<Vec<String>>,
7959    name__niew: Option<Vec<String>>,
7960    name__nisw: Option<Vec<String>>,
7961    name__regex: Option<Vec<String>>,
7962    offset: Option<i32>,
7963    ordering: Option<&str>,
7964    owner: Option<Vec<String>>,
7965    owner__n: Option<Vec<String>>,
7966    owner_group: Option<Vec<String>>,
7967    owner_group__n: Option<Vec<String>>,
7968    owner_group_id: Option<Vec<i32>>,
7969    owner_group_id__n: Option<Vec<i32>>,
7970    owner_id: Option<Vec<i32>>,
7971    owner_id__n: Option<Vec<i32>>,
7972    q: Option<&str>,
7973    tag: Option<Vec<String>>,
7974    tag__n: Option<Vec<String>>,
7975    tag_id: Option<Vec<i32>>,
7976    tag_id__n: Option<Vec<i32>>,
7977    updated_by_request: Option<&str>,
7978) -> Result<crate::models::PaginatedIpSecProfileList, Error<VpnIpsecProfilesListError>> {
7979    let local_var_configuration = configuration;
7980
7981    let local_var_client = &local_var_configuration.client;
7982
7983    let local_var_uri_str = format!(
7984        "{}/api/vpn/ipsec-profiles/",
7985        local_var_configuration.base_path
7986    );
7987    let mut local_var_req_builder =
7988        local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
7989
7990    if let Some(ref local_var_str) = created {
7991        local_var_req_builder = match "multi" {
7992            "multi" => local_var_req_builder.query(
7993                &local_var_str
7994                    .into_iter()
7995                    .map(|p| ("created".to_owned(), p.to_string()))
7996                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7997            ),
7998            _ => local_var_req_builder.query(&[(
7999                "created",
8000                &local_var_str
8001                    .into_iter()
8002                    .map(|p| p.to_string())
8003                    .collect::<Vec<String>>()
8004                    .join(",")
8005                    .to_string(),
8006            )]),
8007        };
8008    }
8009    if let Some(ref local_var_str) = created__empty {
8010        local_var_req_builder = match "multi" {
8011            "multi" => local_var_req_builder.query(
8012                &local_var_str
8013                    .into_iter()
8014                    .map(|p| ("created__empty".to_owned(), p.to_string()))
8015                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8016            ),
8017            _ => local_var_req_builder.query(&[(
8018                "created__empty",
8019                &local_var_str
8020                    .into_iter()
8021                    .map(|p| p.to_string())
8022                    .collect::<Vec<String>>()
8023                    .join(",")
8024                    .to_string(),
8025            )]),
8026        };
8027    }
8028    if let Some(ref local_var_str) = created__gt {
8029        local_var_req_builder = match "multi" {
8030            "multi" => local_var_req_builder.query(
8031                &local_var_str
8032                    .into_iter()
8033                    .map(|p| ("created__gt".to_owned(), p.to_string()))
8034                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8035            ),
8036            _ => local_var_req_builder.query(&[(
8037                "created__gt",
8038                &local_var_str
8039                    .into_iter()
8040                    .map(|p| p.to_string())
8041                    .collect::<Vec<String>>()
8042                    .join(",")
8043                    .to_string(),
8044            )]),
8045        };
8046    }
8047    if let Some(ref local_var_str) = created__gte {
8048        local_var_req_builder = match "multi" {
8049            "multi" => local_var_req_builder.query(
8050                &local_var_str
8051                    .into_iter()
8052                    .map(|p| ("created__gte".to_owned(), p.to_string()))
8053                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8054            ),
8055            _ => local_var_req_builder.query(&[(
8056                "created__gte",
8057                &local_var_str
8058                    .into_iter()
8059                    .map(|p| p.to_string())
8060                    .collect::<Vec<String>>()
8061                    .join(",")
8062                    .to_string(),
8063            )]),
8064        };
8065    }
8066    if let Some(ref local_var_str) = created__lt {
8067        local_var_req_builder = match "multi" {
8068            "multi" => local_var_req_builder.query(
8069                &local_var_str
8070                    .into_iter()
8071                    .map(|p| ("created__lt".to_owned(), p.to_string()))
8072                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8073            ),
8074            _ => local_var_req_builder.query(&[(
8075                "created__lt",
8076                &local_var_str
8077                    .into_iter()
8078                    .map(|p| p.to_string())
8079                    .collect::<Vec<String>>()
8080                    .join(",")
8081                    .to_string(),
8082            )]),
8083        };
8084    }
8085    if let Some(ref local_var_str) = created__lte {
8086        local_var_req_builder = match "multi" {
8087            "multi" => local_var_req_builder.query(
8088                &local_var_str
8089                    .into_iter()
8090                    .map(|p| ("created__lte".to_owned(), p.to_string()))
8091                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8092            ),
8093            _ => local_var_req_builder.query(&[(
8094                "created__lte",
8095                &local_var_str
8096                    .into_iter()
8097                    .map(|p| p.to_string())
8098                    .collect::<Vec<String>>()
8099                    .join(",")
8100                    .to_string(),
8101            )]),
8102        };
8103    }
8104    if let Some(ref local_var_str) = created__n {
8105        local_var_req_builder = match "multi" {
8106            "multi" => local_var_req_builder.query(
8107                &local_var_str
8108                    .into_iter()
8109                    .map(|p| ("created__n".to_owned(), p.to_string()))
8110                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8111            ),
8112            _ => local_var_req_builder.query(&[(
8113                "created__n",
8114                &local_var_str
8115                    .into_iter()
8116                    .map(|p| p.to_string())
8117                    .collect::<Vec<String>>()
8118                    .join(",")
8119                    .to_string(),
8120            )]),
8121        };
8122    }
8123    if let Some(ref local_var_str) = created_by_request {
8124        local_var_req_builder =
8125            local_var_req_builder.query(&[("created_by_request", &local_var_str.to_string())]);
8126    }
8127    if let Some(ref local_var_str) = description {
8128        local_var_req_builder = match "multi" {
8129            "multi" => local_var_req_builder.query(
8130                &local_var_str
8131                    .into_iter()
8132                    .map(|p| ("description".to_owned(), p.to_string()))
8133                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8134            ),
8135            _ => local_var_req_builder.query(&[(
8136                "description",
8137                &local_var_str
8138                    .into_iter()
8139                    .map(|p| p.to_string())
8140                    .collect::<Vec<String>>()
8141                    .join(",")
8142                    .to_string(),
8143            )]),
8144        };
8145    }
8146    if let Some(ref local_var_str) = description__empty {
8147        local_var_req_builder =
8148            local_var_req_builder.query(&[("description__empty", &local_var_str.to_string())]);
8149    }
8150    if let Some(ref local_var_str) = description__ic {
8151        local_var_req_builder = match "multi" {
8152            "multi" => local_var_req_builder.query(
8153                &local_var_str
8154                    .into_iter()
8155                    .map(|p| ("description__ic".to_owned(), p.to_string()))
8156                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8157            ),
8158            _ => local_var_req_builder.query(&[(
8159                "description__ic",
8160                &local_var_str
8161                    .into_iter()
8162                    .map(|p| p.to_string())
8163                    .collect::<Vec<String>>()
8164                    .join(",")
8165                    .to_string(),
8166            )]),
8167        };
8168    }
8169    if let Some(ref local_var_str) = description__ie {
8170        local_var_req_builder = match "multi" {
8171            "multi" => local_var_req_builder.query(
8172                &local_var_str
8173                    .into_iter()
8174                    .map(|p| ("description__ie".to_owned(), p.to_string()))
8175                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8176            ),
8177            _ => local_var_req_builder.query(&[(
8178                "description__ie",
8179                &local_var_str
8180                    .into_iter()
8181                    .map(|p| p.to_string())
8182                    .collect::<Vec<String>>()
8183                    .join(",")
8184                    .to_string(),
8185            )]),
8186        };
8187    }
8188    if let Some(ref local_var_str) = description__iew {
8189        local_var_req_builder = match "multi" {
8190            "multi" => local_var_req_builder.query(
8191                &local_var_str
8192                    .into_iter()
8193                    .map(|p| ("description__iew".to_owned(), p.to_string()))
8194                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8195            ),
8196            _ => local_var_req_builder.query(&[(
8197                "description__iew",
8198                &local_var_str
8199                    .into_iter()
8200                    .map(|p| p.to_string())
8201                    .collect::<Vec<String>>()
8202                    .join(",")
8203                    .to_string(),
8204            )]),
8205        };
8206    }
8207    if let Some(ref local_var_str) = description__iregex {
8208        local_var_req_builder = match "multi" {
8209            "multi" => local_var_req_builder.query(
8210                &local_var_str
8211                    .into_iter()
8212                    .map(|p| ("description__iregex".to_owned(), p.to_string()))
8213                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8214            ),
8215            _ => local_var_req_builder.query(&[(
8216                "description__iregex",
8217                &local_var_str
8218                    .into_iter()
8219                    .map(|p| p.to_string())
8220                    .collect::<Vec<String>>()
8221                    .join(",")
8222                    .to_string(),
8223            )]),
8224        };
8225    }
8226    if let Some(ref local_var_str) = description__isw {
8227        local_var_req_builder = match "multi" {
8228            "multi" => local_var_req_builder.query(
8229                &local_var_str
8230                    .into_iter()
8231                    .map(|p| ("description__isw".to_owned(), p.to_string()))
8232                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8233            ),
8234            _ => local_var_req_builder.query(&[(
8235                "description__isw",
8236                &local_var_str
8237                    .into_iter()
8238                    .map(|p| p.to_string())
8239                    .collect::<Vec<String>>()
8240                    .join(",")
8241                    .to_string(),
8242            )]),
8243        };
8244    }
8245    if let Some(ref local_var_str) = description__n {
8246        local_var_req_builder = match "multi" {
8247            "multi" => local_var_req_builder.query(
8248                &local_var_str
8249                    .into_iter()
8250                    .map(|p| ("description__n".to_owned(), p.to_string()))
8251                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8252            ),
8253            _ => local_var_req_builder.query(&[(
8254                "description__n",
8255                &local_var_str
8256                    .into_iter()
8257                    .map(|p| p.to_string())
8258                    .collect::<Vec<String>>()
8259                    .join(",")
8260                    .to_string(),
8261            )]),
8262        };
8263    }
8264    if let Some(ref local_var_str) = description__nic {
8265        local_var_req_builder = match "multi" {
8266            "multi" => local_var_req_builder.query(
8267                &local_var_str
8268                    .into_iter()
8269                    .map(|p| ("description__nic".to_owned(), p.to_string()))
8270                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8271            ),
8272            _ => local_var_req_builder.query(&[(
8273                "description__nic",
8274                &local_var_str
8275                    .into_iter()
8276                    .map(|p| p.to_string())
8277                    .collect::<Vec<String>>()
8278                    .join(",")
8279                    .to_string(),
8280            )]),
8281        };
8282    }
8283    if let Some(ref local_var_str) = description__nie {
8284        local_var_req_builder = match "multi" {
8285            "multi" => local_var_req_builder.query(
8286                &local_var_str
8287                    .into_iter()
8288                    .map(|p| ("description__nie".to_owned(), p.to_string()))
8289                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8290            ),
8291            _ => local_var_req_builder.query(&[(
8292                "description__nie",
8293                &local_var_str
8294                    .into_iter()
8295                    .map(|p| p.to_string())
8296                    .collect::<Vec<String>>()
8297                    .join(",")
8298                    .to_string(),
8299            )]),
8300        };
8301    }
8302    if let Some(ref local_var_str) = description__niew {
8303        local_var_req_builder = match "multi" {
8304            "multi" => local_var_req_builder.query(
8305                &local_var_str
8306                    .into_iter()
8307                    .map(|p| ("description__niew".to_owned(), p.to_string()))
8308                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8309            ),
8310            _ => local_var_req_builder.query(&[(
8311                "description__niew",
8312                &local_var_str
8313                    .into_iter()
8314                    .map(|p| p.to_string())
8315                    .collect::<Vec<String>>()
8316                    .join(",")
8317                    .to_string(),
8318            )]),
8319        };
8320    }
8321    if let Some(ref local_var_str) = description__nisw {
8322        local_var_req_builder = match "multi" {
8323            "multi" => local_var_req_builder.query(
8324                &local_var_str
8325                    .into_iter()
8326                    .map(|p| ("description__nisw".to_owned(), p.to_string()))
8327                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8328            ),
8329            _ => local_var_req_builder.query(&[(
8330                "description__nisw",
8331                &local_var_str
8332                    .into_iter()
8333                    .map(|p| p.to_string())
8334                    .collect::<Vec<String>>()
8335                    .join(",")
8336                    .to_string(),
8337            )]),
8338        };
8339    }
8340    if let Some(ref local_var_str) = description__regex {
8341        local_var_req_builder = match "multi" {
8342            "multi" => local_var_req_builder.query(
8343                &local_var_str
8344                    .into_iter()
8345                    .map(|p| ("description__regex".to_owned(), p.to_string()))
8346                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8347            ),
8348            _ => local_var_req_builder.query(&[(
8349                "description__regex",
8350                &local_var_str
8351                    .into_iter()
8352                    .map(|p| p.to_string())
8353                    .collect::<Vec<String>>()
8354                    .join(",")
8355                    .to_string(),
8356            )]),
8357        };
8358    }
8359    if let Some(ref local_var_str) = id {
8360        local_var_req_builder = match "multi" {
8361            "multi" => local_var_req_builder.query(
8362                &local_var_str
8363                    .into_iter()
8364                    .map(|p| ("id".to_owned(), p.to_string()))
8365                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8366            ),
8367            _ => local_var_req_builder.query(&[(
8368                "id",
8369                &local_var_str
8370                    .into_iter()
8371                    .map(|p| p.to_string())
8372                    .collect::<Vec<String>>()
8373                    .join(",")
8374                    .to_string(),
8375            )]),
8376        };
8377    }
8378    if let Some(ref local_var_str) = id__empty {
8379        local_var_req_builder =
8380            local_var_req_builder.query(&[("id__empty", &local_var_str.to_string())]);
8381    }
8382    if let Some(ref local_var_str) = id__gt {
8383        local_var_req_builder = match "multi" {
8384            "multi" => local_var_req_builder.query(
8385                &local_var_str
8386                    .into_iter()
8387                    .map(|p| ("id__gt".to_owned(), p.to_string()))
8388                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8389            ),
8390            _ => local_var_req_builder.query(&[(
8391                "id__gt",
8392                &local_var_str
8393                    .into_iter()
8394                    .map(|p| p.to_string())
8395                    .collect::<Vec<String>>()
8396                    .join(",")
8397                    .to_string(),
8398            )]),
8399        };
8400    }
8401    if let Some(ref local_var_str) = id__gte {
8402        local_var_req_builder = match "multi" {
8403            "multi" => local_var_req_builder.query(
8404                &local_var_str
8405                    .into_iter()
8406                    .map(|p| ("id__gte".to_owned(), p.to_string()))
8407                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8408            ),
8409            _ => local_var_req_builder.query(&[(
8410                "id__gte",
8411                &local_var_str
8412                    .into_iter()
8413                    .map(|p| p.to_string())
8414                    .collect::<Vec<String>>()
8415                    .join(",")
8416                    .to_string(),
8417            )]),
8418        };
8419    }
8420    if let Some(ref local_var_str) = id__lt {
8421        local_var_req_builder = match "multi" {
8422            "multi" => local_var_req_builder.query(
8423                &local_var_str
8424                    .into_iter()
8425                    .map(|p| ("id__lt".to_owned(), p.to_string()))
8426                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8427            ),
8428            _ => local_var_req_builder.query(&[(
8429                "id__lt",
8430                &local_var_str
8431                    .into_iter()
8432                    .map(|p| p.to_string())
8433                    .collect::<Vec<String>>()
8434                    .join(",")
8435                    .to_string(),
8436            )]),
8437        };
8438    }
8439    if let Some(ref local_var_str) = id__lte {
8440        local_var_req_builder = match "multi" {
8441            "multi" => local_var_req_builder.query(
8442                &local_var_str
8443                    .into_iter()
8444                    .map(|p| ("id__lte".to_owned(), p.to_string()))
8445                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8446            ),
8447            _ => local_var_req_builder.query(&[(
8448                "id__lte",
8449                &local_var_str
8450                    .into_iter()
8451                    .map(|p| p.to_string())
8452                    .collect::<Vec<String>>()
8453                    .join(",")
8454                    .to_string(),
8455            )]),
8456        };
8457    }
8458    if let Some(ref local_var_str) = id__n {
8459        local_var_req_builder = match "multi" {
8460            "multi" => local_var_req_builder.query(
8461                &local_var_str
8462                    .into_iter()
8463                    .map(|p| ("id__n".to_owned(), p.to_string()))
8464                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8465            ),
8466            _ => local_var_req_builder.query(&[(
8467                "id__n",
8468                &local_var_str
8469                    .into_iter()
8470                    .map(|p| p.to_string())
8471                    .collect::<Vec<String>>()
8472                    .join(",")
8473                    .to_string(),
8474            )]),
8475        };
8476    }
8477    if let Some(ref local_var_str) = ike_policy {
8478        local_var_req_builder = match "multi" {
8479            "multi" => local_var_req_builder.query(
8480                &local_var_str
8481                    .into_iter()
8482                    .map(|p| ("ike_policy".to_owned(), p.to_string()))
8483                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8484            ),
8485            _ => local_var_req_builder.query(&[(
8486                "ike_policy",
8487                &local_var_str
8488                    .into_iter()
8489                    .map(|p| p.to_string())
8490                    .collect::<Vec<String>>()
8491                    .join(",")
8492                    .to_string(),
8493            )]),
8494        };
8495    }
8496    if let Some(ref local_var_str) = ike_policy__n {
8497        local_var_req_builder = match "multi" {
8498            "multi" => local_var_req_builder.query(
8499                &local_var_str
8500                    .into_iter()
8501                    .map(|p| ("ike_policy__n".to_owned(), p.to_string()))
8502                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8503            ),
8504            _ => local_var_req_builder.query(&[(
8505                "ike_policy__n",
8506                &local_var_str
8507                    .into_iter()
8508                    .map(|p| p.to_string())
8509                    .collect::<Vec<String>>()
8510                    .join(",")
8511                    .to_string(),
8512            )]),
8513        };
8514    }
8515    if let Some(ref local_var_str) = ike_policy_id {
8516        local_var_req_builder = match "multi" {
8517            "multi" => local_var_req_builder.query(
8518                &local_var_str
8519                    .into_iter()
8520                    .map(|p| ("ike_policy_id".to_owned(), p.to_string()))
8521                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8522            ),
8523            _ => local_var_req_builder.query(&[(
8524                "ike_policy_id",
8525                &local_var_str
8526                    .into_iter()
8527                    .map(|p| p.to_string())
8528                    .collect::<Vec<String>>()
8529                    .join(",")
8530                    .to_string(),
8531            )]),
8532        };
8533    }
8534    if let Some(ref local_var_str) = ike_policy_id__n {
8535        local_var_req_builder = match "multi" {
8536            "multi" => local_var_req_builder.query(
8537                &local_var_str
8538                    .into_iter()
8539                    .map(|p| ("ike_policy_id__n".to_owned(), p.to_string()))
8540                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8541            ),
8542            _ => local_var_req_builder.query(&[(
8543                "ike_policy_id__n",
8544                &local_var_str
8545                    .into_iter()
8546                    .map(|p| p.to_string())
8547                    .collect::<Vec<String>>()
8548                    .join(",")
8549                    .to_string(),
8550            )]),
8551        };
8552    }
8553    if let Some(ref local_var_str) = ipsec_policy {
8554        local_var_req_builder = match "multi" {
8555            "multi" => local_var_req_builder.query(
8556                &local_var_str
8557                    .into_iter()
8558                    .map(|p| ("ipsec_policy".to_owned(), p.to_string()))
8559                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8560            ),
8561            _ => local_var_req_builder.query(&[(
8562                "ipsec_policy",
8563                &local_var_str
8564                    .into_iter()
8565                    .map(|p| p.to_string())
8566                    .collect::<Vec<String>>()
8567                    .join(",")
8568                    .to_string(),
8569            )]),
8570        };
8571    }
8572    if let Some(ref local_var_str) = ipsec_policy__n {
8573        local_var_req_builder = match "multi" {
8574            "multi" => local_var_req_builder.query(
8575                &local_var_str
8576                    .into_iter()
8577                    .map(|p| ("ipsec_policy__n".to_owned(), p.to_string()))
8578                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8579            ),
8580            _ => local_var_req_builder.query(&[(
8581                "ipsec_policy__n",
8582                &local_var_str
8583                    .into_iter()
8584                    .map(|p| p.to_string())
8585                    .collect::<Vec<String>>()
8586                    .join(",")
8587                    .to_string(),
8588            )]),
8589        };
8590    }
8591    if let Some(ref local_var_str) = ipsec_policy_id {
8592        local_var_req_builder = match "multi" {
8593            "multi" => local_var_req_builder.query(
8594                &local_var_str
8595                    .into_iter()
8596                    .map(|p| ("ipsec_policy_id".to_owned(), p.to_string()))
8597                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8598            ),
8599            _ => local_var_req_builder.query(&[(
8600                "ipsec_policy_id",
8601                &local_var_str
8602                    .into_iter()
8603                    .map(|p| p.to_string())
8604                    .collect::<Vec<String>>()
8605                    .join(",")
8606                    .to_string(),
8607            )]),
8608        };
8609    }
8610    if let Some(ref local_var_str) = ipsec_policy_id__n {
8611        local_var_req_builder = match "multi" {
8612            "multi" => local_var_req_builder.query(
8613                &local_var_str
8614                    .into_iter()
8615                    .map(|p| ("ipsec_policy_id__n".to_owned(), p.to_string()))
8616                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8617            ),
8618            _ => local_var_req_builder.query(&[(
8619                "ipsec_policy_id__n",
8620                &local_var_str
8621                    .into_iter()
8622                    .map(|p| p.to_string())
8623                    .collect::<Vec<String>>()
8624                    .join(",")
8625                    .to_string(),
8626            )]),
8627        };
8628    }
8629    if let Some(ref local_var_str) = last_updated {
8630        local_var_req_builder = match "multi" {
8631            "multi" => local_var_req_builder.query(
8632                &local_var_str
8633                    .into_iter()
8634                    .map(|p| ("last_updated".to_owned(), p.to_string()))
8635                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8636            ),
8637            _ => local_var_req_builder.query(&[(
8638                "last_updated",
8639                &local_var_str
8640                    .into_iter()
8641                    .map(|p| p.to_string())
8642                    .collect::<Vec<String>>()
8643                    .join(",")
8644                    .to_string(),
8645            )]),
8646        };
8647    }
8648    if let Some(ref local_var_str) = last_updated__empty {
8649        local_var_req_builder = match "multi" {
8650            "multi" => local_var_req_builder.query(
8651                &local_var_str
8652                    .into_iter()
8653                    .map(|p| ("last_updated__empty".to_owned(), p.to_string()))
8654                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8655            ),
8656            _ => local_var_req_builder.query(&[(
8657                "last_updated__empty",
8658                &local_var_str
8659                    .into_iter()
8660                    .map(|p| p.to_string())
8661                    .collect::<Vec<String>>()
8662                    .join(",")
8663                    .to_string(),
8664            )]),
8665        };
8666    }
8667    if let Some(ref local_var_str) = last_updated__gt {
8668        local_var_req_builder = match "multi" {
8669            "multi" => local_var_req_builder.query(
8670                &local_var_str
8671                    .into_iter()
8672                    .map(|p| ("last_updated__gt".to_owned(), p.to_string()))
8673                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8674            ),
8675            _ => local_var_req_builder.query(&[(
8676                "last_updated__gt",
8677                &local_var_str
8678                    .into_iter()
8679                    .map(|p| p.to_string())
8680                    .collect::<Vec<String>>()
8681                    .join(",")
8682                    .to_string(),
8683            )]),
8684        };
8685    }
8686    if let Some(ref local_var_str) = last_updated__gte {
8687        local_var_req_builder = match "multi" {
8688            "multi" => local_var_req_builder.query(
8689                &local_var_str
8690                    .into_iter()
8691                    .map(|p| ("last_updated__gte".to_owned(), p.to_string()))
8692                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8693            ),
8694            _ => local_var_req_builder.query(&[(
8695                "last_updated__gte",
8696                &local_var_str
8697                    .into_iter()
8698                    .map(|p| p.to_string())
8699                    .collect::<Vec<String>>()
8700                    .join(",")
8701                    .to_string(),
8702            )]),
8703        };
8704    }
8705    if let Some(ref local_var_str) = last_updated__lt {
8706        local_var_req_builder = match "multi" {
8707            "multi" => local_var_req_builder.query(
8708                &local_var_str
8709                    .into_iter()
8710                    .map(|p| ("last_updated__lt".to_owned(), p.to_string()))
8711                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8712            ),
8713            _ => local_var_req_builder.query(&[(
8714                "last_updated__lt",
8715                &local_var_str
8716                    .into_iter()
8717                    .map(|p| p.to_string())
8718                    .collect::<Vec<String>>()
8719                    .join(",")
8720                    .to_string(),
8721            )]),
8722        };
8723    }
8724    if let Some(ref local_var_str) = last_updated__lte {
8725        local_var_req_builder = match "multi" {
8726            "multi" => local_var_req_builder.query(
8727                &local_var_str
8728                    .into_iter()
8729                    .map(|p| ("last_updated__lte".to_owned(), p.to_string()))
8730                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8731            ),
8732            _ => local_var_req_builder.query(&[(
8733                "last_updated__lte",
8734                &local_var_str
8735                    .into_iter()
8736                    .map(|p| p.to_string())
8737                    .collect::<Vec<String>>()
8738                    .join(",")
8739                    .to_string(),
8740            )]),
8741        };
8742    }
8743    if let Some(ref local_var_str) = last_updated__n {
8744        local_var_req_builder = match "multi" {
8745            "multi" => local_var_req_builder.query(
8746                &local_var_str
8747                    .into_iter()
8748                    .map(|p| ("last_updated__n".to_owned(), p.to_string()))
8749                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8750            ),
8751            _ => local_var_req_builder.query(&[(
8752                "last_updated__n",
8753                &local_var_str
8754                    .into_iter()
8755                    .map(|p| p.to_string())
8756                    .collect::<Vec<String>>()
8757                    .join(",")
8758                    .to_string(),
8759            )]),
8760        };
8761    }
8762    if let Some(ref local_var_str) = limit {
8763        local_var_req_builder =
8764            local_var_req_builder.query(&[("limit", &local_var_str.to_string())]);
8765    }
8766    if let Some(ref local_var_str) = mode {
8767        local_var_req_builder = match "multi" {
8768            "multi" => local_var_req_builder.query(
8769                &local_var_str
8770                    .into_iter()
8771                    .map(|p| ("mode".to_owned(), p.to_string()))
8772                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8773            ),
8774            _ => local_var_req_builder.query(&[(
8775                "mode",
8776                &local_var_str
8777                    .into_iter()
8778                    .map(|p| p.to_string())
8779                    .collect::<Vec<String>>()
8780                    .join(",")
8781                    .to_string(),
8782            )]),
8783        };
8784    }
8785    if let Some(ref local_var_str) = mode__empty {
8786        local_var_req_builder =
8787            local_var_req_builder.query(&[("mode__empty", &local_var_str.to_string())]);
8788    }
8789    if let Some(ref local_var_str) = mode__ic {
8790        local_var_req_builder = match "multi" {
8791            "multi" => local_var_req_builder.query(
8792                &local_var_str
8793                    .into_iter()
8794                    .map(|p| ("mode__ic".to_owned(), p.to_string()))
8795                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8796            ),
8797            _ => local_var_req_builder.query(&[(
8798                "mode__ic",
8799                &local_var_str
8800                    .into_iter()
8801                    .map(|p| p.to_string())
8802                    .collect::<Vec<String>>()
8803                    .join(",")
8804                    .to_string(),
8805            )]),
8806        };
8807    }
8808    if let Some(ref local_var_str) = mode__ie {
8809        local_var_req_builder = match "multi" {
8810            "multi" => local_var_req_builder.query(
8811                &local_var_str
8812                    .into_iter()
8813                    .map(|p| ("mode__ie".to_owned(), p.to_string()))
8814                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8815            ),
8816            _ => local_var_req_builder.query(&[(
8817                "mode__ie",
8818                &local_var_str
8819                    .into_iter()
8820                    .map(|p| p.to_string())
8821                    .collect::<Vec<String>>()
8822                    .join(",")
8823                    .to_string(),
8824            )]),
8825        };
8826    }
8827    if let Some(ref local_var_str) = mode__iew {
8828        local_var_req_builder = match "multi" {
8829            "multi" => local_var_req_builder.query(
8830                &local_var_str
8831                    .into_iter()
8832                    .map(|p| ("mode__iew".to_owned(), p.to_string()))
8833                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8834            ),
8835            _ => local_var_req_builder.query(&[(
8836                "mode__iew",
8837                &local_var_str
8838                    .into_iter()
8839                    .map(|p| p.to_string())
8840                    .collect::<Vec<String>>()
8841                    .join(",")
8842                    .to_string(),
8843            )]),
8844        };
8845    }
8846    if let Some(ref local_var_str) = mode__iregex {
8847        local_var_req_builder = match "multi" {
8848            "multi" => local_var_req_builder.query(
8849                &local_var_str
8850                    .into_iter()
8851                    .map(|p| ("mode__iregex".to_owned(), p.to_string()))
8852                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8853            ),
8854            _ => local_var_req_builder.query(&[(
8855                "mode__iregex",
8856                &local_var_str
8857                    .into_iter()
8858                    .map(|p| p.to_string())
8859                    .collect::<Vec<String>>()
8860                    .join(",")
8861                    .to_string(),
8862            )]),
8863        };
8864    }
8865    if let Some(ref local_var_str) = mode__isw {
8866        local_var_req_builder = match "multi" {
8867            "multi" => local_var_req_builder.query(
8868                &local_var_str
8869                    .into_iter()
8870                    .map(|p| ("mode__isw".to_owned(), p.to_string()))
8871                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8872            ),
8873            _ => local_var_req_builder.query(&[(
8874                "mode__isw",
8875                &local_var_str
8876                    .into_iter()
8877                    .map(|p| p.to_string())
8878                    .collect::<Vec<String>>()
8879                    .join(",")
8880                    .to_string(),
8881            )]),
8882        };
8883    }
8884    if let Some(ref local_var_str) = mode__n {
8885        local_var_req_builder = match "multi" {
8886            "multi" => local_var_req_builder.query(
8887                &local_var_str
8888                    .into_iter()
8889                    .map(|p| ("mode__n".to_owned(), p.to_string()))
8890                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8891            ),
8892            _ => local_var_req_builder.query(&[(
8893                "mode__n",
8894                &local_var_str
8895                    .into_iter()
8896                    .map(|p| p.to_string())
8897                    .collect::<Vec<String>>()
8898                    .join(",")
8899                    .to_string(),
8900            )]),
8901        };
8902    }
8903    if let Some(ref local_var_str) = mode__nic {
8904        local_var_req_builder = match "multi" {
8905            "multi" => local_var_req_builder.query(
8906                &local_var_str
8907                    .into_iter()
8908                    .map(|p| ("mode__nic".to_owned(), p.to_string()))
8909                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8910            ),
8911            _ => local_var_req_builder.query(&[(
8912                "mode__nic",
8913                &local_var_str
8914                    .into_iter()
8915                    .map(|p| p.to_string())
8916                    .collect::<Vec<String>>()
8917                    .join(",")
8918                    .to_string(),
8919            )]),
8920        };
8921    }
8922    if let Some(ref local_var_str) = mode__nie {
8923        local_var_req_builder = match "multi" {
8924            "multi" => local_var_req_builder.query(
8925                &local_var_str
8926                    .into_iter()
8927                    .map(|p| ("mode__nie".to_owned(), p.to_string()))
8928                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8929            ),
8930            _ => local_var_req_builder.query(&[(
8931                "mode__nie",
8932                &local_var_str
8933                    .into_iter()
8934                    .map(|p| p.to_string())
8935                    .collect::<Vec<String>>()
8936                    .join(",")
8937                    .to_string(),
8938            )]),
8939        };
8940    }
8941    if let Some(ref local_var_str) = mode__niew {
8942        local_var_req_builder = match "multi" {
8943            "multi" => local_var_req_builder.query(
8944                &local_var_str
8945                    .into_iter()
8946                    .map(|p| ("mode__niew".to_owned(), p.to_string()))
8947                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8948            ),
8949            _ => local_var_req_builder.query(&[(
8950                "mode__niew",
8951                &local_var_str
8952                    .into_iter()
8953                    .map(|p| p.to_string())
8954                    .collect::<Vec<String>>()
8955                    .join(",")
8956                    .to_string(),
8957            )]),
8958        };
8959    }
8960    if let Some(ref local_var_str) = mode__nisw {
8961        local_var_req_builder = match "multi" {
8962            "multi" => local_var_req_builder.query(
8963                &local_var_str
8964                    .into_iter()
8965                    .map(|p| ("mode__nisw".to_owned(), p.to_string()))
8966                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8967            ),
8968            _ => local_var_req_builder.query(&[(
8969                "mode__nisw",
8970                &local_var_str
8971                    .into_iter()
8972                    .map(|p| p.to_string())
8973                    .collect::<Vec<String>>()
8974                    .join(",")
8975                    .to_string(),
8976            )]),
8977        };
8978    }
8979    if let Some(ref local_var_str) = mode__regex {
8980        local_var_req_builder = match "multi" {
8981            "multi" => local_var_req_builder.query(
8982                &local_var_str
8983                    .into_iter()
8984                    .map(|p| ("mode__regex".to_owned(), p.to_string()))
8985                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8986            ),
8987            _ => local_var_req_builder.query(&[(
8988                "mode__regex",
8989                &local_var_str
8990                    .into_iter()
8991                    .map(|p| p.to_string())
8992                    .collect::<Vec<String>>()
8993                    .join(",")
8994                    .to_string(),
8995            )]),
8996        };
8997    }
8998    if let Some(ref local_var_str) = modified_by_request {
8999        local_var_req_builder =
9000            local_var_req_builder.query(&[("modified_by_request", &local_var_str.to_string())]);
9001    }
9002    if let Some(ref local_var_str) = name {
9003        local_var_req_builder = match "multi" {
9004            "multi" => local_var_req_builder.query(
9005                &local_var_str
9006                    .into_iter()
9007                    .map(|p| ("name".to_owned(), p.to_string()))
9008                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9009            ),
9010            _ => local_var_req_builder.query(&[(
9011                "name",
9012                &local_var_str
9013                    .into_iter()
9014                    .map(|p| p.to_string())
9015                    .collect::<Vec<String>>()
9016                    .join(",")
9017                    .to_string(),
9018            )]),
9019        };
9020    }
9021    if let Some(ref local_var_str) = name__empty {
9022        local_var_req_builder =
9023            local_var_req_builder.query(&[("name__empty", &local_var_str.to_string())]);
9024    }
9025    if let Some(ref local_var_str) = name__ic {
9026        local_var_req_builder = match "multi" {
9027            "multi" => local_var_req_builder.query(
9028                &local_var_str
9029                    .into_iter()
9030                    .map(|p| ("name__ic".to_owned(), p.to_string()))
9031                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9032            ),
9033            _ => local_var_req_builder.query(&[(
9034                "name__ic",
9035                &local_var_str
9036                    .into_iter()
9037                    .map(|p| p.to_string())
9038                    .collect::<Vec<String>>()
9039                    .join(",")
9040                    .to_string(),
9041            )]),
9042        };
9043    }
9044    if let Some(ref local_var_str) = name__ie {
9045        local_var_req_builder = match "multi" {
9046            "multi" => local_var_req_builder.query(
9047                &local_var_str
9048                    .into_iter()
9049                    .map(|p| ("name__ie".to_owned(), p.to_string()))
9050                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9051            ),
9052            _ => local_var_req_builder.query(&[(
9053                "name__ie",
9054                &local_var_str
9055                    .into_iter()
9056                    .map(|p| p.to_string())
9057                    .collect::<Vec<String>>()
9058                    .join(",")
9059                    .to_string(),
9060            )]),
9061        };
9062    }
9063    if let Some(ref local_var_str) = name__iew {
9064        local_var_req_builder = match "multi" {
9065            "multi" => local_var_req_builder.query(
9066                &local_var_str
9067                    .into_iter()
9068                    .map(|p| ("name__iew".to_owned(), p.to_string()))
9069                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9070            ),
9071            _ => local_var_req_builder.query(&[(
9072                "name__iew",
9073                &local_var_str
9074                    .into_iter()
9075                    .map(|p| p.to_string())
9076                    .collect::<Vec<String>>()
9077                    .join(",")
9078                    .to_string(),
9079            )]),
9080        };
9081    }
9082    if let Some(ref local_var_str) = name__iregex {
9083        local_var_req_builder = match "multi" {
9084            "multi" => local_var_req_builder.query(
9085                &local_var_str
9086                    .into_iter()
9087                    .map(|p| ("name__iregex".to_owned(), p.to_string()))
9088                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9089            ),
9090            _ => local_var_req_builder.query(&[(
9091                "name__iregex",
9092                &local_var_str
9093                    .into_iter()
9094                    .map(|p| p.to_string())
9095                    .collect::<Vec<String>>()
9096                    .join(",")
9097                    .to_string(),
9098            )]),
9099        };
9100    }
9101    if let Some(ref local_var_str) = name__isw {
9102        local_var_req_builder = match "multi" {
9103            "multi" => local_var_req_builder.query(
9104                &local_var_str
9105                    .into_iter()
9106                    .map(|p| ("name__isw".to_owned(), p.to_string()))
9107                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9108            ),
9109            _ => local_var_req_builder.query(&[(
9110                "name__isw",
9111                &local_var_str
9112                    .into_iter()
9113                    .map(|p| p.to_string())
9114                    .collect::<Vec<String>>()
9115                    .join(",")
9116                    .to_string(),
9117            )]),
9118        };
9119    }
9120    if let Some(ref local_var_str) = name__n {
9121        local_var_req_builder = match "multi" {
9122            "multi" => local_var_req_builder.query(
9123                &local_var_str
9124                    .into_iter()
9125                    .map(|p| ("name__n".to_owned(), p.to_string()))
9126                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9127            ),
9128            _ => local_var_req_builder.query(&[(
9129                "name__n",
9130                &local_var_str
9131                    .into_iter()
9132                    .map(|p| p.to_string())
9133                    .collect::<Vec<String>>()
9134                    .join(",")
9135                    .to_string(),
9136            )]),
9137        };
9138    }
9139    if let Some(ref local_var_str) = name__nic {
9140        local_var_req_builder = match "multi" {
9141            "multi" => local_var_req_builder.query(
9142                &local_var_str
9143                    .into_iter()
9144                    .map(|p| ("name__nic".to_owned(), p.to_string()))
9145                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9146            ),
9147            _ => local_var_req_builder.query(&[(
9148                "name__nic",
9149                &local_var_str
9150                    .into_iter()
9151                    .map(|p| p.to_string())
9152                    .collect::<Vec<String>>()
9153                    .join(",")
9154                    .to_string(),
9155            )]),
9156        };
9157    }
9158    if let Some(ref local_var_str) = name__nie {
9159        local_var_req_builder = match "multi" {
9160            "multi" => local_var_req_builder.query(
9161                &local_var_str
9162                    .into_iter()
9163                    .map(|p| ("name__nie".to_owned(), p.to_string()))
9164                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9165            ),
9166            _ => local_var_req_builder.query(&[(
9167                "name__nie",
9168                &local_var_str
9169                    .into_iter()
9170                    .map(|p| p.to_string())
9171                    .collect::<Vec<String>>()
9172                    .join(",")
9173                    .to_string(),
9174            )]),
9175        };
9176    }
9177    if let Some(ref local_var_str) = name__niew {
9178        local_var_req_builder = match "multi" {
9179            "multi" => local_var_req_builder.query(
9180                &local_var_str
9181                    .into_iter()
9182                    .map(|p| ("name__niew".to_owned(), p.to_string()))
9183                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9184            ),
9185            _ => local_var_req_builder.query(&[(
9186                "name__niew",
9187                &local_var_str
9188                    .into_iter()
9189                    .map(|p| p.to_string())
9190                    .collect::<Vec<String>>()
9191                    .join(",")
9192                    .to_string(),
9193            )]),
9194        };
9195    }
9196    if let Some(ref local_var_str) = name__nisw {
9197        local_var_req_builder = match "multi" {
9198            "multi" => local_var_req_builder.query(
9199                &local_var_str
9200                    .into_iter()
9201                    .map(|p| ("name__nisw".to_owned(), p.to_string()))
9202                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9203            ),
9204            _ => local_var_req_builder.query(&[(
9205                "name__nisw",
9206                &local_var_str
9207                    .into_iter()
9208                    .map(|p| p.to_string())
9209                    .collect::<Vec<String>>()
9210                    .join(",")
9211                    .to_string(),
9212            )]),
9213        };
9214    }
9215    if let Some(ref local_var_str) = name__regex {
9216        local_var_req_builder = match "multi" {
9217            "multi" => local_var_req_builder.query(
9218                &local_var_str
9219                    .into_iter()
9220                    .map(|p| ("name__regex".to_owned(), p.to_string()))
9221                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9222            ),
9223            _ => local_var_req_builder.query(&[(
9224                "name__regex",
9225                &local_var_str
9226                    .into_iter()
9227                    .map(|p| p.to_string())
9228                    .collect::<Vec<String>>()
9229                    .join(",")
9230                    .to_string(),
9231            )]),
9232        };
9233    }
9234    if let Some(ref local_var_str) = offset {
9235        local_var_req_builder =
9236            local_var_req_builder.query(&[("offset", &local_var_str.to_string())]);
9237    }
9238    if let Some(ref local_var_str) = ordering {
9239        local_var_req_builder =
9240            local_var_req_builder.query(&[("ordering", &local_var_str.to_string())]);
9241    }
9242    if let Some(ref local_var_str) = owner {
9243        local_var_req_builder = match "multi" {
9244            "multi" => local_var_req_builder.query(
9245                &local_var_str
9246                    .into_iter()
9247                    .map(|p| ("owner".to_owned(), p.to_string()))
9248                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9249            ),
9250            _ => local_var_req_builder.query(&[(
9251                "owner",
9252                &local_var_str
9253                    .into_iter()
9254                    .map(|p| p.to_string())
9255                    .collect::<Vec<String>>()
9256                    .join(",")
9257                    .to_string(),
9258            )]),
9259        };
9260    }
9261    if let Some(ref local_var_str) = owner__n {
9262        local_var_req_builder = match "multi" {
9263            "multi" => local_var_req_builder.query(
9264                &local_var_str
9265                    .into_iter()
9266                    .map(|p| ("owner__n".to_owned(), p.to_string()))
9267                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9268            ),
9269            _ => local_var_req_builder.query(&[(
9270                "owner__n",
9271                &local_var_str
9272                    .into_iter()
9273                    .map(|p| p.to_string())
9274                    .collect::<Vec<String>>()
9275                    .join(",")
9276                    .to_string(),
9277            )]),
9278        };
9279    }
9280    if let Some(ref local_var_str) = owner_group {
9281        local_var_req_builder = match "multi" {
9282            "multi" => local_var_req_builder.query(
9283                &local_var_str
9284                    .into_iter()
9285                    .map(|p| ("owner_group".to_owned(), p.to_string()))
9286                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9287            ),
9288            _ => local_var_req_builder.query(&[(
9289                "owner_group",
9290                &local_var_str
9291                    .into_iter()
9292                    .map(|p| p.to_string())
9293                    .collect::<Vec<String>>()
9294                    .join(",")
9295                    .to_string(),
9296            )]),
9297        };
9298    }
9299    if let Some(ref local_var_str) = owner_group__n {
9300        local_var_req_builder = match "multi" {
9301            "multi" => local_var_req_builder.query(
9302                &local_var_str
9303                    .into_iter()
9304                    .map(|p| ("owner_group__n".to_owned(), p.to_string()))
9305                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9306            ),
9307            _ => local_var_req_builder.query(&[(
9308                "owner_group__n",
9309                &local_var_str
9310                    .into_iter()
9311                    .map(|p| p.to_string())
9312                    .collect::<Vec<String>>()
9313                    .join(",")
9314                    .to_string(),
9315            )]),
9316        };
9317    }
9318    if let Some(ref local_var_str) = owner_group_id {
9319        local_var_req_builder = match "multi" {
9320            "multi" => local_var_req_builder.query(
9321                &local_var_str
9322                    .into_iter()
9323                    .map(|p| ("owner_group_id".to_owned(), p.to_string()))
9324                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9325            ),
9326            _ => local_var_req_builder.query(&[(
9327                "owner_group_id",
9328                &local_var_str
9329                    .into_iter()
9330                    .map(|p| p.to_string())
9331                    .collect::<Vec<String>>()
9332                    .join(",")
9333                    .to_string(),
9334            )]),
9335        };
9336    }
9337    if let Some(ref local_var_str) = owner_group_id__n {
9338        local_var_req_builder = match "multi" {
9339            "multi" => local_var_req_builder.query(
9340                &local_var_str
9341                    .into_iter()
9342                    .map(|p| ("owner_group_id__n".to_owned(), p.to_string()))
9343                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9344            ),
9345            _ => local_var_req_builder.query(&[(
9346                "owner_group_id__n",
9347                &local_var_str
9348                    .into_iter()
9349                    .map(|p| p.to_string())
9350                    .collect::<Vec<String>>()
9351                    .join(",")
9352                    .to_string(),
9353            )]),
9354        };
9355    }
9356    if let Some(ref local_var_str) = owner_id {
9357        local_var_req_builder = match "multi" {
9358            "multi" => local_var_req_builder.query(
9359                &local_var_str
9360                    .into_iter()
9361                    .map(|p| ("owner_id".to_owned(), p.to_string()))
9362                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9363            ),
9364            _ => local_var_req_builder.query(&[(
9365                "owner_id",
9366                &local_var_str
9367                    .into_iter()
9368                    .map(|p| p.to_string())
9369                    .collect::<Vec<String>>()
9370                    .join(",")
9371                    .to_string(),
9372            )]),
9373        };
9374    }
9375    if let Some(ref local_var_str) = owner_id__n {
9376        local_var_req_builder = match "multi" {
9377            "multi" => local_var_req_builder.query(
9378                &local_var_str
9379                    .into_iter()
9380                    .map(|p| ("owner_id__n".to_owned(), p.to_string()))
9381                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9382            ),
9383            _ => local_var_req_builder.query(&[(
9384                "owner_id__n",
9385                &local_var_str
9386                    .into_iter()
9387                    .map(|p| p.to_string())
9388                    .collect::<Vec<String>>()
9389                    .join(",")
9390                    .to_string(),
9391            )]),
9392        };
9393    }
9394    if let Some(ref local_var_str) = q {
9395        local_var_req_builder = local_var_req_builder.query(&[("q", &local_var_str.to_string())]);
9396    }
9397    if let Some(ref local_var_str) = tag {
9398        local_var_req_builder = match "multi" {
9399            "multi" => local_var_req_builder.query(
9400                &local_var_str
9401                    .into_iter()
9402                    .map(|p| ("tag".to_owned(), p.to_string()))
9403                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9404            ),
9405            _ => local_var_req_builder.query(&[(
9406                "tag",
9407                &local_var_str
9408                    .into_iter()
9409                    .map(|p| p.to_string())
9410                    .collect::<Vec<String>>()
9411                    .join(",")
9412                    .to_string(),
9413            )]),
9414        };
9415    }
9416    if let Some(ref local_var_str) = tag__n {
9417        local_var_req_builder = match "multi" {
9418            "multi" => local_var_req_builder.query(
9419                &local_var_str
9420                    .into_iter()
9421                    .map(|p| ("tag__n".to_owned(), p.to_string()))
9422                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9423            ),
9424            _ => local_var_req_builder.query(&[(
9425                "tag__n",
9426                &local_var_str
9427                    .into_iter()
9428                    .map(|p| p.to_string())
9429                    .collect::<Vec<String>>()
9430                    .join(",")
9431                    .to_string(),
9432            )]),
9433        };
9434    }
9435    if let Some(ref local_var_str) = tag_id {
9436        local_var_req_builder = match "multi" {
9437            "multi" => local_var_req_builder.query(
9438                &local_var_str
9439                    .into_iter()
9440                    .map(|p| ("tag_id".to_owned(), p.to_string()))
9441                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9442            ),
9443            _ => local_var_req_builder.query(&[(
9444                "tag_id",
9445                &local_var_str
9446                    .into_iter()
9447                    .map(|p| p.to_string())
9448                    .collect::<Vec<String>>()
9449                    .join(",")
9450                    .to_string(),
9451            )]),
9452        };
9453    }
9454    if let Some(ref local_var_str) = tag_id__n {
9455        local_var_req_builder = match "multi" {
9456            "multi" => local_var_req_builder.query(
9457                &local_var_str
9458                    .into_iter()
9459                    .map(|p| ("tag_id__n".to_owned(), p.to_string()))
9460                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9461            ),
9462            _ => local_var_req_builder.query(&[(
9463                "tag_id__n",
9464                &local_var_str
9465                    .into_iter()
9466                    .map(|p| p.to_string())
9467                    .collect::<Vec<String>>()
9468                    .join(",")
9469                    .to_string(),
9470            )]),
9471        };
9472    }
9473    if let Some(ref local_var_str) = updated_by_request {
9474        local_var_req_builder =
9475            local_var_req_builder.query(&[("updated_by_request", &local_var_str.to_string())]);
9476    }
9477    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
9478        local_var_req_builder =
9479            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
9480    }
9481    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
9482        let local_var_key = local_var_apikey.key.clone();
9483        let local_var_value = match local_var_apikey.prefix {
9484            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
9485            None => local_var_key,
9486        };
9487        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
9488    };
9489
9490    let local_var_req = local_var_req_builder.build()?;
9491    let local_var_resp = local_var_client.execute(local_var_req).await?;
9492
9493    let local_var_status = local_var_resp.status();
9494    let local_var_content = local_var_resp.text().await?;
9495
9496    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
9497        serde_json::from_str(&local_var_content).map_err(Error::from)
9498    } else {
9499        let local_var_entity: Option<VpnIpsecProfilesListError> =
9500            serde_json::from_str(&local_var_content).ok();
9501        let local_var_error = ResponseContent {
9502            status: local_var_status,
9503            content: local_var_content,
9504            entity: local_var_entity,
9505        };
9506        Err(Error::ResponseError(local_var_error))
9507    }
9508}
9509
9510/// Patch a IPSec profile object.
9511pub async fn vpn_ipsec_profiles_partial_update(
9512    configuration: &configuration::Configuration,
9513    id: i32,
9514    patched_writable_ip_sec_profile_request: Option<
9515        crate::models::PatchedWritableIpSecProfileRequest,
9516    >,
9517) -> Result<crate::models::IpSecProfile, Error<VpnIpsecProfilesPartialUpdateError>> {
9518    let local_var_configuration = configuration;
9519
9520    let local_var_client = &local_var_configuration.client;
9521
9522    let local_var_uri_str = format!(
9523        "{}/api/vpn/ipsec-profiles/{id}/",
9524        local_var_configuration.base_path,
9525        id = id
9526    );
9527    let mut local_var_req_builder =
9528        local_var_client.request(reqwest::Method::PATCH, local_var_uri_str.as_str());
9529
9530    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
9531        local_var_req_builder =
9532            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
9533    }
9534    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
9535        let local_var_key = local_var_apikey.key.clone();
9536        let local_var_value = match local_var_apikey.prefix {
9537            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
9538            None => local_var_key,
9539        };
9540        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
9541    };
9542    local_var_req_builder = local_var_req_builder.json(&patched_writable_ip_sec_profile_request);
9543
9544    let local_var_req = local_var_req_builder.build()?;
9545    let local_var_resp = local_var_client.execute(local_var_req).await?;
9546
9547    let local_var_status = local_var_resp.status();
9548    let local_var_content = local_var_resp.text().await?;
9549
9550    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
9551        serde_json::from_str(&local_var_content).map_err(Error::from)
9552    } else {
9553        let local_var_entity: Option<VpnIpsecProfilesPartialUpdateError> =
9554            serde_json::from_str(&local_var_content).ok();
9555        let local_var_error = ResponseContent {
9556            status: local_var_status,
9557            content: local_var_content,
9558            entity: local_var_entity,
9559        };
9560        Err(Error::ResponseError(local_var_error))
9561    }
9562}
9563
9564/// Get a IPSec profile object.
9565pub async fn vpn_ipsec_profiles_retrieve(
9566    configuration: &configuration::Configuration,
9567    id: i32,
9568) -> Result<crate::models::IpSecProfile, Error<VpnIpsecProfilesRetrieveError>> {
9569    let local_var_configuration = configuration;
9570
9571    let local_var_client = &local_var_configuration.client;
9572
9573    let local_var_uri_str = format!(
9574        "{}/api/vpn/ipsec-profiles/{id}/",
9575        local_var_configuration.base_path,
9576        id = id
9577    );
9578    let mut local_var_req_builder =
9579        local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
9580
9581    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
9582        local_var_req_builder =
9583            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
9584    }
9585    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
9586        let local_var_key = local_var_apikey.key.clone();
9587        let local_var_value = match local_var_apikey.prefix {
9588            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
9589            None => local_var_key,
9590        };
9591        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
9592    };
9593
9594    let local_var_req = local_var_req_builder.build()?;
9595    let local_var_resp = local_var_client.execute(local_var_req).await?;
9596
9597    let local_var_status = local_var_resp.status();
9598    let local_var_content = local_var_resp.text().await?;
9599
9600    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
9601        serde_json::from_str(&local_var_content).map_err(Error::from)
9602    } else {
9603        let local_var_entity: Option<VpnIpsecProfilesRetrieveError> =
9604            serde_json::from_str(&local_var_content).ok();
9605        let local_var_error = ResponseContent {
9606            status: local_var_status,
9607            content: local_var_content,
9608            entity: local_var_entity,
9609        };
9610        Err(Error::ResponseError(local_var_error))
9611    }
9612}
9613
9614/// Put a IPSec profile object.
9615pub async fn vpn_ipsec_profiles_update(
9616    configuration: &configuration::Configuration,
9617    id: i32,
9618    writable_ip_sec_profile_request: crate::models::WritableIpSecProfileRequest,
9619) -> Result<crate::models::IpSecProfile, Error<VpnIpsecProfilesUpdateError>> {
9620    let local_var_configuration = configuration;
9621
9622    let local_var_client = &local_var_configuration.client;
9623
9624    let local_var_uri_str = format!(
9625        "{}/api/vpn/ipsec-profiles/{id}/",
9626        local_var_configuration.base_path,
9627        id = id
9628    );
9629    let mut local_var_req_builder =
9630        local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());
9631
9632    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
9633        local_var_req_builder =
9634            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
9635    }
9636    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
9637        let local_var_key = local_var_apikey.key.clone();
9638        let local_var_value = match local_var_apikey.prefix {
9639            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
9640            None => local_var_key,
9641        };
9642        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
9643    };
9644    local_var_req_builder = local_var_req_builder.json(&writable_ip_sec_profile_request);
9645
9646    let local_var_req = local_var_req_builder.build()?;
9647    let local_var_resp = local_var_client.execute(local_var_req).await?;
9648
9649    let local_var_status = local_var_resp.status();
9650    let local_var_content = local_var_resp.text().await?;
9651
9652    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
9653        serde_json::from_str(&local_var_content).map_err(Error::from)
9654    } else {
9655        let local_var_entity: Option<VpnIpsecProfilesUpdateError> =
9656            serde_json::from_str(&local_var_content).ok();
9657        let local_var_error = ResponseContent {
9658            status: local_var_status,
9659            content: local_var_content,
9660            entity: local_var_entity,
9661        };
9662        Err(Error::ResponseError(local_var_error))
9663    }
9664}
9665
9666/// Delete a list of IPSec proposal objects.
9667pub async fn vpn_ipsec_proposals_bulk_destroy(
9668    configuration: &configuration::Configuration,
9669    ip_sec_proposal_request: Vec<crate::models::IpSecProposalRequest>,
9670) -> Result<(), Error<VpnIpsecProposalsBulkDestroyError>> {
9671    let local_var_configuration = configuration;
9672
9673    let local_var_client = &local_var_configuration.client;
9674
9675    let local_var_uri_str = format!(
9676        "{}/api/vpn/ipsec-proposals/",
9677        local_var_configuration.base_path
9678    );
9679    let mut local_var_req_builder =
9680        local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());
9681
9682    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
9683        local_var_req_builder =
9684            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
9685    }
9686    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
9687        let local_var_key = local_var_apikey.key.clone();
9688        let local_var_value = match local_var_apikey.prefix {
9689            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
9690            None => local_var_key,
9691        };
9692        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
9693    };
9694    local_var_req_builder = local_var_req_builder.json(&ip_sec_proposal_request);
9695
9696    let local_var_req = local_var_req_builder.build()?;
9697    let local_var_resp = local_var_client.execute(local_var_req).await?;
9698
9699    let local_var_status = local_var_resp.status();
9700    let local_var_content = local_var_resp.text().await?;
9701
9702    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
9703        Ok(())
9704    } else {
9705        let local_var_entity: Option<VpnIpsecProposalsBulkDestroyError> =
9706            serde_json::from_str(&local_var_content).ok();
9707        let local_var_error = ResponseContent {
9708            status: local_var_status,
9709            content: local_var_content,
9710            entity: local_var_entity,
9711        };
9712        Err(Error::ResponseError(local_var_error))
9713    }
9714}
9715
9716/// Patch a list of IPSec proposal objects.
9717pub async fn vpn_ipsec_proposals_bulk_partial_update(
9718    configuration: &configuration::Configuration,
9719    ip_sec_proposal_request: Vec<crate::models::IpSecProposalRequest>,
9720) -> Result<Vec<crate::models::IpSecProposal>, Error<VpnIpsecProposalsBulkPartialUpdateError>> {
9721    let local_var_configuration = configuration;
9722
9723    let local_var_client = &local_var_configuration.client;
9724
9725    let local_var_uri_str = format!(
9726        "{}/api/vpn/ipsec-proposals/",
9727        local_var_configuration.base_path
9728    );
9729    let mut local_var_req_builder =
9730        local_var_client.request(reqwest::Method::PATCH, local_var_uri_str.as_str());
9731
9732    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
9733        local_var_req_builder =
9734            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
9735    }
9736    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
9737        let local_var_key = local_var_apikey.key.clone();
9738        let local_var_value = match local_var_apikey.prefix {
9739            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
9740            None => local_var_key,
9741        };
9742        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
9743    };
9744    local_var_req_builder = local_var_req_builder.json(&ip_sec_proposal_request);
9745
9746    let local_var_req = local_var_req_builder.build()?;
9747    let local_var_resp = local_var_client.execute(local_var_req).await?;
9748
9749    let local_var_status = local_var_resp.status();
9750    let local_var_content = local_var_resp.text().await?;
9751
9752    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
9753        serde_json::from_str(&local_var_content).map_err(Error::from)
9754    } else {
9755        let local_var_entity: Option<VpnIpsecProposalsBulkPartialUpdateError> =
9756            serde_json::from_str(&local_var_content).ok();
9757        let local_var_error = ResponseContent {
9758            status: local_var_status,
9759            content: local_var_content,
9760            entity: local_var_entity,
9761        };
9762        Err(Error::ResponseError(local_var_error))
9763    }
9764}
9765
9766/// Put a list of IPSec proposal objects.
9767pub async fn vpn_ipsec_proposals_bulk_update(
9768    configuration: &configuration::Configuration,
9769    ip_sec_proposal_request: Vec<crate::models::IpSecProposalRequest>,
9770) -> Result<Vec<crate::models::IpSecProposal>, Error<VpnIpsecProposalsBulkUpdateError>> {
9771    let local_var_configuration = configuration;
9772
9773    let local_var_client = &local_var_configuration.client;
9774
9775    let local_var_uri_str = format!(
9776        "{}/api/vpn/ipsec-proposals/",
9777        local_var_configuration.base_path
9778    );
9779    let mut local_var_req_builder =
9780        local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());
9781
9782    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
9783        local_var_req_builder =
9784            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
9785    }
9786    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
9787        let local_var_key = local_var_apikey.key.clone();
9788        let local_var_value = match local_var_apikey.prefix {
9789            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
9790            None => local_var_key,
9791        };
9792        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
9793    };
9794    local_var_req_builder = local_var_req_builder.json(&ip_sec_proposal_request);
9795
9796    let local_var_req = local_var_req_builder.build()?;
9797    let local_var_resp = local_var_client.execute(local_var_req).await?;
9798
9799    let local_var_status = local_var_resp.status();
9800    let local_var_content = local_var_resp.text().await?;
9801
9802    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
9803        serde_json::from_str(&local_var_content).map_err(Error::from)
9804    } else {
9805        let local_var_entity: Option<VpnIpsecProposalsBulkUpdateError> =
9806            serde_json::from_str(&local_var_content).ok();
9807        let local_var_error = ResponseContent {
9808            status: local_var_status,
9809            content: local_var_content,
9810            entity: local_var_entity,
9811        };
9812        Err(Error::ResponseError(local_var_error))
9813    }
9814}
9815
9816/// Post a list of IPSec proposal objects.
9817pub async fn vpn_ipsec_proposals_create(
9818    configuration: &configuration::Configuration,
9819    vpn_ipsec_proposals_create_request: crate::models::VpnIpsecProposalsCreateRequest,
9820) -> Result<crate::models::IpSecProposal, Error<VpnIpsecProposalsCreateError>> {
9821    let local_var_configuration = configuration;
9822
9823    let local_var_client = &local_var_configuration.client;
9824
9825    let local_var_uri_str = format!(
9826        "{}/api/vpn/ipsec-proposals/",
9827        local_var_configuration.base_path
9828    );
9829    let mut local_var_req_builder =
9830        local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
9831
9832    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
9833        local_var_req_builder =
9834            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
9835    }
9836    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
9837        let local_var_key = local_var_apikey.key.clone();
9838        let local_var_value = match local_var_apikey.prefix {
9839            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
9840            None => local_var_key,
9841        };
9842        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
9843    };
9844    local_var_req_builder = local_var_req_builder.json(&vpn_ipsec_proposals_create_request);
9845
9846    let local_var_req = local_var_req_builder.build()?;
9847    let local_var_resp = local_var_client.execute(local_var_req).await?;
9848
9849    let local_var_status = local_var_resp.status();
9850    let local_var_content = local_var_resp.text().await?;
9851
9852    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
9853        serde_json::from_str(&local_var_content).map_err(Error::from)
9854    } else {
9855        let local_var_entity: Option<VpnIpsecProposalsCreateError> =
9856            serde_json::from_str(&local_var_content).ok();
9857        let local_var_error = ResponseContent {
9858            status: local_var_status,
9859            content: local_var_content,
9860            entity: local_var_entity,
9861        };
9862        Err(Error::ResponseError(local_var_error))
9863    }
9864}
9865
9866/// Delete a IPSec proposal object.
9867pub async fn vpn_ipsec_proposals_destroy(
9868    configuration: &configuration::Configuration,
9869    id: i32,
9870) -> Result<(), Error<VpnIpsecProposalsDestroyError>> {
9871    let local_var_configuration = configuration;
9872
9873    let local_var_client = &local_var_configuration.client;
9874
9875    let local_var_uri_str = format!(
9876        "{}/api/vpn/ipsec-proposals/{id}/",
9877        local_var_configuration.base_path,
9878        id = id
9879    );
9880    let mut local_var_req_builder =
9881        local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());
9882
9883    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
9884        local_var_req_builder =
9885            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
9886    }
9887    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
9888        let local_var_key = local_var_apikey.key.clone();
9889        let local_var_value = match local_var_apikey.prefix {
9890            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
9891            None => local_var_key,
9892        };
9893        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
9894    };
9895
9896    let local_var_req = local_var_req_builder.build()?;
9897    let local_var_resp = local_var_client.execute(local_var_req).await?;
9898
9899    let local_var_status = local_var_resp.status();
9900    let local_var_content = local_var_resp.text().await?;
9901
9902    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
9903        Ok(())
9904    } else {
9905        let local_var_entity: Option<VpnIpsecProposalsDestroyError> =
9906            serde_json::from_str(&local_var_content).ok();
9907        let local_var_error = ResponseContent {
9908            status: local_var_status,
9909            content: local_var_content,
9910            entity: local_var_entity,
9911        };
9912        Err(Error::ResponseError(local_var_error))
9913    }
9914}
9915
9916/// Get a list of IPSec proposal objects.
9917pub async fn vpn_ipsec_proposals_list(
9918    configuration: &configuration::Configuration,
9919    authentication_algorithm: Option<Vec<String>>,
9920    authentication_algorithm__empty: Option<bool>,
9921    authentication_algorithm__ic: Option<Vec<String>>,
9922    authentication_algorithm__ie: Option<Vec<String>>,
9923    authentication_algorithm__iew: Option<Vec<String>>,
9924    authentication_algorithm__iregex: Option<Vec<String>>,
9925    authentication_algorithm__isw: Option<Vec<String>>,
9926    authentication_algorithm__n: Option<Vec<String>>,
9927    authentication_algorithm__nic: Option<Vec<String>>,
9928    authentication_algorithm__nie: Option<Vec<String>>,
9929    authentication_algorithm__niew: Option<Vec<String>>,
9930    authentication_algorithm__nisw: Option<Vec<String>>,
9931    authentication_algorithm__regex: Option<Vec<String>>,
9932    created: Option<Vec<String>>,
9933    created__empty: Option<Vec<String>>,
9934    created__gt: Option<Vec<String>>,
9935    created__gte: Option<Vec<String>>,
9936    created__lt: Option<Vec<String>>,
9937    created__lte: Option<Vec<String>>,
9938    created__n: Option<Vec<String>>,
9939    created_by_request: Option<&str>,
9940    description: Option<Vec<String>>,
9941    description__empty: Option<bool>,
9942    description__ic: Option<Vec<String>>,
9943    description__ie: Option<Vec<String>>,
9944    description__iew: Option<Vec<String>>,
9945    description__iregex: Option<Vec<String>>,
9946    description__isw: Option<Vec<String>>,
9947    description__n: Option<Vec<String>>,
9948    description__nic: Option<Vec<String>>,
9949    description__nie: Option<Vec<String>>,
9950    description__niew: Option<Vec<String>>,
9951    description__nisw: Option<Vec<String>>,
9952    description__regex: Option<Vec<String>>,
9953    encryption_algorithm: Option<Vec<String>>,
9954    encryption_algorithm__empty: Option<bool>,
9955    encryption_algorithm__ic: Option<Vec<String>>,
9956    encryption_algorithm__ie: Option<Vec<String>>,
9957    encryption_algorithm__iew: Option<Vec<String>>,
9958    encryption_algorithm__iregex: Option<Vec<String>>,
9959    encryption_algorithm__isw: Option<Vec<String>>,
9960    encryption_algorithm__n: Option<Vec<String>>,
9961    encryption_algorithm__nic: Option<Vec<String>>,
9962    encryption_algorithm__nie: Option<Vec<String>>,
9963    encryption_algorithm__niew: Option<Vec<String>>,
9964    encryption_algorithm__nisw: Option<Vec<String>>,
9965    encryption_algorithm__regex: Option<Vec<String>>,
9966    id: Option<Vec<i32>>,
9967    id__empty: Option<bool>,
9968    id__gt: Option<Vec<i32>>,
9969    id__gte: Option<Vec<i32>>,
9970    id__lt: Option<Vec<i32>>,
9971    id__lte: Option<Vec<i32>>,
9972    id__n: Option<Vec<i32>>,
9973    ipsec_policy: Option<Vec<String>>,
9974    ipsec_policy__n: Option<Vec<String>>,
9975    ipsec_policy_id: Option<Vec<i32>>,
9976    ipsec_policy_id__n: Option<Vec<i32>>,
9977    last_updated: Option<Vec<String>>,
9978    last_updated__empty: Option<Vec<String>>,
9979    last_updated__gt: Option<Vec<String>>,
9980    last_updated__gte: Option<Vec<String>>,
9981    last_updated__lt: Option<Vec<String>>,
9982    last_updated__lte: Option<Vec<String>>,
9983    last_updated__n: Option<Vec<String>>,
9984    limit: Option<i32>,
9985    modified_by_request: Option<&str>,
9986    name: Option<Vec<String>>,
9987    name__empty: Option<bool>,
9988    name__ic: Option<Vec<String>>,
9989    name__ie: Option<Vec<String>>,
9990    name__iew: Option<Vec<String>>,
9991    name__iregex: Option<Vec<String>>,
9992    name__isw: Option<Vec<String>>,
9993    name__n: Option<Vec<String>>,
9994    name__nic: Option<Vec<String>>,
9995    name__nie: Option<Vec<String>>,
9996    name__niew: Option<Vec<String>>,
9997    name__nisw: Option<Vec<String>>,
9998    name__regex: Option<Vec<String>>,
9999    offset: Option<i32>,
10000    ordering: Option<&str>,
10001    owner: Option<Vec<String>>,
10002    owner__n: Option<Vec<String>>,
10003    owner_group: Option<Vec<String>>,
10004    owner_group__n: Option<Vec<String>>,
10005    owner_group_id: Option<Vec<i32>>,
10006    owner_group_id__n: Option<Vec<i32>>,
10007    owner_id: Option<Vec<i32>>,
10008    owner_id__n: Option<Vec<i32>>,
10009    q: Option<&str>,
10010    sa_lifetime_data: Option<Vec<i32>>,
10011    sa_lifetime_data__empty: Option<bool>,
10012    sa_lifetime_data__gt: Option<Vec<i32>>,
10013    sa_lifetime_data__gte: Option<Vec<i32>>,
10014    sa_lifetime_data__lt: Option<Vec<i32>>,
10015    sa_lifetime_data__lte: Option<Vec<i32>>,
10016    sa_lifetime_data__n: Option<Vec<i32>>,
10017    sa_lifetime_seconds: Option<Vec<i32>>,
10018    sa_lifetime_seconds__empty: Option<bool>,
10019    sa_lifetime_seconds__gt: Option<Vec<i32>>,
10020    sa_lifetime_seconds__gte: Option<Vec<i32>>,
10021    sa_lifetime_seconds__lt: Option<Vec<i32>>,
10022    sa_lifetime_seconds__lte: Option<Vec<i32>>,
10023    sa_lifetime_seconds__n: Option<Vec<i32>>,
10024    tag: Option<Vec<String>>,
10025    tag__n: Option<Vec<String>>,
10026    tag_id: Option<Vec<i32>>,
10027    tag_id__n: Option<Vec<i32>>,
10028    updated_by_request: Option<&str>,
10029) -> Result<crate::models::PaginatedIpSecProposalList, Error<VpnIpsecProposalsListError>> {
10030    let local_var_configuration = configuration;
10031
10032    let local_var_client = &local_var_configuration.client;
10033
10034    let local_var_uri_str = format!(
10035        "{}/api/vpn/ipsec-proposals/",
10036        local_var_configuration.base_path
10037    );
10038    let mut local_var_req_builder =
10039        local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
10040
10041    if let Some(ref local_var_str) = authentication_algorithm {
10042        local_var_req_builder = match "multi" {
10043            "multi" => local_var_req_builder.query(
10044                &local_var_str
10045                    .into_iter()
10046                    .map(|p| ("authentication_algorithm".to_owned(), p.to_string()))
10047                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10048            ),
10049            _ => local_var_req_builder.query(&[(
10050                "authentication_algorithm",
10051                &local_var_str
10052                    .into_iter()
10053                    .map(|p| p.to_string())
10054                    .collect::<Vec<String>>()
10055                    .join(",")
10056                    .to_string(),
10057            )]),
10058        };
10059    }
10060    if let Some(ref local_var_str) = authentication_algorithm__empty {
10061        local_var_req_builder = local_var_req_builder.query(&[(
10062            "authentication_algorithm__empty",
10063            &local_var_str.to_string(),
10064        )]);
10065    }
10066    if let Some(ref local_var_str) = authentication_algorithm__ic {
10067        local_var_req_builder = match "multi" {
10068            "multi" => local_var_req_builder.query(
10069                &local_var_str
10070                    .into_iter()
10071                    .map(|p| ("authentication_algorithm__ic".to_owned(), p.to_string()))
10072                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10073            ),
10074            _ => local_var_req_builder.query(&[(
10075                "authentication_algorithm__ic",
10076                &local_var_str
10077                    .into_iter()
10078                    .map(|p| p.to_string())
10079                    .collect::<Vec<String>>()
10080                    .join(",")
10081                    .to_string(),
10082            )]),
10083        };
10084    }
10085    if let Some(ref local_var_str) = authentication_algorithm__ie {
10086        local_var_req_builder = match "multi" {
10087            "multi" => local_var_req_builder.query(
10088                &local_var_str
10089                    .into_iter()
10090                    .map(|p| ("authentication_algorithm__ie".to_owned(), p.to_string()))
10091                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10092            ),
10093            _ => local_var_req_builder.query(&[(
10094                "authentication_algorithm__ie",
10095                &local_var_str
10096                    .into_iter()
10097                    .map(|p| p.to_string())
10098                    .collect::<Vec<String>>()
10099                    .join(",")
10100                    .to_string(),
10101            )]),
10102        };
10103    }
10104    if let Some(ref local_var_str) = authentication_algorithm__iew {
10105        local_var_req_builder = match "multi" {
10106            "multi" => local_var_req_builder.query(
10107                &local_var_str
10108                    .into_iter()
10109                    .map(|p| ("authentication_algorithm__iew".to_owned(), p.to_string()))
10110                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10111            ),
10112            _ => local_var_req_builder.query(&[(
10113                "authentication_algorithm__iew",
10114                &local_var_str
10115                    .into_iter()
10116                    .map(|p| p.to_string())
10117                    .collect::<Vec<String>>()
10118                    .join(",")
10119                    .to_string(),
10120            )]),
10121        };
10122    }
10123    if let Some(ref local_var_str) = authentication_algorithm__iregex {
10124        local_var_req_builder = match "multi" {
10125            "multi" => local_var_req_builder.query(
10126                &local_var_str
10127                    .into_iter()
10128                    .map(|p| ("authentication_algorithm__iregex".to_owned(), p.to_string()))
10129                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10130            ),
10131            _ => local_var_req_builder.query(&[(
10132                "authentication_algorithm__iregex",
10133                &local_var_str
10134                    .into_iter()
10135                    .map(|p| p.to_string())
10136                    .collect::<Vec<String>>()
10137                    .join(",")
10138                    .to_string(),
10139            )]),
10140        };
10141    }
10142    if let Some(ref local_var_str) = authentication_algorithm__isw {
10143        local_var_req_builder = match "multi" {
10144            "multi" => local_var_req_builder.query(
10145                &local_var_str
10146                    .into_iter()
10147                    .map(|p| ("authentication_algorithm__isw".to_owned(), p.to_string()))
10148                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10149            ),
10150            _ => local_var_req_builder.query(&[(
10151                "authentication_algorithm__isw",
10152                &local_var_str
10153                    .into_iter()
10154                    .map(|p| p.to_string())
10155                    .collect::<Vec<String>>()
10156                    .join(",")
10157                    .to_string(),
10158            )]),
10159        };
10160    }
10161    if let Some(ref local_var_str) = authentication_algorithm__n {
10162        local_var_req_builder = match "multi" {
10163            "multi" => local_var_req_builder.query(
10164                &local_var_str
10165                    .into_iter()
10166                    .map(|p| ("authentication_algorithm__n".to_owned(), p.to_string()))
10167                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10168            ),
10169            _ => local_var_req_builder.query(&[(
10170                "authentication_algorithm__n",
10171                &local_var_str
10172                    .into_iter()
10173                    .map(|p| p.to_string())
10174                    .collect::<Vec<String>>()
10175                    .join(",")
10176                    .to_string(),
10177            )]),
10178        };
10179    }
10180    if let Some(ref local_var_str) = authentication_algorithm__nic {
10181        local_var_req_builder = match "multi" {
10182            "multi" => local_var_req_builder.query(
10183                &local_var_str
10184                    .into_iter()
10185                    .map(|p| ("authentication_algorithm__nic".to_owned(), p.to_string()))
10186                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10187            ),
10188            _ => local_var_req_builder.query(&[(
10189                "authentication_algorithm__nic",
10190                &local_var_str
10191                    .into_iter()
10192                    .map(|p| p.to_string())
10193                    .collect::<Vec<String>>()
10194                    .join(",")
10195                    .to_string(),
10196            )]),
10197        };
10198    }
10199    if let Some(ref local_var_str) = authentication_algorithm__nie {
10200        local_var_req_builder = match "multi" {
10201            "multi" => local_var_req_builder.query(
10202                &local_var_str
10203                    .into_iter()
10204                    .map(|p| ("authentication_algorithm__nie".to_owned(), p.to_string()))
10205                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10206            ),
10207            _ => local_var_req_builder.query(&[(
10208                "authentication_algorithm__nie",
10209                &local_var_str
10210                    .into_iter()
10211                    .map(|p| p.to_string())
10212                    .collect::<Vec<String>>()
10213                    .join(",")
10214                    .to_string(),
10215            )]),
10216        };
10217    }
10218    if let Some(ref local_var_str) = authentication_algorithm__niew {
10219        local_var_req_builder = match "multi" {
10220            "multi" => local_var_req_builder.query(
10221                &local_var_str
10222                    .into_iter()
10223                    .map(|p| ("authentication_algorithm__niew".to_owned(), p.to_string()))
10224                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10225            ),
10226            _ => local_var_req_builder.query(&[(
10227                "authentication_algorithm__niew",
10228                &local_var_str
10229                    .into_iter()
10230                    .map(|p| p.to_string())
10231                    .collect::<Vec<String>>()
10232                    .join(",")
10233                    .to_string(),
10234            )]),
10235        };
10236    }
10237    if let Some(ref local_var_str) = authentication_algorithm__nisw {
10238        local_var_req_builder = match "multi" {
10239            "multi" => local_var_req_builder.query(
10240                &local_var_str
10241                    .into_iter()
10242                    .map(|p| ("authentication_algorithm__nisw".to_owned(), p.to_string()))
10243                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10244            ),
10245            _ => local_var_req_builder.query(&[(
10246                "authentication_algorithm__nisw",
10247                &local_var_str
10248                    .into_iter()
10249                    .map(|p| p.to_string())
10250                    .collect::<Vec<String>>()
10251                    .join(",")
10252                    .to_string(),
10253            )]),
10254        };
10255    }
10256    if let Some(ref local_var_str) = authentication_algorithm__regex {
10257        local_var_req_builder = match "multi" {
10258            "multi" => local_var_req_builder.query(
10259                &local_var_str
10260                    .into_iter()
10261                    .map(|p| ("authentication_algorithm__regex".to_owned(), p.to_string()))
10262                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10263            ),
10264            _ => local_var_req_builder.query(&[(
10265                "authentication_algorithm__regex",
10266                &local_var_str
10267                    .into_iter()
10268                    .map(|p| p.to_string())
10269                    .collect::<Vec<String>>()
10270                    .join(",")
10271                    .to_string(),
10272            )]),
10273        };
10274    }
10275    if let Some(ref local_var_str) = created {
10276        local_var_req_builder = match "multi" {
10277            "multi" => local_var_req_builder.query(
10278                &local_var_str
10279                    .into_iter()
10280                    .map(|p| ("created".to_owned(), p.to_string()))
10281                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10282            ),
10283            _ => local_var_req_builder.query(&[(
10284                "created",
10285                &local_var_str
10286                    .into_iter()
10287                    .map(|p| p.to_string())
10288                    .collect::<Vec<String>>()
10289                    .join(",")
10290                    .to_string(),
10291            )]),
10292        };
10293    }
10294    if let Some(ref local_var_str) = created__empty {
10295        local_var_req_builder = match "multi" {
10296            "multi" => local_var_req_builder.query(
10297                &local_var_str
10298                    .into_iter()
10299                    .map(|p| ("created__empty".to_owned(), p.to_string()))
10300                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10301            ),
10302            _ => local_var_req_builder.query(&[(
10303                "created__empty",
10304                &local_var_str
10305                    .into_iter()
10306                    .map(|p| p.to_string())
10307                    .collect::<Vec<String>>()
10308                    .join(",")
10309                    .to_string(),
10310            )]),
10311        };
10312    }
10313    if let Some(ref local_var_str) = created__gt {
10314        local_var_req_builder = match "multi" {
10315            "multi" => local_var_req_builder.query(
10316                &local_var_str
10317                    .into_iter()
10318                    .map(|p| ("created__gt".to_owned(), p.to_string()))
10319                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10320            ),
10321            _ => local_var_req_builder.query(&[(
10322                "created__gt",
10323                &local_var_str
10324                    .into_iter()
10325                    .map(|p| p.to_string())
10326                    .collect::<Vec<String>>()
10327                    .join(",")
10328                    .to_string(),
10329            )]),
10330        };
10331    }
10332    if let Some(ref local_var_str) = created__gte {
10333        local_var_req_builder = match "multi" {
10334            "multi" => local_var_req_builder.query(
10335                &local_var_str
10336                    .into_iter()
10337                    .map(|p| ("created__gte".to_owned(), p.to_string()))
10338                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10339            ),
10340            _ => local_var_req_builder.query(&[(
10341                "created__gte",
10342                &local_var_str
10343                    .into_iter()
10344                    .map(|p| p.to_string())
10345                    .collect::<Vec<String>>()
10346                    .join(",")
10347                    .to_string(),
10348            )]),
10349        };
10350    }
10351    if let Some(ref local_var_str) = created__lt {
10352        local_var_req_builder = match "multi" {
10353            "multi" => local_var_req_builder.query(
10354                &local_var_str
10355                    .into_iter()
10356                    .map(|p| ("created__lt".to_owned(), p.to_string()))
10357                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10358            ),
10359            _ => local_var_req_builder.query(&[(
10360                "created__lt",
10361                &local_var_str
10362                    .into_iter()
10363                    .map(|p| p.to_string())
10364                    .collect::<Vec<String>>()
10365                    .join(",")
10366                    .to_string(),
10367            )]),
10368        };
10369    }
10370    if let Some(ref local_var_str) = created__lte {
10371        local_var_req_builder = match "multi" {
10372            "multi" => local_var_req_builder.query(
10373                &local_var_str
10374                    .into_iter()
10375                    .map(|p| ("created__lte".to_owned(), p.to_string()))
10376                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10377            ),
10378            _ => local_var_req_builder.query(&[(
10379                "created__lte",
10380                &local_var_str
10381                    .into_iter()
10382                    .map(|p| p.to_string())
10383                    .collect::<Vec<String>>()
10384                    .join(",")
10385                    .to_string(),
10386            )]),
10387        };
10388    }
10389    if let Some(ref local_var_str) = created__n {
10390        local_var_req_builder = match "multi" {
10391            "multi" => local_var_req_builder.query(
10392                &local_var_str
10393                    .into_iter()
10394                    .map(|p| ("created__n".to_owned(), p.to_string()))
10395                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10396            ),
10397            _ => local_var_req_builder.query(&[(
10398                "created__n",
10399                &local_var_str
10400                    .into_iter()
10401                    .map(|p| p.to_string())
10402                    .collect::<Vec<String>>()
10403                    .join(",")
10404                    .to_string(),
10405            )]),
10406        };
10407    }
10408    if let Some(ref local_var_str) = created_by_request {
10409        local_var_req_builder =
10410            local_var_req_builder.query(&[("created_by_request", &local_var_str.to_string())]);
10411    }
10412    if let Some(ref local_var_str) = description {
10413        local_var_req_builder = match "multi" {
10414            "multi" => local_var_req_builder.query(
10415                &local_var_str
10416                    .into_iter()
10417                    .map(|p| ("description".to_owned(), p.to_string()))
10418                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10419            ),
10420            _ => local_var_req_builder.query(&[(
10421                "description",
10422                &local_var_str
10423                    .into_iter()
10424                    .map(|p| p.to_string())
10425                    .collect::<Vec<String>>()
10426                    .join(",")
10427                    .to_string(),
10428            )]),
10429        };
10430    }
10431    if let Some(ref local_var_str) = description__empty {
10432        local_var_req_builder =
10433            local_var_req_builder.query(&[("description__empty", &local_var_str.to_string())]);
10434    }
10435    if let Some(ref local_var_str) = description__ic {
10436        local_var_req_builder = match "multi" {
10437            "multi" => local_var_req_builder.query(
10438                &local_var_str
10439                    .into_iter()
10440                    .map(|p| ("description__ic".to_owned(), p.to_string()))
10441                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10442            ),
10443            _ => local_var_req_builder.query(&[(
10444                "description__ic",
10445                &local_var_str
10446                    .into_iter()
10447                    .map(|p| p.to_string())
10448                    .collect::<Vec<String>>()
10449                    .join(",")
10450                    .to_string(),
10451            )]),
10452        };
10453    }
10454    if let Some(ref local_var_str) = description__ie {
10455        local_var_req_builder = match "multi" {
10456            "multi" => local_var_req_builder.query(
10457                &local_var_str
10458                    .into_iter()
10459                    .map(|p| ("description__ie".to_owned(), p.to_string()))
10460                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10461            ),
10462            _ => local_var_req_builder.query(&[(
10463                "description__ie",
10464                &local_var_str
10465                    .into_iter()
10466                    .map(|p| p.to_string())
10467                    .collect::<Vec<String>>()
10468                    .join(",")
10469                    .to_string(),
10470            )]),
10471        };
10472    }
10473    if let Some(ref local_var_str) = description__iew {
10474        local_var_req_builder = match "multi" {
10475            "multi" => local_var_req_builder.query(
10476                &local_var_str
10477                    .into_iter()
10478                    .map(|p| ("description__iew".to_owned(), p.to_string()))
10479                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10480            ),
10481            _ => local_var_req_builder.query(&[(
10482                "description__iew",
10483                &local_var_str
10484                    .into_iter()
10485                    .map(|p| p.to_string())
10486                    .collect::<Vec<String>>()
10487                    .join(",")
10488                    .to_string(),
10489            )]),
10490        };
10491    }
10492    if let Some(ref local_var_str) = description__iregex {
10493        local_var_req_builder = match "multi" {
10494            "multi" => local_var_req_builder.query(
10495                &local_var_str
10496                    .into_iter()
10497                    .map(|p| ("description__iregex".to_owned(), p.to_string()))
10498                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10499            ),
10500            _ => local_var_req_builder.query(&[(
10501                "description__iregex",
10502                &local_var_str
10503                    .into_iter()
10504                    .map(|p| p.to_string())
10505                    .collect::<Vec<String>>()
10506                    .join(",")
10507                    .to_string(),
10508            )]),
10509        };
10510    }
10511    if let Some(ref local_var_str) = description__isw {
10512        local_var_req_builder = match "multi" {
10513            "multi" => local_var_req_builder.query(
10514                &local_var_str
10515                    .into_iter()
10516                    .map(|p| ("description__isw".to_owned(), p.to_string()))
10517                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10518            ),
10519            _ => local_var_req_builder.query(&[(
10520                "description__isw",
10521                &local_var_str
10522                    .into_iter()
10523                    .map(|p| p.to_string())
10524                    .collect::<Vec<String>>()
10525                    .join(",")
10526                    .to_string(),
10527            )]),
10528        };
10529    }
10530    if let Some(ref local_var_str) = description__n {
10531        local_var_req_builder = match "multi" {
10532            "multi" => local_var_req_builder.query(
10533                &local_var_str
10534                    .into_iter()
10535                    .map(|p| ("description__n".to_owned(), p.to_string()))
10536                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10537            ),
10538            _ => local_var_req_builder.query(&[(
10539                "description__n",
10540                &local_var_str
10541                    .into_iter()
10542                    .map(|p| p.to_string())
10543                    .collect::<Vec<String>>()
10544                    .join(",")
10545                    .to_string(),
10546            )]),
10547        };
10548    }
10549    if let Some(ref local_var_str) = description__nic {
10550        local_var_req_builder = match "multi" {
10551            "multi" => local_var_req_builder.query(
10552                &local_var_str
10553                    .into_iter()
10554                    .map(|p| ("description__nic".to_owned(), p.to_string()))
10555                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10556            ),
10557            _ => local_var_req_builder.query(&[(
10558                "description__nic",
10559                &local_var_str
10560                    .into_iter()
10561                    .map(|p| p.to_string())
10562                    .collect::<Vec<String>>()
10563                    .join(",")
10564                    .to_string(),
10565            )]),
10566        };
10567    }
10568    if let Some(ref local_var_str) = description__nie {
10569        local_var_req_builder = match "multi" {
10570            "multi" => local_var_req_builder.query(
10571                &local_var_str
10572                    .into_iter()
10573                    .map(|p| ("description__nie".to_owned(), p.to_string()))
10574                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10575            ),
10576            _ => local_var_req_builder.query(&[(
10577                "description__nie",
10578                &local_var_str
10579                    .into_iter()
10580                    .map(|p| p.to_string())
10581                    .collect::<Vec<String>>()
10582                    .join(",")
10583                    .to_string(),
10584            )]),
10585        };
10586    }
10587    if let Some(ref local_var_str) = description__niew {
10588        local_var_req_builder = match "multi" {
10589            "multi" => local_var_req_builder.query(
10590                &local_var_str
10591                    .into_iter()
10592                    .map(|p| ("description__niew".to_owned(), p.to_string()))
10593                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10594            ),
10595            _ => local_var_req_builder.query(&[(
10596                "description__niew",
10597                &local_var_str
10598                    .into_iter()
10599                    .map(|p| p.to_string())
10600                    .collect::<Vec<String>>()
10601                    .join(",")
10602                    .to_string(),
10603            )]),
10604        };
10605    }
10606    if let Some(ref local_var_str) = description__nisw {
10607        local_var_req_builder = match "multi" {
10608            "multi" => local_var_req_builder.query(
10609                &local_var_str
10610                    .into_iter()
10611                    .map(|p| ("description__nisw".to_owned(), p.to_string()))
10612                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10613            ),
10614            _ => local_var_req_builder.query(&[(
10615                "description__nisw",
10616                &local_var_str
10617                    .into_iter()
10618                    .map(|p| p.to_string())
10619                    .collect::<Vec<String>>()
10620                    .join(",")
10621                    .to_string(),
10622            )]),
10623        };
10624    }
10625    if let Some(ref local_var_str) = description__regex {
10626        local_var_req_builder = match "multi" {
10627            "multi" => local_var_req_builder.query(
10628                &local_var_str
10629                    .into_iter()
10630                    .map(|p| ("description__regex".to_owned(), p.to_string()))
10631                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10632            ),
10633            _ => local_var_req_builder.query(&[(
10634                "description__regex",
10635                &local_var_str
10636                    .into_iter()
10637                    .map(|p| p.to_string())
10638                    .collect::<Vec<String>>()
10639                    .join(",")
10640                    .to_string(),
10641            )]),
10642        };
10643    }
10644    if let Some(ref local_var_str) = encryption_algorithm {
10645        local_var_req_builder = match "multi" {
10646            "multi" => local_var_req_builder.query(
10647                &local_var_str
10648                    .into_iter()
10649                    .map(|p| ("encryption_algorithm".to_owned(), p.to_string()))
10650                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10651            ),
10652            _ => local_var_req_builder.query(&[(
10653                "encryption_algorithm",
10654                &local_var_str
10655                    .into_iter()
10656                    .map(|p| p.to_string())
10657                    .collect::<Vec<String>>()
10658                    .join(",")
10659                    .to_string(),
10660            )]),
10661        };
10662    }
10663    if let Some(ref local_var_str) = encryption_algorithm__empty {
10664        local_var_req_builder = local_var_req_builder
10665            .query(&[("encryption_algorithm__empty", &local_var_str.to_string())]);
10666    }
10667    if let Some(ref local_var_str) = encryption_algorithm__ic {
10668        local_var_req_builder = match "multi" {
10669            "multi" => local_var_req_builder.query(
10670                &local_var_str
10671                    .into_iter()
10672                    .map(|p| ("encryption_algorithm__ic".to_owned(), p.to_string()))
10673                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10674            ),
10675            _ => local_var_req_builder.query(&[(
10676                "encryption_algorithm__ic",
10677                &local_var_str
10678                    .into_iter()
10679                    .map(|p| p.to_string())
10680                    .collect::<Vec<String>>()
10681                    .join(",")
10682                    .to_string(),
10683            )]),
10684        };
10685    }
10686    if let Some(ref local_var_str) = encryption_algorithm__ie {
10687        local_var_req_builder = match "multi" {
10688            "multi" => local_var_req_builder.query(
10689                &local_var_str
10690                    .into_iter()
10691                    .map(|p| ("encryption_algorithm__ie".to_owned(), p.to_string()))
10692                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10693            ),
10694            _ => local_var_req_builder.query(&[(
10695                "encryption_algorithm__ie",
10696                &local_var_str
10697                    .into_iter()
10698                    .map(|p| p.to_string())
10699                    .collect::<Vec<String>>()
10700                    .join(",")
10701                    .to_string(),
10702            )]),
10703        };
10704    }
10705    if let Some(ref local_var_str) = encryption_algorithm__iew {
10706        local_var_req_builder = match "multi" {
10707            "multi" => local_var_req_builder.query(
10708                &local_var_str
10709                    .into_iter()
10710                    .map(|p| ("encryption_algorithm__iew".to_owned(), p.to_string()))
10711                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10712            ),
10713            _ => local_var_req_builder.query(&[(
10714                "encryption_algorithm__iew",
10715                &local_var_str
10716                    .into_iter()
10717                    .map(|p| p.to_string())
10718                    .collect::<Vec<String>>()
10719                    .join(",")
10720                    .to_string(),
10721            )]),
10722        };
10723    }
10724    if let Some(ref local_var_str) = encryption_algorithm__iregex {
10725        local_var_req_builder = match "multi" {
10726            "multi" => local_var_req_builder.query(
10727                &local_var_str
10728                    .into_iter()
10729                    .map(|p| ("encryption_algorithm__iregex".to_owned(), p.to_string()))
10730                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10731            ),
10732            _ => local_var_req_builder.query(&[(
10733                "encryption_algorithm__iregex",
10734                &local_var_str
10735                    .into_iter()
10736                    .map(|p| p.to_string())
10737                    .collect::<Vec<String>>()
10738                    .join(",")
10739                    .to_string(),
10740            )]),
10741        };
10742    }
10743    if let Some(ref local_var_str) = encryption_algorithm__isw {
10744        local_var_req_builder = match "multi" {
10745            "multi" => local_var_req_builder.query(
10746                &local_var_str
10747                    .into_iter()
10748                    .map(|p| ("encryption_algorithm__isw".to_owned(), p.to_string()))
10749                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10750            ),
10751            _ => local_var_req_builder.query(&[(
10752                "encryption_algorithm__isw",
10753                &local_var_str
10754                    .into_iter()
10755                    .map(|p| p.to_string())
10756                    .collect::<Vec<String>>()
10757                    .join(",")
10758                    .to_string(),
10759            )]),
10760        };
10761    }
10762    if let Some(ref local_var_str) = encryption_algorithm__n {
10763        local_var_req_builder = match "multi" {
10764            "multi" => local_var_req_builder.query(
10765                &local_var_str
10766                    .into_iter()
10767                    .map(|p| ("encryption_algorithm__n".to_owned(), p.to_string()))
10768                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10769            ),
10770            _ => local_var_req_builder.query(&[(
10771                "encryption_algorithm__n",
10772                &local_var_str
10773                    .into_iter()
10774                    .map(|p| p.to_string())
10775                    .collect::<Vec<String>>()
10776                    .join(",")
10777                    .to_string(),
10778            )]),
10779        };
10780    }
10781    if let Some(ref local_var_str) = encryption_algorithm__nic {
10782        local_var_req_builder = match "multi" {
10783            "multi" => local_var_req_builder.query(
10784                &local_var_str
10785                    .into_iter()
10786                    .map(|p| ("encryption_algorithm__nic".to_owned(), p.to_string()))
10787                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10788            ),
10789            _ => local_var_req_builder.query(&[(
10790                "encryption_algorithm__nic",
10791                &local_var_str
10792                    .into_iter()
10793                    .map(|p| p.to_string())
10794                    .collect::<Vec<String>>()
10795                    .join(",")
10796                    .to_string(),
10797            )]),
10798        };
10799    }
10800    if let Some(ref local_var_str) = encryption_algorithm__nie {
10801        local_var_req_builder = match "multi" {
10802            "multi" => local_var_req_builder.query(
10803                &local_var_str
10804                    .into_iter()
10805                    .map(|p| ("encryption_algorithm__nie".to_owned(), p.to_string()))
10806                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10807            ),
10808            _ => local_var_req_builder.query(&[(
10809                "encryption_algorithm__nie",
10810                &local_var_str
10811                    .into_iter()
10812                    .map(|p| p.to_string())
10813                    .collect::<Vec<String>>()
10814                    .join(",")
10815                    .to_string(),
10816            )]),
10817        };
10818    }
10819    if let Some(ref local_var_str) = encryption_algorithm__niew {
10820        local_var_req_builder = match "multi" {
10821            "multi" => local_var_req_builder.query(
10822                &local_var_str
10823                    .into_iter()
10824                    .map(|p| ("encryption_algorithm__niew".to_owned(), p.to_string()))
10825                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10826            ),
10827            _ => local_var_req_builder.query(&[(
10828                "encryption_algorithm__niew",
10829                &local_var_str
10830                    .into_iter()
10831                    .map(|p| p.to_string())
10832                    .collect::<Vec<String>>()
10833                    .join(",")
10834                    .to_string(),
10835            )]),
10836        };
10837    }
10838    if let Some(ref local_var_str) = encryption_algorithm__nisw {
10839        local_var_req_builder = match "multi" {
10840            "multi" => local_var_req_builder.query(
10841                &local_var_str
10842                    .into_iter()
10843                    .map(|p| ("encryption_algorithm__nisw".to_owned(), p.to_string()))
10844                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10845            ),
10846            _ => local_var_req_builder.query(&[(
10847                "encryption_algorithm__nisw",
10848                &local_var_str
10849                    .into_iter()
10850                    .map(|p| p.to_string())
10851                    .collect::<Vec<String>>()
10852                    .join(",")
10853                    .to_string(),
10854            )]),
10855        };
10856    }
10857    if let Some(ref local_var_str) = encryption_algorithm__regex {
10858        local_var_req_builder = match "multi" {
10859            "multi" => local_var_req_builder.query(
10860                &local_var_str
10861                    .into_iter()
10862                    .map(|p| ("encryption_algorithm__regex".to_owned(), p.to_string()))
10863                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10864            ),
10865            _ => local_var_req_builder.query(&[(
10866                "encryption_algorithm__regex",
10867                &local_var_str
10868                    .into_iter()
10869                    .map(|p| p.to_string())
10870                    .collect::<Vec<String>>()
10871                    .join(",")
10872                    .to_string(),
10873            )]),
10874        };
10875    }
10876    if let Some(ref local_var_str) = id {
10877        local_var_req_builder = match "multi" {
10878            "multi" => local_var_req_builder.query(
10879                &local_var_str
10880                    .into_iter()
10881                    .map(|p| ("id".to_owned(), p.to_string()))
10882                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10883            ),
10884            _ => local_var_req_builder.query(&[(
10885                "id",
10886                &local_var_str
10887                    .into_iter()
10888                    .map(|p| p.to_string())
10889                    .collect::<Vec<String>>()
10890                    .join(",")
10891                    .to_string(),
10892            )]),
10893        };
10894    }
10895    if let Some(ref local_var_str) = id__empty {
10896        local_var_req_builder =
10897            local_var_req_builder.query(&[("id__empty", &local_var_str.to_string())]);
10898    }
10899    if let Some(ref local_var_str) = id__gt {
10900        local_var_req_builder = match "multi" {
10901            "multi" => local_var_req_builder.query(
10902                &local_var_str
10903                    .into_iter()
10904                    .map(|p| ("id__gt".to_owned(), p.to_string()))
10905                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10906            ),
10907            _ => local_var_req_builder.query(&[(
10908                "id__gt",
10909                &local_var_str
10910                    .into_iter()
10911                    .map(|p| p.to_string())
10912                    .collect::<Vec<String>>()
10913                    .join(",")
10914                    .to_string(),
10915            )]),
10916        };
10917    }
10918    if let Some(ref local_var_str) = id__gte {
10919        local_var_req_builder = match "multi" {
10920            "multi" => local_var_req_builder.query(
10921                &local_var_str
10922                    .into_iter()
10923                    .map(|p| ("id__gte".to_owned(), p.to_string()))
10924                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10925            ),
10926            _ => local_var_req_builder.query(&[(
10927                "id__gte",
10928                &local_var_str
10929                    .into_iter()
10930                    .map(|p| p.to_string())
10931                    .collect::<Vec<String>>()
10932                    .join(",")
10933                    .to_string(),
10934            )]),
10935        };
10936    }
10937    if let Some(ref local_var_str) = id__lt {
10938        local_var_req_builder = match "multi" {
10939            "multi" => local_var_req_builder.query(
10940                &local_var_str
10941                    .into_iter()
10942                    .map(|p| ("id__lt".to_owned(), p.to_string()))
10943                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10944            ),
10945            _ => local_var_req_builder.query(&[(
10946                "id__lt",
10947                &local_var_str
10948                    .into_iter()
10949                    .map(|p| p.to_string())
10950                    .collect::<Vec<String>>()
10951                    .join(",")
10952                    .to_string(),
10953            )]),
10954        };
10955    }
10956    if let Some(ref local_var_str) = id__lte {
10957        local_var_req_builder = match "multi" {
10958            "multi" => local_var_req_builder.query(
10959                &local_var_str
10960                    .into_iter()
10961                    .map(|p| ("id__lte".to_owned(), p.to_string()))
10962                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10963            ),
10964            _ => local_var_req_builder.query(&[(
10965                "id__lte",
10966                &local_var_str
10967                    .into_iter()
10968                    .map(|p| p.to_string())
10969                    .collect::<Vec<String>>()
10970                    .join(",")
10971                    .to_string(),
10972            )]),
10973        };
10974    }
10975    if let Some(ref local_var_str) = id__n {
10976        local_var_req_builder = match "multi" {
10977            "multi" => local_var_req_builder.query(
10978                &local_var_str
10979                    .into_iter()
10980                    .map(|p| ("id__n".to_owned(), p.to_string()))
10981                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10982            ),
10983            _ => local_var_req_builder.query(&[(
10984                "id__n",
10985                &local_var_str
10986                    .into_iter()
10987                    .map(|p| p.to_string())
10988                    .collect::<Vec<String>>()
10989                    .join(",")
10990                    .to_string(),
10991            )]),
10992        };
10993    }
10994    if let Some(ref local_var_str) = ipsec_policy {
10995        local_var_req_builder = match "multi" {
10996            "multi" => local_var_req_builder.query(
10997                &local_var_str
10998                    .into_iter()
10999                    .map(|p| ("ipsec_policy".to_owned(), p.to_string()))
11000                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11001            ),
11002            _ => local_var_req_builder.query(&[(
11003                "ipsec_policy",
11004                &local_var_str
11005                    .into_iter()
11006                    .map(|p| p.to_string())
11007                    .collect::<Vec<String>>()
11008                    .join(",")
11009                    .to_string(),
11010            )]),
11011        };
11012    }
11013    if let Some(ref local_var_str) = ipsec_policy__n {
11014        local_var_req_builder = match "multi" {
11015            "multi" => local_var_req_builder.query(
11016                &local_var_str
11017                    .into_iter()
11018                    .map(|p| ("ipsec_policy__n".to_owned(), p.to_string()))
11019                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11020            ),
11021            _ => local_var_req_builder.query(&[(
11022                "ipsec_policy__n",
11023                &local_var_str
11024                    .into_iter()
11025                    .map(|p| p.to_string())
11026                    .collect::<Vec<String>>()
11027                    .join(",")
11028                    .to_string(),
11029            )]),
11030        };
11031    }
11032    if let Some(ref local_var_str) = ipsec_policy_id {
11033        local_var_req_builder = match "multi" {
11034            "multi" => local_var_req_builder.query(
11035                &local_var_str
11036                    .into_iter()
11037                    .map(|p| ("ipsec_policy_id".to_owned(), p.to_string()))
11038                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11039            ),
11040            _ => local_var_req_builder.query(&[(
11041                "ipsec_policy_id",
11042                &local_var_str
11043                    .into_iter()
11044                    .map(|p| p.to_string())
11045                    .collect::<Vec<String>>()
11046                    .join(",")
11047                    .to_string(),
11048            )]),
11049        };
11050    }
11051    if let Some(ref local_var_str) = ipsec_policy_id__n {
11052        local_var_req_builder = match "multi" {
11053            "multi" => local_var_req_builder.query(
11054                &local_var_str
11055                    .into_iter()
11056                    .map(|p| ("ipsec_policy_id__n".to_owned(), p.to_string()))
11057                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11058            ),
11059            _ => local_var_req_builder.query(&[(
11060                "ipsec_policy_id__n",
11061                &local_var_str
11062                    .into_iter()
11063                    .map(|p| p.to_string())
11064                    .collect::<Vec<String>>()
11065                    .join(",")
11066                    .to_string(),
11067            )]),
11068        };
11069    }
11070    if let Some(ref local_var_str) = last_updated {
11071        local_var_req_builder = match "multi" {
11072            "multi" => local_var_req_builder.query(
11073                &local_var_str
11074                    .into_iter()
11075                    .map(|p| ("last_updated".to_owned(), p.to_string()))
11076                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11077            ),
11078            _ => local_var_req_builder.query(&[(
11079                "last_updated",
11080                &local_var_str
11081                    .into_iter()
11082                    .map(|p| p.to_string())
11083                    .collect::<Vec<String>>()
11084                    .join(",")
11085                    .to_string(),
11086            )]),
11087        };
11088    }
11089    if let Some(ref local_var_str) = last_updated__empty {
11090        local_var_req_builder = match "multi" {
11091            "multi" => local_var_req_builder.query(
11092                &local_var_str
11093                    .into_iter()
11094                    .map(|p| ("last_updated__empty".to_owned(), p.to_string()))
11095                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11096            ),
11097            _ => local_var_req_builder.query(&[(
11098                "last_updated__empty",
11099                &local_var_str
11100                    .into_iter()
11101                    .map(|p| p.to_string())
11102                    .collect::<Vec<String>>()
11103                    .join(",")
11104                    .to_string(),
11105            )]),
11106        };
11107    }
11108    if let Some(ref local_var_str) = last_updated__gt {
11109        local_var_req_builder = match "multi" {
11110            "multi" => local_var_req_builder.query(
11111                &local_var_str
11112                    .into_iter()
11113                    .map(|p| ("last_updated__gt".to_owned(), p.to_string()))
11114                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11115            ),
11116            _ => local_var_req_builder.query(&[(
11117                "last_updated__gt",
11118                &local_var_str
11119                    .into_iter()
11120                    .map(|p| p.to_string())
11121                    .collect::<Vec<String>>()
11122                    .join(",")
11123                    .to_string(),
11124            )]),
11125        };
11126    }
11127    if let Some(ref local_var_str) = last_updated__gte {
11128        local_var_req_builder = match "multi" {
11129            "multi" => local_var_req_builder.query(
11130                &local_var_str
11131                    .into_iter()
11132                    .map(|p| ("last_updated__gte".to_owned(), p.to_string()))
11133                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11134            ),
11135            _ => local_var_req_builder.query(&[(
11136                "last_updated__gte",
11137                &local_var_str
11138                    .into_iter()
11139                    .map(|p| p.to_string())
11140                    .collect::<Vec<String>>()
11141                    .join(",")
11142                    .to_string(),
11143            )]),
11144        };
11145    }
11146    if let Some(ref local_var_str) = last_updated__lt {
11147        local_var_req_builder = match "multi" {
11148            "multi" => local_var_req_builder.query(
11149                &local_var_str
11150                    .into_iter()
11151                    .map(|p| ("last_updated__lt".to_owned(), p.to_string()))
11152                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11153            ),
11154            _ => local_var_req_builder.query(&[(
11155                "last_updated__lt",
11156                &local_var_str
11157                    .into_iter()
11158                    .map(|p| p.to_string())
11159                    .collect::<Vec<String>>()
11160                    .join(",")
11161                    .to_string(),
11162            )]),
11163        };
11164    }
11165    if let Some(ref local_var_str) = last_updated__lte {
11166        local_var_req_builder = match "multi" {
11167            "multi" => local_var_req_builder.query(
11168                &local_var_str
11169                    .into_iter()
11170                    .map(|p| ("last_updated__lte".to_owned(), p.to_string()))
11171                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11172            ),
11173            _ => local_var_req_builder.query(&[(
11174                "last_updated__lte",
11175                &local_var_str
11176                    .into_iter()
11177                    .map(|p| p.to_string())
11178                    .collect::<Vec<String>>()
11179                    .join(",")
11180                    .to_string(),
11181            )]),
11182        };
11183    }
11184    if let Some(ref local_var_str) = last_updated__n {
11185        local_var_req_builder = match "multi" {
11186            "multi" => local_var_req_builder.query(
11187                &local_var_str
11188                    .into_iter()
11189                    .map(|p| ("last_updated__n".to_owned(), p.to_string()))
11190                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11191            ),
11192            _ => local_var_req_builder.query(&[(
11193                "last_updated__n",
11194                &local_var_str
11195                    .into_iter()
11196                    .map(|p| p.to_string())
11197                    .collect::<Vec<String>>()
11198                    .join(",")
11199                    .to_string(),
11200            )]),
11201        };
11202    }
11203    if let Some(ref local_var_str) = limit {
11204        local_var_req_builder =
11205            local_var_req_builder.query(&[("limit", &local_var_str.to_string())]);
11206    }
11207    if let Some(ref local_var_str) = modified_by_request {
11208        local_var_req_builder =
11209            local_var_req_builder.query(&[("modified_by_request", &local_var_str.to_string())]);
11210    }
11211    if let Some(ref local_var_str) = name {
11212        local_var_req_builder = match "multi" {
11213            "multi" => local_var_req_builder.query(
11214                &local_var_str
11215                    .into_iter()
11216                    .map(|p| ("name".to_owned(), p.to_string()))
11217                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11218            ),
11219            _ => local_var_req_builder.query(&[(
11220                "name",
11221                &local_var_str
11222                    .into_iter()
11223                    .map(|p| p.to_string())
11224                    .collect::<Vec<String>>()
11225                    .join(",")
11226                    .to_string(),
11227            )]),
11228        };
11229    }
11230    if let Some(ref local_var_str) = name__empty {
11231        local_var_req_builder =
11232            local_var_req_builder.query(&[("name__empty", &local_var_str.to_string())]);
11233    }
11234    if let Some(ref local_var_str) = name__ic {
11235        local_var_req_builder = match "multi" {
11236            "multi" => local_var_req_builder.query(
11237                &local_var_str
11238                    .into_iter()
11239                    .map(|p| ("name__ic".to_owned(), p.to_string()))
11240                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11241            ),
11242            _ => local_var_req_builder.query(&[(
11243                "name__ic",
11244                &local_var_str
11245                    .into_iter()
11246                    .map(|p| p.to_string())
11247                    .collect::<Vec<String>>()
11248                    .join(",")
11249                    .to_string(),
11250            )]),
11251        };
11252    }
11253    if let Some(ref local_var_str) = name__ie {
11254        local_var_req_builder = match "multi" {
11255            "multi" => local_var_req_builder.query(
11256                &local_var_str
11257                    .into_iter()
11258                    .map(|p| ("name__ie".to_owned(), p.to_string()))
11259                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11260            ),
11261            _ => local_var_req_builder.query(&[(
11262                "name__ie",
11263                &local_var_str
11264                    .into_iter()
11265                    .map(|p| p.to_string())
11266                    .collect::<Vec<String>>()
11267                    .join(",")
11268                    .to_string(),
11269            )]),
11270        };
11271    }
11272    if let Some(ref local_var_str) = name__iew {
11273        local_var_req_builder = match "multi" {
11274            "multi" => local_var_req_builder.query(
11275                &local_var_str
11276                    .into_iter()
11277                    .map(|p| ("name__iew".to_owned(), p.to_string()))
11278                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11279            ),
11280            _ => local_var_req_builder.query(&[(
11281                "name__iew",
11282                &local_var_str
11283                    .into_iter()
11284                    .map(|p| p.to_string())
11285                    .collect::<Vec<String>>()
11286                    .join(",")
11287                    .to_string(),
11288            )]),
11289        };
11290    }
11291    if let Some(ref local_var_str) = name__iregex {
11292        local_var_req_builder = match "multi" {
11293            "multi" => local_var_req_builder.query(
11294                &local_var_str
11295                    .into_iter()
11296                    .map(|p| ("name__iregex".to_owned(), p.to_string()))
11297                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11298            ),
11299            _ => local_var_req_builder.query(&[(
11300                "name__iregex",
11301                &local_var_str
11302                    .into_iter()
11303                    .map(|p| p.to_string())
11304                    .collect::<Vec<String>>()
11305                    .join(",")
11306                    .to_string(),
11307            )]),
11308        };
11309    }
11310    if let Some(ref local_var_str) = name__isw {
11311        local_var_req_builder = match "multi" {
11312            "multi" => local_var_req_builder.query(
11313                &local_var_str
11314                    .into_iter()
11315                    .map(|p| ("name__isw".to_owned(), p.to_string()))
11316                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11317            ),
11318            _ => local_var_req_builder.query(&[(
11319                "name__isw",
11320                &local_var_str
11321                    .into_iter()
11322                    .map(|p| p.to_string())
11323                    .collect::<Vec<String>>()
11324                    .join(",")
11325                    .to_string(),
11326            )]),
11327        };
11328    }
11329    if let Some(ref local_var_str) = name__n {
11330        local_var_req_builder = match "multi" {
11331            "multi" => local_var_req_builder.query(
11332                &local_var_str
11333                    .into_iter()
11334                    .map(|p| ("name__n".to_owned(), p.to_string()))
11335                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11336            ),
11337            _ => local_var_req_builder.query(&[(
11338                "name__n",
11339                &local_var_str
11340                    .into_iter()
11341                    .map(|p| p.to_string())
11342                    .collect::<Vec<String>>()
11343                    .join(",")
11344                    .to_string(),
11345            )]),
11346        };
11347    }
11348    if let Some(ref local_var_str) = name__nic {
11349        local_var_req_builder = match "multi" {
11350            "multi" => local_var_req_builder.query(
11351                &local_var_str
11352                    .into_iter()
11353                    .map(|p| ("name__nic".to_owned(), p.to_string()))
11354                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11355            ),
11356            _ => local_var_req_builder.query(&[(
11357                "name__nic",
11358                &local_var_str
11359                    .into_iter()
11360                    .map(|p| p.to_string())
11361                    .collect::<Vec<String>>()
11362                    .join(",")
11363                    .to_string(),
11364            )]),
11365        };
11366    }
11367    if let Some(ref local_var_str) = name__nie {
11368        local_var_req_builder = match "multi" {
11369            "multi" => local_var_req_builder.query(
11370                &local_var_str
11371                    .into_iter()
11372                    .map(|p| ("name__nie".to_owned(), p.to_string()))
11373                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11374            ),
11375            _ => local_var_req_builder.query(&[(
11376                "name__nie",
11377                &local_var_str
11378                    .into_iter()
11379                    .map(|p| p.to_string())
11380                    .collect::<Vec<String>>()
11381                    .join(",")
11382                    .to_string(),
11383            )]),
11384        };
11385    }
11386    if let Some(ref local_var_str) = name__niew {
11387        local_var_req_builder = match "multi" {
11388            "multi" => local_var_req_builder.query(
11389                &local_var_str
11390                    .into_iter()
11391                    .map(|p| ("name__niew".to_owned(), p.to_string()))
11392                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11393            ),
11394            _ => local_var_req_builder.query(&[(
11395                "name__niew",
11396                &local_var_str
11397                    .into_iter()
11398                    .map(|p| p.to_string())
11399                    .collect::<Vec<String>>()
11400                    .join(",")
11401                    .to_string(),
11402            )]),
11403        };
11404    }
11405    if let Some(ref local_var_str) = name__nisw {
11406        local_var_req_builder = match "multi" {
11407            "multi" => local_var_req_builder.query(
11408                &local_var_str
11409                    .into_iter()
11410                    .map(|p| ("name__nisw".to_owned(), p.to_string()))
11411                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11412            ),
11413            _ => local_var_req_builder.query(&[(
11414                "name__nisw",
11415                &local_var_str
11416                    .into_iter()
11417                    .map(|p| p.to_string())
11418                    .collect::<Vec<String>>()
11419                    .join(",")
11420                    .to_string(),
11421            )]),
11422        };
11423    }
11424    if let Some(ref local_var_str) = name__regex {
11425        local_var_req_builder = match "multi" {
11426            "multi" => local_var_req_builder.query(
11427                &local_var_str
11428                    .into_iter()
11429                    .map(|p| ("name__regex".to_owned(), p.to_string()))
11430                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11431            ),
11432            _ => local_var_req_builder.query(&[(
11433                "name__regex",
11434                &local_var_str
11435                    .into_iter()
11436                    .map(|p| p.to_string())
11437                    .collect::<Vec<String>>()
11438                    .join(",")
11439                    .to_string(),
11440            )]),
11441        };
11442    }
11443    if let Some(ref local_var_str) = offset {
11444        local_var_req_builder =
11445            local_var_req_builder.query(&[("offset", &local_var_str.to_string())]);
11446    }
11447    if let Some(ref local_var_str) = ordering {
11448        local_var_req_builder =
11449            local_var_req_builder.query(&[("ordering", &local_var_str.to_string())]);
11450    }
11451    if let Some(ref local_var_str) = owner {
11452        local_var_req_builder = match "multi" {
11453            "multi" => local_var_req_builder.query(
11454                &local_var_str
11455                    .into_iter()
11456                    .map(|p| ("owner".to_owned(), p.to_string()))
11457                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11458            ),
11459            _ => local_var_req_builder.query(&[(
11460                "owner",
11461                &local_var_str
11462                    .into_iter()
11463                    .map(|p| p.to_string())
11464                    .collect::<Vec<String>>()
11465                    .join(",")
11466                    .to_string(),
11467            )]),
11468        };
11469    }
11470    if let Some(ref local_var_str) = owner__n {
11471        local_var_req_builder = match "multi" {
11472            "multi" => local_var_req_builder.query(
11473                &local_var_str
11474                    .into_iter()
11475                    .map(|p| ("owner__n".to_owned(), p.to_string()))
11476                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11477            ),
11478            _ => local_var_req_builder.query(&[(
11479                "owner__n",
11480                &local_var_str
11481                    .into_iter()
11482                    .map(|p| p.to_string())
11483                    .collect::<Vec<String>>()
11484                    .join(",")
11485                    .to_string(),
11486            )]),
11487        };
11488    }
11489    if let Some(ref local_var_str) = owner_group {
11490        local_var_req_builder = match "multi" {
11491            "multi" => local_var_req_builder.query(
11492                &local_var_str
11493                    .into_iter()
11494                    .map(|p| ("owner_group".to_owned(), p.to_string()))
11495                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11496            ),
11497            _ => local_var_req_builder.query(&[(
11498                "owner_group",
11499                &local_var_str
11500                    .into_iter()
11501                    .map(|p| p.to_string())
11502                    .collect::<Vec<String>>()
11503                    .join(",")
11504                    .to_string(),
11505            )]),
11506        };
11507    }
11508    if let Some(ref local_var_str) = owner_group__n {
11509        local_var_req_builder = match "multi" {
11510            "multi" => local_var_req_builder.query(
11511                &local_var_str
11512                    .into_iter()
11513                    .map(|p| ("owner_group__n".to_owned(), p.to_string()))
11514                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11515            ),
11516            _ => local_var_req_builder.query(&[(
11517                "owner_group__n",
11518                &local_var_str
11519                    .into_iter()
11520                    .map(|p| p.to_string())
11521                    .collect::<Vec<String>>()
11522                    .join(",")
11523                    .to_string(),
11524            )]),
11525        };
11526    }
11527    if let Some(ref local_var_str) = owner_group_id {
11528        local_var_req_builder = match "multi" {
11529            "multi" => local_var_req_builder.query(
11530                &local_var_str
11531                    .into_iter()
11532                    .map(|p| ("owner_group_id".to_owned(), p.to_string()))
11533                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11534            ),
11535            _ => local_var_req_builder.query(&[(
11536                "owner_group_id",
11537                &local_var_str
11538                    .into_iter()
11539                    .map(|p| p.to_string())
11540                    .collect::<Vec<String>>()
11541                    .join(",")
11542                    .to_string(),
11543            )]),
11544        };
11545    }
11546    if let Some(ref local_var_str) = owner_group_id__n {
11547        local_var_req_builder = match "multi" {
11548            "multi" => local_var_req_builder.query(
11549                &local_var_str
11550                    .into_iter()
11551                    .map(|p| ("owner_group_id__n".to_owned(), p.to_string()))
11552                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11553            ),
11554            _ => local_var_req_builder.query(&[(
11555                "owner_group_id__n",
11556                &local_var_str
11557                    .into_iter()
11558                    .map(|p| p.to_string())
11559                    .collect::<Vec<String>>()
11560                    .join(",")
11561                    .to_string(),
11562            )]),
11563        };
11564    }
11565    if let Some(ref local_var_str) = owner_id {
11566        local_var_req_builder = match "multi" {
11567            "multi" => local_var_req_builder.query(
11568                &local_var_str
11569                    .into_iter()
11570                    .map(|p| ("owner_id".to_owned(), p.to_string()))
11571                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11572            ),
11573            _ => local_var_req_builder.query(&[(
11574                "owner_id",
11575                &local_var_str
11576                    .into_iter()
11577                    .map(|p| p.to_string())
11578                    .collect::<Vec<String>>()
11579                    .join(",")
11580                    .to_string(),
11581            )]),
11582        };
11583    }
11584    if let Some(ref local_var_str) = owner_id__n {
11585        local_var_req_builder = match "multi" {
11586            "multi" => local_var_req_builder.query(
11587                &local_var_str
11588                    .into_iter()
11589                    .map(|p| ("owner_id__n".to_owned(), p.to_string()))
11590                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11591            ),
11592            _ => local_var_req_builder.query(&[(
11593                "owner_id__n",
11594                &local_var_str
11595                    .into_iter()
11596                    .map(|p| p.to_string())
11597                    .collect::<Vec<String>>()
11598                    .join(",")
11599                    .to_string(),
11600            )]),
11601        };
11602    }
11603    if let Some(ref local_var_str) = q {
11604        local_var_req_builder = local_var_req_builder.query(&[("q", &local_var_str.to_string())]);
11605    }
11606    if let Some(ref local_var_str) = sa_lifetime_data {
11607        local_var_req_builder = match "multi" {
11608            "multi" => local_var_req_builder.query(
11609                &local_var_str
11610                    .into_iter()
11611                    .map(|p| ("sa_lifetime_data".to_owned(), p.to_string()))
11612                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11613            ),
11614            _ => local_var_req_builder.query(&[(
11615                "sa_lifetime_data",
11616                &local_var_str
11617                    .into_iter()
11618                    .map(|p| p.to_string())
11619                    .collect::<Vec<String>>()
11620                    .join(",")
11621                    .to_string(),
11622            )]),
11623        };
11624    }
11625    if let Some(ref local_var_str) = sa_lifetime_data__empty {
11626        local_var_req_builder =
11627            local_var_req_builder.query(&[("sa_lifetime_data__empty", &local_var_str.to_string())]);
11628    }
11629    if let Some(ref local_var_str) = sa_lifetime_data__gt {
11630        local_var_req_builder = match "multi" {
11631            "multi" => local_var_req_builder.query(
11632                &local_var_str
11633                    .into_iter()
11634                    .map(|p| ("sa_lifetime_data__gt".to_owned(), p.to_string()))
11635                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11636            ),
11637            _ => local_var_req_builder.query(&[(
11638                "sa_lifetime_data__gt",
11639                &local_var_str
11640                    .into_iter()
11641                    .map(|p| p.to_string())
11642                    .collect::<Vec<String>>()
11643                    .join(",")
11644                    .to_string(),
11645            )]),
11646        };
11647    }
11648    if let Some(ref local_var_str) = sa_lifetime_data__gte {
11649        local_var_req_builder = match "multi" {
11650            "multi" => local_var_req_builder.query(
11651                &local_var_str
11652                    .into_iter()
11653                    .map(|p| ("sa_lifetime_data__gte".to_owned(), p.to_string()))
11654                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11655            ),
11656            _ => local_var_req_builder.query(&[(
11657                "sa_lifetime_data__gte",
11658                &local_var_str
11659                    .into_iter()
11660                    .map(|p| p.to_string())
11661                    .collect::<Vec<String>>()
11662                    .join(",")
11663                    .to_string(),
11664            )]),
11665        };
11666    }
11667    if let Some(ref local_var_str) = sa_lifetime_data__lt {
11668        local_var_req_builder = match "multi" {
11669            "multi" => local_var_req_builder.query(
11670                &local_var_str
11671                    .into_iter()
11672                    .map(|p| ("sa_lifetime_data__lt".to_owned(), p.to_string()))
11673                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11674            ),
11675            _ => local_var_req_builder.query(&[(
11676                "sa_lifetime_data__lt",
11677                &local_var_str
11678                    .into_iter()
11679                    .map(|p| p.to_string())
11680                    .collect::<Vec<String>>()
11681                    .join(",")
11682                    .to_string(),
11683            )]),
11684        };
11685    }
11686    if let Some(ref local_var_str) = sa_lifetime_data__lte {
11687        local_var_req_builder = match "multi" {
11688            "multi" => local_var_req_builder.query(
11689                &local_var_str
11690                    .into_iter()
11691                    .map(|p| ("sa_lifetime_data__lte".to_owned(), p.to_string()))
11692                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11693            ),
11694            _ => local_var_req_builder.query(&[(
11695                "sa_lifetime_data__lte",
11696                &local_var_str
11697                    .into_iter()
11698                    .map(|p| p.to_string())
11699                    .collect::<Vec<String>>()
11700                    .join(",")
11701                    .to_string(),
11702            )]),
11703        };
11704    }
11705    if let Some(ref local_var_str) = sa_lifetime_data__n {
11706        local_var_req_builder = match "multi" {
11707            "multi" => local_var_req_builder.query(
11708                &local_var_str
11709                    .into_iter()
11710                    .map(|p| ("sa_lifetime_data__n".to_owned(), p.to_string()))
11711                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11712            ),
11713            _ => local_var_req_builder.query(&[(
11714                "sa_lifetime_data__n",
11715                &local_var_str
11716                    .into_iter()
11717                    .map(|p| p.to_string())
11718                    .collect::<Vec<String>>()
11719                    .join(",")
11720                    .to_string(),
11721            )]),
11722        };
11723    }
11724    if let Some(ref local_var_str) = sa_lifetime_seconds {
11725        local_var_req_builder = match "multi" {
11726            "multi" => local_var_req_builder.query(
11727                &local_var_str
11728                    .into_iter()
11729                    .map(|p| ("sa_lifetime_seconds".to_owned(), p.to_string()))
11730                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11731            ),
11732            _ => local_var_req_builder.query(&[(
11733                "sa_lifetime_seconds",
11734                &local_var_str
11735                    .into_iter()
11736                    .map(|p| p.to_string())
11737                    .collect::<Vec<String>>()
11738                    .join(",")
11739                    .to_string(),
11740            )]),
11741        };
11742    }
11743    if let Some(ref local_var_str) = sa_lifetime_seconds__empty {
11744        local_var_req_builder = local_var_req_builder
11745            .query(&[("sa_lifetime_seconds__empty", &local_var_str.to_string())]);
11746    }
11747    if let Some(ref local_var_str) = sa_lifetime_seconds__gt {
11748        local_var_req_builder = match "multi" {
11749            "multi" => local_var_req_builder.query(
11750                &local_var_str
11751                    .into_iter()
11752                    .map(|p| ("sa_lifetime_seconds__gt".to_owned(), p.to_string()))
11753                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11754            ),
11755            _ => local_var_req_builder.query(&[(
11756                "sa_lifetime_seconds__gt",
11757                &local_var_str
11758                    .into_iter()
11759                    .map(|p| p.to_string())
11760                    .collect::<Vec<String>>()
11761                    .join(",")
11762                    .to_string(),
11763            )]),
11764        };
11765    }
11766    if let Some(ref local_var_str) = sa_lifetime_seconds__gte {
11767        local_var_req_builder = match "multi" {
11768            "multi" => local_var_req_builder.query(
11769                &local_var_str
11770                    .into_iter()
11771                    .map(|p| ("sa_lifetime_seconds__gte".to_owned(), p.to_string()))
11772                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11773            ),
11774            _ => local_var_req_builder.query(&[(
11775                "sa_lifetime_seconds__gte",
11776                &local_var_str
11777                    .into_iter()
11778                    .map(|p| p.to_string())
11779                    .collect::<Vec<String>>()
11780                    .join(",")
11781                    .to_string(),
11782            )]),
11783        };
11784    }
11785    if let Some(ref local_var_str) = sa_lifetime_seconds__lt {
11786        local_var_req_builder = match "multi" {
11787            "multi" => local_var_req_builder.query(
11788                &local_var_str
11789                    .into_iter()
11790                    .map(|p| ("sa_lifetime_seconds__lt".to_owned(), p.to_string()))
11791                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11792            ),
11793            _ => local_var_req_builder.query(&[(
11794                "sa_lifetime_seconds__lt",
11795                &local_var_str
11796                    .into_iter()
11797                    .map(|p| p.to_string())
11798                    .collect::<Vec<String>>()
11799                    .join(",")
11800                    .to_string(),
11801            )]),
11802        };
11803    }
11804    if let Some(ref local_var_str) = sa_lifetime_seconds__lte {
11805        local_var_req_builder = match "multi" {
11806            "multi" => local_var_req_builder.query(
11807                &local_var_str
11808                    .into_iter()
11809                    .map(|p| ("sa_lifetime_seconds__lte".to_owned(), p.to_string()))
11810                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11811            ),
11812            _ => local_var_req_builder.query(&[(
11813                "sa_lifetime_seconds__lte",
11814                &local_var_str
11815                    .into_iter()
11816                    .map(|p| p.to_string())
11817                    .collect::<Vec<String>>()
11818                    .join(",")
11819                    .to_string(),
11820            )]),
11821        };
11822    }
11823    if let Some(ref local_var_str) = sa_lifetime_seconds__n {
11824        local_var_req_builder = match "multi" {
11825            "multi" => local_var_req_builder.query(
11826                &local_var_str
11827                    .into_iter()
11828                    .map(|p| ("sa_lifetime_seconds__n".to_owned(), p.to_string()))
11829                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11830            ),
11831            _ => local_var_req_builder.query(&[(
11832                "sa_lifetime_seconds__n",
11833                &local_var_str
11834                    .into_iter()
11835                    .map(|p| p.to_string())
11836                    .collect::<Vec<String>>()
11837                    .join(",")
11838                    .to_string(),
11839            )]),
11840        };
11841    }
11842    if let Some(ref local_var_str) = tag {
11843        local_var_req_builder = match "multi" {
11844            "multi" => local_var_req_builder.query(
11845                &local_var_str
11846                    .into_iter()
11847                    .map(|p| ("tag".to_owned(), p.to_string()))
11848                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11849            ),
11850            _ => local_var_req_builder.query(&[(
11851                "tag",
11852                &local_var_str
11853                    .into_iter()
11854                    .map(|p| p.to_string())
11855                    .collect::<Vec<String>>()
11856                    .join(",")
11857                    .to_string(),
11858            )]),
11859        };
11860    }
11861    if let Some(ref local_var_str) = tag__n {
11862        local_var_req_builder = match "multi" {
11863            "multi" => local_var_req_builder.query(
11864                &local_var_str
11865                    .into_iter()
11866                    .map(|p| ("tag__n".to_owned(), p.to_string()))
11867                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11868            ),
11869            _ => local_var_req_builder.query(&[(
11870                "tag__n",
11871                &local_var_str
11872                    .into_iter()
11873                    .map(|p| p.to_string())
11874                    .collect::<Vec<String>>()
11875                    .join(",")
11876                    .to_string(),
11877            )]),
11878        };
11879    }
11880    if let Some(ref local_var_str) = tag_id {
11881        local_var_req_builder = match "multi" {
11882            "multi" => local_var_req_builder.query(
11883                &local_var_str
11884                    .into_iter()
11885                    .map(|p| ("tag_id".to_owned(), p.to_string()))
11886                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11887            ),
11888            _ => local_var_req_builder.query(&[(
11889                "tag_id",
11890                &local_var_str
11891                    .into_iter()
11892                    .map(|p| p.to_string())
11893                    .collect::<Vec<String>>()
11894                    .join(",")
11895                    .to_string(),
11896            )]),
11897        };
11898    }
11899    if let Some(ref local_var_str) = tag_id__n {
11900        local_var_req_builder = match "multi" {
11901            "multi" => local_var_req_builder.query(
11902                &local_var_str
11903                    .into_iter()
11904                    .map(|p| ("tag_id__n".to_owned(), p.to_string()))
11905                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11906            ),
11907            _ => local_var_req_builder.query(&[(
11908                "tag_id__n",
11909                &local_var_str
11910                    .into_iter()
11911                    .map(|p| p.to_string())
11912                    .collect::<Vec<String>>()
11913                    .join(",")
11914                    .to_string(),
11915            )]),
11916        };
11917    }
11918    if let Some(ref local_var_str) = updated_by_request {
11919        local_var_req_builder =
11920            local_var_req_builder.query(&[("updated_by_request", &local_var_str.to_string())]);
11921    }
11922    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
11923        local_var_req_builder =
11924            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
11925    }
11926    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
11927        let local_var_key = local_var_apikey.key.clone();
11928        let local_var_value = match local_var_apikey.prefix {
11929            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
11930            None => local_var_key,
11931        };
11932        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
11933    };
11934
11935    let local_var_req = local_var_req_builder.build()?;
11936    let local_var_resp = local_var_client.execute(local_var_req).await?;
11937
11938    let local_var_status = local_var_resp.status();
11939    let local_var_content = local_var_resp.text().await?;
11940
11941    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
11942        serde_json::from_str(&local_var_content).map_err(Error::from)
11943    } else {
11944        let local_var_entity: Option<VpnIpsecProposalsListError> =
11945            serde_json::from_str(&local_var_content).ok();
11946        let local_var_error = ResponseContent {
11947            status: local_var_status,
11948            content: local_var_content,
11949            entity: local_var_entity,
11950        };
11951        Err(Error::ResponseError(local_var_error))
11952    }
11953}
11954
11955/// Patch a IPSec proposal object.
11956pub async fn vpn_ipsec_proposals_partial_update(
11957    configuration: &configuration::Configuration,
11958    id: i32,
11959    patched_writable_ip_sec_proposal_request: Option<
11960        crate::models::PatchedWritableIpSecProposalRequest,
11961    >,
11962) -> Result<crate::models::IpSecProposal, Error<VpnIpsecProposalsPartialUpdateError>> {
11963    let local_var_configuration = configuration;
11964
11965    let local_var_client = &local_var_configuration.client;
11966
11967    let local_var_uri_str = format!(
11968        "{}/api/vpn/ipsec-proposals/{id}/",
11969        local_var_configuration.base_path,
11970        id = id
11971    );
11972    let mut local_var_req_builder =
11973        local_var_client.request(reqwest::Method::PATCH, local_var_uri_str.as_str());
11974
11975    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
11976        local_var_req_builder =
11977            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
11978    }
11979    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
11980        let local_var_key = local_var_apikey.key.clone();
11981        let local_var_value = match local_var_apikey.prefix {
11982            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
11983            None => local_var_key,
11984        };
11985        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
11986    };
11987    local_var_req_builder = local_var_req_builder.json(&patched_writable_ip_sec_proposal_request);
11988
11989    let local_var_req = local_var_req_builder.build()?;
11990    let local_var_resp = local_var_client.execute(local_var_req).await?;
11991
11992    let local_var_status = local_var_resp.status();
11993    let local_var_content = local_var_resp.text().await?;
11994
11995    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
11996        serde_json::from_str(&local_var_content).map_err(Error::from)
11997    } else {
11998        let local_var_entity: Option<VpnIpsecProposalsPartialUpdateError> =
11999            serde_json::from_str(&local_var_content).ok();
12000        let local_var_error = ResponseContent {
12001            status: local_var_status,
12002            content: local_var_content,
12003            entity: local_var_entity,
12004        };
12005        Err(Error::ResponseError(local_var_error))
12006    }
12007}
12008
12009/// Get a IPSec proposal object.
12010pub async fn vpn_ipsec_proposals_retrieve(
12011    configuration: &configuration::Configuration,
12012    id: i32,
12013) -> Result<crate::models::IpSecProposal, Error<VpnIpsecProposalsRetrieveError>> {
12014    let local_var_configuration = configuration;
12015
12016    let local_var_client = &local_var_configuration.client;
12017
12018    let local_var_uri_str = format!(
12019        "{}/api/vpn/ipsec-proposals/{id}/",
12020        local_var_configuration.base_path,
12021        id = id
12022    );
12023    let mut local_var_req_builder =
12024        local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
12025
12026    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
12027        local_var_req_builder =
12028            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
12029    }
12030    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
12031        let local_var_key = local_var_apikey.key.clone();
12032        let local_var_value = match local_var_apikey.prefix {
12033            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
12034            None => local_var_key,
12035        };
12036        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
12037    };
12038
12039    let local_var_req = local_var_req_builder.build()?;
12040    let local_var_resp = local_var_client.execute(local_var_req).await?;
12041
12042    let local_var_status = local_var_resp.status();
12043    let local_var_content = local_var_resp.text().await?;
12044
12045    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
12046        serde_json::from_str(&local_var_content).map_err(Error::from)
12047    } else {
12048        let local_var_entity: Option<VpnIpsecProposalsRetrieveError> =
12049            serde_json::from_str(&local_var_content).ok();
12050        let local_var_error = ResponseContent {
12051            status: local_var_status,
12052            content: local_var_content,
12053            entity: local_var_entity,
12054        };
12055        Err(Error::ResponseError(local_var_error))
12056    }
12057}
12058
12059/// Put a IPSec proposal object.
12060pub async fn vpn_ipsec_proposals_update(
12061    configuration: &configuration::Configuration,
12062    id: i32,
12063    writable_ip_sec_proposal_request: crate::models::WritableIpSecProposalRequest,
12064) -> Result<crate::models::IpSecProposal, Error<VpnIpsecProposalsUpdateError>> {
12065    let local_var_configuration = configuration;
12066
12067    let local_var_client = &local_var_configuration.client;
12068
12069    let local_var_uri_str = format!(
12070        "{}/api/vpn/ipsec-proposals/{id}/",
12071        local_var_configuration.base_path,
12072        id = id
12073    );
12074    let mut local_var_req_builder =
12075        local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());
12076
12077    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
12078        local_var_req_builder =
12079            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
12080    }
12081    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
12082        let local_var_key = local_var_apikey.key.clone();
12083        let local_var_value = match local_var_apikey.prefix {
12084            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
12085            None => local_var_key,
12086        };
12087        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
12088    };
12089    local_var_req_builder = local_var_req_builder.json(&writable_ip_sec_proposal_request);
12090
12091    let local_var_req = local_var_req_builder.build()?;
12092    let local_var_resp = local_var_client.execute(local_var_req).await?;
12093
12094    let local_var_status = local_var_resp.status();
12095    let local_var_content = local_var_resp.text().await?;
12096
12097    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
12098        serde_json::from_str(&local_var_content).map_err(Error::from)
12099    } else {
12100        let local_var_entity: Option<VpnIpsecProposalsUpdateError> =
12101            serde_json::from_str(&local_var_content).ok();
12102        let local_var_error = ResponseContent {
12103            status: local_var_status,
12104            content: local_var_content,
12105            entity: local_var_entity,
12106        };
12107        Err(Error::ResponseError(local_var_error))
12108    }
12109}
12110
12111/// Delete a list of L2VPN termination objects.
12112pub async fn vpn_l2vpn_terminations_bulk_destroy(
12113    configuration: &configuration::Configuration,
12114    l2_vpn_termination_request: Vec<crate::models::L2VpnTerminationRequest>,
12115) -> Result<(), Error<VpnL2vpnTerminationsBulkDestroyError>> {
12116    let local_var_configuration = configuration;
12117
12118    let local_var_client = &local_var_configuration.client;
12119
12120    let local_var_uri_str = format!(
12121        "{}/api/vpn/l2vpn-terminations/",
12122        local_var_configuration.base_path
12123    );
12124    let mut local_var_req_builder =
12125        local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());
12126
12127    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
12128        local_var_req_builder =
12129            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
12130    }
12131    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
12132        let local_var_key = local_var_apikey.key.clone();
12133        let local_var_value = match local_var_apikey.prefix {
12134            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
12135            None => local_var_key,
12136        };
12137        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
12138    };
12139    local_var_req_builder = local_var_req_builder.json(&l2_vpn_termination_request);
12140
12141    let local_var_req = local_var_req_builder.build()?;
12142    let local_var_resp = local_var_client.execute(local_var_req).await?;
12143
12144    let local_var_status = local_var_resp.status();
12145    let local_var_content = local_var_resp.text().await?;
12146
12147    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
12148        Ok(())
12149    } else {
12150        let local_var_entity: Option<VpnL2vpnTerminationsBulkDestroyError> =
12151            serde_json::from_str(&local_var_content).ok();
12152        let local_var_error = ResponseContent {
12153            status: local_var_status,
12154            content: local_var_content,
12155            entity: local_var_entity,
12156        };
12157        Err(Error::ResponseError(local_var_error))
12158    }
12159}
12160
12161/// Patch a list of L2VPN termination objects.
12162pub async fn vpn_l2vpn_terminations_bulk_partial_update(
12163    configuration: &configuration::Configuration,
12164    l2_vpn_termination_request: Vec<crate::models::L2VpnTerminationRequest>,
12165) -> Result<Vec<crate::models::L2VpnTermination>, Error<VpnL2vpnTerminationsBulkPartialUpdateError>>
12166{
12167    let local_var_configuration = configuration;
12168
12169    let local_var_client = &local_var_configuration.client;
12170
12171    let local_var_uri_str = format!(
12172        "{}/api/vpn/l2vpn-terminations/",
12173        local_var_configuration.base_path
12174    );
12175    let mut local_var_req_builder =
12176        local_var_client.request(reqwest::Method::PATCH, local_var_uri_str.as_str());
12177
12178    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
12179        local_var_req_builder =
12180            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
12181    }
12182    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
12183        let local_var_key = local_var_apikey.key.clone();
12184        let local_var_value = match local_var_apikey.prefix {
12185            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
12186            None => local_var_key,
12187        };
12188        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
12189    };
12190    local_var_req_builder = local_var_req_builder.json(&l2_vpn_termination_request);
12191
12192    let local_var_req = local_var_req_builder.build()?;
12193    let local_var_resp = local_var_client.execute(local_var_req).await?;
12194
12195    let local_var_status = local_var_resp.status();
12196    let local_var_content = local_var_resp.text().await?;
12197
12198    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
12199        serde_json::from_str(&local_var_content).map_err(Error::from)
12200    } else {
12201        let local_var_entity: Option<VpnL2vpnTerminationsBulkPartialUpdateError> =
12202            serde_json::from_str(&local_var_content).ok();
12203        let local_var_error = ResponseContent {
12204            status: local_var_status,
12205            content: local_var_content,
12206            entity: local_var_entity,
12207        };
12208        Err(Error::ResponseError(local_var_error))
12209    }
12210}
12211
12212/// Put a list of L2VPN termination objects.
12213pub async fn vpn_l2vpn_terminations_bulk_update(
12214    configuration: &configuration::Configuration,
12215    l2_vpn_termination_request: Vec<crate::models::L2VpnTerminationRequest>,
12216) -> Result<Vec<crate::models::L2VpnTermination>, Error<VpnL2vpnTerminationsBulkUpdateError>> {
12217    let local_var_configuration = configuration;
12218
12219    let local_var_client = &local_var_configuration.client;
12220
12221    let local_var_uri_str = format!(
12222        "{}/api/vpn/l2vpn-terminations/",
12223        local_var_configuration.base_path
12224    );
12225    let mut local_var_req_builder =
12226        local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());
12227
12228    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
12229        local_var_req_builder =
12230            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
12231    }
12232    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
12233        let local_var_key = local_var_apikey.key.clone();
12234        let local_var_value = match local_var_apikey.prefix {
12235            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
12236            None => local_var_key,
12237        };
12238        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
12239    };
12240    local_var_req_builder = local_var_req_builder.json(&l2_vpn_termination_request);
12241
12242    let local_var_req = local_var_req_builder.build()?;
12243    let local_var_resp = local_var_client.execute(local_var_req).await?;
12244
12245    let local_var_status = local_var_resp.status();
12246    let local_var_content = local_var_resp.text().await?;
12247
12248    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
12249        serde_json::from_str(&local_var_content).map_err(Error::from)
12250    } else {
12251        let local_var_entity: Option<VpnL2vpnTerminationsBulkUpdateError> =
12252            serde_json::from_str(&local_var_content).ok();
12253        let local_var_error = ResponseContent {
12254            status: local_var_status,
12255            content: local_var_content,
12256            entity: local_var_entity,
12257        };
12258        Err(Error::ResponseError(local_var_error))
12259    }
12260}
12261
12262/// Post a list of L2VPN termination objects.
12263pub async fn vpn_l2vpn_terminations_create(
12264    configuration: &configuration::Configuration,
12265    vpn_l2vpn_terminations_create_request: crate::models::VpnL2vpnTerminationsCreateRequest,
12266) -> Result<crate::models::L2VpnTermination, Error<VpnL2vpnTerminationsCreateError>> {
12267    let local_var_configuration = configuration;
12268
12269    let local_var_client = &local_var_configuration.client;
12270
12271    let local_var_uri_str = format!(
12272        "{}/api/vpn/l2vpn-terminations/",
12273        local_var_configuration.base_path
12274    );
12275    let mut local_var_req_builder =
12276        local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
12277
12278    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
12279        local_var_req_builder =
12280            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
12281    }
12282    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
12283        let local_var_key = local_var_apikey.key.clone();
12284        let local_var_value = match local_var_apikey.prefix {
12285            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
12286            None => local_var_key,
12287        };
12288        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
12289    };
12290    local_var_req_builder = local_var_req_builder.json(&vpn_l2vpn_terminations_create_request);
12291
12292    let local_var_req = local_var_req_builder.build()?;
12293    let local_var_resp = local_var_client.execute(local_var_req).await?;
12294
12295    let local_var_status = local_var_resp.status();
12296    let local_var_content = local_var_resp.text().await?;
12297
12298    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
12299        serde_json::from_str(&local_var_content).map_err(Error::from)
12300    } else {
12301        let local_var_entity: Option<VpnL2vpnTerminationsCreateError> =
12302            serde_json::from_str(&local_var_content).ok();
12303        let local_var_error = ResponseContent {
12304            status: local_var_status,
12305            content: local_var_content,
12306            entity: local_var_entity,
12307        };
12308        Err(Error::ResponseError(local_var_error))
12309    }
12310}
12311
12312/// Delete a L2VPN termination object.
12313pub async fn vpn_l2vpn_terminations_destroy(
12314    configuration: &configuration::Configuration,
12315    id: i32,
12316) -> Result<(), Error<VpnL2vpnTerminationsDestroyError>> {
12317    let local_var_configuration = configuration;
12318
12319    let local_var_client = &local_var_configuration.client;
12320
12321    let local_var_uri_str = format!(
12322        "{}/api/vpn/l2vpn-terminations/{id}/",
12323        local_var_configuration.base_path,
12324        id = id
12325    );
12326    let mut local_var_req_builder =
12327        local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());
12328
12329    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
12330        local_var_req_builder =
12331            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
12332    }
12333    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
12334        let local_var_key = local_var_apikey.key.clone();
12335        let local_var_value = match local_var_apikey.prefix {
12336            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
12337            None => local_var_key,
12338        };
12339        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
12340    };
12341
12342    let local_var_req = local_var_req_builder.build()?;
12343    let local_var_resp = local_var_client.execute(local_var_req).await?;
12344
12345    let local_var_status = local_var_resp.status();
12346    let local_var_content = local_var_resp.text().await?;
12347
12348    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
12349        Ok(())
12350    } else {
12351        let local_var_entity: Option<VpnL2vpnTerminationsDestroyError> =
12352            serde_json::from_str(&local_var_content).ok();
12353        let local_var_error = ResponseContent {
12354            status: local_var_status,
12355            content: local_var_content,
12356            entity: local_var_entity,
12357        };
12358        Err(Error::ResponseError(local_var_error))
12359    }
12360}
12361
12362/// Get a list of L2VPN termination objects.
12363pub async fn vpn_l2vpn_terminations_list(
12364    configuration: &configuration::Configuration,
12365    assigned_object_id: Option<Vec<i32>>,
12366    assigned_object_id__empty: Option<bool>,
12367    assigned_object_id__gt: Option<Vec<i32>>,
12368    assigned_object_id__gte: Option<Vec<i32>>,
12369    assigned_object_id__lt: Option<Vec<i32>>,
12370    assigned_object_id__lte: Option<Vec<i32>>,
12371    assigned_object_id__n: Option<Vec<i32>>,
12372    assigned_object_type: Option<Vec<String>>,
12373    assigned_object_type__n: Option<Vec<String>>,
12374    assigned_object_type_id: Option<Vec<i32>>,
12375    assigned_object_type_id__n: Option<Vec<i32>>,
12376    created: Option<Vec<String>>,
12377    created__empty: Option<Vec<String>>,
12378    created__gt: Option<Vec<String>>,
12379    created__gte: Option<Vec<String>>,
12380    created__lt: Option<Vec<String>>,
12381    created__lte: Option<Vec<String>>,
12382    created__n: Option<Vec<String>>,
12383    created_by_request: Option<&str>,
12384    device: Option<Vec<String>>,
12385    device__n: Option<Vec<String>>,
12386    device_id: Option<Vec<i32>>,
12387    device_id__n: Option<Vec<i32>>,
12388    id: Option<Vec<i32>>,
12389    id__empty: Option<bool>,
12390    id__gt: Option<Vec<i32>>,
12391    id__gte: Option<Vec<i32>>,
12392    id__lt: Option<Vec<i32>>,
12393    id__lte: Option<Vec<i32>>,
12394    id__n: Option<Vec<i32>>,
12395    interface: Option<Vec<String>>,
12396    interface__n: Option<Vec<String>>,
12397    interface_id: Option<Vec<i32>>,
12398    interface_id__n: Option<Vec<i32>>,
12399    l2vpn: Option<Vec<String>>,
12400    l2vpn__n: Option<Vec<String>>,
12401    l2vpn_id: Option<Vec<i32>>,
12402    l2vpn_id__n: Option<Vec<i32>>,
12403    last_updated: Option<Vec<String>>,
12404    last_updated__empty: Option<Vec<String>>,
12405    last_updated__gt: Option<Vec<String>>,
12406    last_updated__gte: Option<Vec<String>>,
12407    last_updated__lt: Option<Vec<String>>,
12408    last_updated__lte: Option<Vec<String>>,
12409    last_updated__n: Option<Vec<String>>,
12410    limit: Option<i32>,
12411    modified_by_request: Option<&str>,
12412    offset: Option<i32>,
12413    ordering: Option<&str>,
12414    q: Option<&str>,
12415    region: Option<Vec<String>>,
12416    region_id: Option<Vec<i32>>,
12417    site: Option<Vec<String>>,
12418    site_id: Option<Vec<i32>>,
12419    tag: Option<Vec<String>>,
12420    tag__n: Option<Vec<String>>,
12421    tag_id: Option<Vec<i32>>,
12422    tag_id__n: Option<Vec<i32>>,
12423    updated_by_request: Option<&str>,
12424    virtual_machine: Option<Vec<String>>,
12425    virtual_machine__n: Option<Vec<String>>,
12426    virtual_machine_id: Option<Vec<i32>>,
12427    virtual_machine_id__n: Option<Vec<i32>>,
12428    vlan: Option<Vec<String>>,
12429    vlan__n: Option<Vec<String>>,
12430    vlan_id: Option<Vec<i32>>,
12431    vlan_id__n: Option<Vec<i32>>,
12432    vlan_vid: Option<i32>,
12433    vlan_vid__empty: Option<i32>,
12434    vlan_vid__gt: Option<i32>,
12435    vlan_vid__gte: Option<i32>,
12436    vlan_vid__lt: Option<i32>,
12437    vlan_vid__lte: Option<i32>,
12438    vlan_vid__n: Option<i32>,
12439    vminterface: Option<Vec<String>>,
12440    vminterface__n: Option<Vec<String>>,
12441    vminterface_id: Option<Vec<i32>>,
12442    vminterface_id__n: Option<Vec<i32>>,
12443) -> Result<crate::models::PaginatedL2VpnTerminationList, Error<VpnL2vpnTerminationsListError>> {
12444    let local_var_configuration = configuration;
12445
12446    let local_var_client = &local_var_configuration.client;
12447
12448    let local_var_uri_str = format!(
12449        "{}/api/vpn/l2vpn-terminations/",
12450        local_var_configuration.base_path
12451    );
12452    let mut local_var_req_builder =
12453        local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
12454
12455    if let Some(ref local_var_str) = assigned_object_id {
12456        local_var_req_builder = match "multi" {
12457            "multi" => local_var_req_builder.query(
12458                &local_var_str
12459                    .into_iter()
12460                    .map(|p| ("assigned_object_id".to_owned(), p.to_string()))
12461                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12462            ),
12463            _ => local_var_req_builder.query(&[(
12464                "assigned_object_id",
12465                &local_var_str
12466                    .into_iter()
12467                    .map(|p| p.to_string())
12468                    .collect::<Vec<String>>()
12469                    .join(",")
12470                    .to_string(),
12471            )]),
12472        };
12473    }
12474    if let Some(ref local_var_str) = assigned_object_id__empty {
12475        local_var_req_builder = local_var_req_builder
12476            .query(&[("assigned_object_id__empty", &local_var_str.to_string())]);
12477    }
12478    if let Some(ref local_var_str) = assigned_object_id__gt {
12479        local_var_req_builder = match "multi" {
12480            "multi" => local_var_req_builder.query(
12481                &local_var_str
12482                    .into_iter()
12483                    .map(|p| ("assigned_object_id__gt".to_owned(), p.to_string()))
12484                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12485            ),
12486            _ => local_var_req_builder.query(&[(
12487                "assigned_object_id__gt",
12488                &local_var_str
12489                    .into_iter()
12490                    .map(|p| p.to_string())
12491                    .collect::<Vec<String>>()
12492                    .join(",")
12493                    .to_string(),
12494            )]),
12495        };
12496    }
12497    if let Some(ref local_var_str) = assigned_object_id__gte {
12498        local_var_req_builder = match "multi" {
12499            "multi" => local_var_req_builder.query(
12500                &local_var_str
12501                    .into_iter()
12502                    .map(|p| ("assigned_object_id__gte".to_owned(), p.to_string()))
12503                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12504            ),
12505            _ => local_var_req_builder.query(&[(
12506                "assigned_object_id__gte",
12507                &local_var_str
12508                    .into_iter()
12509                    .map(|p| p.to_string())
12510                    .collect::<Vec<String>>()
12511                    .join(",")
12512                    .to_string(),
12513            )]),
12514        };
12515    }
12516    if let Some(ref local_var_str) = assigned_object_id__lt {
12517        local_var_req_builder = match "multi" {
12518            "multi" => local_var_req_builder.query(
12519                &local_var_str
12520                    .into_iter()
12521                    .map(|p| ("assigned_object_id__lt".to_owned(), p.to_string()))
12522                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12523            ),
12524            _ => local_var_req_builder.query(&[(
12525                "assigned_object_id__lt",
12526                &local_var_str
12527                    .into_iter()
12528                    .map(|p| p.to_string())
12529                    .collect::<Vec<String>>()
12530                    .join(",")
12531                    .to_string(),
12532            )]),
12533        };
12534    }
12535    if let Some(ref local_var_str) = assigned_object_id__lte {
12536        local_var_req_builder = match "multi" {
12537            "multi" => local_var_req_builder.query(
12538                &local_var_str
12539                    .into_iter()
12540                    .map(|p| ("assigned_object_id__lte".to_owned(), p.to_string()))
12541                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12542            ),
12543            _ => local_var_req_builder.query(&[(
12544                "assigned_object_id__lte",
12545                &local_var_str
12546                    .into_iter()
12547                    .map(|p| p.to_string())
12548                    .collect::<Vec<String>>()
12549                    .join(",")
12550                    .to_string(),
12551            )]),
12552        };
12553    }
12554    if let Some(ref local_var_str) = assigned_object_id__n {
12555        local_var_req_builder = match "multi" {
12556            "multi" => local_var_req_builder.query(
12557                &local_var_str
12558                    .into_iter()
12559                    .map(|p| ("assigned_object_id__n".to_owned(), p.to_string()))
12560                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12561            ),
12562            _ => local_var_req_builder.query(&[(
12563                "assigned_object_id__n",
12564                &local_var_str
12565                    .into_iter()
12566                    .map(|p| p.to_string())
12567                    .collect::<Vec<String>>()
12568                    .join(",")
12569                    .to_string(),
12570            )]),
12571        };
12572    }
12573    if let Some(ref local_var_str) = assigned_object_type {
12574        local_var_req_builder = match "multi" {
12575            "multi" => local_var_req_builder.query(
12576                &local_var_str
12577                    .into_iter()
12578                    .map(|p| ("assigned_object_type".to_owned(), p.to_string()))
12579                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12580            ),
12581            _ => local_var_req_builder.query(&[(
12582                "assigned_object_type",
12583                &local_var_str
12584                    .into_iter()
12585                    .map(|p| p.to_string())
12586                    .collect::<Vec<String>>()
12587                    .join(",")
12588                    .to_string(),
12589            )]),
12590        };
12591    }
12592    if let Some(ref local_var_str) = assigned_object_type__n {
12593        local_var_req_builder = match "multi" {
12594            "multi" => local_var_req_builder.query(
12595                &local_var_str
12596                    .into_iter()
12597                    .map(|p| ("assigned_object_type__n".to_owned(), p.to_string()))
12598                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12599            ),
12600            _ => local_var_req_builder.query(&[(
12601                "assigned_object_type__n",
12602                &local_var_str
12603                    .into_iter()
12604                    .map(|p| p.to_string())
12605                    .collect::<Vec<String>>()
12606                    .join(",")
12607                    .to_string(),
12608            )]),
12609        };
12610    }
12611    if let Some(ref local_var_str) = assigned_object_type_id {
12612        local_var_req_builder = match "multi" {
12613            "multi" => local_var_req_builder.query(
12614                &local_var_str
12615                    .into_iter()
12616                    .map(|p| ("assigned_object_type_id".to_owned(), p.to_string()))
12617                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12618            ),
12619            _ => local_var_req_builder.query(&[(
12620                "assigned_object_type_id",
12621                &local_var_str
12622                    .into_iter()
12623                    .map(|p| p.to_string())
12624                    .collect::<Vec<String>>()
12625                    .join(",")
12626                    .to_string(),
12627            )]),
12628        };
12629    }
12630    if let Some(ref local_var_str) = assigned_object_type_id__n {
12631        local_var_req_builder = match "multi" {
12632            "multi" => local_var_req_builder.query(
12633                &local_var_str
12634                    .into_iter()
12635                    .map(|p| ("assigned_object_type_id__n".to_owned(), p.to_string()))
12636                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12637            ),
12638            _ => local_var_req_builder.query(&[(
12639                "assigned_object_type_id__n",
12640                &local_var_str
12641                    .into_iter()
12642                    .map(|p| p.to_string())
12643                    .collect::<Vec<String>>()
12644                    .join(",")
12645                    .to_string(),
12646            )]),
12647        };
12648    }
12649    if let Some(ref local_var_str) = created {
12650        local_var_req_builder = match "multi" {
12651            "multi" => local_var_req_builder.query(
12652                &local_var_str
12653                    .into_iter()
12654                    .map(|p| ("created".to_owned(), p.to_string()))
12655                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12656            ),
12657            _ => local_var_req_builder.query(&[(
12658                "created",
12659                &local_var_str
12660                    .into_iter()
12661                    .map(|p| p.to_string())
12662                    .collect::<Vec<String>>()
12663                    .join(",")
12664                    .to_string(),
12665            )]),
12666        };
12667    }
12668    if let Some(ref local_var_str) = created__empty {
12669        local_var_req_builder = match "multi" {
12670            "multi" => local_var_req_builder.query(
12671                &local_var_str
12672                    .into_iter()
12673                    .map(|p| ("created__empty".to_owned(), p.to_string()))
12674                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12675            ),
12676            _ => local_var_req_builder.query(&[(
12677                "created__empty",
12678                &local_var_str
12679                    .into_iter()
12680                    .map(|p| p.to_string())
12681                    .collect::<Vec<String>>()
12682                    .join(",")
12683                    .to_string(),
12684            )]),
12685        };
12686    }
12687    if let Some(ref local_var_str) = created__gt {
12688        local_var_req_builder = match "multi" {
12689            "multi" => local_var_req_builder.query(
12690                &local_var_str
12691                    .into_iter()
12692                    .map(|p| ("created__gt".to_owned(), p.to_string()))
12693                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12694            ),
12695            _ => local_var_req_builder.query(&[(
12696                "created__gt",
12697                &local_var_str
12698                    .into_iter()
12699                    .map(|p| p.to_string())
12700                    .collect::<Vec<String>>()
12701                    .join(",")
12702                    .to_string(),
12703            )]),
12704        };
12705    }
12706    if let Some(ref local_var_str) = created__gte {
12707        local_var_req_builder = match "multi" {
12708            "multi" => local_var_req_builder.query(
12709                &local_var_str
12710                    .into_iter()
12711                    .map(|p| ("created__gte".to_owned(), p.to_string()))
12712                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12713            ),
12714            _ => local_var_req_builder.query(&[(
12715                "created__gte",
12716                &local_var_str
12717                    .into_iter()
12718                    .map(|p| p.to_string())
12719                    .collect::<Vec<String>>()
12720                    .join(",")
12721                    .to_string(),
12722            )]),
12723        };
12724    }
12725    if let Some(ref local_var_str) = created__lt {
12726        local_var_req_builder = match "multi" {
12727            "multi" => local_var_req_builder.query(
12728                &local_var_str
12729                    .into_iter()
12730                    .map(|p| ("created__lt".to_owned(), p.to_string()))
12731                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12732            ),
12733            _ => local_var_req_builder.query(&[(
12734                "created__lt",
12735                &local_var_str
12736                    .into_iter()
12737                    .map(|p| p.to_string())
12738                    .collect::<Vec<String>>()
12739                    .join(",")
12740                    .to_string(),
12741            )]),
12742        };
12743    }
12744    if let Some(ref local_var_str) = created__lte {
12745        local_var_req_builder = match "multi" {
12746            "multi" => local_var_req_builder.query(
12747                &local_var_str
12748                    .into_iter()
12749                    .map(|p| ("created__lte".to_owned(), p.to_string()))
12750                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12751            ),
12752            _ => local_var_req_builder.query(&[(
12753                "created__lte",
12754                &local_var_str
12755                    .into_iter()
12756                    .map(|p| p.to_string())
12757                    .collect::<Vec<String>>()
12758                    .join(",")
12759                    .to_string(),
12760            )]),
12761        };
12762    }
12763    if let Some(ref local_var_str) = created__n {
12764        local_var_req_builder = match "multi" {
12765            "multi" => local_var_req_builder.query(
12766                &local_var_str
12767                    .into_iter()
12768                    .map(|p| ("created__n".to_owned(), p.to_string()))
12769                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12770            ),
12771            _ => local_var_req_builder.query(&[(
12772                "created__n",
12773                &local_var_str
12774                    .into_iter()
12775                    .map(|p| p.to_string())
12776                    .collect::<Vec<String>>()
12777                    .join(",")
12778                    .to_string(),
12779            )]),
12780        };
12781    }
12782    if let Some(ref local_var_str) = created_by_request {
12783        local_var_req_builder =
12784            local_var_req_builder.query(&[("created_by_request", &local_var_str.to_string())]);
12785    }
12786    if let Some(ref local_var_str) = device {
12787        local_var_req_builder = match "multi" {
12788            "multi" => local_var_req_builder.query(
12789                &local_var_str
12790                    .into_iter()
12791                    .map(|p| ("device".to_owned(), p.to_string()))
12792                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12793            ),
12794            _ => local_var_req_builder.query(&[(
12795                "device",
12796                &local_var_str
12797                    .into_iter()
12798                    .map(|p| p.to_string())
12799                    .collect::<Vec<String>>()
12800                    .join(",")
12801                    .to_string(),
12802            )]),
12803        };
12804    }
12805    if let Some(ref local_var_str) = device__n {
12806        local_var_req_builder = match "multi" {
12807            "multi" => local_var_req_builder.query(
12808                &local_var_str
12809                    .into_iter()
12810                    .map(|p| ("device__n".to_owned(), p.to_string()))
12811                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12812            ),
12813            _ => local_var_req_builder.query(&[(
12814                "device__n",
12815                &local_var_str
12816                    .into_iter()
12817                    .map(|p| p.to_string())
12818                    .collect::<Vec<String>>()
12819                    .join(",")
12820                    .to_string(),
12821            )]),
12822        };
12823    }
12824    if let Some(ref local_var_str) = device_id {
12825        local_var_req_builder = match "multi" {
12826            "multi" => local_var_req_builder.query(
12827                &local_var_str
12828                    .into_iter()
12829                    .map(|p| ("device_id".to_owned(), p.to_string()))
12830                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12831            ),
12832            _ => local_var_req_builder.query(&[(
12833                "device_id",
12834                &local_var_str
12835                    .into_iter()
12836                    .map(|p| p.to_string())
12837                    .collect::<Vec<String>>()
12838                    .join(",")
12839                    .to_string(),
12840            )]),
12841        };
12842    }
12843    if let Some(ref local_var_str) = device_id__n {
12844        local_var_req_builder = match "multi" {
12845            "multi" => local_var_req_builder.query(
12846                &local_var_str
12847                    .into_iter()
12848                    .map(|p| ("device_id__n".to_owned(), p.to_string()))
12849                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12850            ),
12851            _ => local_var_req_builder.query(&[(
12852                "device_id__n",
12853                &local_var_str
12854                    .into_iter()
12855                    .map(|p| p.to_string())
12856                    .collect::<Vec<String>>()
12857                    .join(",")
12858                    .to_string(),
12859            )]),
12860        };
12861    }
12862    if let Some(ref local_var_str) = id {
12863        local_var_req_builder = match "multi" {
12864            "multi" => local_var_req_builder.query(
12865                &local_var_str
12866                    .into_iter()
12867                    .map(|p| ("id".to_owned(), p.to_string()))
12868                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12869            ),
12870            _ => local_var_req_builder.query(&[(
12871                "id",
12872                &local_var_str
12873                    .into_iter()
12874                    .map(|p| p.to_string())
12875                    .collect::<Vec<String>>()
12876                    .join(",")
12877                    .to_string(),
12878            )]),
12879        };
12880    }
12881    if let Some(ref local_var_str) = id__empty {
12882        local_var_req_builder =
12883            local_var_req_builder.query(&[("id__empty", &local_var_str.to_string())]);
12884    }
12885    if let Some(ref local_var_str) = id__gt {
12886        local_var_req_builder = match "multi" {
12887            "multi" => local_var_req_builder.query(
12888                &local_var_str
12889                    .into_iter()
12890                    .map(|p| ("id__gt".to_owned(), p.to_string()))
12891                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12892            ),
12893            _ => local_var_req_builder.query(&[(
12894                "id__gt",
12895                &local_var_str
12896                    .into_iter()
12897                    .map(|p| p.to_string())
12898                    .collect::<Vec<String>>()
12899                    .join(",")
12900                    .to_string(),
12901            )]),
12902        };
12903    }
12904    if let Some(ref local_var_str) = id__gte {
12905        local_var_req_builder = match "multi" {
12906            "multi" => local_var_req_builder.query(
12907                &local_var_str
12908                    .into_iter()
12909                    .map(|p| ("id__gte".to_owned(), p.to_string()))
12910                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12911            ),
12912            _ => local_var_req_builder.query(&[(
12913                "id__gte",
12914                &local_var_str
12915                    .into_iter()
12916                    .map(|p| p.to_string())
12917                    .collect::<Vec<String>>()
12918                    .join(",")
12919                    .to_string(),
12920            )]),
12921        };
12922    }
12923    if let Some(ref local_var_str) = id__lt {
12924        local_var_req_builder = match "multi" {
12925            "multi" => local_var_req_builder.query(
12926                &local_var_str
12927                    .into_iter()
12928                    .map(|p| ("id__lt".to_owned(), p.to_string()))
12929                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12930            ),
12931            _ => local_var_req_builder.query(&[(
12932                "id__lt",
12933                &local_var_str
12934                    .into_iter()
12935                    .map(|p| p.to_string())
12936                    .collect::<Vec<String>>()
12937                    .join(",")
12938                    .to_string(),
12939            )]),
12940        };
12941    }
12942    if let Some(ref local_var_str) = id__lte {
12943        local_var_req_builder = match "multi" {
12944            "multi" => local_var_req_builder.query(
12945                &local_var_str
12946                    .into_iter()
12947                    .map(|p| ("id__lte".to_owned(), p.to_string()))
12948                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12949            ),
12950            _ => local_var_req_builder.query(&[(
12951                "id__lte",
12952                &local_var_str
12953                    .into_iter()
12954                    .map(|p| p.to_string())
12955                    .collect::<Vec<String>>()
12956                    .join(",")
12957                    .to_string(),
12958            )]),
12959        };
12960    }
12961    if let Some(ref local_var_str) = id__n {
12962        local_var_req_builder = match "multi" {
12963            "multi" => local_var_req_builder.query(
12964                &local_var_str
12965                    .into_iter()
12966                    .map(|p| ("id__n".to_owned(), p.to_string()))
12967                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12968            ),
12969            _ => local_var_req_builder.query(&[(
12970                "id__n",
12971                &local_var_str
12972                    .into_iter()
12973                    .map(|p| p.to_string())
12974                    .collect::<Vec<String>>()
12975                    .join(",")
12976                    .to_string(),
12977            )]),
12978        };
12979    }
12980    if let Some(ref local_var_str) = interface {
12981        local_var_req_builder = match "multi" {
12982            "multi" => local_var_req_builder.query(
12983                &local_var_str
12984                    .into_iter()
12985                    .map(|p| ("interface".to_owned(), p.to_string()))
12986                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12987            ),
12988            _ => local_var_req_builder.query(&[(
12989                "interface",
12990                &local_var_str
12991                    .into_iter()
12992                    .map(|p| p.to_string())
12993                    .collect::<Vec<String>>()
12994                    .join(",")
12995                    .to_string(),
12996            )]),
12997        };
12998    }
12999    if let Some(ref local_var_str) = interface__n {
13000        local_var_req_builder = match "multi" {
13001            "multi" => local_var_req_builder.query(
13002                &local_var_str
13003                    .into_iter()
13004                    .map(|p| ("interface__n".to_owned(), p.to_string()))
13005                    .collect::<Vec<(std::string::String, std::string::String)>>(),
13006            ),
13007            _ => local_var_req_builder.query(&[(
13008                "interface__n",
13009                &local_var_str
13010                    .into_iter()
13011                    .map(|p| p.to_string())
13012                    .collect::<Vec<String>>()
13013                    .join(",")
13014                    .to_string(),
13015            )]),
13016        };
13017    }
13018    if let Some(ref local_var_str) = interface_id {
13019        local_var_req_builder = match "multi" {
13020            "multi" => local_var_req_builder.query(
13021                &local_var_str
13022                    .into_iter()
13023                    .map(|p| ("interface_id".to_owned(), p.to_string()))
13024                    .collect::<Vec<(std::string::String, std::string::String)>>(),
13025            ),
13026            _ => local_var_req_builder.query(&[(
13027                "interface_id",
13028                &local_var_str
13029                    .into_iter()
13030                    .map(|p| p.to_string())
13031                    .collect::<Vec<String>>()
13032                    .join(",")
13033                    .to_string(),
13034            )]),
13035        };
13036    }
13037    if let Some(ref local_var_str) = interface_id__n {
13038        local_var_req_builder = match "multi" {
13039            "multi" => local_var_req_builder.query(
13040                &local_var_str
13041                    .into_iter()
13042                    .map(|p| ("interface_id__n".to_owned(), p.to_string()))
13043                    .collect::<Vec<(std::string::String, std::string::String)>>(),
13044            ),
13045            _ => local_var_req_builder.query(&[(
13046                "interface_id__n",
13047                &local_var_str
13048                    .into_iter()
13049                    .map(|p| p.to_string())
13050                    .collect::<Vec<String>>()
13051                    .join(",")
13052                    .to_string(),
13053            )]),
13054        };
13055    }
13056    if let Some(ref local_var_str) = l2vpn {
13057        local_var_req_builder = match "multi" {
13058            "multi" => local_var_req_builder.query(
13059                &local_var_str
13060                    .into_iter()
13061                    .map(|p| ("l2vpn".to_owned(), p.to_string()))
13062                    .collect::<Vec<(std::string::String, std::string::String)>>(),
13063            ),
13064            _ => local_var_req_builder.query(&[(
13065                "l2vpn",
13066                &local_var_str
13067                    .into_iter()
13068                    .map(|p| p.to_string())
13069                    .collect::<Vec<String>>()
13070                    .join(",")
13071                    .to_string(),
13072            )]),
13073        };
13074    }
13075    if let Some(ref local_var_str) = l2vpn__n {
13076        local_var_req_builder = match "multi" {
13077            "multi" => local_var_req_builder.query(
13078                &local_var_str
13079                    .into_iter()
13080                    .map(|p| ("l2vpn__n".to_owned(), p.to_string()))
13081                    .collect::<Vec<(std::string::String, std::string::String)>>(),
13082            ),
13083            _ => local_var_req_builder.query(&[(
13084                "l2vpn__n",
13085                &local_var_str
13086                    .into_iter()
13087                    .map(|p| p.to_string())
13088                    .collect::<Vec<String>>()
13089                    .join(",")
13090                    .to_string(),
13091            )]),
13092        };
13093    }
13094    if let Some(ref local_var_str) = l2vpn_id {
13095        local_var_req_builder = match "multi" {
13096            "multi" => local_var_req_builder.query(
13097                &local_var_str
13098                    .into_iter()
13099                    .map(|p| ("l2vpn_id".to_owned(), p.to_string()))
13100                    .collect::<Vec<(std::string::String, std::string::String)>>(),
13101            ),
13102            _ => local_var_req_builder.query(&[(
13103                "l2vpn_id",
13104                &local_var_str
13105                    .into_iter()
13106                    .map(|p| p.to_string())
13107                    .collect::<Vec<String>>()
13108                    .join(",")
13109                    .to_string(),
13110            )]),
13111        };
13112    }
13113    if let Some(ref local_var_str) = l2vpn_id__n {
13114        local_var_req_builder = match "multi" {
13115            "multi" => local_var_req_builder.query(
13116                &local_var_str
13117                    .into_iter()
13118                    .map(|p| ("l2vpn_id__n".to_owned(), p.to_string()))
13119                    .collect::<Vec<(std::string::String, std::string::String)>>(),
13120            ),
13121            _ => local_var_req_builder.query(&[(
13122                "l2vpn_id__n",
13123                &local_var_str
13124                    .into_iter()
13125                    .map(|p| p.to_string())
13126                    .collect::<Vec<String>>()
13127                    .join(",")
13128                    .to_string(),
13129            )]),
13130        };
13131    }
13132    if let Some(ref local_var_str) = last_updated {
13133        local_var_req_builder = match "multi" {
13134            "multi" => local_var_req_builder.query(
13135                &local_var_str
13136                    .into_iter()
13137                    .map(|p| ("last_updated".to_owned(), p.to_string()))
13138                    .collect::<Vec<(std::string::String, std::string::String)>>(),
13139            ),
13140            _ => local_var_req_builder.query(&[(
13141                "last_updated",
13142                &local_var_str
13143                    .into_iter()
13144                    .map(|p| p.to_string())
13145                    .collect::<Vec<String>>()
13146                    .join(",")
13147                    .to_string(),
13148            )]),
13149        };
13150    }
13151    if let Some(ref local_var_str) = last_updated__empty {
13152        local_var_req_builder = match "multi" {
13153            "multi" => local_var_req_builder.query(
13154                &local_var_str
13155                    .into_iter()
13156                    .map(|p| ("last_updated__empty".to_owned(), p.to_string()))
13157                    .collect::<Vec<(std::string::String, std::string::String)>>(),
13158            ),
13159            _ => local_var_req_builder.query(&[(
13160                "last_updated__empty",
13161                &local_var_str
13162                    .into_iter()
13163                    .map(|p| p.to_string())
13164                    .collect::<Vec<String>>()
13165                    .join(",")
13166                    .to_string(),
13167            )]),
13168        };
13169    }
13170    if let Some(ref local_var_str) = last_updated__gt {
13171        local_var_req_builder = match "multi" {
13172            "multi" => local_var_req_builder.query(
13173                &local_var_str
13174                    .into_iter()
13175                    .map(|p| ("last_updated__gt".to_owned(), p.to_string()))
13176                    .collect::<Vec<(std::string::String, std::string::String)>>(),
13177            ),
13178            _ => local_var_req_builder.query(&[(
13179                "last_updated__gt",
13180                &local_var_str
13181                    .into_iter()
13182                    .map(|p| p.to_string())
13183                    .collect::<Vec<String>>()
13184                    .join(",")
13185                    .to_string(),
13186            )]),
13187        };
13188    }
13189    if let Some(ref local_var_str) = last_updated__gte {
13190        local_var_req_builder = match "multi" {
13191            "multi" => local_var_req_builder.query(
13192                &local_var_str
13193                    .into_iter()
13194                    .map(|p| ("last_updated__gte".to_owned(), p.to_string()))
13195                    .collect::<Vec<(std::string::String, std::string::String)>>(),
13196            ),
13197            _ => local_var_req_builder.query(&[(
13198                "last_updated__gte",
13199                &local_var_str
13200                    .into_iter()
13201                    .map(|p| p.to_string())
13202                    .collect::<Vec<String>>()
13203                    .join(",")
13204                    .to_string(),
13205            )]),
13206        };
13207    }
13208    if let Some(ref local_var_str) = last_updated__lt {
13209        local_var_req_builder = match "multi" {
13210            "multi" => local_var_req_builder.query(
13211                &local_var_str
13212                    .into_iter()
13213                    .map(|p| ("last_updated__lt".to_owned(), p.to_string()))
13214                    .collect::<Vec<(std::string::String, std::string::String)>>(),
13215            ),
13216            _ => local_var_req_builder.query(&[(
13217                "last_updated__lt",
13218                &local_var_str
13219                    .into_iter()
13220                    .map(|p| p.to_string())
13221                    .collect::<Vec<String>>()
13222                    .join(",")
13223                    .to_string(),
13224            )]),
13225        };
13226    }
13227    if let Some(ref local_var_str) = last_updated__lte {
13228        local_var_req_builder = match "multi" {
13229            "multi" => local_var_req_builder.query(
13230                &local_var_str
13231                    .into_iter()
13232                    .map(|p| ("last_updated__lte".to_owned(), p.to_string()))
13233                    .collect::<Vec<(std::string::String, std::string::String)>>(),
13234            ),
13235            _ => local_var_req_builder.query(&[(
13236                "last_updated__lte",
13237                &local_var_str
13238                    .into_iter()
13239                    .map(|p| p.to_string())
13240                    .collect::<Vec<String>>()
13241                    .join(",")
13242                    .to_string(),
13243            )]),
13244        };
13245    }
13246    if let Some(ref local_var_str) = last_updated__n {
13247        local_var_req_builder = match "multi" {
13248            "multi" => local_var_req_builder.query(
13249                &local_var_str
13250                    .into_iter()
13251                    .map(|p| ("last_updated__n".to_owned(), p.to_string()))
13252                    .collect::<Vec<(std::string::String, std::string::String)>>(),
13253            ),
13254            _ => local_var_req_builder.query(&[(
13255                "last_updated__n",
13256                &local_var_str
13257                    .into_iter()
13258                    .map(|p| p.to_string())
13259                    .collect::<Vec<String>>()
13260                    .join(",")
13261                    .to_string(),
13262            )]),
13263        };
13264    }
13265    if let Some(ref local_var_str) = limit {
13266        local_var_req_builder =
13267            local_var_req_builder.query(&[("limit", &local_var_str.to_string())]);
13268    }
13269    if let Some(ref local_var_str) = modified_by_request {
13270        local_var_req_builder =
13271            local_var_req_builder.query(&[("modified_by_request", &local_var_str.to_string())]);
13272    }
13273    if let Some(ref local_var_str) = offset {
13274        local_var_req_builder =
13275            local_var_req_builder.query(&[("offset", &local_var_str.to_string())]);
13276    }
13277    if let Some(ref local_var_str) = ordering {
13278        local_var_req_builder =
13279            local_var_req_builder.query(&[("ordering", &local_var_str.to_string())]);
13280    }
13281    if let Some(ref local_var_str) = q {
13282        local_var_req_builder = local_var_req_builder.query(&[("q", &local_var_str.to_string())]);
13283    }
13284    if let Some(ref local_var_str) = region {
13285        local_var_req_builder = match "multi" {
13286            "multi" => local_var_req_builder.query(
13287                &local_var_str
13288                    .into_iter()
13289                    .map(|p| ("region".to_owned(), p.to_string()))
13290                    .collect::<Vec<(std::string::String, std::string::String)>>(),
13291            ),
13292            _ => local_var_req_builder.query(&[(
13293                "region",
13294                &local_var_str
13295                    .into_iter()
13296                    .map(|p| p.to_string())
13297                    .collect::<Vec<String>>()
13298                    .join(",")
13299                    .to_string(),
13300            )]),
13301        };
13302    }
13303    if let Some(ref local_var_str) = region_id {
13304        local_var_req_builder = match "multi" {
13305            "multi" => local_var_req_builder.query(
13306                &local_var_str
13307                    .into_iter()
13308                    .map(|p| ("region_id".to_owned(), p.to_string()))
13309                    .collect::<Vec<(std::string::String, std::string::String)>>(),
13310            ),
13311            _ => local_var_req_builder.query(&[(
13312                "region_id",
13313                &local_var_str
13314                    .into_iter()
13315                    .map(|p| p.to_string())
13316                    .collect::<Vec<String>>()
13317                    .join(",")
13318                    .to_string(),
13319            )]),
13320        };
13321    }
13322    if let Some(ref local_var_str) = site {
13323        local_var_req_builder = match "multi" {
13324            "multi" => local_var_req_builder.query(
13325                &local_var_str
13326                    .into_iter()
13327                    .map(|p| ("site".to_owned(), p.to_string()))
13328                    .collect::<Vec<(std::string::String, std::string::String)>>(),
13329            ),
13330            _ => local_var_req_builder.query(&[(
13331                "site",
13332                &local_var_str
13333                    .into_iter()
13334                    .map(|p| p.to_string())
13335                    .collect::<Vec<String>>()
13336                    .join(",")
13337                    .to_string(),
13338            )]),
13339        };
13340    }
13341    if let Some(ref local_var_str) = site_id {
13342        local_var_req_builder = match "multi" {
13343            "multi" => local_var_req_builder.query(
13344                &local_var_str
13345                    .into_iter()
13346                    .map(|p| ("site_id".to_owned(), p.to_string()))
13347                    .collect::<Vec<(std::string::String, std::string::String)>>(),
13348            ),
13349            _ => local_var_req_builder.query(&[(
13350                "site_id",
13351                &local_var_str
13352                    .into_iter()
13353                    .map(|p| p.to_string())
13354                    .collect::<Vec<String>>()
13355                    .join(",")
13356                    .to_string(),
13357            )]),
13358        };
13359    }
13360    if let Some(ref local_var_str) = tag {
13361        local_var_req_builder = match "multi" {
13362            "multi" => local_var_req_builder.query(
13363                &local_var_str
13364                    .into_iter()
13365                    .map(|p| ("tag".to_owned(), p.to_string()))
13366                    .collect::<Vec<(std::string::String, std::string::String)>>(),
13367            ),
13368            _ => local_var_req_builder.query(&[(
13369                "tag",
13370                &local_var_str
13371                    .into_iter()
13372                    .map(|p| p.to_string())
13373                    .collect::<Vec<String>>()
13374                    .join(",")
13375                    .to_string(),
13376            )]),
13377        };
13378    }
13379    if let Some(ref local_var_str) = tag__n {
13380        local_var_req_builder = match "multi" {
13381            "multi" => local_var_req_builder.query(
13382                &local_var_str
13383                    .into_iter()
13384                    .map(|p| ("tag__n".to_owned(), p.to_string()))
13385                    .collect::<Vec<(std::string::String, std::string::String)>>(),
13386            ),
13387            _ => local_var_req_builder.query(&[(
13388                "tag__n",
13389                &local_var_str
13390                    .into_iter()
13391                    .map(|p| p.to_string())
13392                    .collect::<Vec<String>>()
13393                    .join(",")
13394                    .to_string(),
13395            )]),
13396        };
13397    }
13398    if let Some(ref local_var_str) = tag_id {
13399        local_var_req_builder = match "multi" {
13400            "multi" => local_var_req_builder.query(
13401                &local_var_str
13402                    .into_iter()
13403                    .map(|p| ("tag_id".to_owned(), p.to_string()))
13404                    .collect::<Vec<(std::string::String, std::string::String)>>(),
13405            ),
13406            _ => local_var_req_builder.query(&[(
13407                "tag_id",
13408                &local_var_str
13409                    .into_iter()
13410                    .map(|p| p.to_string())
13411                    .collect::<Vec<String>>()
13412                    .join(",")
13413                    .to_string(),
13414            )]),
13415        };
13416    }
13417    if let Some(ref local_var_str) = tag_id__n {
13418        local_var_req_builder = match "multi" {
13419            "multi" => local_var_req_builder.query(
13420                &local_var_str
13421                    .into_iter()
13422                    .map(|p| ("tag_id__n".to_owned(), p.to_string()))
13423                    .collect::<Vec<(std::string::String, std::string::String)>>(),
13424            ),
13425            _ => local_var_req_builder.query(&[(
13426                "tag_id__n",
13427                &local_var_str
13428                    .into_iter()
13429                    .map(|p| p.to_string())
13430                    .collect::<Vec<String>>()
13431                    .join(",")
13432                    .to_string(),
13433            )]),
13434        };
13435    }
13436    if let Some(ref local_var_str) = updated_by_request {
13437        local_var_req_builder =
13438            local_var_req_builder.query(&[("updated_by_request", &local_var_str.to_string())]);
13439    }
13440    if let Some(ref local_var_str) = virtual_machine {
13441        local_var_req_builder = match "multi" {
13442            "multi" => local_var_req_builder.query(
13443                &local_var_str
13444                    .into_iter()
13445                    .map(|p| ("virtual_machine".to_owned(), p.to_string()))
13446                    .collect::<Vec<(std::string::String, std::string::String)>>(),
13447            ),
13448            _ => local_var_req_builder.query(&[(
13449                "virtual_machine",
13450                &local_var_str
13451                    .into_iter()
13452                    .map(|p| p.to_string())
13453                    .collect::<Vec<String>>()
13454                    .join(",")
13455                    .to_string(),
13456            )]),
13457        };
13458    }
13459    if let Some(ref local_var_str) = virtual_machine__n {
13460        local_var_req_builder = match "multi" {
13461            "multi" => local_var_req_builder.query(
13462                &local_var_str
13463                    .into_iter()
13464                    .map(|p| ("virtual_machine__n".to_owned(), p.to_string()))
13465                    .collect::<Vec<(std::string::String, std::string::String)>>(),
13466            ),
13467            _ => local_var_req_builder.query(&[(
13468                "virtual_machine__n",
13469                &local_var_str
13470                    .into_iter()
13471                    .map(|p| p.to_string())
13472                    .collect::<Vec<String>>()
13473                    .join(",")
13474                    .to_string(),
13475            )]),
13476        };
13477    }
13478    if let Some(ref local_var_str) = virtual_machine_id {
13479        local_var_req_builder = match "multi" {
13480            "multi" => local_var_req_builder.query(
13481                &local_var_str
13482                    .into_iter()
13483                    .map(|p| ("virtual_machine_id".to_owned(), p.to_string()))
13484                    .collect::<Vec<(std::string::String, std::string::String)>>(),
13485            ),
13486            _ => local_var_req_builder.query(&[(
13487                "virtual_machine_id",
13488                &local_var_str
13489                    .into_iter()
13490                    .map(|p| p.to_string())
13491                    .collect::<Vec<String>>()
13492                    .join(",")
13493                    .to_string(),
13494            )]),
13495        };
13496    }
13497    if let Some(ref local_var_str) = virtual_machine_id__n {
13498        local_var_req_builder = match "multi" {
13499            "multi" => local_var_req_builder.query(
13500                &local_var_str
13501                    .into_iter()
13502                    .map(|p| ("virtual_machine_id__n".to_owned(), p.to_string()))
13503                    .collect::<Vec<(std::string::String, std::string::String)>>(),
13504            ),
13505            _ => local_var_req_builder.query(&[(
13506                "virtual_machine_id__n",
13507                &local_var_str
13508                    .into_iter()
13509                    .map(|p| p.to_string())
13510                    .collect::<Vec<String>>()
13511                    .join(",")
13512                    .to_string(),
13513            )]),
13514        };
13515    }
13516    if let Some(ref local_var_str) = vlan {
13517        local_var_req_builder = match "multi" {
13518            "multi" => local_var_req_builder.query(
13519                &local_var_str
13520                    .into_iter()
13521                    .map(|p| ("vlan".to_owned(), p.to_string()))
13522                    .collect::<Vec<(std::string::String, std::string::String)>>(),
13523            ),
13524            _ => local_var_req_builder.query(&[(
13525                "vlan",
13526                &local_var_str
13527                    .into_iter()
13528                    .map(|p| p.to_string())
13529                    .collect::<Vec<String>>()
13530                    .join(",")
13531                    .to_string(),
13532            )]),
13533        };
13534    }
13535    if let Some(ref local_var_str) = vlan__n {
13536        local_var_req_builder = match "multi" {
13537            "multi" => local_var_req_builder.query(
13538                &local_var_str
13539                    .into_iter()
13540                    .map(|p| ("vlan__n".to_owned(), p.to_string()))
13541                    .collect::<Vec<(std::string::String, std::string::String)>>(),
13542            ),
13543            _ => local_var_req_builder.query(&[(
13544                "vlan__n",
13545                &local_var_str
13546                    .into_iter()
13547                    .map(|p| p.to_string())
13548                    .collect::<Vec<String>>()
13549                    .join(",")
13550                    .to_string(),
13551            )]),
13552        };
13553    }
13554    if let Some(ref local_var_str) = vlan_id {
13555        local_var_req_builder = match "multi" {
13556            "multi" => local_var_req_builder.query(
13557                &local_var_str
13558                    .into_iter()
13559                    .map(|p| ("vlan_id".to_owned(), p.to_string()))
13560                    .collect::<Vec<(std::string::String, std::string::String)>>(),
13561            ),
13562            _ => local_var_req_builder.query(&[(
13563                "vlan_id",
13564                &local_var_str
13565                    .into_iter()
13566                    .map(|p| p.to_string())
13567                    .collect::<Vec<String>>()
13568                    .join(",")
13569                    .to_string(),
13570            )]),
13571        };
13572    }
13573    if let Some(ref local_var_str) = vlan_id__n {
13574        local_var_req_builder = match "multi" {
13575            "multi" => local_var_req_builder.query(
13576                &local_var_str
13577                    .into_iter()
13578                    .map(|p| ("vlan_id__n".to_owned(), p.to_string()))
13579                    .collect::<Vec<(std::string::String, std::string::String)>>(),
13580            ),
13581            _ => local_var_req_builder.query(&[(
13582                "vlan_id__n",
13583                &local_var_str
13584                    .into_iter()
13585                    .map(|p| p.to_string())
13586                    .collect::<Vec<String>>()
13587                    .join(",")
13588                    .to_string(),
13589            )]),
13590        };
13591    }
13592    if let Some(ref local_var_str) = vlan_vid {
13593        local_var_req_builder =
13594            local_var_req_builder.query(&[("vlan_vid", &local_var_str.to_string())]);
13595    }
13596    if let Some(ref local_var_str) = vlan_vid__empty {
13597        local_var_req_builder =
13598            local_var_req_builder.query(&[("vlan_vid__empty", &local_var_str.to_string())]);
13599    }
13600    if let Some(ref local_var_str) = vlan_vid__gt {
13601        local_var_req_builder =
13602            local_var_req_builder.query(&[("vlan_vid__gt", &local_var_str.to_string())]);
13603    }
13604    if let Some(ref local_var_str) = vlan_vid__gte {
13605        local_var_req_builder =
13606            local_var_req_builder.query(&[("vlan_vid__gte", &local_var_str.to_string())]);
13607    }
13608    if let Some(ref local_var_str) = vlan_vid__lt {
13609        local_var_req_builder =
13610            local_var_req_builder.query(&[("vlan_vid__lt", &local_var_str.to_string())]);
13611    }
13612    if let Some(ref local_var_str) = vlan_vid__lte {
13613        local_var_req_builder =
13614            local_var_req_builder.query(&[("vlan_vid__lte", &local_var_str.to_string())]);
13615    }
13616    if let Some(ref local_var_str) = vlan_vid__n {
13617        local_var_req_builder =
13618            local_var_req_builder.query(&[("vlan_vid__n", &local_var_str.to_string())]);
13619    }
13620    if let Some(ref local_var_str) = vminterface {
13621        local_var_req_builder = match "multi" {
13622            "multi" => local_var_req_builder.query(
13623                &local_var_str
13624                    .into_iter()
13625                    .map(|p| ("vminterface".to_owned(), p.to_string()))
13626                    .collect::<Vec<(std::string::String, std::string::String)>>(),
13627            ),
13628            _ => local_var_req_builder.query(&[(
13629                "vminterface",
13630                &local_var_str
13631                    .into_iter()
13632                    .map(|p| p.to_string())
13633                    .collect::<Vec<String>>()
13634                    .join(",")
13635                    .to_string(),
13636            )]),
13637        };
13638    }
13639    if let Some(ref local_var_str) = vminterface__n {
13640        local_var_req_builder = match "multi" {
13641            "multi" => local_var_req_builder.query(
13642                &local_var_str
13643                    .into_iter()
13644                    .map(|p| ("vminterface__n".to_owned(), p.to_string()))
13645                    .collect::<Vec<(std::string::String, std::string::String)>>(),
13646            ),
13647            _ => local_var_req_builder.query(&[(
13648                "vminterface__n",
13649                &local_var_str
13650                    .into_iter()
13651                    .map(|p| p.to_string())
13652                    .collect::<Vec<String>>()
13653                    .join(",")
13654                    .to_string(),
13655            )]),
13656        };
13657    }
13658    if let Some(ref local_var_str) = vminterface_id {
13659        local_var_req_builder = match "multi" {
13660            "multi" => local_var_req_builder.query(
13661                &local_var_str
13662                    .into_iter()
13663                    .map(|p| ("vminterface_id".to_owned(), p.to_string()))
13664                    .collect::<Vec<(std::string::String, std::string::String)>>(),
13665            ),
13666            _ => local_var_req_builder.query(&[(
13667                "vminterface_id",
13668                &local_var_str
13669                    .into_iter()
13670                    .map(|p| p.to_string())
13671                    .collect::<Vec<String>>()
13672                    .join(",")
13673                    .to_string(),
13674            )]),
13675        };
13676    }
13677    if let Some(ref local_var_str) = vminterface_id__n {
13678        local_var_req_builder = match "multi" {
13679            "multi" => local_var_req_builder.query(
13680                &local_var_str
13681                    .into_iter()
13682                    .map(|p| ("vminterface_id__n".to_owned(), p.to_string()))
13683                    .collect::<Vec<(std::string::String, std::string::String)>>(),
13684            ),
13685            _ => local_var_req_builder.query(&[(
13686                "vminterface_id__n",
13687                &local_var_str
13688                    .into_iter()
13689                    .map(|p| p.to_string())
13690                    .collect::<Vec<String>>()
13691                    .join(",")
13692                    .to_string(),
13693            )]),
13694        };
13695    }
13696    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
13697        local_var_req_builder =
13698            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
13699    }
13700    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
13701        let local_var_key = local_var_apikey.key.clone();
13702        let local_var_value = match local_var_apikey.prefix {
13703            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
13704            None => local_var_key,
13705        };
13706        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
13707    };
13708
13709    let local_var_req = local_var_req_builder.build()?;
13710    let local_var_resp = local_var_client.execute(local_var_req).await?;
13711
13712    let local_var_status = local_var_resp.status();
13713    let local_var_content = local_var_resp.text().await?;
13714
13715    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
13716        serde_json::from_str(&local_var_content).map_err(Error::from)
13717    } else {
13718        let local_var_entity: Option<VpnL2vpnTerminationsListError> =
13719            serde_json::from_str(&local_var_content).ok();
13720        let local_var_error = ResponseContent {
13721            status: local_var_status,
13722            content: local_var_content,
13723            entity: local_var_entity,
13724        };
13725        Err(Error::ResponseError(local_var_error))
13726    }
13727}
13728
13729/// Patch a L2VPN termination object.
13730pub async fn vpn_l2vpn_terminations_partial_update(
13731    configuration: &configuration::Configuration,
13732    id: i32,
13733    patched_l2_vpn_termination_request: Option<crate::models::PatchedL2VpnTerminationRequest>,
13734) -> Result<crate::models::L2VpnTermination, Error<VpnL2vpnTerminationsPartialUpdateError>> {
13735    let local_var_configuration = configuration;
13736
13737    let local_var_client = &local_var_configuration.client;
13738
13739    let local_var_uri_str = format!(
13740        "{}/api/vpn/l2vpn-terminations/{id}/",
13741        local_var_configuration.base_path,
13742        id = id
13743    );
13744    let mut local_var_req_builder =
13745        local_var_client.request(reqwest::Method::PATCH, local_var_uri_str.as_str());
13746
13747    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
13748        local_var_req_builder =
13749            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
13750    }
13751    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
13752        let local_var_key = local_var_apikey.key.clone();
13753        let local_var_value = match local_var_apikey.prefix {
13754            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
13755            None => local_var_key,
13756        };
13757        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
13758    };
13759    local_var_req_builder = local_var_req_builder.json(&patched_l2_vpn_termination_request);
13760
13761    let local_var_req = local_var_req_builder.build()?;
13762    let local_var_resp = local_var_client.execute(local_var_req).await?;
13763
13764    let local_var_status = local_var_resp.status();
13765    let local_var_content = local_var_resp.text().await?;
13766
13767    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
13768        serde_json::from_str(&local_var_content).map_err(Error::from)
13769    } else {
13770        let local_var_entity: Option<VpnL2vpnTerminationsPartialUpdateError> =
13771            serde_json::from_str(&local_var_content).ok();
13772        let local_var_error = ResponseContent {
13773            status: local_var_status,
13774            content: local_var_content,
13775            entity: local_var_entity,
13776        };
13777        Err(Error::ResponseError(local_var_error))
13778    }
13779}
13780
13781/// Get a L2VPN termination object.
13782pub async fn vpn_l2vpn_terminations_retrieve(
13783    configuration: &configuration::Configuration,
13784    id: i32,
13785) -> Result<crate::models::L2VpnTermination, Error<VpnL2vpnTerminationsRetrieveError>> {
13786    let local_var_configuration = configuration;
13787
13788    let local_var_client = &local_var_configuration.client;
13789
13790    let local_var_uri_str = format!(
13791        "{}/api/vpn/l2vpn-terminations/{id}/",
13792        local_var_configuration.base_path,
13793        id = id
13794    );
13795    let mut local_var_req_builder =
13796        local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
13797
13798    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
13799        local_var_req_builder =
13800            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
13801    }
13802    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
13803        let local_var_key = local_var_apikey.key.clone();
13804        let local_var_value = match local_var_apikey.prefix {
13805            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
13806            None => local_var_key,
13807        };
13808        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
13809    };
13810
13811    let local_var_req = local_var_req_builder.build()?;
13812    let local_var_resp = local_var_client.execute(local_var_req).await?;
13813
13814    let local_var_status = local_var_resp.status();
13815    let local_var_content = local_var_resp.text().await?;
13816
13817    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
13818        serde_json::from_str(&local_var_content).map_err(Error::from)
13819    } else {
13820        let local_var_entity: Option<VpnL2vpnTerminationsRetrieveError> =
13821            serde_json::from_str(&local_var_content).ok();
13822        let local_var_error = ResponseContent {
13823            status: local_var_status,
13824            content: local_var_content,
13825            entity: local_var_entity,
13826        };
13827        Err(Error::ResponseError(local_var_error))
13828    }
13829}
13830
13831/// Put a L2VPN termination object.
13832pub async fn vpn_l2vpn_terminations_update(
13833    configuration: &configuration::Configuration,
13834    id: i32,
13835    l2_vpn_termination_request: crate::models::L2VpnTerminationRequest,
13836) -> Result<crate::models::L2VpnTermination, Error<VpnL2vpnTerminationsUpdateError>> {
13837    let local_var_configuration = configuration;
13838
13839    let local_var_client = &local_var_configuration.client;
13840
13841    let local_var_uri_str = format!(
13842        "{}/api/vpn/l2vpn-terminations/{id}/",
13843        local_var_configuration.base_path,
13844        id = id
13845    );
13846    let mut local_var_req_builder =
13847        local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());
13848
13849    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
13850        local_var_req_builder =
13851            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
13852    }
13853    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
13854        let local_var_key = local_var_apikey.key.clone();
13855        let local_var_value = match local_var_apikey.prefix {
13856            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
13857            None => local_var_key,
13858        };
13859        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
13860    };
13861    local_var_req_builder = local_var_req_builder.json(&l2_vpn_termination_request);
13862
13863    let local_var_req = local_var_req_builder.build()?;
13864    let local_var_resp = local_var_client.execute(local_var_req).await?;
13865
13866    let local_var_status = local_var_resp.status();
13867    let local_var_content = local_var_resp.text().await?;
13868
13869    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
13870        serde_json::from_str(&local_var_content).map_err(Error::from)
13871    } else {
13872        let local_var_entity: Option<VpnL2vpnTerminationsUpdateError> =
13873            serde_json::from_str(&local_var_content).ok();
13874        let local_var_error = ResponseContent {
13875            status: local_var_status,
13876            content: local_var_content,
13877            entity: local_var_entity,
13878        };
13879        Err(Error::ResponseError(local_var_error))
13880    }
13881}
13882
13883/// Delete a list of L2VPN objects.
13884pub async fn vpn_l2vpns_bulk_destroy(
13885    configuration: &configuration::Configuration,
13886    l2_vpn_request: Vec<crate::models::L2VpnRequest>,
13887) -> Result<(), Error<VpnL2vpnsBulkDestroyError>> {
13888    let local_var_configuration = configuration;
13889
13890    let local_var_client = &local_var_configuration.client;
13891
13892    let local_var_uri_str = format!("{}/api/vpn/l2vpns/", local_var_configuration.base_path);
13893    let mut local_var_req_builder =
13894        local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());
13895
13896    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
13897        local_var_req_builder =
13898            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
13899    }
13900    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
13901        let local_var_key = local_var_apikey.key.clone();
13902        let local_var_value = match local_var_apikey.prefix {
13903            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
13904            None => local_var_key,
13905        };
13906        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
13907    };
13908    local_var_req_builder = local_var_req_builder.json(&l2_vpn_request);
13909
13910    let local_var_req = local_var_req_builder.build()?;
13911    let local_var_resp = local_var_client.execute(local_var_req).await?;
13912
13913    let local_var_status = local_var_resp.status();
13914    let local_var_content = local_var_resp.text().await?;
13915
13916    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
13917        Ok(())
13918    } else {
13919        let local_var_entity: Option<VpnL2vpnsBulkDestroyError> =
13920            serde_json::from_str(&local_var_content).ok();
13921        let local_var_error = ResponseContent {
13922            status: local_var_status,
13923            content: local_var_content,
13924            entity: local_var_entity,
13925        };
13926        Err(Error::ResponseError(local_var_error))
13927    }
13928}
13929
13930/// Patch a list of L2VPN objects.
13931pub async fn vpn_l2vpns_bulk_partial_update(
13932    configuration: &configuration::Configuration,
13933    l2_vpn_request: Vec<crate::models::L2VpnRequest>,
13934) -> Result<Vec<crate::models::L2Vpn>, Error<VpnL2vpnsBulkPartialUpdateError>> {
13935    let local_var_configuration = configuration;
13936
13937    let local_var_client = &local_var_configuration.client;
13938
13939    let local_var_uri_str = format!("{}/api/vpn/l2vpns/", local_var_configuration.base_path);
13940    let mut local_var_req_builder =
13941        local_var_client.request(reqwest::Method::PATCH, local_var_uri_str.as_str());
13942
13943    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
13944        local_var_req_builder =
13945            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
13946    }
13947    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
13948        let local_var_key = local_var_apikey.key.clone();
13949        let local_var_value = match local_var_apikey.prefix {
13950            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
13951            None => local_var_key,
13952        };
13953        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
13954    };
13955    local_var_req_builder = local_var_req_builder.json(&l2_vpn_request);
13956
13957    let local_var_req = local_var_req_builder.build()?;
13958    let local_var_resp = local_var_client.execute(local_var_req).await?;
13959
13960    let local_var_status = local_var_resp.status();
13961    let local_var_content = local_var_resp.text().await?;
13962
13963    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
13964        serde_json::from_str(&local_var_content).map_err(Error::from)
13965    } else {
13966        let local_var_entity: Option<VpnL2vpnsBulkPartialUpdateError> =
13967            serde_json::from_str(&local_var_content).ok();
13968        let local_var_error = ResponseContent {
13969            status: local_var_status,
13970            content: local_var_content,
13971            entity: local_var_entity,
13972        };
13973        Err(Error::ResponseError(local_var_error))
13974    }
13975}
13976
13977/// Put a list of L2VPN objects.
13978pub async fn vpn_l2vpns_bulk_update(
13979    configuration: &configuration::Configuration,
13980    l2_vpn_request: Vec<crate::models::L2VpnRequest>,
13981) -> Result<Vec<crate::models::L2Vpn>, Error<VpnL2vpnsBulkUpdateError>> {
13982    let local_var_configuration = configuration;
13983
13984    let local_var_client = &local_var_configuration.client;
13985
13986    let local_var_uri_str = format!("{}/api/vpn/l2vpns/", local_var_configuration.base_path);
13987    let mut local_var_req_builder =
13988        local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());
13989
13990    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
13991        local_var_req_builder =
13992            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
13993    }
13994    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
13995        let local_var_key = local_var_apikey.key.clone();
13996        let local_var_value = match local_var_apikey.prefix {
13997            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
13998            None => local_var_key,
13999        };
14000        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
14001    };
14002    local_var_req_builder = local_var_req_builder.json(&l2_vpn_request);
14003
14004    let local_var_req = local_var_req_builder.build()?;
14005    let local_var_resp = local_var_client.execute(local_var_req).await?;
14006
14007    let local_var_status = local_var_resp.status();
14008    let local_var_content = local_var_resp.text().await?;
14009
14010    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
14011        serde_json::from_str(&local_var_content).map_err(Error::from)
14012    } else {
14013        let local_var_entity: Option<VpnL2vpnsBulkUpdateError> =
14014            serde_json::from_str(&local_var_content).ok();
14015        let local_var_error = ResponseContent {
14016            status: local_var_status,
14017            content: local_var_content,
14018            entity: local_var_entity,
14019        };
14020        Err(Error::ResponseError(local_var_error))
14021    }
14022}
14023
14024/// Post a list of L2VPN objects.
14025pub async fn vpn_l2vpns_create(
14026    configuration: &configuration::Configuration,
14027    vpn_l2vpns_create_request: crate::models::VpnL2vpnsCreateRequest,
14028) -> Result<crate::models::L2Vpn, Error<VpnL2vpnsCreateError>> {
14029    let local_var_configuration = configuration;
14030
14031    let local_var_client = &local_var_configuration.client;
14032
14033    let local_var_uri_str = format!("{}/api/vpn/l2vpns/", local_var_configuration.base_path);
14034    let mut local_var_req_builder =
14035        local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
14036
14037    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
14038        local_var_req_builder =
14039            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
14040    }
14041    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
14042        let local_var_key = local_var_apikey.key.clone();
14043        let local_var_value = match local_var_apikey.prefix {
14044            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
14045            None => local_var_key,
14046        };
14047        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
14048    };
14049    local_var_req_builder = local_var_req_builder.json(&vpn_l2vpns_create_request);
14050
14051    let local_var_req = local_var_req_builder.build()?;
14052    let local_var_resp = local_var_client.execute(local_var_req).await?;
14053
14054    let local_var_status = local_var_resp.status();
14055    let local_var_content = local_var_resp.text().await?;
14056
14057    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
14058        serde_json::from_str(&local_var_content).map_err(Error::from)
14059    } else {
14060        let local_var_entity: Option<VpnL2vpnsCreateError> =
14061            serde_json::from_str(&local_var_content).ok();
14062        let local_var_error = ResponseContent {
14063            status: local_var_status,
14064            content: local_var_content,
14065            entity: local_var_entity,
14066        };
14067        Err(Error::ResponseError(local_var_error))
14068    }
14069}
14070
14071/// Delete a L2VPN object.
14072pub async fn vpn_l2vpns_destroy(
14073    configuration: &configuration::Configuration,
14074    id: i32,
14075) -> Result<(), Error<VpnL2vpnsDestroyError>> {
14076    let local_var_configuration = configuration;
14077
14078    let local_var_client = &local_var_configuration.client;
14079
14080    let local_var_uri_str = format!(
14081        "{}/api/vpn/l2vpns/{id}/",
14082        local_var_configuration.base_path,
14083        id = id
14084    );
14085    let mut local_var_req_builder =
14086        local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());
14087
14088    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
14089        local_var_req_builder =
14090            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
14091    }
14092    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
14093        let local_var_key = local_var_apikey.key.clone();
14094        let local_var_value = match local_var_apikey.prefix {
14095            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
14096            None => local_var_key,
14097        };
14098        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
14099    };
14100
14101    let local_var_req = local_var_req_builder.build()?;
14102    let local_var_resp = local_var_client.execute(local_var_req).await?;
14103
14104    let local_var_status = local_var_resp.status();
14105    let local_var_content = local_var_resp.text().await?;
14106
14107    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
14108        Ok(())
14109    } else {
14110        let local_var_entity: Option<VpnL2vpnsDestroyError> =
14111            serde_json::from_str(&local_var_content).ok();
14112        let local_var_error = ResponseContent {
14113            status: local_var_status,
14114            content: local_var_content,
14115            entity: local_var_entity,
14116        };
14117        Err(Error::ResponseError(local_var_error))
14118    }
14119}
14120
14121/// Get a list of L2VPN objects.
14122pub async fn vpn_l2vpns_list(
14123    configuration: &configuration::Configuration,
14124    contact: Option<Vec<i32>>,
14125    contact__n: Option<Vec<i32>>,
14126    contact_group: Option<Vec<String>>,
14127    contact_group__n: Option<Vec<String>>,
14128    contact_role: Option<Vec<i32>>,
14129    contact_role__n: Option<Vec<i32>>,
14130    created: Option<Vec<String>>,
14131    created__empty: Option<Vec<String>>,
14132    created__gt: Option<Vec<String>>,
14133    created__gte: Option<Vec<String>>,
14134    created__lt: Option<Vec<String>>,
14135    created__lte: Option<Vec<String>>,
14136    created__n: Option<Vec<String>>,
14137    created_by_request: Option<&str>,
14138    description: Option<Vec<String>>,
14139    description__empty: Option<bool>,
14140    description__ic: Option<Vec<String>>,
14141    description__ie: Option<Vec<String>>,
14142    description__iew: Option<Vec<String>>,
14143    description__iregex: Option<Vec<String>>,
14144    description__isw: Option<Vec<String>>,
14145    description__n: Option<Vec<String>>,
14146    description__nic: Option<Vec<String>>,
14147    description__nie: Option<Vec<String>>,
14148    description__niew: Option<Vec<String>>,
14149    description__nisw: Option<Vec<String>>,
14150    description__regex: Option<Vec<String>>,
14151    export_target: Option<Vec<String>>,
14152    export_target__n: Option<Vec<String>>,
14153    export_target_id: Option<Vec<i32>>,
14154    export_target_id__n: Option<Vec<i32>>,
14155    id: Option<Vec<i32>>,
14156    id__empty: Option<bool>,
14157    id__gt: Option<Vec<i32>>,
14158    id__gte: Option<Vec<i32>>,
14159    id__lt: Option<Vec<i32>>,
14160    id__lte: Option<Vec<i32>>,
14161    id__n: Option<Vec<i32>>,
14162    identifier: Option<Vec<i32>>,
14163    identifier__empty: Option<bool>,
14164    identifier__gt: Option<Vec<i32>>,
14165    identifier__gte: Option<Vec<i32>>,
14166    identifier__lt: Option<Vec<i32>>,
14167    identifier__lte: Option<Vec<i32>>,
14168    identifier__n: Option<Vec<i32>>,
14169    import_target: Option<Vec<String>>,
14170    import_target__n: Option<Vec<String>>,
14171    import_target_id: Option<Vec<i32>>,
14172    import_target_id__n: Option<Vec<i32>>,
14173    last_updated: Option<Vec<String>>,
14174    last_updated__empty: Option<Vec<String>>,
14175    last_updated__gt: Option<Vec<String>>,
14176    last_updated__gte: Option<Vec<String>>,
14177    last_updated__lt: Option<Vec<String>>,
14178    last_updated__lte: Option<Vec<String>>,
14179    last_updated__n: Option<Vec<String>>,
14180    limit: Option<i32>,
14181    modified_by_request: Option<&str>,
14182    name: Option<Vec<String>>,
14183    name__empty: Option<bool>,
14184    name__ic: Option<Vec<String>>,
14185    name__ie: Option<Vec<String>>,
14186    name__iew: Option<Vec<String>>,
14187    name__iregex: Option<Vec<String>>,
14188    name__isw: Option<Vec<String>>,
14189    name__n: Option<Vec<String>>,
14190    name__nic: Option<Vec<String>>,
14191    name__nie: Option<Vec<String>>,
14192    name__niew: Option<Vec<String>>,
14193    name__nisw: Option<Vec<String>>,
14194    name__regex: Option<Vec<String>>,
14195    offset: Option<i32>,
14196    ordering: Option<&str>,
14197    owner: Option<Vec<String>>,
14198    owner__n: Option<Vec<String>>,
14199    owner_group: Option<Vec<String>>,
14200    owner_group__n: Option<Vec<String>>,
14201    owner_group_id: Option<Vec<i32>>,
14202    owner_group_id__n: Option<Vec<i32>>,
14203    owner_id: Option<Vec<i32>>,
14204    owner_id__n: Option<Vec<i32>>,
14205    q: Option<&str>,
14206    slug: Option<Vec<String>>,
14207    slug__empty: Option<bool>,
14208    slug__ic: Option<Vec<String>>,
14209    slug__ie: Option<Vec<String>>,
14210    slug__iew: Option<Vec<String>>,
14211    slug__iregex: Option<Vec<String>>,
14212    slug__isw: Option<Vec<String>>,
14213    slug__n: Option<Vec<String>>,
14214    slug__nic: Option<Vec<String>>,
14215    slug__nie: Option<Vec<String>>,
14216    slug__niew: Option<Vec<String>>,
14217    slug__nisw: Option<Vec<String>>,
14218    slug__regex: Option<Vec<String>>,
14219    status: Option<Vec<String>>,
14220    status__empty: Option<bool>,
14221    status__ic: Option<Vec<String>>,
14222    status__ie: Option<Vec<String>>,
14223    status__iew: Option<Vec<String>>,
14224    status__iregex: Option<Vec<String>>,
14225    status__isw: Option<Vec<String>>,
14226    status__n: Option<Vec<String>>,
14227    status__nic: Option<Vec<String>>,
14228    status__nie: Option<Vec<String>>,
14229    status__niew: Option<Vec<String>>,
14230    status__nisw: Option<Vec<String>>,
14231    status__regex: Option<Vec<String>>,
14232    tag: Option<Vec<String>>,
14233    tag__n: Option<Vec<String>>,
14234    tag_id: Option<Vec<i32>>,
14235    tag_id__n: Option<Vec<i32>>,
14236    tenant: Option<Vec<String>>,
14237    tenant__n: Option<Vec<String>>,
14238    tenant_group: Option<Vec<String>>,
14239    tenant_group__n: Option<Vec<String>>,
14240    tenant_group_id: Option<Vec<String>>,
14241    tenant_group_id__n: Option<Vec<String>>,
14242    tenant_id: Option<Vec<i32>>,
14243    tenant_id__n: Option<Vec<i32>>,
14244    r#type: Option<Vec<String>>,
14245    type__empty: Option<bool>,
14246    type__ic: Option<Vec<String>>,
14247    type__ie: Option<Vec<String>>,
14248    type__iew: Option<Vec<String>>,
14249    type__iregex: Option<Vec<String>>,
14250    type__isw: Option<Vec<String>>,
14251    type__n: Option<Vec<String>>,
14252    type__nic: Option<Vec<String>>,
14253    type__nie: Option<Vec<String>>,
14254    type__niew: Option<Vec<String>>,
14255    type__nisw: Option<Vec<String>>,
14256    type__regex: Option<Vec<String>>,
14257    updated_by_request: Option<&str>,
14258) -> Result<crate::models::PaginatedL2VpnList, Error<VpnL2vpnsListError>> {
14259    let local_var_configuration = configuration;
14260
14261    let local_var_client = &local_var_configuration.client;
14262
14263    let local_var_uri_str = format!("{}/api/vpn/l2vpns/", local_var_configuration.base_path);
14264    let mut local_var_req_builder =
14265        local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
14266
14267    if let Some(ref local_var_str) = contact {
14268        local_var_req_builder = match "multi" {
14269            "multi" => local_var_req_builder.query(
14270                &local_var_str
14271                    .into_iter()
14272                    .map(|p| ("contact".to_owned(), p.to_string()))
14273                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14274            ),
14275            _ => local_var_req_builder.query(&[(
14276                "contact",
14277                &local_var_str
14278                    .into_iter()
14279                    .map(|p| p.to_string())
14280                    .collect::<Vec<String>>()
14281                    .join(",")
14282                    .to_string(),
14283            )]),
14284        };
14285    }
14286    if let Some(ref local_var_str) = contact__n {
14287        local_var_req_builder = match "multi" {
14288            "multi" => local_var_req_builder.query(
14289                &local_var_str
14290                    .into_iter()
14291                    .map(|p| ("contact__n".to_owned(), p.to_string()))
14292                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14293            ),
14294            _ => local_var_req_builder.query(&[(
14295                "contact__n",
14296                &local_var_str
14297                    .into_iter()
14298                    .map(|p| p.to_string())
14299                    .collect::<Vec<String>>()
14300                    .join(",")
14301                    .to_string(),
14302            )]),
14303        };
14304    }
14305    if let Some(ref local_var_str) = contact_group {
14306        local_var_req_builder = match "multi" {
14307            "multi" => local_var_req_builder.query(
14308                &local_var_str
14309                    .into_iter()
14310                    .map(|p| ("contact_group".to_owned(), p.to_string()))
14311                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14312            ),
14313            _ => local_var_req_builder.query(&[(
14314                "contact_group",
14315                &local_var_str
14316                    .into_iter()
14317                    .map(|p| p.to_string())
14318                    .collect::<Vec<String>>()
14319                    .join(",")
14320                    .to_string(),
14321            )]),
14322        };
14323    }
14324    if let Some(ref local_var_str) = contact_group__n {
14325        local_var_req_builder = match "multi" {
14326            "multi" => local_var_req_builder.query(
14327                &local_var_str
14328                    .into_iter()
14329                    .map(|p| ("contact_group__n".to_owned(), p.to_string()))
14330                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14331            ),
14332            _ => local_var_req_builder.query(&[(
14333                "contact_group__n",
14334                &local_var_str
14335                    .into_iter()
14336                    .map(|p| p.to_string())
14337                    .collect::<Vec<String>>()
14338                    .join(",")
14339                    .to_string(),
14340            )]),
14341        };
14342    }
14343    if let Some(ref local_var_str) = contact_role {
14344        local_var_req_builder = match "multi" {
14345            "multi" => local_var_req_builder.query(
14346                &local_var_str
14347                    .into_iter()
14348                    .map(|p| ("contact_role".to_owned(), p.to_string()))
14349                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14350            ),
14351            _ => local_var_req_builder.query(&[(
14352                "contact_role",
14353                &local_var_str
14354                    .into_iter()
14355                    .map(|p| p.to_string())
14356                    .collect::<Vec<String>>()
14357                    .join(",")
14358                    .to_string(),
14359            )]),
14360        };
14361    }
14362    if let Some(ref local_var_str) = contact_role__n {
14363        local_var_req_builder = match "multi" {
14364            "multi" => local_var_req_builder.query(
14365                &local_var_str
14366                    .into_iter()
14367                    .map(|p| ("contact_role__n".to_owned(), p.to_string()))
14368                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14369            ),
14370            _ => local_var_req_builder.query(&[(
14371                "contact_role__n",
14372                &local_var_str
14373                    .into_iter()
14374                    .map(|p| p.to_string())
14375                    .collect::<Vec<String>>()
14376                    .join(",")
14377                    .to_string(),
14378            )]),
14379        };
14380    }
14381    if let Some(ref local_var_str) = created {
14382        local_var_req_builder = match "multi" {
14383            "multi" => local_var_req_builder.query(
14384                &local_var_str
14385                    .into_iter()
14386                    .map(|p| ("created".to_owned(), p.to_string()))
14387                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14388            ),
14389            _ => local_var_req_builder.query(&[(
14390                "created",
14391                &local_var_str
14392                    .into_iter()
14393                    .map(|p| p.to_string())
14394                    .collect::<Vec<String>>()
14395                    .join(",")
14396                    .to_string(),
14397            )]),
14398        };
14399    }
14400    if let Some(ref local_var_str) = created__empty {
14401        local_var_req_builder = match "multi" {
14402            "multi" => local_var_req_builder.query(
14403                &local_var_str
14404                    .into_iter()
14405                    .map(|p| ("created__empty".to_owned(), p.to_string()))
14406                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14407            ),
14408            _ => local_var_req_builder.query(&[(
14409                "created__empty",
14410                &local_var_str
14411                    .into_iter()
14412                    .map(|p| p.to_string())
14413                    .collect::<Vec<String>>()
14414                    .join(",")
14415                    .to_string(),
14416            )]),
14417        };
14418    }
14419    if let Some(ref local_var_str) = created__gt {
14420        local_var_req_builder = match "multi" {
14421            "multi" => local_var_req_builder.query(
14422                &local_var_str
14423                    .into_iter()
14424                    .map(|p| ("created__gt".to_owned(), p.to_string()))
14425                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14426            ),
14427            _ => local_var_req_builder.query(&[(
14428                "created__gt",
14429                &local_var_str
14430                    .into_iter()
14431                    .map(|p| p.to_string())
14432                    .collect::<Vec<String>>()
14433                    .join(",")
14434                    .to_string(),
14435            )]),
14436        };
14437    }
14438    if let Some(ref local_var_str) = created__gte {
14439        local_var_req_builder = match "multi" {
14440            "multi" => local_var_req_builder.query(
14441                &local_var_str
14442                    .into_iter()
14443                    .map(|p| ("created__gte".to_owned(), p.to_string()))
14444                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14445            ),
14446            _ => local_var_req_builder.query(&[(
14447                "created__gte",
14448                &local_var_str
14449                    .into_iter()
14450                    .map(|p| p.to_string())
14451                    .collect::<Vec<String>>()
14452                    .join(",")
14453                    .to_string(),
14454            )]),
14455        };
14456    }
14457    if let Some(ref local_var_str) = created__lt {
14458        local_var_req_builder = match "multi" {
14459            "multi" => local_var_req_builder.query(
14460                &local_var_str
14461                    .into_iter()
14462                    .map(|p| ("created__lt".to_owned(), p.to_string()))
14463                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14464            ),
14465            _ => local_var_req_builder.query(&[(
14466                "created__lt",
14467                &local_var_str
14468                    .into_iter()
14469                    .map(|p| p.to_string())
14470                    .collect::<Vec<String>>()
14471                    .join(",")
14472                    .to_string(),
14473            )]),
14474        };
14475    }
14476    if let Some(ref local_var_str) = created__lte {
14477        local_var_req_builder = match "multi" {
14478            "multi" => local_var_req_builder.query(
14479                &local_var_str
14480                    .into_iter()
14481                    .map(|p| ("created__lte".to_owned(), p.to_string()))
14482                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14483            ),
14484            _ => local_var_req_builder.query(&[(
14485                "created__lte",
14486                &local_var_str
14487                    .into_iter()
14488                    .map(|p| p.to_string())
14489                    .collect::<Vec<String>>()
14490                    .join(",")
14491                    .to_string(),
14492            )]),
14493        };
14494    }
14495    if let Some(ref local_var_str) = created__n {
14496        local_var_req_builder = match "multi" {
14497            "multi" => local_var_req_builder.query(
14498                &local_var_str
14499                    .into_iter()
14500                    .map(|p| ("created__n".to_owned(), p.to_string()))
14501                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14502            ),
14503            _ => local_var_req_builder.query(&[(
14504                "created__n",
14505                &local_var_str
14506                    .into_iter()
14507                    .map(|p| p.to_string())
14508                    .collect::<Vec<String>>()
14509                    .join(",")
14510                    .to_string(),
14511            )]),
14512        };
14513    }
14514    if let Some(ref local_var_str) = created_by_request {
14515        local_var_req_builder =
14516            local_var_req_builder.query(&[("created_by_request", &local_var_str.to_string())]);
14517    }
14518    if let Some(ref local_var_str) = description {
14519        local_var_req_builder = match "multi" {
14520            "multi" => local_var_req_builder.query(
14521                &local_var_str
14522                    .into_iter()
14523                    .map(|p| ("description".to_owned(), p.to_string()))
14524                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14525            ),
14526            _ => local_var_req_builder.query(&[(
14527                "description",
14528                &local_var_str
14529                    .into_iter()
14530                    .map(|p| p.to_string())
14531                    .collect::<Vec<String>>()
14532                    .join(",")
14533                    .to_string(),
14534            )]),
14535        };
14536    }
14537    if let Some(ref local_var_str) = description__empty {
14538        local_var_req_builder =
14539            local_var_req_builder.query(&[("description__empty", &local_var_str.to_string())]);
14540    }
14541    if let Some(ref local_var_str) = description__ic {
14542        local_var_req_builder = match "multi" {
14543            "multi" => local_var_req_builder.query(
14544                &local_var_str
14545                    .into_iter()
14546                    .map(|p| ("description__ic".to_owned(), p.to_string()))
14547                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14548            ),
14549            _ => local_var_req_builder.query(&[(
14550                "description__ic",
14551                &local_var_str
14552                    .into_iter()
14553                    .map(|p| p.to_string())
14554                    .collect::<Vec<String>>()
14555                    .join(",")
14556                    .to_string(),
14557            )]),
14558        };
14559    }
14560    if let Some(ref local_var_str) = description__ie {
14561        local_var_req_builder = match "multi" {
14562            "multi" => local_var_req_builder.query(
14563                &local_var_str
14564                    .into_iter()
14565                    .map(|p| ("description__ie".to_owned(), p.to_string()))
14566                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14567            ),
14568            _ => local_var_req_builder.query(&[(
14569                "description__ie",
14570                &local_var_str
14571                    .into_iter()
14572                    .map(|p| p.to_string())
14573                    .collect::<Vec<String>>()
14574                    .join(",")
14575                    .to_string(),
14576            )]),
14577        };
14578    }
14579    if let Some(ref local_var_str) = description__iew {
14580        local_var_req_builder = match "multi" {
14581            "multi" => local_var_req_builder.query(
14582                &local_var_str
14583                    .into_iter()
14584                    .map(|p| ("description__iew".to_owned(), p.to_string()))
14585                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14586            ),
14587            _ => local_var_req_builder.query(&[(
14588                "description__iew",
14589                &local_var_str
14590                    .into_iter()
14591                    .map(|p| p.to_string())
14592                    .collect::<Vec<String>>()
14593                    .join(",")
14594                    .to_string(),
14595            )]),
14596        };
14597    }
14598    if let Some(ref local_var_str) = description__iregex {
14599        local_var_req_builder = match "multi" {
14600            "multi" => local_var_req_builder.query(
14601                &local_var_str
14602                    .into_iter()
14603                    .map(|p| ("description__iregex".to_owned(), p.to_string()))
14604                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14605            ),
14606            _ => local_var_req_builder.query(&[(
14607                "description__iregex",
14608                &local_var_str
14609                    .into_iter()
14610                    .map(|p| p.to_string())
14611                    .collect::<Vec<String>>()
14612                    .join(",")
14613                    .to_string(),
14614            )]),
14615        };
14616    }
14617    if let Some(ref local_var_str) = description__isw {
14618        local_var_req_builder = match "multi" {
14619            "multi" => local_var_req_builder.query(
14620                &local_var_str
14621                    .into_iter()
14622                    .map(|p| ("description__isw".to_owned(), p.to_string()))
14623                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14624            ),
14625            _ => local_var_req_builder.query(&[(
14626                "description__isw",
14627                &local_var_str
14628                    .into_iter()
14629                    .map(|p| p.to_string())
14630                    .collect::<Vec<String>>()
14631                    .join(",")
14632                    .to_string(),
14633            )]),
14634        };
14635    }
14636    if let Some(ref local_var_str) = description__n {
14637        local_var_req_builder = match "multi" {
14638            "multi" => local_var_req_builder.query(
14639                &local_var_str
14640                    .into_iter()
14641                    .map(|p| ("description__n".to_owned(), p.to_string()))
14642                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14643            ),
14644            _ => local_var_req_builder.query(&[(
14645                "description__n",
14646                &local_var_str
14647                    .into_iter()
14648                    .map(|p| p.to_string())
14649                    .collect::<Vec<String>>()
14650                    .join(",")
14651                    .to_string(),
14652            )]),
14653        };
14654    }
14655    if let Some(ref local_var_str) = description__nic {
14656        local_var_req_builder = match "multi" {
14657            "multi" => local_var_req_builder.query(
14658                &local_var_str
14659                    .into_iter()
14660                    .map(|p| ("description__nic".to_owned(), p.to_string()))
14661                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14662            ),
14663            _ => local_var_req_builder.query(&[(
14664                "description__nic",
14665                &local_var_str
14666                    .into_iter()
14667                    .map(|p| p.to_string())
14668                    .collect::<Vec<String>>()
14669                    .join(",")
14670                    .to_string(),
14671            )]),
14672        };
14673    }
14674    if let Some(ref local_var_str) = description__nie {
14675        local_var_req_builder = match "multi" {
14676            "multi" => local_var_req_builder.query(
14677                &local_var_str
14678                    .into_iter()
14679                    .map(|p| ("description__nie".to_owned(), p.to_string()))
14680                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14681            ),
14682            _ => local_var_req_builder.query(&[(
14683                "description__nie",
14684                &local_var_str
14685                    .into_iter()
14686                    .map(|p| p.to_string())
14687                    .collect::<Vec<String>>()
14688                    .join(",")
14689                    .to_string(),
14690            )]),
14691        };
14692    }
14693    if let Some(ref local_var_str) = description__niew {
14694        local_var_req_builder = match "multi" {
14695            "multi" => local_var_req_builder.query(
14696                &local_var_str
14697                    .into_iter()
14698                    .map(|p| ("description__niew".to_owned(), p.to_string()))
14699                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14700            ),
14701            _ => local_var_req_builder.query(&[(
14702                "description__niew",
14703                &local_var_str
14704                    .into_iter()
14705                    .map(|p| p.to_string())
14706                    .collect::<Vec<String>>()
14707                    .join(",")
14708                    .to_string(),
14709            )]),
14710        };
14711    }
14712    if let Some(ref local_var_str) = description__nisw {
14713        local_var_req_builder = match "multi" {
14714            "multi" => local_var_req_builder.query(
14715                &local_var_str
14716                    .into_iter()
14717                    .map(|p| ("description__nisw".to_owned(), p.to_string()))
14718                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14719            ),
14720            _ => local_var_req_builder.query(&[(
14721                "description__nisw",
14722                &local_var_str
14723                    .into_iter()
14724                    .map(|p| p.to_string())
14725                    .collect::<Vec<String>>()
14726                    .join(",")
14727                    .to_string(),
14728            )]),
14729        };
14730    }
14731    if let Some(ref local_var_str) = description__regex {
14732        local_var_req_builder = match "multi" {
14733            "multi" => local_var_req_builder.query(
14734                &local_var_str
14735                    .into_iter()
14736                    .map(|p| ("description__regex".to_owned(), p.to_string()))
14737                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14738            ),
14739            _ => local_var_req_builder.query(&[(
14740                "description__regex",
14741                &local_var_str
14742                    .into_iter()
14743                    .map(|p| p.to_string())
14744                    .collect::<Vec<String>>()
14745                    .join(",")
14746                    .to_string(),
14747            )]),
14748        };
14749    }
14750    if let Some(ref local_var_str) = export_target {
14751        local_var_req_builder = match "multi" {
14752            "multi" => local_var_req_builder.query(
14753                &local_var_str
14754                    .into_iter()
14755                    .map(|p| ("export_target".to_owned(), p.to_string()))
14756                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14757            ),
14758            _ => local_var_req_builder.query(&[(
14759                "export_target",
14760                &local_var_str
14761                    .into_iter()
14762                    .map(|p| p.to_string())
14763                    .collect::<Vec<String>>()
14764                    .join(",")
14765                    .to_string(),
14766            )]),
14767        };
14768    }
14769    if let Some(ref local_var_str) = export_target__n {
14770        local_var_req_builder = match "multi" {
14771            "multi" => local_var_req_builder.query(
14772                &local_var_str
14773                    .into_iter()
14774                    .map(|p| ("export_target__n".to_owned(), p.to_string()))
14775                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14776            ),
14777            _ => local_var_req_builder.query(&[(
14778                "export_target__n",
14779                &local_var_str
14780                    .into_iter()
14781                    .map(|p| p.to_string())
14782                    .collect::<Vec<String>>()
14783                    .join(",")
14784                    .to_string(),
14785            )]),
14786        };
14787    }
14788    if let Some(ref local_var_str) = export_target_id {
14789        local_var_req_builder = match "multi" {
14790            "multi" => local_var_req_builder.query(
14791                &local_var_str
14792                    .into_iter()
14793                    .map(|p| ("export_target_id".to_owned(), p.to_string()))
14794                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14795            ),
14796            _ => local_var_req_builder.query(&[(
14797                "export_target_id",
14798                &local_var_str
14799                    .into_iter()
14800                    .map(|p| p.to_string())
14801                    .collect::<Vec<String>>()
14802                    .join(",")
14803                    .to_string(),
14804            )]),
14805        };
14806    }
14807    if let Some(ref local_var_str) = export_target_id__n {
14808        local_var_req_builder = match "multi" {
14809            "multi" => local_var_req_builder.query(
14810                &local_var_str
14811                    .into_iter()
14812                    .map(|p| ("export_target_id__n".to_owned(), p.to_string()))
14813                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14814            ),
14815            _ => local_var_req_builder.query(&[(
14816                "export_target_id__n",
14817                &local_var_str
14818                    .into_iter()
14819                    .map(|p| p.to_string())
14820                    .collect::<Vec<String>>()
14821                    .join(",")
14822                    .to_string(),
14823            )]),
14824        };
14825    }
14826    if let Some(ref local_var_str) = id {
14827        local_var_req_builder = match "multi" {
14828            "multi" => local_var_req_builder.query(
14829                &local_var_str
14830                    .into_iter()
14831                    .map(|p| ("id".to_owned(), p.to_string()))
14832                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14833            ),
14834            _ => local_var_req_builder.query(&[(
14835                "id",
14836                &local_var_str
14837                    .into_iter()
14838                    .map(|p| p.to_string())
14839                    .collect::<Vec<String>>()
14840                    .join(",")
14841                    .to_string(),
14842            )]),
14843        };
14844    }
14845    if let Some(ref local_var_str) = id__empty {
14846        local_var_req_builder =
14847            local_var_req_builder.query(&[("id__empty", &local_var_str.to_string())]);
14848    }
14849    if let Some(ref local_var_str) = id__gt {
14850        local_var_req_builder = match "multi" {
14851            "multi" => local_var_req_builder.query(
14852                &local_var_str
14853                    .into_iter()
14854                    .map(|p| ("id__gt".to_owned(), p.to_string()))
14855                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14856            ),
14857            _ => local_var_req_builder.query(&[(
14858                "id__gt",
14859                &local_var_str
14860                    .into_iter()
14861                    .map(|p| p.to_string())
14862                    .collect::<Vec<String>>()
14863                    .join(",")
14864                    .to_string(),
14865            )]),
14866        };
14867    }
14868    if let Some(ref local_var_str) = id__gte {
14869        local_var_req_builder = match "multi" {
14870            "multi" => local_var_req_builder.query(
14871                &local_var_str
14872                    .into_iter()
14873                    .map(|p| ("id__gte".to_owned(), p.to_string()))
14874                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14875            ),
14876            _ => local_var_req_builder.query(&[(
14877                "id__gte",
14878                &local_var_str
14879                    .into_iter()
14880                    .map(|p| p.to_string())
14881                    .collect::<Vec<String>>()
14882                    .join(",")
14883                    .to_string(),
14884            )]),
14885        };
14886    }
14887    if let Some(ref local_var_str) = id__lt {
14888        local_var_req_builder = match "multi" {
14889            "multi" => local_var_req_builder.query(
14890                &local_var_str
14891                    .into_iter()
14892                    .map(|p| ("id__lt".to_owned(), p.to_string()))
14893                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14894            ),
14895            _ => local_var_req_builder.query(&[(
14896                "id__lt",
14897                &local_var_str
14898                    .into_iter()
14899                    .map(|p| p.to_string())
14900                    .collect::<Vec<String>>()
14901                    .join(",")
14902                    .to_string(),
14903            )]),
14904        };
14905    }
14906    if let Some(ref local_var_str) = id__lte {
14907        local_var_req_builder = match "multi" {
14908            "multi" => local_var_req_builder.query(
14909                &local_var_str
14910                    .into_iter()
14911                    .map(|p| ("id__lte".to_owned(), p.to_string()))
14912                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14913            ),
14914            _ => local_var_req_builder.query(&[(
14915                "id__lte",
14916                &local_var_str
14917                    .into_iter()
14918                    .map(|p| p.to_string())
14919                    .collect::<Vec<String>>()
14920                    .join(",")
14921                    .to_string(),
14922            )]),
14923        };
14924    }
14925    if let Some(ref local_var_str) = id__n {
14926        local_var_req_builder = match "multi" {
14927            "multi" => local_var_req_builder.query(
14928                &local_var_str
14929                    .into_iter()
14930                    .map(|p| ("id__n".to_owned(), p.to_string()))
14931                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14932            ),
14933            _ => local_var_req_builder.query(&[(
14934                "id__n",
14935                &local_var_str
14936                    .into_iter()
14937                    .map(|p| p.to_string())
14938                    .collect::<Vec<String>>()
14939                    .join(",")
14940                    .to_string(),
14941            )]),
14942        };
14943    }
14944    if let Some(ref local_var_str) = identifier {
14945        local_var_req_builder = match "multi" {
14946            "multi" => local_var_req_builder.query(
14947                &local_var_str
14948                    .into_iter()
14949                    .map(|p| ("identifier".to_owned(), p.to_string()))
14950                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14951            ),
14952            _ => local_var_req_builder.query(&[(
14953                "identifier",
14954                &local_var_str
14955                    .into_iter()
14956                    .map(|p| p.to_string())
14957                    .collect::<Vec<String>>()
14958                    .join(",")
14959                    .to_string(),
14960            )]),
14961        };
14962    }
14963    if let Some(ref local_var_str) = identifier__empty {
14964        local_var_req_builder =
14965            local_var_req_builder.query(&[("identifier__empty", &local_var_str.to_string())]);
14966    }
14967    if let Some(ref local_var_str) = identifier__gt {
14968        local_var_req_builder = match "multi" {
14969            "multi" => local_var_req_builder.query(
14970                &local_var_str
14971                    .into_iter()
14972                    .map(|p| ("identifier__gt".to_owned(), p.to_string()))
14973                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14974            ),
14975            _ => local_var_req_builder.query(&[(
14976                "identifier__gt",
14977                &local_var_str
14978                    .into_iter()
14979                    .map(|p| p.to_string())
14980                    .collect::<Vec<String>>()
14981                    .join(",")
14982                    .to_string(),
14983            )]),
14984        };
14985    }
14986    if let Some(ref local_var_str) = identifier__gte {
14987        local_var_req_builder = match "multi" {
14988            "multi" => local_var_req_builder.query(
14989                &local_var_str
14990                    .into_iter()
14991                    .map(|p| ("identifier__gte".to_owned(), p.to_string()))
14992                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14993            ),
14994            _ => local_var_req_builder.query(&[(
14995                "identifier__gte",
14996                &local_var_str
14997                    .into_iter()
14998                    .map(|p| p.to_string())
14999                    .collect::<Vec<String>>()
15000                    .join(",")
15001                    .to_string(),
15002            )]),
15003        };
15004    }
15005    if let Some(ref local_var_str) = identifier__lt {
15006        local_var_req_builder = match "multi" {
15007            "multi" => local_var_req_builder.query(
15008                &local_var_str
15009                    .into_iter()
15010                    .map(|p| ("identifier__lt".to_owned(), p.to_string()))
15011                    .collect::<Vec<(std::string::String, std::string::String)>>(),
15012            ),
15013            _ => local_var_req_builder.query(&[(
15014                "identifier__lt",
15015                &local_var_str
15016                    .into_iter()
15017                    .map(|p| p.to_string())
15018                    .collect::<Vec<String>>()
15019                    .join(",")
15020                    .to_string(),
15021            )]),
15022        };
15023    }
15024    if let Some(ref local_var_str) = identifier__lte {
15025        local_var_req_builder = match "multi" {
15026            "multi" => local_var_req_builder.query(
15027                &local_var_str
15028                    .into_iter()
15029                    .map(|p| ("identifier__lte".to_owned(), p.to_string()))
15030                    .collect::<Vec<(std::string::String, std::string::String)>>(),
15031            ),
15032            _ => local_var_req_builder.query(&[(
15033                "identifier__lte",
15034                &local_var_str
15035                    .into_iter()
15036                    .map(|p| p.to_string())
15037                    .collect::<Vec<String>>()
15038                    .join(",")
15039                    .to_string(),
15040            )]),
15041        };
15042    }
15043    if let Some(ref local_var_str) = identifier__n {
15044        local_var_req_builder = match "multi" {
15045            "multi" => local_var_req_builder.query(
15046                &local_var_str
15047                    .into_iter()
15048                    .map(|p| ("identifier__n".to_owned(), p.to_string()))
15049                    .collect::<Vec<(std::string::String, std::string::String)>>(),
15050            ),
15051            _ => local_var_req_builder.query(&[(
15052                "identifier__n",
15053                &local_var_str
15054                    .into_iter()
15055                    .map(|p| p.to_string())
15056                    .collect::<Vec<String>>()
15057                    .join(",")
15058                    .to_string(),
15059            )]),
15060        };
15061    }
15062    if let Some(ref local_var_str) = import_target {
15063        local_var_req_builder = match "multi" {
15064            "multi" => local_var_req_builder.query(
15065                &local_var_str
15066                    .into_iter()
15067                    .map(|p| ("import_target".to_owned(), p.to_string()))
15068                    .collect::<Vec<(std::string::String, std::string::String)>>(),
15069            ),
15070            _ => local_var_req_builder.query(&[(
15071                "import_target",
15072                &local_var_str
15073                    .into_iter()
15074                    .map(|p| p.to_string())
15075                    .collect::<Vec<String>>()
15076                    .join(",")
15077                    .to_string(),
15078            )]),
15079        };
15080    }
15081    if let Some(ref local_var_str) = import_target__n {
15082        local_var_req_builder = match "multi" {
15083            "multi" => local_var_req_builder.query(
15084                &local_var_str
15085                    .into_iter()
15086                    .map(|p| ("import_target__n".to_owned(), p.to_string()))
15087                    .collect::<Vec<(std::string::String, std::string::String)>>(),
15088            ),
15089            _ => local_var_req_builder.query(&[(
15090                "import_target__n",
15091                &local_var_str
15092                    .into_iter()
15093                    .map(|p| p.to_string())
15094                    .collect::<Vec<String>>()
15095                    .join(",")
15096                    .to_string(),
15097            )]),
15098        };
15099    }
15100    if let Some(ref local_var_str) = import_target_id {
15101        local_var_req_builder = match "multi" {
15102            "multi" => local_var_req_builder.query(
15103                &local_var_str
15104                    .into_iter()
15105                    .map(|p| ("import_target_id".to_owned(), p.to_string()))
15106                    .collect::<Vec<(std::string::String, std::string::String)>>(),
15107            ),
15108            _ => local_var_req_builder.query(&[(
15109                "import_target_id",
15110                &local_var_str
15111                    .into_iter()
15112                    .map(|p| p.to_string())
15113                    .collect::<Vec<String>>()
15114                    .join(",")
15115                    .to_string(),
15116            )]),
15117        };
15118    }
15119    if let Some(ref local_var_str) = import_target_id__n {
15120        local_var_req_builder = match "multi" {
15121            "multi" => local_var_req_builder.query(
15122                &local_var_str
15123                    .into_iter()
15124                    .map(|p| ("import_target_id__n".to_owned(), p.to_string()))
15125                    .collect::<Vec<(std::string::String, std::string::String)>>(),
15126            ),
15127            _ => local_var_req_builder.query(&[(
15128                "import_target_id__n",
15129                &local_var_str
15130                    .into_iter()
15131                    .map(|p| p.to_string())
15132                    .collect::<Vec<String>>()
15133                    .join(",")
15134                    .to_string(),
15135            )]),
15136        };
15137    }
15138    if let Some(ref local_var_str) = last_updated {
15139        local_var_req_builder = match "multi" {
15140            "multi" => local_var_req_builder.query(
15141                &local_var_str
15142                    .into_iter()
15143                    .map(|p| ("last_updated".to_owned(), p.to_string()))
15144                    .collect::<Vec<(std::string::String, std::string::String)>>(),
15145            ),
15146            _ => local_var_req_builder.query(&[(
15147                "last_updated",
15148                &local_var_str
15149                    .into_iter()
15150                    .map(|p| p.to_string())
15151                    .collect::<Vec<String>>()
15152                    .join(",")
15153                    .to_string(),
15154            )]),
15155        };
15156    }
15157    if let Some(ref local_var_str) = last_updated__empty {
15158        local_var_req_builder = match "multi" {
15159            "multi" => local_var_req_builder.query(
15160                &local_var_str
15161                    .into_iter()
15162                    .map(|p| ("last_updated__empty".to_owned(), p.to_string()))
15163                    .collect::<Vec<(std::string::String, std::string::String)>>(),
15164            ),
15165            _ => local_var_req_builder.query(&[(
15166                "last_updated__empty",
15167                &local_var_str
15168                    .into_iter()
15169                    .map(|p| p.to_string())
15170                    .collect::<Vec<String>>()
15171                    .join(",")
15172                    .to_string(),
15173            )]),
15174        };
15175    }
15176    if let Some(ref local_var_str) = last_updated__gt {
15177        local_var_req_builder = match "multi" {
15178            "multi" => local_var_req_builder.query(
15179                &local_var_str
15180                    .into_iter()
15181                    .map(|p| ("last_updated__gt".to_owned(), p.to_string()))
15182                    .collect::<Vec<(std::string::String, std::string::String)>>(),
15183            ),
15184            _ => local_var_req_builder.query(&[(
15185                "last_updated__gt",
15186                &local_var_str
15187                    .into_iter()
15188                    .map(|p| p.to_string())
15189                    .collect::<Vec<String>>()
15190                    .join(",")
15191                    .to_string(),
15192            )]),
15193        };
15194    }
15195    if let Some(ref local_var_str) = last_updated__gte {
15196        local_var_req_builder = match "multi" {
15197            "multi" => local_var_req_builder.query(
15198                &local_var_str
15199                    .into_iter()
15200                    .map(|p| ("last_updated__gte".to_owned(), p.to_string()))
15201                    .collect::<Vec<(std::string::String, std::string::String)>>(),
15202            ),
15203            _ => local_var_req_builder.query(&[(
15204                "last_updated__gte",
15205                &local_var_str
15206                    .into_iter()
15207                    .map(|p| p.to_string())
15208                    .collect::<Vec<String>>()
15209                    .join(",")
15210                    .to_string(),
15211            )]),
15212        };
15213    }
15214    if let Some(ref local_var_str) = last_updated__lt {
15215        local_var_req_builder = match "multi" {
15216            "multi" => local_var_req_builder.query(
15217                &local_var_str
15218                    .into_iter()
15219                    .map(|p| ("last_updated__lt".to_owned(), p.to_string()))
15220                    .collect::<Vec<(std::string::String, std::string::String)>>(),
15221            ),
15222            _ => local_var_req_builder.query(&[(
15223                "last_updated__lt",
15224                &local_var_str
15225                    .into_iter()
15226                    .map(|p| p.to_string())
15227                    .collect::<Vec<String>>()
15228                    .join(",")
15229                    .to_string(),
15230            )]),
15231        };
15232    }
15233    if let Some(ref local_var_str) = last_updated__lte {
15234        local_var_req_builder = match "multi" {
15235            "multi" => local_var_req_builder.query(
15236                &local_var_str
15237                    .into_iter()
15238                    .map(|p| ("last_updated__lte".to_owned(), p.to_string()))
15239                    .collect::<Vec<(std::string::String, std::string::String)>>(),
15240            ),
15241            _ => local_var_req_builder.query(&[(
15242                "last_updated__lte",
15243                &local_var_str
15244                    .into_iter()
15245                    .map(|p| p.to_string())
15246                    .collect::<Vec<String>>()
15247                    .join(",")
15248                    .to_string(),
15249            )]),
15250        };
15251    }
15252    if let Some(ref local_var_str) = last_updated__n {
15253        local_var_req_builder = match "multi" {
15254            "multi" => local_var_req_builder.query(
15255                &local_var_str
15256                    .into_iter()
15257                    .map(|p| ("last_updated__n".to_owned(), p.to_string()))
15258                    .collect::<Vec<(std::string::String, std::string::String)>>(),
15259            ),
15260            _ => local_var_req_builder.query(&[(
15261                "last_updated__n",
15262                &local_var_str
15263                    .into_iter()
15264                    .map(|p| p.to_string())
15265                    .collect::<Vec<String>>()
15266                    .join(",")
15267                    .to_string(),
15268            )]),
15269        };
15270    }
15271    if let Some(ref local_var_str) = limit {
15272        local_var_req_builder =
15273            local_var_req_builder.query(&[("limit", &local_var_str.to_string())]);
15274    }
15275    if let Some(ref local_var_str) = modified_by_request {
15276        local_var_req_builder =
15277            local_var_req_builder.query(&[("modified_by_request", &local_var_str.to_string())]);
15278    }
15279    if let Some(ref local_var_str) = name {
15280        local_var_req_builder = match "multi" {
15281            "multi" => local_var_req_builder.query(
15282                &local_var_str
15283                    .into_iter()
15284                    .map(|p| ("name".to_owned(), p.to_string()))
15285                    .collect::<Vec<(std::string::String, std::string::String)>>(),
15286            ),
15287            _ => local_var_req_builder.query(&[(
15288                "name",
15289                &local_var_str
15290                    .into_iter()
15291                    .map(|p| p.to_string())
15292                    .collect::<Vec<String>>()
15293                    .join(",")
15294                    .to_string(),
15295            )]),
15296        };
15297    }
15298    if let Some(ref local_var_str) = name__empty {
15299        local_var_req_builder =
15300            local_var_req_builder.query(&[("name__empty", &local_var_str.to_string())]);
15301    }
15302    if let Some(ref local_var_str) = name__ic {
15303        local_var_req_builder = match "multi" {
15304            "multi" => local_var_req_builder.query(
15305                &local_var_str
15306                    .into_iter()
15307                    .map(|p| ("name__ic".to_owned(), p.to_string()))
15308                    .collect::<Vec<(std::string::String, std::string::String)>>(),
15309            ),
15310            _ => local_var_req_builder.query(&[(
15311                "name__ic",
15312                &local_var_str
15313                    .into_iter()
15314                    .map(|p| p.to_string())
15315                    .collect::<Vec<String>>()
15316                    .join(",")
15317                    .to_string(),
15318            )]),
15319        };
15320    }
15321    if let Some(ref local_var_str) = name__ie {
15322        local_var_req_builder = match "multi" {
15323            "multi" => local_var_req_builder.query(
15324                &local_var_str
15325                    .into_iter()
15326                    .map(|p| ("name__ie".to_owned(), p.to_string()))
15327                    .collect::<Vec<(std::string::String, std::string::String)>>(),
15328            ),
15329            _ => local_var_req_builder.query(&[(
15330                "name__ie",
15331                &local_var_str
15332                    .into_iter()
15333                    .map(|p| p.to_string())
15334                    .collect::<Vec<String>>()
15335                    .join(",")
15336                    .to_string(),
15337            )]),
15338        };
15339    }
15340    if let Some(ref local_var_str) = name__iew {
15341        local_var_req_builder = match "multi" {
15342            "multi" => local_var_req_builder.query(
15343                &local_var_str
15344                    .into_iter()
15345                    .map(|p| ("name__iew".to_owned(), p.to_string()))
15346                    .collect::<Vec<(std::string::String, std::string::String)>>(),
15347            ),
15348            _ => local_var_req_builder.query(&[(
15349                "name__iew",
15350                &local_var_str
15351                    .into_iter()
15352                    .map(|p| p.to_string())
15353                    .collect::<Vec<String>>()
15354                    .join(",")
15355                    .to_string(),
15356            )]),
15357        };
15358    }
15359    if let Some(ref local_var_str) = name__iregex {
15360        local_var_req_builder = match "multi" {
15361            "multi" => local_var_req_builder.query(
15362                &local_var_str
15363                    .into_iter()
15364                    .map(|p| ("name__iregex".to_owned(), p.to_string()))
15365                    .collect::<Vec<(std::string::String, std::string::String)>>(),
15366            ),
15367            _ => local_var_req_builder.query(&[(
15368                "name__iregex",
15369                &local_var_str
15370                    .into_iter()
15371                    .map(|p| p.to_string())
15372                    .collect::<Vec<String>>()
15373                    .join(",")
15374                    .to_string(),
15375            )]),
15376        };
15377    }
15378    if let Some(ref local_var_str) = name__isw {
15379        local_var_req_builder = match "multi" {
15380            "multi" => local_var_req_builder.query(
15381                &local_var_str
15382                    .into_iter()
15383                    .map(|p| ("name__isw".to_owned(), p.to_string()))
15384                    .collect::<Vec<(std::string::String, std::string::String)>>(),
15385            ),
15386            _ => local_var_req_builder.query(&[(
15387                "name__isw",
15388                &local_var_str
15389                    .into_iter()
15390                    .map(|p| p.to_string())
15391                    .collect::<Vec<String>>()
15392                    .join(",")
15393                    .to_string(),
15394            )]),
15395        };
15396    }
15397    if let Some(ref local_var_str) = name__n {
15398        local_var_req_builder = match "multi" {
15399            "multi" => local_var_req_builder.query(
15400                &local_var_str
15401                    .into_iter()
15402                    .map(|p| ("name__n".to_owned(), p.to_string()))
15403                    .collect::<Vec<(std::string::String, std::string::String)>>(),
15404            ),
15405            _ => local_var_req_builder.query(&[(
15406                "name__n",
15407                &local_var_str
15408                    .into_iter()
15409                    .map(|p| p.to_string())
15410                    .collect::<Vec<String>>()
15411                    .join(",")
15412                    .to_string(),
15413            )]),
15414        };
15415    }
15416    if let Some(ref local_var_str) = name__nic {
15417        local_var_req_builder = match "multi" {
15418            "multi" => local_var_req_builder.query(
15419                &local_var_str
15420                    .into_iter()
15421                    .map(|p| ("name__nic".to_owned(), p.to_string()))
15422                    .collect::<Vec<(std::string::String, std::string::String)>>(),
15423            ),
15424            _ => local_var_req_builder.query(&[(
15425                "name__nic",
15426                &local_var_str
15427                    .into_iter()
15428                    .map(|p| p.to_string())
15429                    .collect::<Vec<String>>()
15430                    .join(",")
15431                    .to_string(),
15432            )]),
15433        };
15434    }
15435    if let Some(ref local_var_str) = name__nie {
15436        local_var_req_builder = match "multi" {
15437            "multi" => local_var_req_builder.query(
15438                &local_var_str
15439                    .into_iter()
15440                    .map(|p| ("name__nie".to_owned(), p.to_string()))
15441                    .collect::<Vec<(std::string::String, std::string::String)>>(),
15442            ),
15443            _ => local_var_req_builder.query(&[(
15444                "name__nie",
15445                &local_var_str
15446                    .into_iter()
15447                    .map(|p| p.to_string())
15448                    .collect::<Vec<String>>()
15449                    .join(",")
15450                    .to_string(),
15451            )]),
15452        };
15453    }
15454    if let Some(ref local_var_str) = name__niew {
15455        local_var_req_builder = match "multi" {
15456            "multi" => local_var_req_builder.query(
15457                &local_var_str
15458                    .into_iter()
15459                    .map(|p| ("name__niew".to_owned(), p.to_string()))
15460                    .collect::<Vec<(std::string::String, std::string::String)>>(),
15461            ),
15462            _ => local_var_req_builder.query(&[(
15463                "name__niew",
15464                &local_var_str
15465                    .into_iter()
15466                    .map(|p| p.to_string())
15467                    .collect::<Vec<String>>()
15468                    .join(",")
15469                    .to_string(),
15470            )]),
15471        };
15472    }
15473    if let Some(ref local_var_str) = name__nisw {
15474        local_var_req_builder = match "multi" {
15475            "multi" => local_var_req_builder.query(
15476                &local_var_str
15477                    .into_iter()
15478                    .map(|p| ("name__nisw".to_owned(), p.to_string()))
15479                    .collect::<Vec<(std::string::String, std::string::String)>>(),
15480            ),
15481            _ => local_var_req_builder.query(&[(
15482                "name__nisw",
15483                &local_var_str
15484                    .into_iter()
15485                    .map(|p| p.to_string())
15486                    .collect::<Vec<String>>()
15487                    .join(",")
15488                    .to_string(),
15489            )]),
15490        };
15491    }
15492    if let Some(ref local_var_str) = name__regex {
15493        local_var_req_builder = match "multi" {
15494            "multi" => local_var_req_builder.query(
15495                &local_var_str
15496                    .into_iter()
15497                    .map(|p| ("name__regex".to_owned(), p.to_string()))
15498                    .collect::<Vec<(std::string::String, std::string::String)>>(),
15499            ),
15500            _ => local_var_req_builder.query(&[(
15501                "name__regex",
15502                &local_var_str
15503                    .into_iter()
15504                    .map(|p| p.to_string())
15505                    .collect::<Vec<String>>()
15506                    .join(",")
15507                    .to_string(),
15508            )]),
15509        };
15510    }
15511    if let Some(ref local_var_str) = offset {
15512        local_var_req_builder =
15513            local_var_req_builder.query(&[("offset", &local_var_str.to_string())]);
15514    }
15515    if let Some(ref local_var_str) = ordering {
15516        local_var_req_builder =
15517            local_var_req_builder.query(&[("ordering", &local_var_str.to_string())]);
15518    }
15519    if let Some(ref local_var_str) = owner {
15520        local_var_req_builder = match "multi" {
15521            "multi" => local_var_req_builder.query(
15522                &local_var_str
15523                    .into_iter()
15524                    .map(|p| ("owner".to_owned(), p.to_string()))
15525                    .collect::<Vec<(std::string::String, std::string::String)>>(),
15526            ),
15527            _ => local_var_req_builder.query(&[(
15528                "owner",
15529                &local_var_str
15530                    .into_iter()
15531                    .map(|p| p.to_string())
15532                    .collect::<Vec<String>>()
15533                    .join(",")
15534                    .to_string(),
15535            )]),
15536        };
15537    }
15538    if let Some(ref local_var_str) = owner__n {
15539        local_var_req_builder = match "multi" {
15540            "multi" => local_var_req_builder.query(
15541                &local_var_str
15542                    .into_iter()
15543                    .map(|p| ("owner__n".to_owned(), p.to_string()))
15544                    .collect::<Vec<(std::string::String, std::string::String)>>(),
15545            ),
15546            _ => local_var_req_builder.query(&[(
15547                "owner__n",
15548                &local_var_str
15549                    .into_iter()
15550                    .map(|p| p.to_string())
15551                    .collect::<Vec<String>>()
15552                    .join(",")
15553                    .to_string(),
15554            )]),
15555        };
15556    }
15557    if let Some(ref local_var_str) = owner_group {
15558        local_var_req_builder = match "multi" {
15559            "multi" => local_var_req_builder.query(
15560                &local_var_str
15561                    .into_iter()
15562                    .map(|p| ("owner_group".to_owned(), p.to_string()))
15563                    .collect::<Vec<(std::string::String, std::string::String)>>(),
15564            ),
15565            _ => local_var_req_builder.query(&[(
15566                "owner_group",
15567                &local_var_str
15568                    .into_iter()
15569                    .map(|p| p.to_string())
15570                    .collect::<Vec<String>>()
15571                    .join(",")
15572                    .to_string(),
15573            )]),
15574        };
15575    }
15576    if let Some(ref local_var_str) = owner_group__n {
15577        local_var_req_builder = match "multi" {
15578            "multi" => local_var_req_builder.query(
15579                &local_var_str
15580                    .into_iter()
15581                    .map(|p| ("owner_group__n".to_owned(), p.to_string()))
15582                    .collect::<Vec<(std::string::String, std::string::String)>>(),
15583            ),
15584            _ => local_var_req_builder.query(&[(
15585                "owner_group__n",
15586                &local_var_str
15587                    .into_iter()
15588                    .map(|p| p.to_string())
15589                    .collect::<Vec<String>>()
15590                    .join(",")
15591                    .to_string(),
15592            )]),
15593        };
15594    }
15595    if let Some(ref local_var_str) = owner_group_id {
15596        local_var_req_builder = match "multi" {
15597            "multi" => local_var_req_builder.query(
15598                &local_var_str
15599                    .into_iter()
15600                    .map(|p| ("owner_group_id".to_owned(), p.to_string()))
15601                    .collect::<Vec<(std::string::String, std::string::String)>>(),
15602            ),
15603            _ => local_var_req_builder.query(&[(
15604                "owner_group_id",
15605                &local_var_str
15606                    .into_iter()
15607                    .map(|p| p.to_string())
15608                    .collect::<Vec<String>>()
15609                    .join(",")
15610                    .to_string(),
15611            )]),
15612        };
15613    }
15614    if let Some(ref local_var_str) = owner_group_id__n {
15615        local_var_req_builder = match "multi" {
15616            "multi" => local_var_req_builder.query(
15617                &local_var_str
15618                    .into_iter()
15619                    .map(|p| ("owner_group_id__n".to_owned(), p.to_string()))
15620                    .collect::<Vec<(std::string::String, std::string::String)>>(),
15621            ),
15622            _ => local_var_req_builder.query(&[(
15623                "owner_group_id__n",
15624                &local_var_str
15625                    .into_iter()
15626                    .map(|p| p.to_string())
15627                    .collect::<Vec<String>>()
15628                    .join(",")
15629                    .to_string(),
15630            )]),
15631        };
15632    }
15633    if let Some(ref local_var_str) = owner_id {
15634        local_var_req_builder = match "multi" {
15635            "multi" => local_var_req_builder.query(
15636                &local_var_str
15637                    .into_iter()
15638                    .map(|p| ("owner_id".to_owned(), p.to_string()))
15639                    .collect::<Vec<(std::string::String, std::string::String)>>(),
15640            ),
15641            _ => local_var_req_builder.query(&[(
15642                "owner_id",
15643                &local_var_str
15644                    .into_iter()
15645                    .map(|p| p.to_string())
15646                    .collect::<Vec<String>>()
15647                    .join(",")
15648                    .to_string(),
15649            )]),
15650        };
15651    }
15652    if let Some(ref local_var_str) = owner_id__n {
15653        local_var_req_builder = match "multi" {
15654            "multi" => local_var_req_builder.query(
15655                &local_var_str
15656                    .into_iter()
15657                    .map(|p| ("owner_id__n".to_owned(), p.to_string()))
15658                    .collect::<Vec<(std::string::String, std::string::String)>>(),
15659            ),
15660            _ => local_var_req_builder.query(&[(
15661                "owner_id__n",
15662                &local_var_str
15663                    .into_iter()
15664                    .map(|p| p.to_string())
15665                    .collect::<Vec<String>>()
15666                    .join(",")
15667                    .to_string(),
15668            )]),
15669        };
15670    }
15671    if let Some(ref local_var_str) = q {
15672        local_var_req_builder = local_var_req_builder.query(&[("q", &local_var_str.to_string())]);
15673    }
15674    if let Some(ref local_var_str) = slug {
15675        local_var_req_builder = match "multi" {
15676            "multi" => local_var_req_builder.query(
15677                &local_var_str
15678                    .into_iter()
15679                    .map(|p| ("slug".to_owned(), p.to_string()))
15680                    .collect::<Vec<(std::string::String, std::string::String)>>(),
15681            ),
15682            _ => local_var_req_builder.query(&[(
15683                "slug",
15684                &local_var_str
15685                    .into_iter()
15686                    .map(|p| p.to_string())
15687                    .collect::<Vec<String>>()
15688                    .join(",")
15689                    .to_string(),
15690            )]),
15691        };
15692    }
15693    if let Some(ref local_var_str) = slug__empty {
15694        local_var_req_builder =
15695            local_var_req_builder.query(&[("slug__empty", &local_var_str.to_string())]);
15696    }
15697    if let Some(ref local_var_str) = slug__ic {
15698        local_var_req_builder = match "multi" {
15699            "multi" => local_var_req_builder.query(
15700                &local_var_str
15701                    .into_iter()
15702                    .map(|p| ("slug__ic".to_owned(), p.to_string()))
15703                    .collect::<Vec<(std::string::String, std::string::String)>>(),
15704            ),
15705            _ => local_var_req_builder.query(&[(
15706                "slug__ic",
15707                &local_var_str
15708                    .into_iter()
15709                    .map(|p| p.to_string())
15710                    .collect::<Vec<String>>()
15711                    .join(",")
15712                    .to_string(),
15713            )]),
15714        };
15715    }
15716    if let Some(ref local_var_str) = slug__ie {
15717        local_var_req_builder = match "multi" {
15718            "multi" => local_var_req_builder.query(
15719                &local_var_str
15720                    .into_iter()
15721                    .map(|p| ("slug__ie".to_owned(), p.to_string()))
15722                    .collect::<Vec<(std::string::String, std::string::String)>>(),
15723            ),
15724            _ => local_var_req_builder.query(&[(
15725                "slug__ie",
15726                &local_var_str
15727                    .into_iter()
15728                    .map(|p| p.to_string())
15729                    .collect::<Vec<String>>()
15730                    .join(",")
15731                    .to_string(),
15732            )]),
15733        };
15734    }
15735    if let Some(ref local_var_str) = slug__iew {
15736        local_var_req_builder = match "multi" {
15737            "multi" => local_var_req_builder.query(
15738                &local_var_str
15739                    .into_iter()
15740                    .map(|p| ("slug__iew".to_owned(), p.to_string()))
15741                    .collect::<Vec<(std::string::String, std::string::String)>>(),
15742            ),
15743            _ => local_var_req_builder.query(&[(
15744                "slug__iew",
15745                &local_var_str
15746                    .into_iter()
15747                    .map(|p| p.to_string())
15748                    .collect::<Vec<String>>()
15749                    .join(",")
15750                    .to_string(),
15751            )]),
15752        };
15753    }
15754    if let Some(ref local_var_str) = slug__iregex {
15755        local_var_req_builder = match "multi" {
15756            "multi" => local_var_req_builder.query(
15757                &local_var_str
15758                    .into_iter()
15759                    .map(|p| ("slug__iregex".to_owned(), p.to_string()))
15760                    .collect::<Vec<(std::string::String, std::string::String)>>(),
15761            ),
15762            _ => local_var_req_builder.query(&[(
15763                "slug__iregex",
15764                &local_var_str
15765                    .into_iter()
15766                    .map(|p| p.to_string())
15767                    .collect::<Vec<String>>()
15768                    .join(",")
15769                    .to_string(),
15770            )]),
15771        };
15772    }
15773    if let Some(ref local_var_str) = slug__isw {
15774        local_var_req_builder = match "multi" {
15775            "multi" => local_var_req_builder.query(
15776                &local_var_str
15777                    .into_iter()
15778                    .map(|p| ("slug__isw".to_owned(), p.to_string()))
15779                    .collect::<Vec<(std::string::String, std::string::String)>>(),
15780            ),
15781            _ => local_var_req_builder.query(&[(
15782                "slug__isw",
15783                &local_var_str
15784                    .into_iter()
15785                    .map(|p| p.to_string())
15786                    .collect::<Vec<String>>()
15787                    .join(",")
15788                    .to_string(),
15789            )]),
15790        };
15791    }
15792    if let Some(ref local_var_str) = slug__n {
15793        local_var_req_builder = match "multi" {
15794            "multi" => local_var_req_builder.query(
15795                &local_var_str
15796                    .into_iter()
15797                    .map(|p| ("slug__n".to_owned(), p.to_string()))
15798                    .collect::<Vec<(std::string::String, std::string::String)>>(),
15799            ),
15800            _ => local_var_req_builder.query(&[(
15801                "slug__n",
15802                &local_var_str
15803                    .into_iter()
15804                    .map(|p| p.to_string())
15805                    .collect::<Vec<String>>()
15806                    .join(",")
15807                    .to_string(),
15808            )]),
15809        };
15810    }
15811    if let Some(ref local_var_str) = slug__nic {
15812        local_var_req_builder = match "multi" {
15813            "multi" => local_var_req_builder.query(
15814                &local_var_str
15815                    .into_iter()
15816                    .map(|p| ("slug__nic".to_owned(), p.to_string()))
15817                    .collect::<Vec<(std::string::String, std::string::String)>>(),
15818            ),
15819            _ => local_var_req_builder.query(&[(
15820                "slug__nic",
15821                &local_var_str
15822                    .into_iter()
15823                    .map(|p| p.to_string())
15824                    .collect::<Vec<String>>()
15825                    .join(",")
15826                    .to_string(),
15827            )]),
15828        };
15829    }
15830    if let Some(ref local_var_str) = slug__nie {
15831        local_var_req_builder = match "multi" {
15832            "multi" => local_var_req_builder.query(
15833                &local_var_str
15834                    .into_iter()
15835                    .map(|p| ("slug__nie".to_owned(), p.to_string()))
15836                    .collect::<Vec<(std::string::String, std::string::String)>>(),
15837            ),
15838            _ => local_var_req_builder.query(&[(
15839                "slug__nie",
15840                &local_var_str
15841                    .into_iter()
15842                    .map(|p| p.to_string())
15843                    .collect::<Vec<String>>()
15844                    .join(",")
15845                    .to_string(),
15846            )]),
15847        };
15848    }
15849    if let Some(ref local_var_str) = slug__niew {
15850        local_var_req_builder = match "multi" {
15851            "multi" => local_var_req_builder.query(
15852                &local_var_str
15853                    .into_iter()
15854                    .map(|p| ("slug__niew".to_owned(), p.to_string()))
15855                    .collect::<Vec<(std::string::String, std::string::String)>>(),
15856            ),
15857            _ => local_var_req_builder.query(&[(
15858                "slug__niew",
15859                &local_var_str
15860                    .into_iter()
15861                    .map(|p| p.to_string())
15862                    .collect::<Vec<String>>()
15863                    .join(",")
15864                    .to_string(),
15865            )]),
15866        };
15867    }
15868    if let Some(ref local_var_str) = slug__nisw {
15869        local_var_req_builder = match "multi" {
15870            "multi" => local_var_req_builder.query(
15871                &local_var_str
15872                    .into_iter()
15873                    .map(|p| ("slug__nisw".to_owned(), p.to_string()))
15874                    .collect::<Vec<(std::string::String, std::string::String)>>(),
15875            ),
15876            _ => local_var_req_builder.query(&[(
15877                "slug__nisw",
15878                &local_var_str
15879                    .into_iter()
15880                    .map(|p| p.to_string())
15881                    .collect::<Vec<String>>()
15882                    .join(",")
15883                    .to_string(),
15884            )]),
15885        };
15886    }
15887    if let Some(ref local_var_str) = slug__regex {
15888        local_var_req_builder = match "multi" {
15889            "multi" => local_var_req_builder.query(
15890                &local_var_str
15891                    .into_iter()
15892                    .map(|p| ("slug__regex".to_owned(), p.to_string()))
15893                    .collect::<Vec<(std::string::String, std::string::String)>>(),
15894            ),
15895            _ => local_var_req_builder.query(&[(
15896                "slug__regex",
15897                &local_var_str
15898                    .into_iter()
15899                    .map(|p| p.to_string())
15900                    .collect::<Vec<String>>()
15901                    .join(",")
15902                    .to_string(),
15903            )]),
15904        };
15905    }
15906    if let Some(ref local_var_str) = status {
15907        local_var_req_builder = match "multi" {
15908            "multi" => local_var_req_builder.query(
15909                &local_var_str
15910                    .into_iter()
15911                    .map(|p| ("status".to_owned(), p.to_string()))
15912                    .collect::<Vec<(std::string::String, std::string::String)>>(),
15913            ),
15914            _ => local_var_req_builder.query(&[(
15915                "status",
15916                &local_var_str
15917                    .into_iter()
15918                    .map(|p| p.to_string())
15919                    .collect::<Vec<String>>()
15920                    .join(",")
15921                    .to_string(),
15922            )]),
15923        };
15924    }
15925    if let Some(ref local_var_str) = status__empty {
15926        local_var_req_builder =
15927            local_var_req_builder.query(&[("status__empty", &local_var_str.to_string())]);
15928    }
15929    if let Some(ref local_var_str) = status__ic {
15930        local_var_req_builder = match "multi" {
15931            "multi" => local_var_req_builder.query(
15932                &local_var_str
15933                    .into_iter()
15934                    .map(|p| ("status__ic".to_owned(), p.to_string()))
15935                    .collect::<Vec<(std::string::String, std::string::String)>>(),
15936            ),
15937            _ => local_var_req_builder.query(&[(
15938                "status__ic",
15939                &local_var_str
15940                    .into_iter()
15941                    .map(|p| p.to_string())
15942                    .collect::<Vec<String>>()
15943                    .join(",")
15944                    .to_string(),
15945            )]),
15946        };
15947    }
15948    if let Some(ref local_var_str) = status__ie {
15949        local_var_req_builder = match "multi" {
15950            "multi" => local_var_req_builder.query(
15951                &local_var_str
15952                    .into_iter()
15953                    .map(|p| ("status__ie".to_owned(), p.to_string()))
15954                    .collect::<Vec<(std::string::String, std::string::String)>>(),
15955            ),
15956            _ => local_var_req_builder.query(&[(
15957                "status__ie",
15958                &local_var_str
15959                    .into_iter()
15960                    .map(|p| p.to_string())
15961                    .collect::<Vec<String>>()
15962                    .join(",")
15963                    .to_string(),
15964            )]),
15965        };
15966    }
15967    if let Some(ref local_var_str) = status__iew {
15968        local_var_req_builder = match "multi" {
15969            "multi" => local_var_req_builder.query(
15970                &local_var_str
15971                    .into_iter()
15972                    .map(|p| ("status__iew".to_owned(), p.to_string()))
15973                    .collect::<Vec<(std::string::String, std::string::String)>>(),
15974            ),
15975            _ => local_var_req_builder.query(&[(
15976                "status__iew",
15977                &local_var_str
15978                    .into_iter()
15979                    .map(|p| p.to_string())
15980                    .collect::<Vec<String>>()
15981                    .join(",")
15982                    .to_string(),
15983            )]),
15984        };
15985    }
15986    if let Some(ref local_var_str) = status__iregex {
15987        local_var_req_builder = match "multi" {
15988            "multi" => local_var_req_builder.query(
15989                &local_var_str
15990                    .into_iter()
15991                    .map(|p| ("status__iregex".to_owned(), p.to_string()))
15992                    .collect::<Vec<(std::string::String, std::string::String)>>(),
15993            ),
15994            _ => local_var_req_builder.query(&[(
15995                "status__iregex",
15996                &local_var_str
15997                    .into_iter()
15998                    .map(|p| p.to_string())
15999                    .collect::<Vec<String>>()
16000                    .join(",")
16001                    .to_string(),
16002            )]),
16003        };
16004    }
16005    if let Some(ref local_var_str) = status__isw {
16006        local_var_req_builder = match "multi" {
16007            "multi" => local_var_req_builder.query(
16008                &local_var_str
16009                    .into_iter()
16010                    .map(|p| ("status__isw".to_owned(), p.to_string()))
16011                    .collect::<Vec<(std::string::String, std::string::String)>>(),
16012            ),
16013            _ => local_var_req_builder.query(&[(
16014                "status__isw",
16015                &local_var_str
16016                    .into_iter()
16017                    .map(|p| p.to_string())
16018                    .collect::<Vec<String>>()
16019                    .join(",")
16020                    .to_string(),
16021            )]),
16022        };
16023    }
16024    if let Some(ref local_var_str) = status__n {
16025        local_var_req_builder = match "multi" {
16026            "multi" => local_var_req_builder.query(
16027                &local_var_str
16028                    .into_iter()
16029                    .map(|p| ("status__n".to_owned(), p.to_string()))
16030                    .collect::<Vec<(std::string::String, std::string::String)>>(),
16031            ),
16032            _ => local_var_req_builder.query(&[(
16033                "status__n",
16034                &local_var_str
16035                    .into_iter()
16036                    .map(|p| p.to_string())
16037                    .collect::<Vec<String>>()
16038                    .join(",")
16039                    .to_string(),
16040            )]),
16041        };
16042    }
16043    if let Some(ref local_var_str) = status__nic {
16044        local_var_req_builder = match "multi" {
16045            "multi" => local_var_req_builder.query(
16046                &local_var_str
16047                    .into_iter()
16048                    .map(|p| ("status__nic".to_owned(), p.to_string()))
16049                    .collect::<Vec<(std::string::String, std::string::String)>>(),
16050            ),
16051            _ => local_var_req_builder.query(&[(
16052                "status__nic",
16053                &local_var_str
16054                    .into_iter()
16055                    .map(|p| p.to_string())
16056                    .collect::<Vec<String>>()
16057                    .join(",")
16058                    .to_string(),
16059            )]),
16060        };
16061    }
16062    if let Some(ref local_var_str) = status__nie {
16063        local_var_req_builder = match "multi" {
16064            "multi" => local_var_req_builder.query(
16065                &local_var_str
16066                    .into_iter()
16067                    .map(|p| ("status__nie".to_owned(), p.to_string()))
16068                    .collect::<Vec<(std::string::String, std::string::String)>>(),
16069            ),
16070            _ => local_var_req_builder.query(&[(
16071                "status__nie",
16072                &local_var_str
16073                    .into_iter()
16074                    .map(|p| p.to_string())
16075                    .collect::<Vec<String>>()
16076                    .join(",")
16077                    .to_string(),
16078            )]),
16079        };
16080    }
16081    if let Some(ref local_var_str) = status__niew {
16082        local_var_req_builder = match "multi" {
16083            "multi" => local_var_req_builder.query(
16084                &local_var_str
16085                    .into_iter()
16086                    .map(|p| ("status__niew".to_owned(), p.to_string()))
16087                    .collect::<Vec<(std::string::String, std::string::String)>>(),
16088            ),
16089            _ => local_var_req_builder.query(&[(
16090                "status__niew",
16091                &local_var_str
16092                    .into_iter()
16093                    .map(|p| p.to_string())
16094                    .collect::<Vec<String>>()
16095                    .join(",")
16096                    .to_string(),
16097            )]),
16098        };
16099    }
16100    if let Some(ref local_var_str) = status__nisw {
16101        local_var_req_builder = match "multi" {
16102            "multi" => local_var_req_builder.query(
16103                &local_var_str
16104                    .into_iter()
16105                    .map(|p| ("status__nisw".to_owned(), p.to_string()))
16106                    .collect::<Vec<(std::string::String, std::string::String)>>(),
16107            ),
16108            _ => local_var_req_builder.query(&[(
16109                "status__nisw",
16110                &local_var_str
16111                    .into_iter()
16112                    .map(|p| p.to_string())
16113                    .collect::<Vec<String>>()
16114                    .join(",")
16115                    .to_string(),
16116            )]),
16117        };
16118    }
16119    if let Some(ref local_var_str) = status__regex {
16120        local_var_req_builder = match "multi" {
16121            "multi" => local_var_req_builder.query(
16122                &local_var_str
16123                    .into_iter()
16124                    .map(|p| ("status__regex".to_owned(), p.to_string()))
16125                    .collect::<Vec<(std::string::String, std::string::String)>>(),
16126            ),
16127            _ => local_var_req_builder.query(&[(
16128                "status__regex",
16129                &local_var_str
16130                    .into_iter()
16131                    .map(|p| p.to_string())
16132                    .collect::<Vec<String>>()
16133                    .join(",")
16134                    .to_string(),
16135            )]),
16136        };
16137    }
16138    if let Some(ref local_var_str) = tag {
16139        local_var_req_builder = match "multi" {
16140            "multi" => local_var_req_builder.query(
16141                &local_var_str
16142                    .into_iter()
16143                    .map(|p| ("tag".to_owned(), p.to_string()))
16144                    .collect::<Vec<(std::string::String, std::string::String)>>(),
16145            ),
16146            _ => local_var_req_builder.query(&[(
16147                "tag",
16148                &local_var_str
16149                    .into_iter()
16150                    .map(|p| p.to_string())
16151                    .collect::<Vec<String>>()
16152                    .join(",")
16153                    .to_string(),
16154            )]),
16155        };
16156    }
16157    if let Some(ref local_var_str) = tag__n {
16158        local_var_req_builder = match "multi" {
16159            "multi" => local_var_req_builder.query(
16160                &local_var_str
16161                    .into_iter()
16162                    .map(|p| ("tag__n".to_owned(), p.to_string()))
16163                    .collect::<Vec<(std::string::String, std::string::String)>>(),
16164            ),
16165            _ => local_var_req_builder.query(&[(
16166                "tag__n",
16167                &local_var_str
16168                    .into_iter()
16169                    .map(|p| p.to_string())
16170                    .collect::<Vec<String>>()
16171                    .join(",")
16172                    .to_string(),
16173            )]),
16174        };
16175    }
16176    if let Some(ref local_var_str) = tag_id {
16177        local_var_req_builder = match "multi" {
16178            "multi" => local_var_req_builder.query(
16179                &local_var_str
16180                    .into_iter()
16181                    .map(|p| ("tag_id".to_owned(), p.to_string()))
16182                    .collect::<Vec<(std::string::String, std::string::String)>>(),
16183            ),
16184            _ => local_var_req_builder.query(&[(
16185                "tag_id",
16186                &local_var_str
16187                    .into_iter()
16188                    .map(|p| p.to_string())
16189                    .collect::<Vec<String>>()
16190                    .join(",")
16191                    .to_string(),
16192            )]),
16193        };
16194    }
16195    if let Some(ref local_var_str) = tag_id__n {
16196        local_var_req_builder = match "multi" {
16197            "multi" => local_var_req_builder.query(
16198                &local_var_str
16199                    .into_iter()
16200                    .map(|p| ("tag_id__n".to_owned(), p.to_string()))
16201                    .collect::<Vec<(std::string::String, std::string::String)>>(),
16202            ),
16203            _ => local_var_req_builder.query(&[(
16204                "tag_id__n",
16205                &local_var_str
16206                    .into_iter()
16207                    .map(|p| p.to_string())
16208                    .collect::<Vec<String>>()
16209                    .join(",")
16210                    .to_string(),
16211            )]),
16212        };
16213    }
16214    if let Some(ref local_var_str) = tenant {
16215        local_var_req_builder = match "multi" {
16216            "multi" => local_var_req_builder.query(
16217                &local_var_str
16218                    .into_iter()
16219                    .map(|p| ("tenant".to_owned(), p.to_string()))
16220                    .collect::<Vec<(std::string::String, std::string::String)>>(),
16221            ),
16222            _ => local_var_req_builder.query(&[(
16223                "tenant",
16224                &local_var_str
16225                    .into_iter()
16226                    .map(|p| p.to_string())
16227                    .collect::<Vec<String>>()
16228                    .join(",")
16229                    .to_string(),
16230            )]),
16231        };
16232    }
16233    if let Some(ref local_var_str) = tenant__n {
16234        local_var_req_builder = match "multi" {
16235            "multi" => local_var_req_builder.query(
16236                &local_var_str
16237                    .into_iter()
16238                    .map(|p| ("tenant__n".to_owned(), p.to_string()))
16239                    .collect::<Vec<(std::string::String, std::string::String)>>(),
16240            ),
16241            _ => local_var_req_builder.query(&[(
16242                "tenant__n",
16243                &local_var_str
16244                    .into_iter()
16245                    .map(|p| p.to_string())
16246                    .collect::<Vec<String>>()
16247                    .join(",")
16248                    .to_string(),
16249            )]),
16250        };
16251    }
16252    if let Some(ref local_var_str) = tenant_group {
16253        local_var_req_builder = match "multi" {
16254            "multi" => local_var_req_builder.query(
16255                &local_var_str
16256                    .into_iter()
16257                    .map(|p| ("tenant_group".to_owned(), p.to_string()))
16258                    .collect::<Vec<(std::string::String, std::string::String)>>(),
16259            ),
16260            _ => local_var_req_builder.query(&[(
16261                "tenant_group",
16262                &local_var_str
16263                    .into_iter()
16264                    .map(|p| p.to_string())
16265                    .collect::<Vec<String>>()
16266                    .join(",")
16267                    .to_string(),
16268            )]),
16269        };
16270    }
16271    if let Some(ref local_var_str) = tenant_group__n {
16272        local_var_req_builder = match "multi" {
16273            "multi" => local_var_req_builder.query(
16274                &local_var_str
16275                    .into_iter()
16276                    .map(|p| ("tenant_group__n".to_owned(), p.to_string()))
16277                    .collect::<Vec<(std::string::String, std::string::String)>>(),
16278            ),
16279            _ => local_var_req_builder.query(&[(
16280                "tenant_group__n",
16281                &local_var_str
16282                    .into_iter()
16283                    .map(|p| p.to_string())
16284                    .collect::<Vec<String>>()
16285                    .join(",")
16286                    .to_string(),
16287            )]),
16288        };
16289    }
16290    if let Some(ref local_var_str) = tenant_group_id {
16291        local_var_req_builder = match "multi" {
16292            "multi" => local_var_req_builder.query(
16293                &local_var_str
16294                    .into_iter()
16295                    .map(|p| ("tenant_group_id".to_owned(), p.to_string()))
16296                    .collect::<Vec<(std::string::String, std::string::String)>>(),
16297            ),
16298            _ => local_var_req_builder.query(&[(
16299                "tenant_group_id",
16300                &local_var_str
16301                    .into_iter()
16302                    .map(|p| p.to_string())
16303                    .collect::<Vec<String>>()
16304                    .join(",")
16305                    .to_string(),
16306            )]),
16307        };
16308    }
16309    if let Some(ref local_var_str) = tenant_group_id__n {
16310        local_var_req_builder = match "multi" {
16311            "multi" => local_var_req_builder.query(
16312                &local_var_str
16313                    .into_iter()
16314                    .map(|p| ("tenant_group_id__n".to_owned(), p.to_string()))
16315                    .collect::<Vec<(std::string::String, std::string::String)>>(),
16316            ),
16317            _ => local_var_req_builder.query(&[(
16318                "tenant_group_id__n",
16319                &local_var_str
16320                    .into_iter()
16321                    .map(|p| p.to_string())
16322                    .collect::<Vec<String>>()
16323                    .join(",")
16324                    .to_string(),
16325            )]),
16326        };
16327    }
16328    if let Some(ref local_var_str) = tenant_id {
16329        local_var_req_builder = match "multi" {
16330            "multi" => local_var_req_builder.query(
16331                &local_var_str
16332                    .into_iter()
16333                    .map(|p| ("tenant_id".to_owned(), p.to_string()))
16334                    .collect::<Vec<(std::string::String, std::string::String)>>(),
16335            ),
16336            _ => local_var_req_builder.query(&[(
16337                "tenant_id",
16338                &local_var_str
16339                    .into_iter()
16340                    .map(|p| p.to_string())
16341                    .collect::<Vec<String>>()
16342                    .join(",")
16343                    .to_string(),
16344            )]),
16345        };
16346    }
16347    if let Some(ref local_var_str) = tenant_id__n {
16348        local_var_req_builder = match "multi" {
16349            "multi" => local_var_req_builder.query(
16350                &local_var_str
16351                    .into_iter()
16352                    .map(|p| ("tenant_id__n".to_owned(), p.to_string()))
16353                    .collect::<Vec<(std::string::String, std::string::String)>>(),
16354            ),
16355            _ => local_var_req_builder.query(&[(
16356                "tenant_id__n",
16357                &local_var_str
16358                    .into_iter()
16359                    .map(|p| p.to_string())
16360                    .collect::<Vec<String>>()
16361                    .join(",")
16362                    .to_string(),
16363            )]),
16364        };
16365    }
16366    if let Some(ref local_var_str) = r#type {
16367        local_var_req_builder = match "multi" {
16368            "multi" => local_var_req_builder.query(
16369                &local_var_str
16370                    .into_iter()
16371                    .map(|p| ("type".to_owned(), p.to_string()))
16372                    .collect::<Vec<(std::string::String, std::string::String)>>(),
16373            ),
16374            _ => local_var_req_builder.query(&[(
16375                "type",
16376                &local_var_str
16377                    .into_iter()
16378                    .map(|p| p.to_string())
16379                    .collect::<Vec<String>>()
16380                    .join(",")
16381                    .to_string(),
16382            )]),
16383        };
16384    }
16385    if let Some(ref local_var_str) = type__empty {
16386        local_var_req_builder =
16387            local_var_req_builder.query(&[("type__empty", &local_var_str.to_string())]);
16388    }
16389    if let Some(ref local_var_str) = type__ic {
16390        local_var_req_builder = match "multi" {
16391            "multi" => local_var_req_builder.query(
16392                &local_var_str
16393                    .into_iter()
16394                    .map(|p| ("type__ic".to_owned(), p.to_string()))
16395                    .collect::<Vec<(std::string::String, std::string::String)>>(),
16396            ),
16397            _ => local_var_req_builder.query(&[(
16398                "type__ic",
16399                &local_var_str
16400                    .into_iter()
16401                    .map(|p| p.to_string())
16402                    .collect::<Vec<String>>()
16403                    .join(",")
16404                    .to_string(),
16405            )]),
16406        };
16407    }
16408    if let Some(ref local_var_str) = type__ie {
16409        local_var_req_builder = match "multi" {
16410            "multi" => local_var_req_builder.query(
16411                &local_var_str
16412                    .into_iter()
16413                    .map(|p| ("type__ie".to_owned(), p.to_string()))
16414                    .collect::<Vec<(std::string::String, std::string::String)>>(),
16415            ),
16416            _ => local_var_req_builder.query(&[(
16417                "type__ie",
16418                &local_var_str
16419                    .into_iter()
16420                    .map(|p| p.to_string())
16421                    .collect::<Vec<String>>()
16422                    .join(",")
16423                    .to_string(),
16424            )]),
16425        };
16426    }
16427    if let Some(ref local_var_str) = type__iew {
16428        local_var_req_builder = match "multi" {
16429            "multi" => local_var_req_builder.query(
16430                &local_var_str
16431                    .into_iter()
16432                    .map(|p| ("type__iew".to_owned(), p.to_string()))
16433                    .collect::<Vec<(std::string::String, std::string::String)>>(),
16434            ),
16435            _ => local_var_req_builder.query(&[(
16436                "type__iew",
16437                &local_var_str
16438                    .into_iter()
16439                    .map(|p| p.to_string())
16440                    .collect::<Vec<String>>()
16441                    .join(",")
16442                    .to_string(),
16443            )]),
16444        };
16445    }
16446    if let Some(ref local_var_str) = type__iregex {
16447        local_var_req_builder = match "multi" {
16448            "multi" => local_var_req_builder.query(
16449                &local_var_str
16450                    .into_iter()
16451                    .map(|p| ("type__iregex".to_owned(), p.to_string()))
16452                    .collect::<Vec<(std::string::String, std::string::String)>>(),
16453            ),
16454            _ => local_var_req_builder.query(&[(
16455                "type__iregex",
16456                &local_var_str
16457                    .into_iter()
16458                    .map(|p| p.to_string())
16459                    .collect::<Vec<String>>()
16460                    .join(",")
16461                    .to_string(),
16462            )]),
16463        };
16464    }
16465    if let Some(ref local_var_str) = type__isw {
16466        local_var_req_builder = match "multi" {
16467            "multi" => local_var_req_builder.query(
16468                &local_var_str
16469                    .into_iter()
16470                    .map(|p| ("type__isw".to_owned(), p.to_string()))
16471                    .collect::<Vec<(std::string::String, std::string::String)>>(),
16472            ),
16473            _ => local_var_req_builder.query(&[(
16474                "type__isw",
16475                &local_var_str
16476                    .into_iter()
16477                    .map(|p| p.to_string())
16478                    .collect::<Vec<String>>()
16479                    .join(",")
16480                    .to_string(),
16481            )]),
16482        };
16483    }
16484    if let Some(ref local_var_str) = type__n {
16485        local_var_req_builder = match "multi" {
16486            "multi" => local_var_req_builder.query(
16487                &local_var_str
16488                    .into_iter()
16489                    .map(|p| ("type__n".to_owned(), p.to_string()))
16490                    .collect::<Vec<(std::string::String, std::string::String)>>(),
16491            ),
16492            _ => local_var_req_builder.query(&[(
16493                "type__n",
16494                &local_var_str
16495                    .into_iter()
16496                    .map(|p| p.to_string())
16497                    .collect::<Vec<String>>()
16498                    .join(",")
16499                    .to_string(),
16500            )]),
16501        };
16502    }
16503    if let Some(ref local_var_str) = type__nic {
16504        local_var_req_builder = match "multi" {
16505            "multi" => local_var_req_builder.query(
16506                &local_var_str
16507                    .into_iter()
16508                    .map(|p| ("type__nic".to_owned(), p.to_string()))
16509                    .collect::<Vec<(std::string::String, std::string::String)>>(),
16510            ),
16511            _ => local_var_req_builder.query(&[(
16512                "type__nic",
16513                &local_var_str
16514                    .into_iter()
16515                    .map(|p| p.to_string())
16516                    .collect::<Vec<String>>()
16517                    .join(",")
16518                    .to_string(),
16519            )]),
16520        };
16521    }
16522    if let Some(ref local_var_str) = type__nie {
16523        local_var_req_builder = match "multi" {
16524            "multi" => local_var_req_builder.query(
16525                &local_var_str
16526                    .into_iter()
16527                    .map(|p| ("type__nie".to_owned(), p.to_string()))
16528                    .collect::<Vec<(std::string::String, std::string::String)>>(),
16529            ),
16530            _ => local_var_req_builder.query(&[(
16531                "type__nie",
16532                &local_var_str
16533                    .into_iter()
16534                    .map(|p| p.to_string())
16535                    .collect::<Vec<String>>()
16536                    .join(",")
16537                    .to_string(),
16538            )]),
16539        };
16540    }
16541    if let Some(ref local_var_str) = type__niew {
16542        local_var_req_builder = match "multi" {
16543            "multi" => local_var_req_builder.query(
16544                &local_var_str
16545                    .into_iter()
16546                    .map(|p| ("type__niew".to_owned(), p.to_string()))
16547                    .collect::<Vec<(std::string::String, std::string::String)>>(),
16548            ),
16549            _ => local_var_req_builder.query(&[(
16550                "type__niew",
16551                &local_var_str
16552                    .into_iter()
16553                    .map(|p| p.to_string())
16554                    .collect::<Vec<String>>()
16555                    .join(",")
16556                    .to_string(),
16557            )]),
16558        };
16559    }
16560    if let Some(ref local_var_str) = type__nisw {
16561        local_var_req_builder = match "multi" {
16562            "multi" => local_var_req_builder.query(
16563                &local_var_str
16564                    .into_iter()
16565                    .map(|p| ("type__nisw".to_owned(), p.to_string()))
16566                    .collect::<Vec<(std::string::String, std::string::String)>>(),
16567            ),
16568            _ => local_var_req_builder.query(&[(
16569                "type__nisw",
16570                &local_var_str
16571                    .into_iter()
16572                    .map(|p| p.to_string())
16573                    .collect::<Vec<String>>()
16574                    .join(",")
16575                    .to_string(),
16576            )]),
16577        };
16578    }
16579    if let Some(ref local_var_str) = type__regex {
16580        local_var_req_builder = match "multi" {
16581            "multi" => local_var_req_builder.query(
16582                &local_var_str
16583                    .into_iter()
16584                    .map(|p| ("type__regex".to_owned(), p.to_string()))
16585                    .collect::<Vec<(std::string::String, std::string::String)>>(),
16586            ),
16587            _ => local_var_req_builder.query(&[(
16588                "type__regex",
16589                &local_var_str
16590                    .into_iter()
16591                    .map(|p| p.to_string())
16592                    .collect::<Vec<String>>()
16593                    .join(",")
16594                    .to_string(),
16595            )]),
16596        };
16597    }
16598    if let Some(ref local_var_str) = updated_by_request {
16599        local_var_req_builder =
16600            local_var_req_builder.query(&[("updated_by_request", &local_var_str.to_string())]);
16601    }
16602    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
16603        local_var_req_builder =
16604            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
16605    }
16606    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
16607        let local_var_key = local_var_apikey.key.clone();
16608        let local_var_value = match local_var_apikey.prefix {
16609            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
16610            None => local_var_key,
16611        };
16612        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
16613    };
16614
16615    let local_var_req = local_var_req_builder.build()?;
16616    let local_var_resp = local_var_client.execute(local_var_req).await?;
16617
16618    let local_var_status = local_var_resp.status();
16619    let local_var_content = local_var_resp.text().await?;
16620
16621    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
16622        serde_json::from_str(&local_var_content).map_err(Error::from)
16623    } else {
16624        let local_var_entity: Option<VpnL2vpnsListError> =
16625            serde_json::from_str(&local_var_content).ok();
16626        let local_var_error = ResponseContent {
16627            status: local_var_status,
16628            content: local_var_content,
16629            entity: local_var_entity,
16630        };
16631        Err(Error::ResponseError(local_var_error))
16632    }
16633}
16634
16635/// Patch a L2VPN object.
16636pub async fn vpn_l2vpns_partial_update(
16637    configuration: &configuration::Configuration,
16638    id: i32,
16639    patched_writable_l2_vpn_request: Option<crate::models::PatchedWritableL2VpnRequest>,
16640) -> Result<crate::models::L2Vpn, Error<VpnL2vpnsPartialUpdateError>> {
16641    let local_var_configuration = configuration;
16642
16643    let local_var_client = &local_var_configuration.client;
16644
16645    let local_var_uri_str = format!(
16646        "{}/api/vpn/l2vpns/{id}/",
16647        local_var_configuration.base_path,
16648        id = id
16649    );
16650    let mut local_var_req_builder =
16651        local_var_client.request(reqwest::Method::PATCH, local_var_uri_str.as_str());
16652
16653    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
16654        local_var_req_builder =
16655            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
16656    }
16657    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
16658        let local_var_key = local_var_apikey.key.clone();
16659        let local_var_value = match local_var_apikey.prefix {
16660            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
16661            None => local_var_key,
16662        };
16663        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
16664    };
16665    local_var_req_builder = local_var_req_builder.json(&patched_writable_l2_vpn_request);
16666
16667    let local_var_req = local_var_req_builder.build()?;
16668    let local_var_resp = local_var_client.execute(local_var_req).await?;
16669
16670    let local_var_status = local_var_resp.status();
16671    let local_var_content = local_var_resp.text().await?;
16672
16673    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
16674        serde_json::from_str(&local_var_content).map_err(Error::from)
16675    } else {
16676        let local_var_entity: Option<VpnL2vpnsPartialUpdateError> =
16677            serde_json::from_str(&local_var_content).ok();
16678        let local_var_error = ResponseContent {
16679            status: local_var_status,
16680            content: local_var_content,
16681            entity: local_var_entity,
16682        };
16683        Err(Error::ResponseError(local_var_error))
16684    }
16685}
16686
16687/// Get a L2VPN object.
16688pub async fn vpn_l2vpns_retrieve(
16689    configuration: &configuration::Configuration,
16690    id: i32,
16691) -> Result<crate::models::L2Vpn, Error<VpnL2vpnsRetrieveError>> {
16692    let local_var_configuration = configuration;
16693
16694    let local_var_client = &local_var_configuration.client;
16695
16696    let local_var_uri_str = format!(
16697        "{}/api/vpn/l2vpns/{id}/",
16698        local_var_configuration.base_path,
16699        id = id
16700    );
16701    let mut local_var_req_builder =
16702        local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
16703
16704    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
16705        local_var_req_builder =
16706            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
16707    }
16708    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
16709        let local_var_key = local_var_apikey.key.clone();
16710        let local_var_value = match local_var_apikey.prefix {
16711            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
16712            None => local_var_key,
16713        };
16714        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
16715    };
16716
16717    let local_var_req = local_var_req_builder.build()?;
16718    let local_var_resp = local_var_client.execute(local_var_req).await?;
16719
16720    let local_var_status = local_var_resp.status();
16721    let local_var_content = local_var_resp.text().await?;
16722
16723    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
16724        serde_json::from_str(&local_var_content).map_err(Error::from)
16725    } else {
16726        let local_var_entity: Option<VpnL2vpnsRetrieveError> =
16727            serde_json::from_str(&local_var_content).ok();
16728        let local_var_error = ResponseContent {
16729            status: local_var_status,
16730            content: local_var_content,
16731            entity: local_var_entity,
16732        };
16733        Err(Error::ResponseError(local_var_error))
16734    }
16735}
16736
16737/// Put a L2VPN object.
16738pub async fn vpn_l2vpns_update(
16739    configuration: &configuration::Configuration,
16740    id: i32,
16741    writable_l2_vpn_request: crate::models::WritableL2VpnRequest,
16742) -> Result<crate::models::L2Vpn, Error<VpnL2vpnsUpdateError>> {
16743    let local_var_configuration = configuration;
16744
16745    let local_var_client = &local_var_configuration.client;
16746
16747    let local_var_uri_str = format!(
16748        "{}/api/vpn/l2vpns/{id}/",
16749        local_var_configuration.base_path,
16750        id = id
16751    );
16752    let mut local_var_req_builder =
16753        local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());
16754
16755    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
16756        local_var_req_builder =
16757            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
16758    }
16759    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
16760        let local_var_key = local_var_apikey.key.clone();
16761        let local_var_value = match local_var_apikey.prefix {
16762            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
16763            None => local_var_key,
16764        };
16765        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
16766    };
16767    local_var_req_builder = local_var_req_builder.json(&writable_l2_vpn_request);
16768
16769    let local_var_req = local_var_req_builder.build()?;
16770    let local_var_resp = local_var_client.execute(local_var_req).await?;
16771
16772    let local_var_status = local_var_resp.status();
16773    let local_var_content = local_var_resp.text().await?;
16774
16775    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
16776        serde_json::from_str(&local_var_content).map_err(Error::from)
16777    } else {
16778        let local_var_entity: Option<VpnL2vpnsUpdateError> =
16779            serde_json::from_str(&local_var_content).ok();
16780        let local_var_error = ResponseContent {
16781            status: local_var_status,
16782            content: local_var_content,
16783            entity: local_var_entity,
16784        };
16785        Err(Error::ResponseError(local_var_error))
16786    }
16787}
16788
16789/// Delete a list of tunnel group objects.
16790pub async fn vpn_tunnel_groups_bulk_destroy(
16791    configuration: &configuration::Configuration,
16792    tunnel_group_request: Vec<crate::models::TunnelGroupRequest>,
16793) -> Result<(), Error<VpnTunnelGroupsBulkDestroyError>> {
16794    let local_var_configuration = configuration;
16795
16796    let local_var_client = &local_var_configuration.client;
16797
16798    let local_var_uri_str = format!(
16799        "{}/api/vpn/tunnel-groups/",
16800        local_var_configuration.base_path
16801    );
16802    let mut local_var_req_builder =
16803        local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());
16804
16805    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
16806        local_var_req_builder =
16807            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
16808    }
16809    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
16810        let local_var_key = local_var_apikey.key.clone();
16811        let local_var_value = match local_var_apikey.prefix {
16812            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
16813            None => local_var_key,
16814        };
16815        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
16816    };
16817    local_var_req_builder = local_var_req_builder.json(&tunnel_group_request);
16818
16819    let local_var_req = local_var_req_builder.build()?;
16820    let local_var_resp = local_var_client.execute(local_var_req).await?;
16821
16822    let local_var_status = local_var_resp.status();
16823    let local_var_content = local_var_resp.text().await?;
16824
16825    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
16826        Ok(())
16827    } else {
16828        let local_var_entity: Option<VpnTunnelGroupsBulkDestroyError> =
16829            serde_json::from_str(&local_var_content).ok();
16830        let local_var_error = ResponseContent {
16831            status: local_var_status,
16832            content: local_var_content,
16833            entity: local_var_entity,
16834        };
16835        Err(Error::ResponseError(local_var_error))
16836    }
16837}
16838
16839/// Patch a list of tunnel group objects.
16840pub async fn vpn_tunnel_groups_bulk_partial_update(
16841    configuration: &configuration::Configuration,
16842    tunnel_group_request: Vec<crate::models::TunnelGroupRequest>,
16843) -> Result<Vec<crate::models::TunnelGroup>, Error<VpnTunnelGroupsBulkPartialUpdateError>> {
16844    let local_var_configuration = configuration;
16845
16846    let local_var_client = &local_var_configuration.client;
16847
16848    let local_var_uri_str = format!(
16849        "{}/api/vpn/tunnel-groups/",
16850        local_var_configuration.base_path
16851    );
16852    let mut local_var_req_builder =
16853        local_var_client.request(reqwest::Method::PATCH, local_var_uri_str.as_str());
16854
16855    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
16856        local_var_req_builder =
16857            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
16858    }
16859    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
16860        let local_var_key = local_var_apikey.key.clone();
16861        let local_var_value = match local_var_apikey.prefix {
16862            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
16863            None => local_var_key,
16864        };
16865        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
16866    };
16867    local_var_req_builder = local_var_req_builder.json(&tunnel_group_request);
16868
16869    let local_var_req = local_var_req_builder.build()?;
16870    let local_var_resp = local_var_client.execute(local_var_req).await?;
16871
16872    let local_var_status = local_var_resp.status();
16873    let local_var_content = local_var_resp.text().await?;
16874
16875    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
16876        serde_json::from_str(&local_var_content).map_err(Error::from)
16877    } else {
16878        let local_var_entity: Option<VpnTunnelGroupsBulkPartialUpdateError> =
16879            serde_json::from_str(&local_var_content).ok();
16880        let local_var_error = ResponseContent {
16881            status: local_var_status,
16882            content: local_var_content,
16883            entity: local_var_entity,
16884        };
16885        Err(Error::ResponseError(local_var_error))
16886    }
16887}
16888
16889/// Put a list of tunnel group objects.
16890pub async fn vpn_tunnel_groups_bulk_update(
16891    configuration: &configuration::Configuration,
16892    tunnel_group_request: Vec<crate::models::TunnelGroupRequest>,
16893) -> Result<Vec<crate::models::TunnelGroup>, Error<VpnTunnelGroupsBulkUpdateError>> {
16894    let local_var_configuration = configuration;
16895
16896    let local_var_client = &local_var_configuration.client;
16897
16898    let local_var_uri_str = format!(
16899        "{}/api/vpn/tunnel-groups/",
16900        local_var_configuration.base_path
16901    );
16902    let mut local_var_req_builder =
16903        local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());
16904
16905    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
16906        local_var_req_builder =
16907            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
16908    }
16909    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
16910        let local_var_key = local_var_apikey.key.clone();
16911        let local_var_value = match local_var_apikey.prefix {
16912            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
16913            None => local_var_key,
16914        };
16915        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
16916    };
16917    local_var_req_builder = local_var_req_builder.json(&tunnel_group_request);
16918
16919    let local_var_req = local_var_req_builder.build()?;
16920    let local_var_resp = local_var_client.execute(local_var_req).await?;
16921
16922    let local_var_status = local_var_resp.status();
16923    let local_var_content = local_var_resp.text().await?;
16924
16925    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
16926        serde_json::from_str(&local_var_content).map_err(Error::from)
16927    } else {
16928        let local_var_entity: Option<VpnTunnelGroupsBulkUpdateError> =
16929            serde_json::from_str(&local_var_content).ok();
16930        let local_var_error = ResponseContent {
16931            status: local_var_status,
16932            content: local_var_content,
16933            entity: local_var_entity,
16934        };
16935        Err(Error::ResponseError(local_var_error))
16936    }
16937}
16938
16939/// Post a list of tunnel group objects.
16940pub async fn vpn_tunnel_groups_create(
16941    configuration: &configuration::Configuration,
16942    vpn_tunnel_groups_create_request: crate::models::VpnTunnelGroupsCreateRequest,
16943) -> Result<crate::models::TunnelGroup, Error<VpnTunnelGroupsCreateError>> {
16944    let local_var_configuration = configuration;
16945
16946    let local_var_client = &local_var_configuration.client;
16947
16948    let local_var_uri_str = format!(
16949        "{}/api/vpn/tunnel-groups/",
16950        local_var_configuration.base_path
16951    );
16952    let mut local_var_req_builder =
16953        local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
16954
16955    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
16956        local_var_req_builder =
16957            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
16958    }
16959    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
16960        let local_var_key = local_var_apikey.key.clone();
16961        let local_var_value = match local_var_apikey.prefix {
16962            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
16963            None => local_var_key,
16964        };
16965        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
16966    };
16967    local_var_req_builder = local_var_req_builder.json(&vpn_tunnel_groups_create_request);
16968
16969    let local_var_req = local_var_req_builder.build()?;
16970    let local_var_resp = local_var_client.execute(local_var_req).await?;
16971
16972    let local_var_status = local_var_resp.status();
16973    let local_var_content = local_var_resp.text().await?;
16974
16975    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
16976        serde_json::from_str(&local_var_content).map_err(Error::from)
16977    } else {
16978        let local_var_entity: Option<VpnTunnelGroupsCreateError> =
16979            serde_json::from_str(&local_var_content).ok();
16980        let local_var_error = ResponseContent {
16981            status: local_var_status,
16982            content: local_var_content,
16983            entity: local_var_entity,
16984        };
16985        Err(Error::ResponseError(local_var_error))
16986    }
16987}
16988
16989/// Delete a tunnel group object.
16990pub async fn vpn_tunnel_groups_destroy(
16991    configuration: &configuration::Configuration,
16992    id: i32,
16993) -> Result<(), Error<VpnTunnelGroupsDestroyError>> {
16994    let local_var_configuration = configuration;
16995
16996    let local_var_client = &local_var_configuration.client;
16997
16998    let local_var_uri_str = format!(
16999        "{}/api/vpn/tunnel-groups/{id}/",
17000        local_var_configuration.base_path,
17001        id = id
17002    );
17003    let mut local_var_req_builder =
17004        local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());
17005
17006    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
17007        local_var_req_builder =
17008            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
17009    }
17010    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
17011        let local_var_key = local_var_apikey.key.clone();
17012        let local_var_value = match local_var_apikey.prefix {
17013            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
17014            None => local_var_key,
17015        };
17016        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
17017    };
17018
17019    let local_var_req = local_var_req_builder.build()?;
17020    let local_var_resp = local_var_client.execute(local_var_req).await?;
17021
17022    let local_var_status = local_var_resp.status();
17023    let local_var_content = local_var_resp.text().await?;
17024
17025    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
17026        Ok(())
17027    } else {
17028        let local_var_entity: Option<VpnTunnelGroupsDestroyError> =
17029            serde_json::from_str(&local_var_content).ok();
17030        let local_var_error = ResponseContent {
17031            status: local_var_status,
17032            content: local_var_content,
17033            entity: local_var_entity,
17034        };
17035        Err(Error::ResponseError(local_var_error))
17036    }
17037}
17038
17039/// Get a list of tunnel group objects.
17040pub async fn vpn_tunnel_groups_list(
17041    configuration: &configuration::Configuration,
17042    contact: Option<Vec<i32>>,
17043    contact__n: Option<Vec<i32>>,
17044    contact_group: Option<Vec<String>>,
17045    contact_group__n: Option<Vec<String>>,
17046    contact_role: Option<Vec<i32>>,
17047    contact_role__n: Option<Vec<i32>>,
17048    created: Option<Vec<String>>,
17049    created__empty: Option<Vec<String>>,
17050    created__gt: Option<Vec<String>>,
17051    created__gte: Option<Vec<String>>,
17052    created__lt: Option<Vec<String>>,
17053    created__lte: Option<Vec<String>>,
17054    created__n: Option<Vec<String>>,
17055    created_by_request: Option<&str>,
17056    description: Option<Vec<String>>,
17057    description__empty: Option<bool>,
17058    description__ic: Option<Vec<String>>,
17059    description__ie: Option<Vec<String>>,
17060    description__iew: Option<Vec<String>>,
17061    description__iregex: Option<Vec<String>>,
17062    description__isw: Option<Vec<String>>,
17063    description__n: Option<Vec<String>>,
17064    description__nic: Option<Vec<String>>,
17065    description__nie: Option<Vec<String>>,
17066    description__niew: Option<Vec<String>>,
17067    description__nisw: Option<Vec<String>>,
17068    description__regex: Option<Vec<String>>,
17069    id: Option<Vec<i32>>,
17070    id__empty: Option<bool>,
17071    id__gt: Option<Vec<i32>>,
17072    id__gte: Option<Vec<i32>>,
17073    id__lt: Option<Vec<i32>>,
17074    id__lte: Option<Vec<i32>>,
17075    id__n: Option<Vec<i32>>,
17076    last_updated: Option<Vec<String>>,
17077    last_updated__empty: Option<Vec<String>>,
17078    last_updated__gt: Option<Vec<String>>,
17079    last_updated__gte: Option<Vec<String>>,
17080    last_updated__lt: Option<Vec<String>>,
17081    last_updated__lte: Option<Vec<String>>,
17082    last_updated__n: Option<Vec<String>>,
17083    limit: Option<i32>,
17084    modified_by_request: Option<&str>,
17085    name: Option<Vec<String>>,
17086    name__empty: Option<bool>,
17087    name__ic: Option<Vec<String>>,
17088    name__ie: Option<Vec<String>>,
17089    name__iew: Option<Vec<String>>,
17090    name__iregex: Option<Vec<String>>,
17091    name__isw: Option<Vec<String>>,
17092    name__n: Option<Vec<String>>,
17093    name__nic: Option<Vec<String>>,
17094    name__nie: Option<Vec<String>>,
17095    name__niew: Option<Vec<String>>,
17096    name__nisw: Option<Vec<String>>,
17097    name__regex: Option<Vec<String>>,
17098    offset: Option<i32>,
17099    ordering: Option<&str>,
17100    owner: Option<Vec<String>>,
17101    owner__n: Option<Vec<String>>,
17102    owner_group: Option<Vec<String>>,
17103    owner_group__n: Option<Vec<String>>,
17104    owner_group_id: Option<Vec<i32>>,
17105    owner_group_id__n: Option<Vec<i32>>,
17106    owner_id: Option<Vec<i32>>,
17107    owner_id__n: Option<Vec<i32>>,
17108    q: Option<&str>,
17109    slug: Option<Vec<String>>,
17110    slug__empty: Option<bool>,
17111    slug__ic: Option<Vec<String>>,
17112    slug__ie: Option<Vec<String>>,
17113    slug__iew: Option<Vec<String>>,
17114    slug__iregex: Option<Vec<String>>,
17115    slug__isw: Option<Vec<String>>,
17116    slug__n: Option<Vec<String>>,
17117    slug__nic: Option<Vec<String>>,
17118    slug__nie: Option<Vec<String>>,
17119    slug__niew: Option<Vec<String>>,
17120    slug__nisw: Option<Vec<String>>,
17121    slug__regex: Option<Vec<String>>,
17122    tag: Option<Vec<String>>,
17123    tag__n: Option<Vec<String>>,
17124    tag_id: Option<Vec<i32>>,
17125    tag_id__n: Option<Vec<i32>>,
17126    updated_by_request: Option<&str>,
17127) -> Result<crate::models::PaginatedTunnelGroupList, Error<VpnTunnelGroupsListError>> {
17128    let local_var_configuration = configuration;
17129
17130    let local_var_client = &local_var_configuration.client;
17131
17132    let local_var_uri_str = format!(
17133        "{}/api/vpn/tunnel-groups/",
17134        local_var_configuration.base_path
17135    );
17136    let mut local_var_req_builder =
17137        local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
17138
17139    if let Some(ref local_var_str) = contact {
17140        local_var_req_builder = match "multi" {
17141            "multi" => local_var_req_builder.query(
17142                &local_var_str
17143                    .into_iter()
17144                    .map(|p| ("contact".to_owned(), p.to_string()))
17145                    .collect::<Vec<(std::string::String, std::string::String)>>(),
17146            ),
17147            _ => local_var_req_builder.query(&[(
17148                "contact",
17149                &local_var_str
17150                    .into_iter()
17151                    .map(|p| p.to_string())
17152                    .collect::<Vec<String>>()
17153                    .join(",")
17154                    .to_string(),
17155            )]),
17156        };
17157    }
17158    if let Some(ref local_var_str) = contact__n {
17159        local_var_req_builder = match "multi" {
17160            "multi" => local_var_req_builder.query(
17161                &local_var_str
17162                    .into_iter()
17163                    .map(|p| ("contact__n".to_owned(), p.to_string()))
17164                    .collect::<Vec<(std::string::String, std::string::String)>>(),
17165            ),
17166            _ => local_var_req_builder.query(&[(
17167                "contact__n",
17168                &local_var_str
17169                    .into_iter()
17170                    .map(|p| p.to_string())
17171                    .collect::<Vec<String>>()
17172                    .join(",")
17173                    .to_string(),
17174            )]),
17175        };
17176    }
17177    if let Some(ref local_var_str) = contact_group {
17178        local_var_req_builder = match "multi" {
17179            "multi" => local_var_req_builder.query(
17180                &local_var_str
17181                    .into_iter()
17182                    .map(|p| ("contact_group".to_owned(), p.to_string()))
17183                    .collect::<Vec<(std::string::String, std::string::String)>>(),
17184            ),
17185            _ => local_var_req_builder.query(&[(
17186                "contact_group",
17187                &local_var_str
17188                    .into_iter()
17189                    .map(|p| p.to_string())
17190                    .collect::<Vec<String>>()
17191                    .join(",")
17192                    .to_string(),
17193            )]),
17194        };
17195    }
17196    if let Some(ref local_var_str) = contact_group__n {
17197        local_var_req_builder = match "multi" {
17198            "multi" => local_var_req_builder.query(
17199                &local_var_str
17200                    .into_iter()
17201                    .map(|p| ("contact_group__n".to_owned(), p.to_string()))
17202                    .collect::<Vec<(std::string::String, std::string::String)>>(),
17203            ),
17204            _ => local_var_req_builder.query(&[(
17205                "contact_group__n",
17206                &local_var_str
17207                    .into_iter()
17208                    .map(|p| p.to_string())
17209                    .collect::<Vec<String>>()
17210                    .join(",")
17211                    .to_string(),
17212            )]),
17213        };
17214    }
17215    if let Some(ref local_var_str) = contact_role {
17216        local_var_req_builder = match "multi" {
17217            "multi" => local_var_req_builder.query(
17218                &local_var_str
17219                    .into_iter()
17220                    .map(|p| ("contact_role".to_owned(), p.to_string()))
17221                    .collect::<Vec<(std::string::String, std::string::String)>>(),
17222            ),
17223            _ => local_var_req_builder.query(&[(
17224                "contact_role",
17225                &local_var_str
17226                    .into_iter()
17227                    .map(|p| p.to_string())
17228                    .collect::<Vec<String>>()
17229                    .join(",")
17230                    .to_string(),
17231            )]),
17232        };
17233    }
17234    if let Some(ref local_var_str) = contact_role__n {
17235        local_var_req_builder = match "multi" {
17236            "multi" => local_var_req_builder.query(
17237                &local_var_str
17238                    .into_iter()
17239                    .map(|p| ("contact_role__n".to_owned(), p.to_string()))
17240                    .collect::<Vec<(std::string::String, std::string::String)>>(),
17241            ),
17242            _ => local_var_req_builder.query(&[(
17243                "contact_role__n",
17244                &local_var_str
17245                    .into_iter()
17246                    .map(|p| p.to_string())
17247                    .collect::<Vec<String>>()
17248                    .join(",")
17249                    .to_string(),
17250            )]),
17251        };
17252    }
17253    if let Some(ref local_var_str) = created {
17254        local_var_req_builder = match "multi" {
17255            "multi" => local_var_req_builder.query(
17256                &local_var_str
17257                    .into_iter()
17258                    .map(|p| ("created".to_owned(), p.to_string()))
17259                    .collect::<Vec<(std::string::String, std::string::String)>>(),
17260            ),
17261            _ => local_var_req_builder.query(&[(
17262                "created",
17263                &local_var_str
17264                    .into_iter()
17265                    .map(|p| p.to_string())
17266                    .collect::<Vec<String>>()
17267                    .join(",")
17268                    .to_string(),
17269            )]),
17270        };
17271    }
17272    if let Some(ref local_var_str) = created__empty {
17273        local_var_req_builder = match "multi" {
17274            "multi" => local_var_req_builder.query(
17275                &local_var_str
17276                    .into_iter()
17277                    .map(|p| ("created__empty".to_owned(), p.to_string()))
17278                    .collect::<Vec<(std::string::String, std::string::String)>>(),
17279            ),
17280            _ => local_var_req_builder.query(&[(
17281                "created__empty",
17282                &local_var_str
17283                    .into_iter()
17284                    .map(|p| p.to_string())
17285                    .collect::<Vec<String>>()
17286                    .join(",")
17287                    .to_string(),
17288            )]),
17289        };
17290    }
17291    if let Some(ref local_var_str) = created__gt {
17292        local_var_req_builder = match "multi" {
17293            "multi" => local_var_req_builder.query(
17294                &local_var_str
17295                    .into_iter()
17296                    .map(|p| ("created__gt".to_owned(), p.to_string()))
17297                    .collect::<Vec<(std::string::String, std::string::String)>>(),
17298            ),
17299            _ => local_var_req_builder.query(&[(
17300                "created__gt",
17301                &local_var_str
17302                    .into_iter()
17303                    .map(|p| p.to_string())
17304                    .collect::<Vec<String>>()
17305                    .join(",")
17306                    .to_string(),
17307            )]),
17308        };
17309    }
17310    if let Some(ref local_var_str) = created__gte {
17311        local_var_req_builder = match "multi" {
17312            "multi" => local_var_req_builder.query(
17313                &local_var_str
17314                    .into_iter()
17315                    .map(|p| ("created__gte".to_owned(), p.to_string()))
17316                    .collect::<Vec<(std::string::String, std::string::String)>>(),
17317            ),
17318            _ => local_var_req_builder.query(&[(
17319                "created__gte",
17320                &local_var_str
17321                    .into_iter()
17322                    .map(|p| p.to_string())
17323                    .collect::<Vec<String>>()
17324                    .join(",")
17325                    .to_string(),
17326            )]),
17327        };
17328    }
17329    if let Some(ref local_var_str) = created__lt {
17330        local_var_req_builder = match "multi" {
17331            "multi" => local_var_req_builder.query(
17332                &local_var_str
17333                    .into_iter()
17334                    .map(|p| ("created__lt".to_owned(), p.to_string()))
17335                    .collect::<Vec<(std::string::String, std::string::String)>>(),
17336            ),
17337            _ => local_var_req_builder.query(&[(
17338                "created__lt",
17339                &local_var_str
17340                    .into_iter()
17341                    .map(|p| p.to_string())
17342                    .collect::<Vec<String>>()
17343                    .join(",")
17344                    .to_string(),
17345            )]),
17346        };
17347    }
17348    if let Some(ref local_var_str) = created__lte {
17349        local_var_req_builder = match "multi" {
17350            "multi" => local_var_req_builder.query(
17351                &local_var_str
17352                    .into_iter()
17353                    .map(|p| ("created__lte".to_owned(), p.to_string()))
17354                    .collect::<Vec<(std::string::String, std::string::String)>>(),
17355            ),
17356            _ => local_var_req_builder.query(&[(
17357                "created__lte",
17358                &local_var_str
17359                    .into_iter()
17360                    .map(|p| p.to_string())
17361                    .collect::<Vec<String>>()
17362                    .join(",")
17363                    .to_string(),
17364            )]),
17365        };
17366    }
17367    if let Some(ref local_var_str) = created__n {
17368        local_var_req_builder = match "multi" {
17369            "multi" => local_var_req_builder.query(
17370                &local_var_str
17371                    .into_iter()
17372                    .map(|p| ("created__n".to_owned(), p.to_string()))
17373                    .collect::<Vec<(std::string::String, std::string::String)>>(),
17374            ),
17375            _ => local_var_req_builder.query(&[(
17376                "created__n",
17377                &local_var_str
17378                    .into_iter()
17379                    .map(|p| p.to_string())
17380                    .collect::<Vec<String>>()
17381                    .join(",")
17382                    .to_string(),
17383            )]),
17384        };
17385    }
17386    if let Some(ref local_var_str) = created_by_request {
17387        local_var_req_builder =
17388            local_var_req_builder.query(&[("created_by_request", &local_var_str.to_string())]);
17389    }
17390    if let Some(ref local_var_str) = description {
17391        local_var_req_builder = match "multi" {
17392            "multi" => local_var_req_builder.query(
17393                &local_var_str
17394                    .into_iter()
17395                    .map(|p| ("description".to_owned(), p.to_string()))
17396                    .collect::<Vec<(std::string::String, std::string::String)>>(),
17397            ),
17398            _ => local_var_req_builder.query(&[(
17399                "description",
17400                &local_var_str
17401                    .into_iter()
17402                    .map(|p| p.to_string())
17403                    .collect::<Vec<String>>()
17404                    .join(",")
17405                    .to_string(),
17406            )]),
17407        };
17408    }
17409    if let Some(ref local_var_str) = description__empty {
17410        local_var_req_builder =
17411            local_var_req_builder.query(&[("description__empty", &local_var_str.to_string())]);
17412    }
17413    if let Some(ref local_var_str) = description__ic {
17414        local_var_req_builder = match "multi" {
17415            "multi" => local_var_req_builder.query(
17416                &local_var_str
17417                    .into_iter()
17418                    .map(|p| ("description__ic".to_owned(), p.to_string()))
17419                    .collect::<Vec<(std::string::String, std::string::String)>>(),
17420            ),
17421            _ => local_var_req_builder.query(&[(
17422                "description__ic",
17423                &local_var_str
17424                    .into_iter()
17425                    .map(|p| p.to_string())
17426                    .collect::<Vec<String>>()
17427                    .join(",")
17428                    .to_string(),
17429            )]),
17430        };
17431    }
17432    if let Some(ref local_var_str) = description__ie {
17433        local_var_req_builder = match "multi" {
17434            "multi" => local_var_req_builder.query(
17435                &local_var_str
17436                    .into_iter()
17437                    .map(|p| ("description__ie".to_owned(), p.to_string()))
17438                    .collect::<Vec<(std::string::String, std::string::String)>>(),
17439            ),
17440            _ => local_var_req_builder.query(&[(
17441                "description__ie",
17442                &local_var_str
17443                    .into_iter()
17444                    .map(|p| p.to_string())
17445                    .collect::<Vec<String>>()
17446                    .join(",")
17447                    .to_string(),
17448            )]),
17449        };
17450    }
17451    if let Some(ref local_var_str) = description__iew {
17452        local_var_req_builder = match "multi" {
17453            "multi" => local_var_req_builder.query(
17454                &local_var_str
17455                    .into_iter()
17456                    .map(|p| ("description__iew".to_owned(), p.to_string()))
17457                    .collect::<Vec<(std::string::String, std::string::String)>>(),
17458            ),
17459            _ => local_var_req_builder.query(&[(
17460                "description__iew",
17461                &local_var_str
17462                    .into_iter()
17463                    .map(|p| p.to_string())
17464                    .collect::<Vec<String>>()
17465                    .join(",")
17466                    .to_string(),
17467            )]),
17468        };
17469    }
17470    if let Some(ref local_var_str) = description__iregex {
17471        local_var_req_builder = match "multi" {
17472            "multi" => local_var_req_builder.query(
17473                &local_var_str
17474                    .into_iter()
17475                    .map(|p| ("description__iregex".to_owned(), p.to_string()))
17476                    .collect::<Vec<(std::string::String, std::string::String)>>(),
17477            ),
17478            _ => local_var_req_builder.query(&[(
17479                "description__iregex",
17480                &local_var_str
17481                    .into_iter()
17482                    .map(|p| p.to_string())
17483                    .collect::<Vec<String>>()
17484                    .join(",")
17485                    .to_string(),
17486            )]),
17487        };
17488    }
17489    if let Some(ref local_var_str) = description__isw {
17490        local_var_req_builder = match "multi" {
17491            "multi" => local_var_req_builder.query(
17492                &local_var_str
17493                    .into_iter()
17494                    .map(|p| ("description__isw".to_owned(), p.to_string()))
17495                    .collect::<Vec<(std::string::String, std::string::String)>>(),
17496            ),
17497            _ => local_var_req_builder.query(&[(
17498                "description__isw",
17499                &local_var_str
17500                    .into_iter()
17501                    .map(|p| p.to_string())
17502                    .collect::<Vec<String>>()
17503                    .join(",")
17504                    .to_string(),
17505            )]),
17506        };
17507    }
17508    if let Some(ref local_var_str) = description__n {
17509        local_var_req_builder = match "multi" {
17510            "multi" => local_var_req_builder.query(
17511                &local_var_str
17512                    .into_iter()
17513                    .map(|p| ("description__n".to_owned(), p.to_string()))
17514                    .collect::<Vec<(std::string::String, std::string::String)>>(),
17515            ),
17516            _ => local_var_req_builder.query(&[(
17517                "description__n",
17518                &local_var_str
17519                    .into_iter()
17520                    .map(|p| p.to_string())
17521                    .collect::<Vec<String>>()
17522                    .join(",")
17523                    .to_string(),
17524            )]),
17525        };
17526    }
17527    if let Some(ref local_var_str) = description__nic {
17528        local_var_req_builder = match "multi" {
17529            "multi" => local_var_req_builder.query(
17530                &local_var_str
17531                    .into_iter()
17532                    .map(|p| ("description__nic".to_owned(), p.to_string()))
17533                    .collect::<Vec<(std::string::String, std::string::String)>>(),
17534            ),
17535            _ => local_var_req_builder.query(&[(
17536                "description__nic",
17537                &local_var_str
17538                    .into_iter()
17539                    .map(|p| p.to_string())
17540                    .collect::<Vec<String>>()
17541                    .join(",")
17542                    .to_string(),
17543            )]),
17544        };
17545    }
17546    if let Some(ref local_var_str) = description__nie {
17547        local_var_req_builder = match "multi" {
17548            "multi" => local_var_req_builder.query(
17549                &local_var_str
17550                    .into_iter()
17551                    .map(|p| ("description__nie".to_owned(), p.to_string()))
17552                    .collect::<Vec<(std::string::String, std::string::String)>>(),
17553            ),
17554            _ => local_var_req_builder.query(&[(
17555                "description__nie",
17556                &local_var_str
17557                    .into_iter()
17558                    .map(|p| p.to_string())
17559                    .collect::<Vec<String>>()
17560                    .join(",")
17561                    .to_string(),
17562            )]),
17563        };
17564    }
17565    if let Some(ref local_var_str) = description__niew {
17566        local_var_req_builder = match "multi" {
17567            "multi" => local_var_req_builder.query(
17568                &local_var_str
17569                    .into_iter()
17570                    .map(|p| ("description__niew".to_owned(), p.to_string()))
17571                    .collect::<Vec<(std::string::String, std::string::String)>>(),
17572            ),
17573            _ => local_var_req_builder.query(&[(
17574                "description__niew",
17575                &local_var_str
17576                    .into_iter()
17577                    .map(|p| p.to_string())
17578                    .collect::<Vec<String>>()
17579                    .join(",")
17580                    .to_string(),
17581            )]),
17582        };
17583    }
17584    if let Some(ref local_var_str) = description__nisw {
17585        local_var_req_builder = match "multi" {
17586            "multi" => local_var_req_builder.query(
17587                &local_var_str
17588                    .into_iter()
17589                    .map(|p| ("description__nisw".to_owned(), p.to_string()))
17590                    .collect::<Vec<(std::string::String, std::string::String)>>(),
17591            ),
17592            _ => local_var_req_builder.query(&[(
17593                "description__nisw",
17594                &local_var_str
17595                    .into_iter()
17596                    .map(|p| p.to_string())
17597                    .collect::<Vec<String>>()
17598                    .join(",")
17599                    .to_string(),
17600            )]),
17601        };
17602    }
17603    if let Some(ref local_var_str) = description__regex {
17604        local_var_req_builder = match "multi" {
17605            "multi" => local_var_req_builder.query(
17606                &local_var_str
17607                    .into_iter()
17608                    .map(|p| ("description__regex".to_owned(), p.to_string()))
17609                    .collect::<Vec<(std::string::String, std::string::String)>>(),
17610            ),
17611            _ => local_var_req_builder.query(&[(
17612                "description__regex",
17613                &local_var_str
17614                    .into_iter()
17615                    .map(|p| p.to_string())
17616                    .collect::<Vec<String>>()
17617                    .join(",")
17618                    .to_string(),
17619            )]),
17620        };
17621    }
17622    if let Some(ref local_var_str) = id {
17623        local_var_req_builder = match "multi" {
17624            "multi" => local_var_req_builder.query(
17625                &local_var_str
17626                    .into_iter()
17627                    .map(|p| ("id".to_owned(), p.to_string()))
17628                    .collect::<Vec<(std::string::String, std::string::String)>>(),
17629            ),
17630            _ => local_var_req_builder.query(&[(
17631                "id",
17632                &local_var_str
17633                    .into_iter()
17634                    .map(|p| p.to_string())
17635                    .collect::<Vec<String>>()
17636                    .join(",")
17637                    .to_string(),
17638            )]),
17639        };
17640    }
17641    if let Some(ref local_var_str) = id__empty {
17642        local_var_req_builder =
17643            local_var_req_builder.query(&[("id__empty", &local_var_str.to_string())]);
17644    }
17645    if let Some(ref local_var_str) = id__gt {
17646        local_var_req_builder = match "multi" {
17647            "multi" => local_var_req_builder.query(
17648                &local_var_str
17649                    .into_iter()
17650                    .map(|p| ("id__gt".to_owned(), p.to_string()))
17651                    .collect::<Vec<(std::string::String, std::string::String)>>(),
17652            ),
17653            _ => local_var_req_builder.query(&[(
17654                "id__gt",
17655                &local_var_str
17656                    .into_iter()
17657                    .map(|p| p.to_string())
17658                    .collect::<Vec<String>>()
17659                    .join(",")
17660                    .to_string(),
17661            )]),
17662        };
17663    }
17664    if let Some(ref local_var_str) = id__gte {
17665        local_var_req_builder = match "multi" {
17666            "multi" => local_var_req_builder.query(
17667                &local_var_str
17668                    .into_iter()
17669                    .map(|p| ("id__gte".to_owned(), p.to_string()))
17670                    .collect::<Vec<(std::string::String, std::string::String)>>(),
17671            ),
17672            _ => local_var_req_builder.query(&[(
17673                "id__gte",
17674                &local_var_str
17675                    .into_iter()
17676                    .map(|p| p.to_string())
17677                    .collect::<Vec<String>>()
17678                    .join(",")
17679                    .to_string(),
17680            )]),
17681        };
17682    }
17683    if let Some(ref local_var_str) = id__lt {
17684        local_var_req_builder = match "multi" {
17685            "multi" => local_var_req_builder.query(
17686                &local_var_str
17687                    .into_iter()
17688                    .map(|p| ("id__lt".to_owned(), p.to_string()))
17689                    .collect::<Vec<(std::string::String, std::string::String)>>(),
17690            ),
17691            _ => local_var_req_builder.query(&[(
17692                "id__lt",
17693                &local_var_str
17694                    .into_iter()
17695                    .map(|p| p.to_string())
17696                    .collect::<Vec<String>>()
17697                    .join(",")
17698                    .to_string(),
17699            )]),
17700        };
17701    }
17702    if let Some(ref local_var_str) = id__lte {
17703        local_var_req_builder = match "multi" {
17704            "multi" => local_var_req_builder.query(
17705                &local_var_str
17706                    .into_iter()
17707                    .map(|p| ("id__lte".to_owned(), p.to_string()))
17708                    .collect::<Vec<(std::string::String, std::string::String)>>(),
17709            ),
17710            _ => local_var_req_builder.query(&[(
17711                "id__lte",
17712                &local_var_str
17713                    .into_iter()
17714                    .map(|p| p.to_string())
17715                    .collect::<Vec<String>>()
17716                    .join(",")
17717                    .to_string(),
17718            )]),
17719        };
17720    }
17721    if let Some(ref local_var_str) = id__n {
17722        local_var_req_builder = match "multi" {
17723            "multi" => local_var_req_builder.query(
17724                &local_var_str
17725                    .into_iter()
17726                    .map(|p| ("id__n".to_owned(), p.to_string()))
17727                    .collect::<Vec<(std::string::String, std::string::String)>>(),
17728            ),
17729            _ => local_var_req_builder.query(&[(
17730                "id__n",
17731                &local_var_str
17732                    .into_iter()
17733                    .map(|p| p.to_string())
17734                    .collect::<Vec<String>>()
17735                    .join(",")
17736                    .to_string(),
17737            )]),
17738        };
17739    }
17740    if let Some(ref local_var_str) = last_updated {
17741        local_var_req_builder = match "multi" {
17742            "multi" => local_var_req_builder.query(
17743                &local_var_str
17744                    .into_iter()
17745                    .map(|p| ("last_updated".to_owned(), p.to_string()))
17746                    .collect::<Vec<(std::string::String, std::string::String)>>(),
17747            ),
17748            _ => local_var_req_builder.query(&[(
17749                "last_updated",
17750                &local_var_str
17751                    .into_iter()
17752                    .map(|p| p.to_string())
17753                    .collect::<Vec<String>>()
17754                    .join(",")
17755                    .to_string(),
17756            )]),
17757        };
17758    }
17759    if let Some(ref local_var_str) = last_updated__empty {
17760        local_var_req_builder = match "multi" {
17761            "multi" => local_var_req_builder.query(
17762                &local_var_str
17763                    .into_iter()
17764                    .map(|p| ("last_updated__empty".to_owned(), p.to_string()))
17765                    .collect::<Vec<(std::string::String, std::string::String)>>(),
17766            ),
17767            _ => local_var_req_builder.query(&[(
17768                "last_updated__empty",
17769                &local_var_str
17770                    .into_iter()
17771                    .map(|p| p.to_string())
17772                    .collect::<Vec<String>>()
17773                    .join(",")
17774                    .to_string(),
17775            )]),
17776        };
17777    }
17778    if let Some(ref local_var_str) = last_updated__gt {
17779        local_var_req_builder = match "multi" {
17780            "multi" => local_var_req_builder.query(
17781                &local_var_str
17782                    .into_iter()
17783                    .map(|p| ("last_updated__gt".to_owned(), p.to_string()))
17784                    .collect::<Vec<(std::string::String, std::string::String)>>(),
17785            ),
17786            _ => local_var_req_builder.query(&[(
17787                "last_updated__gt",
17788                &local_var_str
17789                    .into_iter()
17790                    .map(|p| p.to_string())
17791                    .collect::<Vec<String>>()
17792                    .join(",")
17793                    .to_string(),
17794            )]),
17795        };
17796    }
17797    if let Some(ref local_var_str) = last_updated__gte {
17798        local_var_req_builder = match "multi" {
17799            "multi" => local_var_req_builder.query(
17800                &local_var_str
17801                    .into_iter()
17802                    .map(|p| ("last_updated__gte".to_owned(), p.to_string()))
17803                    .collect::<Vec<(std::string::String, std::string::String)>>(),
17804            ),
17805            _ => local_var_req_builder.query(&[(
17806                "last_updated__gte",
17807                &local_var_str
17808                    .into_iter()
17809                    .map(|p| p.to_string())
17810                    .collect::<Vec<String>>()
17811                    .join(",")
17812                    .to_string(),
17813            )]),
17814        };
17815    }
17816    if let Some(ref local_var_str) = last_updated__lt {
17817        local_var_req_builder = match "multi" {
17818            "multi" => local_var_req_builder.query(
17819                &local_var_str
17820                    .into_iter()
17821                    .map(|p| ("last_updated__lt".to_owned(), p.to_string()))
17822                    .collect::<Vec<(std::string::String, std::string::String)>>(),
17823            ),
17824            _ => local_var_req_builder.query(&[(
17825                "last_updated__lt",
17826                &local_var_str
17827                    .into_iter()
17828                    .map(|p| p.to_string())
17829                    .collect::<Vec<String>>()
17830                    .join(",")
17831                    .to_string(),
17832            )]),
17833        };
17834    }
17835    if let Some(ref local_var_str) = last_updated__lte {
17836        local_var_req_builder = match "multi" {
17837            "multi" => local_var_req_builder.query(
17838                &local_var_str
17839                    .into_iter()
17840                    .map(|p| ("last_updated__lte".to_owned(), p.to_string()))
17841                    .collect::<Vec<(std::string::String, std::string::String)>>(),
17842            ),
17843            _ => local_var_req_builder.query(&[(
17844                "last_updated__lte",
17845                &local_var_str
17846                    .into_iter()
17847                    .map(|p| p.to_string())
17848                    .collect::<Vec<String>>()
17849                    .join(",")
17850                    .to_string(),
17851            )]),
17852        };
17853    }
17854    if let Some(ref local_var_str) = last_updated__n {
17855        local_var_req_builder = match "multi" {
17856            "multi" => local_var_req_builder.query(
17857                &local_var_str
17858                    .into_iter()
17859                    .map(|p| ("last_updated__n".to_owned(), p.to_string()))
17860                    .collect::<Vec<(std::string::String, std::string::String)>>(),
17861            ),
17862            _ => local_var_req_builder.query(&[(
17863                "last_updated__n",
17864                &local_var_str
17865                    .into_iter()
17866                    .map(|p| p.to_string())
17867                    .collect::<Vec<String>>()
17868                    .join(",")
17869                    .to_string(),
17870            )]),
17871        };
17872    }
17873    if let Some(ref local_var_str) = limit {
17874        local_var_req_builder =
17875            local_var_req_builder.query(&[("limit", &local_var_str.to_string())]);
17876    }
17877    if let Some(ref local_var_str) = modified_by_request {
17878        local_var_req_builder =
17879            local_var_req_builder.query(&[("modified_by_request", &local_var_str.to_string())]);
17880    }
17881    if let Some(ref local_var_str) = name {
17882        local_var_req_builder = match "multi" {
17883            "multi" => local_var_req_builder.query(
17884                &local_var_str
17885                    .into_iter()
17886                    .map(|p| ("name".to_owned(), p.to_string()))
17887                    .collect::<Vec<(std::string::String, std::string::String)>>(),
17888            ),
17889            _ => local_var_req_builder.query(&[(
17890                "name",
17891                &local_var_str
17892                    .into_iter()
17893                    .map(|p| p.to_string())
17894                    .collect::<Vec<String>>()
17895                    .join(",")
17896                    .to_string(),
17897            )]),
17898        };
17899    }
17900    if let Some(ref local_var_str) = name__empty {
17901        local_var_req_builder =
17902            local_var_req_builder.query(&[("name__empty", &local_var_str.to_string())]);
17903    }
17904    if let Some(ref local_var_str) = name__ic {
17905        local_var_req_builder = match "multi" {
17906            "multi" => local_var_req_builder.query(
17907                &local_var_str
17908                    .into_iter()
17909                    .map(|p| ("name__ic".to_owned(), p.to_string()))
17910                    .collect::<Vec<(std::string::String, std::string::String)>>(),
17911            ),
17912            _ => local_var_req_builder.query(&[(
17913                "name__ic",
17914                &local_var_str
17915                    .into_iter()
17916                    .map(|p| p.to_string())
17917                    .collect::<Vec<String>>()
17918                    .join(",")
17919                    .to_string(),
17920            )]),
17921        };
17922    }
17923    if let Some(ref local_var_str) = name__ie {
17924        local_var_req_builder = match "multi" {
17925            "multi" => local_var_req_builder.query(
17926                &local_var_str
17927                    .into_iter()
17928                    .map(|p| ("name__ie".to_owned(), p.to_string()))
17929                    .collect::<Vec<(std::string::String, std::string::String)>>(),
17930            ),
17931            _ => local_var_req_builder.query(&[(
17932                "name__ie",
17933                &local_var_str
17934                    .into_iter()
17935                    .map(|p| p.to_string())
17936                    .collect::<Vec<String>>()
17937                    .join(",")
17938                    .to_string(),
17939            )]),
17940        };
17941    }
17942    if let Some(ref local_var_str) = name__iew {
17943        local_var_req_builder = match "multi" {
17944            "multi" => local_var_req_builder.query(
17945                &local_var_str
17946                    .into_iter()
17947                    .map(|p| ("name__iew".to_owned(), p.to_string()))
17948                    .collect::<Vec<(std::string::String, std::string::String)>>(),
17949            ),
17950            _ => local_var_req_builder.query(&[(
17951                "name__iew",
17952                &local_var_str
17953                    .into_iter()
17954                    .map(|p| p.to_string())
17955                    .collect::<Vec<String>>()
17956                    .join(",")
17957                    .to_string(),
17958            )]),
17959        };
17960    }
17961    if let Some(ref local_var_str) = name__iregex {
17962        local_var_req_builder = match "multi" {
17963            "multi" => local_var_req_builder.query(
17964                &local_var_str
17965                    .into_iter()
17966                    .map(|p| ("name__iregex".to_owned(), p.to_string()))
17967                    .collect::<Vec<(std::string::String, std::string::String)>>(),
17968            ),
17969            _ => local_var_req_builder.query(&[(
17970                "name__iregex",
17971                &local_var_str
17972                    .into_iter()
17973                    .map(|p| p.to_string())
17974                    .collect::<Vec<String>>()
17975                    .join(",")
17976                    .to_string(),
17977            )]),
17978        };
17979    }
17980    if let Some(ref local_var_str) = name__isw {
17981        local_var_req_builder = match "multi" {
17982            "multi" => local_var_req_builder.query(
17983                &local_var_str
17984                    .into_iter()
17985                    .map(|p| ("name__isw".to_owned(), p.to_string()))
17986                    .collect::<Vec<(std::string::String, std::string::String)>>(),
17987            ),
17988            _ => local_var_req_builder.query(&[(
17989                "name__isw",
17990                &local_var_str
17991                    .into_iter()
17992                    .map(|p| p.to_string())
17993                    .collect::<Vec<String>>()
17994                    .join(",")
17995                    .to_string(),
17996            )]),
17997        };
17998    }
17999    if let Some(ref local_var_str) = name__n {
18000        local_var_req_builder = match "multi" {
18001            "multi" => local_var_req_builder.query(
18002                &local_var_str
18003                    .into_iter()
18004                    .map(|p| ("name__n".to_owned(), p.to_string()))
18005                    .collect::<Vec<(std::string::String, std::string::String)>>(),
18006            ),
18007            _ => local_var_req_builder.query(&[(
18008                "name__n",
18009                &local_var_str
18010                    .into_iter()
18011                    .map(|p| p.to_string())
18012                    .collect::<Vec<String>>()
18013                    .join(",")
18014                    .to_string(),
18015            )]),
18016        };
18017    }
18018    if let Some(ref local_var_str) = name__nic {
18019        local_var_req_builder = match "multi" {
18020            "multi" => local_var_req_builder.query(
18021                &local_var_str
18022                    .into_iter()
18023                    .map(|p| ("name__nic".to_owned(), p.to_string()))
18024                    .collect::<Vec<(std::string::String, std::string::String)>>(),
18025            ),
18026            _ => local_var_req_builder.query(&[(
18027                "name__nic",
18028                &local_var_str
18029                    .into_iter()
18030                    .map(|p| p.to_string())
18031                    .collect::<Vec<String>>()
18032                    .join(",")
18033                    .to_string(),
18034            )]),
18035        };
18036    }
18037    if let Some(ref local_var_str) = name__nie {
18038        local_var_req_builder = match "multi" {
18039            "multi" => local_var_req_builder.query(
18040                &local_var_str
18041                    .into_iter()
18042                    .map(|p| ("name__nie".to_owned(), p.to_string()))
18043                    .collect::<Vec<(std::string::String, std::string::String)>>(),
18044            ),
18045            _ => local_var_req_builder.query(&[(
18046                "name__nie",
18047                &local_var_str
18048                    .into_iter()
18049                    .map(|p| p.to_string())
18050                    .collect::<Vec<String>>()
18051                    .join(",")
18052                    .to_string(),
18053            )]),
18054        };
18055    }
18056    if let Some(ref local_var_str) = name__niew {
18057        local_var_req_builder = match "multi" {
18058            "multi" => local_var_req_builder.query(
18059                &local_var_str
18060                    .into_iter()
18061                    .map(|p| ("name__niew".to_owned(), p.to_string()))
18062                    .collect::<Vec<(std::string::String, std::string::String)>>(),
18063            ),
18064            _ => local_var_req_builder.query(&[(
18065                "name__niew",
18066                &local_var_str
18067                    .into_iter()
18068                    .map(|p| p.to_string())
18069                    .collect::<Vec<String>>()
18070                    .join(",")
18071                    .to_string(),
18072            )]),
18073        };
18074    }
18075    if let Some(ref local_var_str) = name__nisw {
18076        local_var_req_builder = match "multi" {
18077            "multi" => local_var_req_builder.query(
18078                &local_var_str
18079                    .into_iter()
18080                    .map(|p| ("name__nisw".to_owned(), p.to_string()))
18081                    .collect::<Vec<(std::string::String, std::string::String)>>(),
18082            ),
18083            _ => local_var_req_builder.query(&[(
18084                "name__nisw",
18085                &local_var_str
18086                    .into_iter()
18087                    .map(|p| p.to_string())
18088                    .collect::<Vec<String>>()
18089                    .join(",")
18090                    .to_string(),
18091            )]),
18092        };
18093    }
18094    if let Some(ref local_var_str) = name__regex {
18095        local_var_req_builder = match "multi" {
18096            "multi" => local_var_req_builder.query(
18097                &local_var_str
18098                    .into_iter()
18099                    .map(|p| ("name__regex".to_owned(), p.to_string()))
18100                    .collect::<Vec<(std::string::String, std::string::String)>>(),
18101            ),
18102            _ => local_var_req_builder.query(&[(
18103                "name__regex",
18104                &local_var_str
18105                    .into_iter()
18106                    .map(|p| p.to_string())
18107                    .collect::<Vec<String>>()
18108                    .join(",")
18109                    .to_string(),
18110            )]),
18111        };
18112    }
18113    if let Some(ref local_var_str) = offset {
18114        local_var_req_builder =
18115            local_var_req_builder.query(&[("offset", &local_var_str.to_string())]);
18116    }
18117    if let Some(ref local_var_str) = ordering {
18118        local_var_req_builder =
18119            local_var_req_builder.query(&[("ordering", &local_var_str.to_string())]);
18120    }
18121    if let Some(ref local_var_str) = owner {
18122        local_var_req_builder = match "multi" {
18123            "multi" => local_var_req_builder.query(
18124                &local_var_str
18125                    .into_iter()
18126                    .map(|p| ("owner".to_owned(), p.to_string()))
18127                    .collect::<Vec<(std::string::String, std::string::String)>>(),
18128            ),
18129            _ => local_var_req_builder.query(&[(
18130                "owner",
18131                &local_var_str
18132                    .into_iter()
18133                    .map(|p| p.to_string())
18134                    .collect::<Vec<String>>()
18135                    .join(",")
18136                    .to_string(),
18137            )]),
18138        };
18139    }
18140    if let Some(ref local_var_str) = owner__n {
18141        local_var_req_builder = match "multi" {
18142            "multi" => local_var_req_builder.query(
18143                &local_var_str
18144                    .into_iter()
18145                    .map(|p| ("owner__n".to_owned(), p.to_string()))
18146                    .collect::<Vec<(std::string::String, std::string::String)>>(),
18147            ),
18148            _ => local_var_req_builder.query(&[(
18149                "owner__n",
18150                &local_var_str
18151                    .into_iter()
18152                    .map(|p| p.to_string())
18153                    .collect::<Vec<String>>()
18154                    .join(",")
18155                    .to_string(),
18156            )]),
18157        };
18158    }
18159    if let Some(ref local_var_str) = owner_group {
18160        local_var_req_builder = match "multi" {
18161            "multi" => local_var_req_builder.query(
18162                &local_var_str
18163                    .into_iter()
18164                    .map(|p| ("owner_group".to_owned(), p.to_string()))
18165                    .collect::<Vec<(std::string::String, std::string::String)>>(),
18166            ),
18167            _ => local_var_req_builder.query(&[(
18168                "owner_group",
18169                &local_var_str
18170                    .into_iter()
18171                    .map(|p| p.to_string())
18172                    .collect::<Vec<String>>()
18173                    .join(",")
18174                    .to_string(),
18175            )]),
18176        };
18177    }
18178    if let Some(ref local_var_str) = owner_group__n {
18179        local_var_req_builder = match "multi" {
18180            "multi" => local_var_req_builder.query(
18181                &local_var_str
18182                    .into_iter()
18183                    .map(|p| ("owner_group__n".to_owned(), p.to_string()))
18184                    .collect::<Vec<(std::string::String, std::string::String)>>(),
18185            ),
18186            _ => local_var_req_builder.query(&[(
18187                "owner_group__n",
18188                &local_var_str
18189                    .into_iter()
18190                    .map(|p| p.to_string())
18191                    .collect::<Vec<String>>()
18192                    .join(",")
18193                    .to_string(),
18194            )]),
18195        };
18196    }
18197    if let Some(ref local_var_str) = owner_group_id {
18198        local_var_req_builder = match "multi" {
18199            "multi" => local_var_req_builder.query(
18200                &local_var_str
18201                    .into_iter()
18202                    .map(|p| ("owner_group_id".to_owned(), p.to_string()))
18203                    .collect::<Vec<(std::string::String, std::string::String)>>(),
18204            ),
18205            _ => local_var_req_builder.query(&[(
18206                "owner_group_id",
18207                &local_var_str
18208                    .into_iter()
18209                    .map(|p| p.to_string())
18210                    .collect::<Vec<String>>()
18211                    .join(",")
18212                    .to_string(),
18213            )]),
18214        };
18215    }
18216    if let Some(ref local_var_str) = owner_group_id__n {
18217        local_var_req_builder = match "multi" {
18218            "multi" => local_var_req_builder.query(
18219                &local_var_str
18220                    .into_iter()
18221                    .map(|p| ("owner_group_id__n".to_owned(), p.to_string()))
18222                    .collect::<Vec<(std::string::String, std::string::String)>>(),
18223            ),
18224            _ => local_var_req_builder.query(&[(
18225                "owner_group_id__n",
18226                &local_var_str
18227                    .into_iter()
18228                    .map(|p| p.to_string())
18229                    .collect::<Vec<String>>()
18230                    .join(",")
18231                    .to_string(),
18232            )]),
18233        };
18234    }
18235    if let Some(ref local_var_str) = owner_id {
18236        local_var_req_builder = match "multi" {
18237            "multi" => local_var_req_builder.query(
18238                &local_var_str
18239                    .into_iter()
18240                    .map(|p| ("owner_id".to_owned(), p.to_string()))
18241                    .collect::<Vec<(std::string::String, std::string::String)>>(),
18242            ),
18243            _ => local_var_req_builder.query(&[(
18244                "owner_id",
18245                &local_var_str
18246                    .into_iter()
18247                    .map(|p| p.to_string())
18248                    .collect::<Vec<String>>()
18249                    .join(",")
18250                    .to_string(),
18251            )]),
18252        };
18253    }
18254    if let Some(ref local_var_str) = owner_id__n {
18255        local_var_req_builder = match "multi" {
18256            "multi" => local_var_req_builder.query(
18257                &local_var_str
18258                    .into_iter()
18259                    .map(|p| ("owner_id__n".to_owned(), p.to_string()))
18260                    .collect::<Vec<(std::string::String, std::string::String)>>(),
18261            ),
18262            _ => local_var_req_builder.query(&[(
18263                "owner_id__n",
18264                &local_var_str
18265                    .into_iter()
18266                    .map(|p| p.to_string())
18267                    .collect::<Vec<String>>()
18268                    .join(",")
18269                    .to_string(),
18270            )]),
18271        };
18272    }
18273    if let Some(ref local_var_str) = q {
18274        local_var_req_builder = local_var_req_builder.query(&[("q", &local_var_str.to_string())]);
18275    }
18276    if let Some(ref local_var_str) = slug {
18277        local_var_req_builder = match "multi" {
18278            "multi" => local_var_req_builder.query(
18279                &local_var_str
18280                    .into_iter()
18281                    .map(|p| ("slug".to_owned(), p.to_string()))
18282                    .collect::<Vec<(std::string::String, std::string::String)>>(),
18283            ),
18284            _ => local_var_req_builder.query(&[(
18285                "slug",
18286                &local_var_str
18287                    .into_iter()
18288                    .map(|p| p.to_string())
18289                    .collect::<Vec<String>>()
18290                    .join(",")
18291                    .to_string(),
18292            )]),
18293        };
18294    }
18295    if let Some(ref local_var_str) = slug__empty {
18296        local_var_req_builder =
18297            local_var_req_builder.query(&[("slug__empty", &local_var_str.to_string())]);
18298    }
18299    if let Some(ref local_var_str) = slug__ic {
18300        local_var_req_builder = match "multi" {
18301            "multi" => local_var_req_builder.query(
18302                &local_var_str
18303                    .into_iter()
18304                    .map(|p| ("slug__ic".to_owned(), p.to_string()))
18305                    .collect::<Vec<(std::string::String, std::string::String)>>(),
18306            ),
18307            _ => local_var_req_builder.query(&[(
18308                "slug__ic",
18309                &local_var_str
18310                    .into_iter()
18311                    .map(|p| p.to_string())
18312                    .collect::<Vec<String>>()
18313                    .join(",")
18314                    .to_string(),
18315            )]),
18316        };
18317    }
18318    if let Some(ref local_var_str) = slug__ie {
18319        local_var_req_builder = match "multi" {
18320            "multi" => local_var_req_builder.query(
18321                &local_var_str
18322                    .into_iter()
18323                    .map(|p| ("slug__ie".to_owned(), p.to_string()))
18324                    .collect::<Vec<(std::string::String, std::string::String)>>(),
18325            ),
18326            _ => local_var_req_builder.query(&[(
18327                "slug__ie",
18328                &local_var_str
18329                    .into_iter()
18330                    .map(|p| p.to_string())
18331                    .collect::<Vec<String>>()
18332                    .join(",")
18333                    .to_string(),
18334            )]),
18335        };
18336    }
18337    if let Some(ref local_var_str) = slug__iew {
18338        local_var_req_builder = match "multi" {
18339            "multi" => local_var_req_builder.query(
18340                &local_var_str
18341                    .into_iter()
18342                    .map(|p| ("slug__iew".to_owned(), p.to_string()))
18343                    .collect::<Vec<(std::string::String, std::string::String)>>(),
18344            ),
18345            _ => local_var_req_builder.query(&[(
18346                "slug__iew",
18347                &local_var_str
18348                    .into_iter()
18349                    .map(|p| p.to_string())
18350                    .collect::<Vec<String>>()
18351                    .join(",")
18352                    .to_string(),
18353            )]),
18354        };
18355    }
18356    if let Some(ref local_var_str) = slug__iregex {
18357        local_var_req_builder = match "multi" {
18358            "multi" => local_var_req_builder.query(
18359                &local_var_str
18360                    .into_iter()
18361                    .map(|p| ("slug__iregex".to_owned(), p.to_string()))
18362                    .collect::<Vec<(std::string::String, std::string::String)>>(),
18363            ),
18364            _ => local_var_req_builder.query(&[(
18365                "slug__iregex",
18366                &local_var_str
18367                    .into_iter()
18368                    .map(|p| p.to_string())
18369                    .collect::<Vec<String>>()
18370                    .join(",")
18371                    .to_string(),
18372            )]),
18373        };
18374    }
18375    if let Some(ref local_var_str) = slug__isw {
18376        local_var_req_builder = match "multi" {
18377            "multi" => local_var_req_builder.query(
18378                &local_var_str
18379                    .into_iter()
18380                    .map(|p| ("slug__isw".to_owned(), p.to_string()))
18381                    .collect::<Vec<(std::string::String, std::string::String)>>(),
18382            ),
18383            _ => local_var_req_builder.query(&[(
18384                "slug__isw",
18385                &local_var_str
18386                    .into_iter()
18387                    .map(|p| p.to_string())
18388                    .collect::<Vec<String>>()
18389                    .join(",")
18390                    .to_string(),
18391            )]),
18392        };
18393    }
18394    if let Some(ref local_var_str) = slug__n {
18395        local_var_req_builder = match "multi" {
18396            "multi" => local_var_req_builder.query(
18397                &local_var_str
18398                    .into_iter()
18399                    .map(|p| ("slug__n".to_owned(), p.to_string()))
18400                    .collect::<Vec<(std::string::String, std::string::String)>>(),
18401            ),
18402            _ => local_var_req_builder.query(&[(
18403                "slug__n",
18404                &local_var_str
18405                    .into_iter()
18406                    .map(|p| p.to_string())
18407                    .collect::<Vec<String>>()
18408                    .join(",")
18409                    .to_string(),
18410            )]),
18411        };
18412    }
18413    if let Some(ref local_var_str) = slug__nic {
18414        local_var_req_builder = match "multi" {
18415            "multi" => local_var_req_builder.query(
18416                &local_var_str
18417                    .into_iter()
18418                    .map(|p| ("slug__nic".to_owned(), p.to_string()))
18419                    .collect::<Vec<(std::string::String, std::string::String)>>(),
18420            ),
18421            _ => local_var_req_builder.query(&[(
18422                "slug__nic",
18423                &local_var_str
18424                    .into_iter()
18425                    .map(|p| p.to_string())
18426                    .collect::<Vec<String>>()
18427                    .join(",")
18428                    .to_string(),
18429            )]),
18430        };
18431    }
18432    if let Some(ref local_var_str) = slug__nie {
18433        local_var_req_builder = match "multi" {
18434            "multi" => local_var_req_builder.query(
18435                &local_var_str
18436                    .into_iter()
18437                    .map(|p| ("slug__nie".to_owned(), p.to_string()))
18438                    .collect::<Vec<(std::string::String, std::string::String)>>(),
18439            ),
18440            _ => local_var_req_builder.query(&[(
18441                "slug__nie",
18442                &local_var_str
18443                    .into_iter()
18444                    .map(|p| p.to_string())
18445                    .collect::<Vec<String>>()
18446                    .join(",")
18447                    .to_string(),
18448            )]),
18449        };
18450    }
18451    if let Some(ref local_var_str) = slug__niew {
18452        local_var_req_builder = match "multi" {
18453            "multi" => local_var_req_builder.query(
18454                &local_var_str
18455                    .into_iter()
18456                    .map(|p| ("slug__niew".to_owned(), p.to_string()))
18457                    .collect::<Vec<(std::string::String, std::string::String)>>(),
18458            ),
18459            _ => local_var_req_builder.query(&[(
18460                "slug__niew",
18461                &local_var_str
18462                    .into_iter()
18463                    .map(|p| p.to_string())
18464                    .collect::<Vec<String>>()
18465                    .join(",")
18466                    .to_string(),
18467            )]),
18468        };
18469    }
18470    if let Some(ref local_var_str) = slug__nisw {
18471        local_var_req_builder = match "multi" {
18472            "multi" => local_var_req_builder.query(
18473                &local_var_str
18474                    .into_iter()
18475                    .map(|p| ("slug__nisw".to_owned(), p.to_string()))
18476                    .collect::<Vec<(std::string::String, std::string::String)>>(),
18477            ),
18478            _ => local_var_req_builder.query(&[(
18479                "slug__nisw",
18480                &local_var_str
18481                    .into_iter()
18482                    .map(|p| p.to_string())
18483                    .collect::<Vec<String>>()
18484                    .join(",")
18485                    .to_string(),
18486            )]),
18487        };
18488    }
18489    if let Some(ref local_var_str) = slug__regex {
18490        local_var_req_builder = match "multi" {
18491            "multi" => local_var_req_builder.query(
18492                &local_var_str
18493                    .into_iter()
18494                    .map(|p| ("slug__regex".to_owned(), p.to_string()))
18495                    .collect::<Vec<(std::string::String, std::string::String)>>(),
18496            ),
18497            _ => local_var_req_builder.query(&[(
18498                "slug__regex",
18499                &local_var_str
18500                    .into_iter()
18501                    .map(|p| p.to_string())
18502                    .collect::<Vec<String>>()
18503                    .join(",")
18504                    .to_string(),
18505            )]),
18506        };
18507    }
18508    if let Some(ref local_var_str) = tag {
18509        local_var_req_builder = match "multi" {
18510            "multi" => local_var_req_builder.query(
18511                &local_var_str
18512                    .into_iter()
18513                    .map(|p| ("tag".to_owned(), p.to_string()))
18514                    .collect::<Vec<(std::string::String, std::string::String)>>(),
18515            ),
18516            _ => local_var_req_builder.query(&[(
18517                "tag",
18518                &local_var_str
18519                    .into_iter()
18520                    .map(|p| p.to_string())
18521                    .collect::<Vec<String>>()
18522                    .join(",")
18523                    .to_string(),
18524            )]),
18525        };
18526    }
18527    if let Some(ref local_var_str) = tag__n {
18528        local_var_req_builder = match "multi" {
18529            "multi" => local_var_req_builder.query(
18530                &local_var_str
18531                    .into_iter()
18532                    .map(|p| ("tag__n".to_owned(), p.to_string()))
18533                    .collect::<Vec<(std::string::String, std::string::String)>>(),
18534            ),
18535            _ => local_var_req_builder.query(&[(
18536                "tag__n",
18537                &local_var_str
18538                    .into_iter()
18539                    .map(|p| p.to_string())
18540                    .collect::<Vec<String>>()
18541                    .join(",")
18542                    .to_string(),
18543            )]),
18544        };
18545    }
18546    if let Some(ref local_var_str) = tag_id {
18547        local_var_req_builder = match "multi" {
18548            "multi" => local_var_req_builder.query(
18549                &local_var_str
18550                    .into_iter()
18551                    .map(|p| ("tag_id".to_owned(), p.to_string()))
18552                    .collect::<Vec<(std::string::String, std::string::String)>>(),
18553            ),
18554            _ => local_var_req_builder.query(&[(
18555                "tag_id",
18556                &local_var_str
18557                    .into_iter()
18558                    .map(|p| p.to_string())
18559                    .collect::<Vec<String>>()
18560                    .join(",")
18561                    .to_string(),
18562            )]),
18563        };
18564    }
18565    if let Some(ref local_var_str) = tag_id__n {
18566        local_var_req_builder = match "multi" {
18567            "multi" => local_var_req_builder.query(
18568                &local_var_str
18569                    .into_iter()
18570                    .map(|p| ("tag_id__n".to_owned(), p.to_string()))
18571                    .collect::<Vec<(std::string::String, std::string::String)>>(),
18572            ),
18573            _ => local_var_req_builder.query(&[(
18574                "tag_id__n",
18575                &local_var_str
18576                    .into_iter()
18577                    .map(|p| p.to_string())
18578                    .collect::<Vec<String>>()
18579                    .join(",")
18580                    .to_string(),
18581            )]),
18582        };
18583    }
18584    if let Some(ref local_var_str) = updated_by_request {
18585        local_var_req_builder =
18586            local_var_req_builder.query(&[("updated_by_request", &local_var_str.to_string())]);
18587    }
18588    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
18589        local_var_req_builder =
18590            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
18591    }
18592    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
18593        let local_var_key = local_var_apikey.key.clone();
18594        let local_var_value = match local_var_apikey.prefix {
18595            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
18596            None => local_var_key,
18597        };
18598        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
18599    };
18600
18601    let local_var_req = local_var_req_builder.build()?;
18602    let local_var_resp = local_var_client.execute(local_var_req).await?;
18603
18604    let local_var_status = local_var_resp.status();
18605    let local_var_content = local_var_resp.text().await?;
18606
18607    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
18608        serde_json::from_str(&local_var_content).map_err(Error::from)
18609    } else {
18610        let local_var_entity: Option<VpnTunnelGroupsListError> =
18611            serde_json::from_str(&local_var_content).ok();
18612        let local_var_error = ResponseContent {
18613            status: local_var_status,
18614            content: local_var_content,
18615            entity: local_var_entity,
18616        };
18617        Err(Error::ResponseError(local_var_error))
18618    }
18619}
18620
18621/// Patch a tunnel group object.
18622pub async fn vpn_tunnel_groups_partial_update(
18623    configuration: &configuration::Configuration,
18624    id: i32,
18625    patched_tunnel_group_request: Option<crate::models::PatchedTunnelGroupRequest>,
18626) -> Result<crate::models::TunnelGroup, Error<VpnTunnelGroupsPartialUpdateError>> {
18627    let local_var_configuration = configuration;
18628
18629    let local_var_client = &local_var_configuration.client;
18630
18631    let local_var_uri_str = format!(
18632        "{}/api/vpn/tunnel-groups/{id}/",
18633        local_var_configuration.base_path,
18634        id = id
18635    );
18636    let mut local_var_req_builder =
18637        local_var_client.request(reqwest::Method::PATCH, local_var_uri_str.as_str());
18638
18639    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
18640        local_var_req_builder =
18641            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
18642    }
18643    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
18644        let local_var_key = local_var_apikey.key.clone();
18645        let local_var_value = match local_var_apikey.prefix {
18646            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
18647            None => local_var_key,
18648        };
18649        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
18650    };
18651    local_var_req_builder = local_var_req_builder.json(&patched_tunnel_group_request);
18652
18653    let local_var_req = local_var_req_builder.build()?;
18654    let local_var_resp = local_var_client.execute(local_var_req).await?;
18655
18656    let local_var_status = local_var_resp.status();
18657    let local_var_content = local_var_resp.text().await?;
18658
18659    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
18660        serde_json::from_str(&local_var_content).map_err(Error::from)
18661    } else {
18662        let local_var_entity: Option<VpnTunnelGroupsPartialUpdateError> =
18663            serde_json::from_str(&local_var_content).ok();
18664        let local_var_error = ResponseContent {
18665            status: local_var_status,
18666            content: local_var_content,
18667            entity: local_var_entity,
18668        };
18669        Err(Error::ResponseError(local_var_error))
18670    }
18671}
18672
18673/// Get a tunnel group object.
18674pub async fn vpn_tunnel_groups_retrieve(
18675    configuration: &configuration::Configuration,
18676    id: i32,
18677) -> Result<crate::models::TunnelGroup, Error<VpnTunnelGroupsRetrieveError>> {
18678    let local_var_configuration = configuration;
18679
18680    let local_var_client = &local_var_configuration.client;
18681
18682    let local_var_uri_str = format!(
18683        "{}/api/vpn/tunnel-groups/{id}/",
18684        local_var_configuration.base_path,
18685        id = id
18686    );
18687    let mut local_var_req_builder =
18688        local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
18689
18690    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
18691        local_var_req_builder =
18692            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
18693    }
18694    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
18695        let local_var_key = local_var_apikey.key.clone();
18696        let local_var_value = match local_var_apikey.prefix {
18697            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
18698            None => local_var_key,
18699        };
18700        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
18701    };
18702
18703    let local_var_req = local_var_req_builder.build()?;
18704    let local_var_resp = local_var_client.execute(local_var_req).await?;
18705
18706    let local_var_status = local_var_resp.status();
18707    let local_var_content = local_var_resp.text().await?;
18708
18709    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
18710        serde_json::from_str(&local_var_content).map_err(Error::from)
18711    } else {
18712        let local_var_entity: Option<VpnTunnelGroupsRetrieveError> =
18713            serde_json::from_str(&local_var_content).ok();
18714        let local_var_error = ResponseContent {
18715            status: local_var_status,
18716            content: local_var_content,
18717            entity: local_var_entity,
18718        };
18719        Err(Error::ResponseError(local_var_error))
18720    }
18721}
18722
18723/// Put a tunnel group object.
18724pub async fn vpn_tunnel_groups_update(
18725    configuration: &configuration::Configuration,
18726    id: i32,
18727    tunnel_group_request: crate::models::TunnelGroupRequest,
18728) -> Result<crate::models::TunnelGroup, Error<VpnTunnelGroupsUpdateError>> {
18729    let local_var_configuration = configuration;
18730
18731    let local_var_client = &local_var_configuration.client;
18732
18733    let local_var_uri_str = format!(
18734        "{}/api/vpn/tunnel-groups/{id}/",
18735        local_var_configuration.base_path,
18736        id = id
18737    );
18738    let mut local_var_req_builder =
18739        local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());
18740
18741    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
18742        local_var_req_builder =
18743            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
18744    }
18745    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
18746        let local_var_key = local_var_apikey.key.clone();
18747        let local_var_value = match local_var_apikey.prefix {
18748            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
18749            None => local_var_key,
18750        };
18751        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
18752    };
18753    local_var_req_builder = local_var_req_builder.json(&tunnel_group_request);
18754
18755    let local_var_req = local_var_req_builder.build()?;
18756    let local_var_resp = local_var_client.execute(local_var_req).await?;
18757
18758    let local_var_status = local_var_resp.status();
18759    let local_var_content = local_var_resp.text().await?;
18760
18761    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
18762        serde_json::from_str(&local_var_content).map_err(Error::from)
18763    } else {
18764        let local_var_entity: Option<VpnTunnelGroupsUpdateError> =
18765            serde_json::from_str(&local_var_content).ok();
18766        let local_var_error = ResponseContent {
18767            status: local_var_status,
18768            content: local_var_content,
18769            entity: local_var_entity,
18770        };
18771        Err(Error::ResponseError(local_var_error))
18772    }
18773}
18774
18775/// Delete a list of tunnel termination objects.
18776pub async fn vpn_tunnel_terminations_bulk_destroy(
18777    configuration: &configuration::Configuration,
18778    tunnel_termination_request: Vec<crate::models::TunnelTerminationRequest>,
18779) -> Result<(), Error<VpnTunnelTerminationsBulkDestroyError>> {
18780    let local_var_configuration = configuration;
18781
18782    let local_var_client = &local_var_configuration.client;
18783
18784    let local_var_uri_str = format!(
18785        "{}/api/vpn/tunnel-terminations/",
18786        local_var_configuration.base_path
18787    );
18788    let mut local_var_req_builder =
18789        local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());
18790
18791    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
18792        local_var_req_builder =
18793            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
18794    }
18795    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
18796        let local_var_key = local_var_apikey.key.clone();
18797        let local_var_value = match local_var_apikey.prefix {
18798            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
18799            None => local_var_key,
18800        };
18801        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
18802    };
18803    local_var_req_builder = local_var_req_builder.json(&tunnel_termination_request);
18804
18805    let local_var_req = local_var_req_builder.build()?;
18806    let local_var_resp = local_var_client.execute(local_var_req).await?;
18807
18808    let local_var_status = local_var_resp.status();
18809    let local_var_content = local_var_resp.text().await?;
18810
18811    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
18812        Ok(())
18813    } else {
18814        let local_var_entity: Option<VpnTunnelTerminationsBulkDestroyError> =
18815            serde_json::from_str(&local_var_content).ok();
18816        let local_var_error = ResponseContent {
18817            status: local_var_status,
18818            content: local_var_content,
18819            entity: local_var_entity,
18820        };
18821        Err(Error::ResponseError(local_var_error))
18822    }
18823}
18824
18825/// Patch a list of tunnel termination objects.
18826pub async fn vpn_tunnel_terminations_bulk_partial_update(
18827    configuration: &configuration::Configuration,
18828    tunnel_termination_request: Vec<crate::models::TunnelTerminationRequest>,
18829) -> Result<Vec<crate::models::TunnelTermination>, Error<VpnTunnelTerminationsBulkPartialUpdateError>>
18830{
18831    let local_var_configuration = configuration;
18832
18833    let local_var_client = &local_var_configuration.client;
18834
18835    let local_var_uri_str = format!(
18836        "{}/api/vpn/tunnel-terminations/",
18837        local_var_configuration.base_path
18838    );
18839    let mut local_var_req_builder =
18840        local_var_client.request(reqwest::Method::PATCH, local_var_uri_str.as_str());
18841
18842    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
18843        local_var_req_builder =
18844            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
18845    }
18846    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
18847        let local_var_key = local_var_apikey.key.clone();
18848        let local_var_value = match local_var_apikey.prefix {
18849            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
18850            None => local_var_key,
18851        };
18852        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
18853    };
18854    local_var_req_builder = local_var_req_builder.json(&tunnel_termination_request);
18855
18856    let local_var_req = local_var_req_builder.build()?;
18857    let local_var_resp = local_var_client.execute(local_var_req).await?;
18858
18859    let local_var_status = local_var_resp.status();
18860    let local_var_content = local_var_resp.text().await?;
18861
18862    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
18863        serde_json::from_str(&local_var_content).map_err(Error::from)
18864    } else {
18865        let local_var_entity: Option<VpnTunnelTerminationsBulkPartialUpdateError> =
18866            serde_json::from_str(&local_var_content).ok();
18867        let local_var_error = ResponseContent {
18868            status: local_var_status,
18869            content: local_var_content,
18870            entity: local_var_entity,
18871        };
18872        Err(Error::ResponseError(local_var_error))
18873    }
18874}
18875
18876/// Put a list of tunnel termination objects.
18877pub async fn vpn_tunnel_terminations_bulk_update(
18878    configuration: &configuration::Configuration,
18879    tunnel_termination_request: Vec<crate::models::TunnelTerminationRequest>,
18880) -> Result<Vec<crate::models::TunnelTermination>, Error<VpnTunnelTerminationsBulkUpdateError>> {
18881    let local_var_configuration = configuration;
18882
18883    let local_var_client = &local_var_configuration.client;
18884
18885    let local_var_uri_str = format!(
18886        "{}/api/vpn/tunnel-terminations/",
18887        local_var_configuration.base_path
18888    );
18889    let mut local_var_req_builder =
18890        local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());
18891
18892    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
18893        local_var_req_builder =
18894            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
18895    }
18896    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
18897        let local_var_key = local_var_apikey.key.clone();
18898        let local_var_value = match local_var_apikey.prefix {
18899            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
18900            None => local_var_key,
18901        };
18902        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
18903    };
18904    local_var_req_builder = local_var_req_builder.json(&tunnel_termination_request);
18905
18906    let local_var_req = local_var_req_builder.build()?;
18907    let local_var_resp = local_var_client.execute(local_var_req).await?;
18908
18909    let local_var_status = local_var_resp.status();
18910    let local_var_content = local_var_resp.text().await?;
18911
18912    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
18913        serde_json::from_str(&local_var_content).map_err(Error::from)
18914    } else {
18915        let local_var_entity: Option<VpnTunnelTerminationsBulkUpdateError> =
18916            serde_json::from_str(&local_var_content).ok();
18917        let local_var_error = ResponseContent {
18918            status: local_var_status,
18919            content: local_var_content,
18920            entity: local_var_entity,
18921        };
18922        Err(Error::ResponseError(local_var_error))
18923    }
18924}
18925
18926/// Post a list of tunnel termination objects.
18927pub async fn vpn_tunnel_terminations_create(
18928    configuration: &configuration::Configuration,
18929    vpn_tunnel_terminations_create_request: crate::models::VpnTunnelTerminationsCreateRequest,
18930) -> Result<crate::models::TunnelTermination, Error<VpnTunnelTerminationsCreateError>> {
18931    let local_var_configuration = configuration;
18932
18933    let local_var_client = &local_var_configuration.client;
18934
18935    let local_var_uri_str = format!(
18936        "{}/api/vpn/tunnel-terminations/",
18937        local_var_configuration.base_path
18938    );
18939    let mut local_var_req_builder =
18940        local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
18941
18942    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
18943        local_var_req_builder =
18944            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
18945    }
18946    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
18947        let local_var_key = local_var_apikey.key.clone();
18948        let local_var_value = match local_var_apikey.prefix {
18949            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
18950            None => local_var_key,
18951        };
18952        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
18953    };
18954    local_var_req_builder = local_var_req_builder.json(&vpn_tunnel_terminations_create_request);
18955
18956    let local_var_req = local_var_req_builder.build()?;
18957    let local_var_resp = local_var_client.execute(local_var_req).await?;
18958
18959    let local_var_status = local_var_resp.status();
18960    let local_var_content = local_var_resp.text().await?;
18961
18962    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
18963        serde_json::from_str(&local_var_content).map_err(Error::from)
18964    } else {
18965        let local_var_entity: Option<VpnTunnelTerminationsCreateError> =
18966            serde_json::from_str(&local_var_content).ok();
18967        let local_var_error = ResponseContent {
18968            status: local_var_status,
18969            content: local_var_content,
18970            entity: local_var_entity,
18971        };
18972        Err(Error::ResponseError(local_var_error))
18973    }
18974}
18975
18976/// Delete a tunnel termination object.
18977pub async fn vpn_tunnel_terminations_destroy(
18978    configuration: &configuration::Configuration,
18979    id: i32,
18980) -> Result<(), Error<VpnTunnelTerminationsDestroyError>> {
18981    let local_var_configuration = configuration;
18982
18983    let local_var_client = &local_var_configuration.client;
18984
18985    let local_var_uri_str = format!(
18986        "{}/api/vpn/tunnel-terminations/{id}/",
18987        local_var_configuration.base_path,
18988        id = id
18989    );
18990    let mut local_var_req_builder =
18991        local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());
18992
18993    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
18994        local_var_req_builder =
18995            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
18996    }
18997    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
18998        let local_var_key = local_var_apikey.key.clone();
18999        let local_var_value = match local_var_apikey.prefix {
19000            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
19001            None => local_var_key,
19002        };
19003        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
19004    };
19005
19006    let local_var_req = local_var_req_builder.build()?;
19007    let local_var_resp = local_var_client.execute(local_var_req).await?;
19008
19009    let local_var_status = local_var_resp.status();
19010    let local_var_content = local_var_resp.text().await?;
19011
19012    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
19013        Ok(())
19014    } else {
19015        let local_var_entity: Option<VpnTunnelTerminationsDestroyError> =
19016            serde_json::from_str(&local_var_content).ok();
19017        let local_var_error = ResponseContent {
19018            status: local_var_status,
19019            content: local_var_content,
19020            entity: local_var_entity,
19021        };
19022        Err(Error::ResponseError(local_var_error))
19023    }
19024}
19025
19026/// Get a list of tunnel termination objects.
19027pub async fn vpn_tunnel_terminations_list(
19028    configuration: &configuration::Configuration,
19029    created: Option<Vec<String>>,
19030    created__empty: Option<Vec<String>>,
19031    created__gt: Option<Vec<String>>,
19032    created__gte: Option<Vec<String>>,
19033    created__lt: Option<Vec<String>>,
19034    created__lte: Option<Vec<String>>,
19035    created__n: Option<Vec<String>>,
19036    created_by_request: Option<&str>,
19037    id: Option<Vec<i32>>,
19038    id__empty: Option<bool>,
19039    id__gt: Option<Vec<i32>>,
19040    id__gte: Option<Vec<i32>>,
19041    id__lt: Option<Vec<i32>>,
19042    id__lte: Option<Vec<i32>>,
19043    id__n: Option<Vec<i32>>,
19044    interface: Option<Vec<String>>,
19045    interface__n: Option<Vec<String>>,
19046    interface_id: Option<Vec<i32>>,
19047    interface_id__n: Option<Vec<i32>>,
19048    last_updated: Option<Vec<String>>,
19049    last_updated__empty: Option<Vec<String>>,
19050    last_updated__gt: Option<Vec<String>>,
19051    last_updated__gte: Option<Vec<String>>,
19052    last_updated__lt: Option<Vec<String>>,
19053    last_updated__lte: Option<Vec<String>>,
19054    last_updated__n: Option<Vec<String>>,
19055    limit: Option<i32>,
19056    modified_by_request: Option<&str>,
19057    offset: Option<i32>,
19058    ordering: Option<&str>,
19059    outside_ip_id: Option<Vec<i32>>,
19060    outside_ip_id__n: Option<Vec<i32>>,
19061    q: Option<&str>,
19062    role: Option<Vec<String>>,
19063    role__empty: Option<bool>,
19064    role__ic: Option<Vec<String>>,
19065    role__ie: Option<Vec<String>>,
19066    role__iew: Option<Vec<String>>,
19067    role__iregex: Option<Vec<String>>,
19068    role__isw: Option<Vec<String>>,
19069    role__n: Option<Vec<String>>,
19070    role__nic: Option<Vec<String>>,
19071    role__nie: Option<Vec<String>>,
19072    role__niew: Option<Vec<String>>,
19073    role__nisw: Option<Vec<String>>,
19074    role__regex: Option<Vec<String>>,
19075    tag: Option<Vec<String>>,
19076    tag__n: Option<Vec<String>>,
19077    tag_id: Option<Vec<i32>>,
19078    tag_id__n: Option<Vec<i32>>,
19079    termination_id: Option<Vec<i32>>,
19080    termination_id__empty: Option<bool>,
19081    termination_id__gt: Option<Vec<i32>>,
19082    termination_id__gte: Option<Vec<i32>>,
19083    termination_id__lt: Option<Vec<i32>>,
19084    termination_id__lte: Option<Vec<i32>>,
19085    termination_id__n: Option<Vec<i32>>,
19086    termination_type: Option<Vec<String>>,
19087    termination_type__n: Option<Vec<String>>,
19088    tunnel: Option<Vec<String>>,
19089    tunnel__n: Option<Vec<String>>,
19090    tunnel_id: Option<Vec<i32>>,
19091    tunnel_id__n: Option<Vec<i32>>,
19092    updated_by_request: Option<&str>,
19093    vminterface: Option<Vec<String>>,
19094    vminterface__n: Option<Vec<String>>,
19095    vminterface_id: Option<Vec<i32>>,
19096    vminterface_id__n: Option<Vec<i32>>,
19097) -> Result<crate::models::PaginatedTunnelTerminationList, Error<VpnTunnelTerminationsListError>> {
19098    let local_var_configuration = configuration;
19099
19100    let local_var_client = &local_var_configuration.client;
19101
19102    let local_var_uri_str = format!(
19103        "{}/api/vpn/tunnel-terminations/",
19104        local_var_configuration.base_path
19105    );
19106    let mut local_var_req_builder =
19107        local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
19108
19109    if let Some(ref local_var_str) = created {
19110        local_var_req_builder = match "multi" {
19111            "multi" => local_var_req_builder.query(
19112                &local_var_str
19113                    .into_iter()
19114                    .map(|p| ("created".to_owned(), p.to_string()))
19115                    .collect::<Vec<(std::string::String, std::string::String)>>(),
19116            ),
19117            _ => local_var_req_builder.query(&[(
19118                "created",
19119                &local_var_str
19120                    .into_iter()
19121                    .map(|p| p.to_string())
19122                    .collect::<Vec<String>>()
19123                    .join(",")
19124                    .to_string(),
19125            )]),
19126        };
19127    }
19128    if let Some(ref local_var_str) = created__empty {
19129        local_var_req_builder = match "multi" {
19130            "multi" => local_var_req_builder.query(
19131                &local_var_str
19132                    .into_iter()
19133                    .map(|p| ("created__empty".to_owned(), p.to_string()))
19134                    .collect::<Vec<(std::string::String, std::string::String)>>(),
19135            ),
19136            _ => local_var_req_builder.query(&[(
19137                "created__empty",
19138                &local_var_str
19139                    .into_iter()
19140                    .map(|p| p.to_string())
19141                    .collect::<Vec<String>>()
19142                    .join(",")
19143                    .to_string(),
19144            )]),
19145        };
19146    }
19147    if let Some(ref local_var_str) = created__gt {
19148        local_var_req_builder = match "multi" {
19149            "multi" => local_var_req_builder.query(
19150                &local_var_str
19151                    .into_iter()
19152                    .map(|p| ("created__gt".to_owned(), p.to_string()))
19153                    .collect::<Vec<(std::string::String, std::string::String)>>(),
19154            ),
19155            _ => local_var_req_builder.query(&[(
19156                "created__gt",
19157                &local_var_str
19158                    .into_iter()
19159                    .map(|p| p.to_string())
19160                    .collect::<Vec<String>>()
19161                    .join(",")
19162                    .to_string(),
19163            )]),
19164        };
19165    }
19166    if let Some(ref local_var_str) = created__gte {
19167        local_var_req_builder = match "multi" {
19168            "multi" => local_var_req_builder.query(
19169                &local_var_str
19170                    .into_iter()
19171                    .map(|p| ("created__gte".to_owned(), p.to_string()))
19172                    .collect::<Vec<(std::string::String, std::string::String)>>(),
19173            ),
19174            _ => local_var_req_builder.query(&[(
19175                "created__gte",
19176                &local_var_str
19177                    .into_iter()
19178                    .map(|p| p.to_string())
19179                    .collect::<Vec<String>>()
19180                    .join(",")
19181                    .to_string(),
19182            )]),
19183        };
19184    }
19185    if let Some(ref local_var_str) = created__lt {
19186        local_var_req_builder = match "multi" {
19187            "multi" => local_var_req_builder.query(
19188                &local_var_str
19189                    .into_iter()
19190                    .map(|p| ("created__lt".to_owned(), p.to_string()))
19191                    .collect::<Vec<(std::string::String, std::string::String)>>(),
19192            ),
19193            _ => local_var_req_builder.query(&[(
19194                "created__lt",
19195                &local_var_str
19196                    .into_iter()
19197                    .map(|p| p.to_string())
19198                    .collect::<Vec<String>>()
19199                    .join(",")
19200                    .to_string(),
19201            )]),
19202        };
19203    }
19204    if let Some(ref local_var_str) = created__lte {
19205        local_var_req_builder = match "multi" {
19206            "multi" => local_var_req_builder.query(
19207                &local_var_str
19208                    .into_iter()
19209                    .map(|p| ("created__lte".to_owned(), p.to_string()))
19210                    .collect::<Vec<(std::string::String, std::string::String)>>(),
19211            ),
19212            _ => local_var_req_builder.query(&[(
19213                "created__lte",
19214                &local_var_str
19215                    .into_iter()
19216                    .map(|p| p.to_string())
19217                    .collect::<Vec<String>>()
19218                    .join(",")
19219                    .to_string(),
19220            )]),
19221        };
19222    }
19223    if let Some(ref local_var_str) = created__n {
19224        local_var_req_builder = match "multi" {
19225            "multi" => local_var_req_builder.query(
19226                &local_var_str
19227                    .into_iter()
19228                    .map(|p| ("created__n".to_owned(), p.to_string()))
19229                    .collect::<Vec<(std::string::String, std::string::String)>>(),
19230            ),
19231            _ => local_var_req_builder.query(&[(
19232                "created__n",
19233                &local_var_str
19234                    .into_iter()
19235                    .map(|p| p.to_string())
19236                    .collect::<Vec<String>>()
19237                    .join(",")
19238                    .to_string(),
19239            )]),
19240        };
19241    }
19242    if let Some(ref local_var_str) = created_by_request {
19243        local_var_req_builder =
19244            local_var_req_builder.query(&[("created_by_request", &local_var_str.to_string())]);
19245    }
19246    if let Some(ref local_var_str) = id {
19247        local_var_req_builder = match "multi" {
19248            "multi" => local_var_req_builder.query(
19249                &local_var_str
19250                    .into_iter()
19251                    .map(|p| ("id".to_owned(), p.to_string()))
19252                    .collect::<Vec<(std::string::String, std::string::String)>>(),
19253            ),
19254            _ => local_var_req_builder.query(&[(
19255                "id",
19256                &local_var_str
19257                    .into_iter()
19258                    .map(|p| p.to_string())
19259                    .collect::<Vec<String>>()
19260                    .join(",")
19261                    .to_string(),
19262            )]),
19263        };
19264    }
19265    if let Some(ref local_var_str) = id__empty {
19266        local_var_req_builder =
19267            local_var_req_builder.query(&[("id__empty", &local_var_str.to_string())]);
19268    }
19269    if let Some(ref local_var_str) = id__gt {
19270        local_var_req_builder = match "multi" {
19271            "multi" => local_var_req_builder.query(
19272                &local_var_str
19273                    .into_iter()
19274                    .map(|p| ("id__gt".to_owned(), p.to_string()))
19275                    .collect::<Vec<(std::string::String, std::string::String)>>(),
19276            ),
19277            _ => local_var_req_builder.query(&[(
19278                "id__gt",
19279                &local_var_str
19280                    .into_iter()
19281                    .map(|p| p.to_string())
19282                    .collect::<Vec<String>>()
19283                    .join(",")
19284                    .to_string(),
19285            )]),
19286        };
19287    }
19288    if let Some(ref local_var_str) = id__gte {
19289        local_var_req_builder = match "multi" {
19290            "multi" => local_var_req_builder.query(
19291                &local_var_str
19292                    .into_iter()
19293                    .map(|p| ("id__gte".to_owned(), p.to_string()))
19294                    .collect::<Vec<(std::string::String, std::string::String)>>(),
19295            ),
19296            _ => local_var_req_builder.query(&[(
19297                "id__gte",
19298                &local_var_str
19299                    .into_iter()
19300                    .map(|p| p.to_string())
19301                    .collect::<Vec<String>>()
19302                    .join(",")
19303                    .to_string(),
19304            )]),
19305        };
19306    }
19307    if let Some(ref local_var_str) = id__lt {
19308        local_var_req_builder = match "multi" {
19309            "multi" => local_var_req_builder.query(
19310                &local_var_str
19311                    .into_iter()
19312                    .map(|p| ("id__lt".to_owned(), p.to_string()))
19313                    .collect::<Vec<(std::string::String, std::string::String)>>(),
19314            ),
19315            _ => local_var_req_builder.query(&[(
19316                "id__lt",
19317                &local_var_str
19318                    .into_iter()
19319                    .map(|p| p.to_string())
19320                    .collect::<Vec<String>>()
19321                    .join(",")
19322                    .to_string(),
19323            )]),
19324        };
19325    }
19326    if let Some(ref local_var_str) = id__lte {
19327        local_var_req_builder = match "multi" {
19328            "multi" => local_var_req_builder.query(
19329                &local_var_str
19330                    .into_iter()
19331                    .map(|p| ("id__lte".to_owned(), p.to_string()))
19332                    .collect::<Vec<(std::string::String, std::string::String)>>(),
19333            ),
19334            _ => local_var_req_builder.query(&[(
19335                "id__lte",
19336                &local_var_str
19337                    .into_iter()
19338                    .map(|p| p.to_string())
19339                    .collect::<Vec<String>>()
19340                    .join(",")
19341                    .to_string(),
19342            )]),
19343        };
19344    }
19345    if let Some(ref local_var_str) = id__n {
19346        local_var_req_builder = match "multi" {
19347            "multi" => local_var_req_builder.query(
19348                &local_var_str
19349                    .into_iter()
19350                    .map(|p| ("id__n".to_owned(), p.to_string()))
19351                    .collect::<Vec<(std::string::String, std::string::String)>>(),
19352            ),
19353            _ => local_var_req_builder.query(&[(
19354                "id__n",
19355                &local_var_str
19356                    .into_iter()
19357                    .map(|p| p.to_string())
19358                    .collect::<Vec<String>>()
19359                    .join(",")
19360                    .to_string(),
19361            )]),
19362        };
19363    }
19364    if let Some(ref local_var_str) = interface {
19365        local_var_req_builder = match "multi" {
19366            "multi" => local_var_req_builder.query(
19367                &local_var_str
19368                    .into_iter()
19369                    .map(|p| ("interface".to_owned(), p.to_string()))
19370                    .collect::<Vec<(std::string::String, std::string::String)>>(),
19371            ),
19372            _ => local_var_req_builder.query(&[(
19373                "interface",
19374                &local_var_str
19375                    .into_iter()
19376                    .map(|p| p.to_string())
19377                    .collect::<Vec<String>>()
19378                    .join(",")
19379                    .to_string(),
19380            )]),
19381        };
19382    }
19383    if let Some(ref local_var_str) = interface__n {
19384        local_var_req_builder = match "multi" {
19385            "multi" => local_var_req_builder.query(
19386                &local_var_str
19387                    .into_iter()
19388                    .map(|p| ("interface__n".to_owned(), p.to_string()))
19389                    .collect::<Vec<(std::string::String, std::string::String)>>(),
19390            ),
19391            _ => local_var_req_builder.query(&[(
19392                "interface__n",
19393                &local_var_str
19394                    .into_iter()
19395                    .map(|p| p.to_string())
19396                    .collect::<Vec<String>>()
19397                    .join(",")
19398                    .to_string(),
19399            )]),
19400        };
19401    }
19402    if let Some(ref local_var_str) = interface_id {
19403        local_var_req_builder = match "multi" {
19404            "multi" => local_var_req_builder.query(
19405                &local_var_str
19406                    .into_iter()
19407                    .map(|p| ("interface_id".to_owned(), p.to_string()))
19408                    .collect::<Vec<(std::string::String, std::string::String)>>(),
19409            ),
19410            _ => local_var_req_builder.query(&[(
19411                "interface_id",
19412                &local_var_str
19413                    .into_iter()
19414                    .map(|p| p.to_string())
19415                    .collect::<Vec<String>>()
19416                    .join(",")
19417                    .to_string(),
19418            )]),
19419        };
19420    }
19421    if let Some(ref local_var_str) = interface_id__n {
19422        local_var_req_builder = match "multi" {
19423            "multi" => local_var_req_builder.query(
19424                &local_var_str
19425                    .into_iter()
19426                    .map(|p| ("interface_id__n".to_owned(), p.to_string()))
19427                    .collect::<Vec<(std::string::String, std::string::String)>>(),
19428            ),
19429            _ => local_var_req_builder.query(&[(
19430                "interface_id__n",
19431                &local_var_str
19432                    .into_iter()
19433                    .map(|p| p.to_string())
19434                    .collect::<Vec<String>>()
19435                    .join(",")
19436                    .to_string(),
19437            )]),
19438        };
19439    }
19440    if let Some(ref local_var_str) = last_updated {
19441        local_var_req_builder = match "multi" {
19442            "multi" => local_var_req_builder.query(
19443                &local_var_str
19444                    .into_iter()
19445                    .map(|p| ("last_updated".to_owned(), p.to_string()))
19446                    .collect::<Vec<(std::string::String, std::string::String)>>(),
19447            ),
19448            _ => local_var_req_builder.query(&[(
19449                "last_updated",
19450                &local_var_str
19451                    .into_iter()
19452                    .map(|p| p.to_string())
19453                    .collect::<Vec<String>>()
19454                    .join(",")
19455                    .to_string(),
19456            )]),
19457        };
19458    }
19459    if let Some(ref local_var_str) = last_updated__empty {
19460        local_var_req_builder = match "multi" {
19461            "multi" => local_var_req_builder.query(
19462                &local_var_str
19463                    .into_iter()
19464                    .map(|p| ("last_updated__empty".to_owned(), p.to_string()))
19465                    .collect::<Vec<(std::string::String, std::string::String)>>(),
19466            ),
19467            _ => local_var_req_builder.query(&[(
19468                "last_updated__empty",
19469                &local_var_str
19470                    .into_iter()
19471                    .map(|p| p.to_string())
19472                    .collect::<Vec<String>>()
19473                    .join(",")
19474                    .to_string(),
19475            )]),
19476        };
19477    }
19478    if let Some(ref local_var_str) = last_updated__gt {
19479        local_var_req_builder = match "multi" {
19480            "multi" => local_var_req_builder.query(
19481                &local_var_str
19482                    .into_iter()
19483                    .map(|p| ("last_updated__gt".to_owned(), p.to_string()))
19484                    .collect::<Vec<(std::string::String, std::string::String)>>(),
19485            ),
19486            _ => local_var_req_builder.query(&[(
19487                "last_updated__gt",
19488                &local_var_str
19489                    .into_iter()
19490                    .map(|p| p.to_string())
19491                    .collect::<Vec<String>>()
19492                    .join(",")
19493                    .to_string(),
19494            )]),
19495        };
19496    }
19497    if let Some(ref local_var_str) = last_updated__gte {
19498        local_var_req_builder = match "multi" {
19499            "multi" => local_var_req_builder.query(
19500                &local_var_str
19501                    .into_iter()
19502                    .map(|p| ("last_updated__gte".to_owned(), p.to_string()))
19503                    .collect::<Vec<(std::string::String, std::string::String)>>(),
19504            ),
19505            _ => local_var_req_builder.query(&[(
19506                "last_updated__gte",
19507                &local_var_str
19508                    .into_iter()
19509                    .map(|p| p.to_string())
19510                    .collect::<Vec<String>>()
19511                    .join(",")
19512                    .to_string(),
19513            )]),
19514        };
19515    }
19516    if let Some(ref local_var_str) = last_updated__lt {
19517        local_var_req_builder = match "multi" {
19518            "multi" => local_var_req_builder.query(
19519                &local_var_str
19520                    .into_iter()
19521                    .map(|p| ("last_updated__lt".to_owned(), p.to_string()))
19522                    .collect::<Vec<(std::string::String, std::string::String)>>(),
19523            ),
19524            _ => local_var_req_builder.query(&[(
19525                "last_updated__lt",
19526                &local_var_str
19527                    .into_iter()
19528                    .map(|p| p.to_string())
19529                    .collect::<Vec<String>>()
19530                    .join(",")
19531                    .to_string(),
19532            )]),
19533        };
19534    }
19535    if let Some(ref local_var_str) = last_updated__lte {
19536        local_var_req_builder = match "multi" {
19537            "multi" => local_var_req_builder.query(
19538                &local_var_str
19539                    .into_iter()
19540                    .map(|p| ("last_updated__lte".to_owned(), p.to_string()))
19541                    .collect::<Vec<(std::string::String, std::string::String)>>(),
19542            ),
19543            _ => local_var_req_builder.query(&[(
19544                "last_updated__lte",
19545                &local_var_str
19546                    .into_iter()
19547                    .map(|p| p.to_string())
19548                    .collect::<Vec<String>>()
19549                    .join(",")
19550                    .to_string(),
19551            )]),
19552        };
19553    }
19554    if let Some(ref local_var_str) = last_updated__n {
19555        local_var_req_builder = match "multi" {
19556            "multi" => local_var_req_builder.query(
19557                &local_var_str
19558                    .into_iter()
19559                    .map(|p| ("last_updated__n".to_owned(), p.to_string()))
19560                    .collect::<Vec<(std::string::String, std::string::String)>>(),
19561            ),
19562            _ => local_var_req_builder.query(&[(
19563                "last_updated__n",
19564                &local_var_str
19565                    .into_iter()
19566                    .map(|p| p.to_string())
19567                    .collect::<Vec<String>>()
19568                    .join(",")
19569                    .to_string(),
19570            )]),
19571        };
19572    }
19573    if let Some(ref local_var_str) = limit {
19574        local_var_req_builder =
19575            local_var_req_builder.query(&[("limit", &local_var_str.to_string())]);
19576    }
19577    if let Some(ref local_var_str) = modified_by_request {
19578        local_var_req_builder =
19579            local_var_req_builder.query(&[("modified_by_request", &local_var_str.to_string())]);
19580    }
19581    if let Some(ref local_var_str) = offset {
19582        local_var_req_builder =
19583            local_var_req_builder.query(&[("offset", &local_var_str.to_string())]);
19584    }
19585    if let Some(ref local_var_str) = ordering {
19586        local_var_req_builder =
19587            local_var_req_builder.query(&[("ordering", &local_var_str.to_string())]);
19588    }
19589    if let Some(ref local_var_str) = outside_ip_id {
19590        local_var_req_builder = match "multi" {
19591            "multi" => local_var_req_builder.query(
19592                &local_var_str
19593                    .into_iter()
19594                    .map(|p| ("outside_ip_id".to_owned(), p.to_string()))
19595                    .collect::<Vec<(std::string::String, std::string::String)>>(),
19596            ),
19597            _ => local_var_req_builder.query(&[(
19598                "outside_ip_id",
19599                &local_var_str
19600                    .into_iter()
19601                    .map(|p| p.to_string())
19602                    .collect::<Vec<String>>()
19603                    .join(",")
19604                    .to_string(),
19605            )]),
19606        };
19607    }
19608    if let Some(ref local_var_str) = outside_ip_id__n {
19609        local_var_req_builder = match "multi" {
19610            "multi" => local_var_req_builder.query(
19611                &local_var_str
19612                    .into_iter()
19613                    .map(|p| ("outside_ip_id__n".to_owned(), p.to_string()))
19614                    .collect::<Vec<(std::string::String, std::string::String)>>(),
19615            ),
19616            _ => local_var_req_builder.query(&[(
19617                "outside_ip_id__n",
19618                &local_var_str
19619                    .into_iter()
19620                    .map(|p| p.to_string())
19621                    .collect::<Vec<String>>()
19622                    .join(",")
19623                    .to_string(),
19624            )]),
19625        };
19626    }
19627    if let Some(ref local_var_str) = q {
19628        local_var_req_builder = local_var_req_builder.query(&[("q", &local_var_str.to_string())]);
19629    }
19630    if let Some(ref local_var_str) = role {
19631        local_var_req_builder = match "multi" {
19632            "multi" => local_var_req_builder.query(
19633                &local_var_str
19634                    .into_iter()
19635                    .map(|p| ("role".to_owned(), p.to_string()))
19636                    .collect::<Vec<(std::string::String, std::string::String)>>(),
19637            ),
19638            _ => local_var_req_builder.query(&[(
19639                "role",
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) = role__empty {
19650        local_var_req_builder =
19651            local_var_req_builder.query(&[("role__empty", &local_var_str.to_string())]);
19652    }
19653    if let Some(ref local_var_str) = role__ic {
19654        local_var_req_builder = match "multi" {
19655            "multi" => local_var_req_builder.query(
19656                &local_var_str
19657                    .into_iter()
19658                    .map(|p| ("role__ic".to_owned(), p.to_string()))
19659                    .collect::<Vec<(std::string::String, std::string::String)>>(),
19660            ),
19661            _ => local_var_req_builder.query(&[(
19662                "role__ic",
19663                &local_var_str
19664                    .into_iter()
19665                    .map(|p| p.to_string())
19666                    .collect::<Vec<String>>()
19667                    .join(",")
19668                    .to_string(),
19669            )]),
19670        };
19671    }
19672    if let Some(ref local_var_str) = role__ie {
19673        local_var_req_builder = match "multi" {
19674            "multi" => local_var_req_builder.query(
19675                &local_var_str
19676                    .into_iter()
19677                    .map(|p| ("role__ie".to_owned(), p.to_string()))
19678                    .collect::<Vec<(std::string::String, std::string::String)>>(),
19679            ),
19680            _ => local_var_req_builder.query(&[(
19681                "role__ie",
19682                &local_var_str
19683                    .into_iter()
19684                    .map(|p| p.to_string())
19685                    .collect::<Vec<String>>()
19686                    .join(",")
19687                    .to_string(),
19688            )]),
19689        };
19690    }
19691    if let Some(ref local_var_str) = role__iew {
19692        local_var_req_builder = match "multi" {
19693            "multi" => local_var_req_builder.query(
19694                &local_var_str
19695                    .into_iter()
19696                    .map(|p| ("role__iew".to_owned(), p.to_string()))
19697                    .collect::<Vec<(std::string::String, std::string::String)>>(),
19698            ),
19699            _ => local_var_req_builder.query(&[(
19700                "role__iew",
19701                &local_var_str
19702                    .into_iter()
19703                    .map(|p| p.to_string())
19704                    .collect::<Vec<String>>()
19705                    .join(",")
19706                    .to_string(),
19707            )]),
19708        };
19709    }
19710    if let Some(ref local_var_str) = role__iregex {
19711        local_var_req_builder = match "multi" {
19712            "multi" => local_var_req_builder.query(
19713                &local_var_str
19714                    .into_iter()
19715                    .map(|p| ("role__iregex".to_owned(), p.to_string()))
19716                    .collect::<Vec<(std::string::String, std::string::String)>>(),
19717            ),
19718            _ => local_var_req_builder.query(&[(
19719                "role__iregex",
19720                &local_var_str
19721                    .into_iter()
19722                    .map(|p| p.to_string())
19723                    .collect::<Vec<String>>()
19724                    .join(",")
19725                    .to_string(),
19726            )]),
19727        };
19728    }
19729    if let Some(ref local_var_str) = role__isw {
19730        local_var_req_builder = match "multi" {
19731            "multi" => local_var_req_builder.query(
19732                &local_var_str
19733                    .into_iter()
19734                    .map(|p| ("role__isw".to_owned(), p.to_string()))
19735                    .collect::<Vec<(std::string::String, std::string::String)>>(),
19736            ),
19737            _ => local_var_req_builder.query(&[(
19738                "role__isw",
19739                &local_var_str
19740                    .into_iter()
19741                    .map(|p| p.to_string())
19742                    .collect::<Vec<String>>()
19743                    .join(",")
19744                    .to_string(),
19745            )]),
19746        };
19747    }
19748    if let Some(ref local_var_str) = role__n {
19749        local_var_req_builder = match "multi" {
19750            "multi" => local_var_req_builder.query(
19751                &local_var_str
19752                    .into_iter()
19753                    .map(|p| ("role__n".to_owned(), p.to_string()))
19754                    .collect::<Vec<(std::string::String, std::string::String)>>(),
19755            ),
19756            _ => local_var_req_builder.query(&[(
19757                "role__n",
19758                &local_var_str
19759                    .into_iter()
19760                    .map(|p| p.to_string())
19761                    .collect::<Vec<String>>()
19762                    .join(",")
19763                    .to_string(),
19764            )]),
19765        };
19766    }
19767    if let Some(ref local_var_str) = role__nic {
19768        local_var_req_builder = match "multi" {
19769            "multi" => local_var_req_builder.query(
19770                &local_var_str
19771                    .into_iter()
19772                    .map(|p| ("role__nic".to_owned(), p.to_string()))
19773                    .collect::<Vec<(std::string::String, std::string::String)>>(),
19774            ),
19775            _ => local_var_req_builder.query(&[(
19776                "role__nic",
19777                &local_var_str
19778                    .into_iter()
19779                    .map(|p| p.to_string())
19780                    .collect::<Vec<String>>()
19781                    .join(",")
19782                    .to_string(),
19783            )]),
19784        };
19785    }
19786    if let Some(ref local_var_str) = role__nie {
19787        local_var_req_builder = match "multi" {
19788            "multi" => local_var_req_builder.query(
19789                &local_var_str
19790                    .into_iter()
19791                    .map(|p| ("role__nie".to_owned(), p.to_string()))
19792                    .collect::<Vec<(std::string::String, std::string::String)>>(),
19793            ),
19794            _ => local_var_req_builder.query(&[(
19795                "role__nie",
19796                &local_var_str
19797                    .into_iter()
19798                    .map(|p| p.to_string())
19799                    .collect::<Vec<String>>()
19800                    .join(",")
19801                    .to_string(),
19802            )]),
19803        };
19804    }
19805    if let Some(ref local_var_str) = role__niew {
19806        local_var_req_builder = match "multi" {
19807            "multi" => local_var_req_builder.query(
19808                &local_var_str
19809                    .into_iter()
19810                    .map(|p| ("role__niew".to_owned(), p.to_string()))
19811                    .collect::<Vec<(std::string::String, std::string::String)>>(),
19812            ),
19813            _ => local_var_req_builder.query(&[(
19814                "role__niew",
19815                &local_var_str
19816                    .into_iter()
19817                    .map(|p| p.to_string())
19818                    .collect::<Vec<String>>()
19819                    .join(",")
19820                    .to_string(),
19821            )]),
19822        };
19823    }
19824    if let Some(ref local_var_str) = role__nisw {
19825        local_var_req_builder = match "multi" {
19826            "multi" => local_var_req_builder.query(
19827                &local_var_str
19828                    .into_iter()
19829                    .map(|p| ("role__nisw".to_owned(), p.to_string()))
19830                    .collect::<Vec<(std::string::String, std::string::String)>>(),
19831            ),
19832            _ => local_var_req_builder.query(&[(
19833                "role__nisw",
19834                &local_var_str
19835                    .into_iter()
19836                    .map(|p| p.to_string())
19837                    .collect::<Vec<String>>()
19838                    .join(",")
19839                    .to_string(),
19840            )]),
19841        };
19842    }
19843    if let Some(ref local_var_str) = role__regex {
19844        local_var_req_builder = match "multi" {
19845            "multi" => local_var_req_builder.query(
19846                &local_var_str
19847                    .into_iter()
19848                    .map(|p| ("role__regex".to_owned(), p.to_string()))
19849                    .collect::<Vec<(std::string::String, std::string::String)>>(),
19850            ),
19851            _ => local_var_req_builder.query(&[(
19852                "role__regex",
19853                &local_var_str
19854                    .into_iter()
19855                    .map(|p| p.to_string())
19856                    .collect::<Vec<String>>()
19857                    .join(",")
19858                    .to_string(),
19859            )]),
19860        };
19861    }
19862    if let Some(ref local_var_str) = tag {
19863        local_var_req_builder = match "multi" {
19864            "multi" => local_var_req_builder.query(
19865                &local_var_str
19866                    .into_iter()
19867                    .map(|p| ("tag".to_owned(), p.to_string()))
19868                    .collect::<Vec<(std::string::String, std::string::String)>>(),
19869            ),
19870            _ => local_var_req_builder.query(&[(
19871                "tag",
19872                &local_var_str
19873                    .into_iter()
19874                    .map(|p| p.to_string())
19875                    .collect::<Vec<String>>()
19876                    .join(",")
19877                    .to_string(),
19878            )]),
19879        };
19880    }
19881    if let Some(ref local_var_str) = tag__n {
19882        local_var_req_builder = match "multi" {
19883            "multi" => local_var_req_builder.query(
19884                &local_var_str
19885                    .into_iter()
19886                    .map(|p| ("tag__n".to_owned(), p.to_string()))
19887                    .collect::<Vec<(std::string::String, std::string::String)>>(),
19888            ),
19889            _ => local_var_req_builder.query(&[(
19890                "tag__n",
19891                &local_var_str
19892                    .into_iter()
19893                    .map(|p| p.to_string())
19894                    .collect::<Vec<String>>()
19895                    .join(",")
19896                    .to_string(),
19897            )]),
19898        };
19899    }
19900    if let Some(ref local_var_str) = tag_id {
19901        local_var_req_builder = match "multi" {
19902            "multi" => local_var_req_builder.query(
19903                &local_var_str
19904                    .into_iter()
19905                    .map(|p| ("tag_id".to_owned(), p.to_string()))
19906                    .collect::<Vec<(std::string::String, std::string::String)>>(),
19907            ),
19908            _ => local_var_req_builder.query(&[(
19909                "tag_id",
19910                &local_var_str
19911                    .into_iter()
19912                    .map(|p| p.to_string())
19913                    .collect::<Vec<String>>()
19914                    .join(",")
19915                    .to_string(),
19916            )]),
19917        };
19918    }
19919    if let Some(ref local_var_str) = tag_id__n {
19920        local_var_req_builder = match "multi" {
19921            "multi" => local_var_req_builder.query(
19922                &local_var_str
19923                    .into_iter()
19924                    .map(|p| ("tag_id__n".to_owned(), p.to_string()))
19925                    .collect::<Vec<(std::string::String, std::string::String)>>(),
19926            ),
19927            _ => local_var_req_builder.query(&[(
19928                "tag_id__n",
19929                &local_var_str
19930                    .into_iter()
19931                    .map(|p| p.to_string())
19932                    .collect::<Vec<String>>()
19933                    .join(",")
19934                    .to_string(),
19935            )]),
19936        };
19937    }
19938    if let Some(ref local_var_str) = termination_id {
19939        local_var_req_builder = match "multi" {
19940            "multi" => local_var_req_builder.query(
19941                &local_var_str
19942                    .into_iter()
19943                    .map(|p| ("termination_id".to_owned(), p.to_string()))
19944                    .collect::<Vec<(std::string::String, std::string::String)>>(),
19945            ),
19946            _ => local_var_req_builder.query(&[(
19947                "termination_id",
19948                &local_var_str
19949                    .into_iter()
19950                    .map(|p| p.to_string())
19951                    .collect::<Vec<String>>()
19952                    .join(",")
19953                    .to_string(),
19954            )]),
19955        };
19956    }
19957    if let Some(ref local_var_str) = termination_id__empty {
19958        local_var_req_builder =
19959            local_var_req_builder.query(&[("termination_id__empty", &local_var_str.to_string())]);
19960    }
19961    if let Some(ref local_var_str) = termination_id__gt {
19962        local_var_req_builder = match "multi" {
19963            "multi" => local_var_req_builder.query(
19964                &local_var_str
19965                    .into_iter()
19966                    .map(|p| ("termination_id__gt".to_owned(), p.to_string()))
19967                    .collect::<Vec<(std::string::String, std::string::String)>>(),
19968            ),
19969            _ => local_var_req_builder.query(&[(
19970                "termination_id__gt",
19971                &local_var_str
19972                    .into_iter()
19973                    .map(|p| p.to_string())
19974                    .collect::<Vec<String>>()
19975                    .join(",")
19976                    .to_string(),
19977            )]),
19978        };
19979    }
19980    if let Some(ref local_var_str) = termination_id__gte {
19981        local_var_req_builder = match "multi" {
19982            "multi" => local_var_req_builder.query(
19983                &local_var_str
19984                    .into_iter()
19985                    .map(|p| ("termination_id__gte".to_owned(), p.to_string()))
19986                    .collect::<Vec<(std::string::String, std::string::String)>>(),
19987            ),
19988            _ => local_var_req_builder.query(&[(
19989                "termination_id__gte",
19990                &local_var_str
19991                    .into_iter()
19992                    .map(|p| p.to_string())
19993                    .collect::<Vec<String>>()
19994                    .join(",")
19995                    .to_string(),
19996            )]),
19997        };
19998    }
19999    if let Some(ref local_var_str) = termination_id__lt {
20000        local_var_req_builder = match "multi" {
20001            "multi" => local_var_req_builder.query(
20002                &local_var_str
20003                    .into_iter()
20004                    .map(|p| ("termination_id__lt".to_owned(), p.to_string()))
20005                    .collect::<Vec<(std::string::String, std::string::String)>>(),
20006            ),
20007            _ => local_var_req_builder.query(&[(
20008                "termination_id__lt",
20009                &local_var_str
20010                    .into_iter()
20011                    .map(|p| p.to_string())
20012                    .collect::<Vec<String>>()
20013                    .join(",")
20014                    .to_string(),
20015            )]),
20016        };
20017    }
20018    if let Some(ref local_var_str) = termination_id__lte {
20019        local_var_req_builder = match "multi" {
20020            "multi" => local_var_req_builder.query(
20021                &local_var_str
20022                    .into_iter()
20023                    .map(|p| ("termination_id__lte".to_owned(), p.to_string()))
20024                    .collect::<Vec<(std::string::String, std::string::String)>>(),
20025            ),
20026            _ => local_var_req_builder.query(&[(
20027                "termination_id__lte",
20028                &local_var_str
20029                    .into_iter()
20030                    .map(|p| p.to_string())
20031                    .collect::<Vec<String>>()
20032                    .join(",")
20033                    .to_string(),
20034            )]),
20035        };
20036    }
20037    if let Some(ref local_var_str) = termination_id__n {
20038        local_var_req_builder = match "multi" {
20039            "multi" => local_var_req_builder.query(
20040                &local_var_str
20041                    .into_iter()
20042                    .map(|p| ("termination_id__n".to_owned(), p.to_string()))
20043                    .collect::<Vec<(std::string::String, std::string::String)>>(),
20044            ),
20045            _ => local_var_req_builder.query(&[(
20046                "termination_id__n",
20047                &local_var_str
20048                    .into_iter()
20049                    .map(|p| p.to_string())
20050                    .collect::<Vec<String>>()
20051                    .join(",")
20052                    .to_string(),
20053            )]),
20054        };
20055    }
20056    if let Some(ref local_var_str) = termination_type {
20057        local_var_req_builder = match "multi" {
20058            "multi" => local_var_req_builder.query(
20059                &local_var_str
20060                    .into_iter()
20061                    .map(|p| ("termination_type".to_owned(), p.to_string()))
20062                    .collect::<Vec<(std::string::String, std::string::String)>>(),
20063            ),
20064            _ => local_var_req_builder.query(&[(
20065                "termination_type",
20066                &local_var_str
20067                    .into_iter()
20068                    .map(|p| p.to_string())
20069                    .collect::<Vec<String>>()
20070                    .join(",")
20071                    .to_string(),
20072            )]),
20073        };
20074    }
20075    if let Some(ref local_var_str) = termination_type__n {
20076        local_var_req_builder = match "multi" {
20077            "multi" => local_var_req_builder.query(
20078                &local_var_str
20079                    .into_iter()
20080                    .map(|p| ("termination_type__n".to_owned(), p.to_string()))
20081                    .collect::<Vec<(std::string::String, std::string::String)>>(),
20082            ),
20083            _ => local_var_req_builder.query(&[(
20084                "termination_type__n",
20085                &local_var_str
20086                    .into_iter()
20087                    .map(|p| p.to_string())
20088                    .collect::<Vec<String>>()
20089                    .join(",")
20090                    .to_string(),
20091            )]),
20092        };
20093    }
20094    if let Some(ref local_var_str) = tunnel {
20095        local_var_req_builder = match "multi" {
20096            "multi" => local_var_req_builder.query(
20097                &local_var_str
20098                    .into_iter()
20099                    .map(|p| ("tunnel".to_owned(), p.to_string()))
20100                    .collect::<Vec<(std::string::String, std::string::String)>>(),
20101            ),
20102            _ => local_var_req_builder.query(&[(
20103                "tunnel",
20104                &local_var_str
20105                    .into_iter()
20106                    .map(|p| p.to_string())
20107                    .collect::<Vec<String>>()
20108                    .join(",")
20109                    .to_string(),
20110            )]),
20111        };
20112    }
20113    if let Some(ref local_var_str) = tunnel__n {
20114        local_var_req_builder = match "multi" {
20115            "multi" => local_var_req_builder.query(
20116                &local_var_str
20117                    .into_iter()
20118                    .map(|p| ("tunnel__n".to_owned(), p.to_string()))
20119                    .collect::<Vec<(std::string::String, std::string::String)>>(),
20120            ),
20121            _ => local_var_req_builder.query(&[(
20122                "tunnel__n",
20123                &local_var_str
20124                    .into_iter()
20125                    .map(|p| p.to_string())
20126                    .collect::<Vec<String>>()
20127                    .join(",")
20128                    .to_string(),
20129            )]),
20130        };
20131    }
20132    if let Some(ref local_var_str) = tunnel_id {
20133        local_var_req_builder = match "multi" {
20134            "multi" => local_var_req_builder.query(
20135                &local_var_str
20136                    .into_iter()
20137                    .map(|p| ("tunnel_id".to_owned(), p.to_string()))
20138                    .collect::<Vec<(std::string::String, std::string::String)>>(),
20139            ),
20140            _ => local_var_req_builder.query(&[(
20141                "tunnel_id",
20142                &local_var_str
20143                    .into_iter()
20144                    .map(|p| p.to_string())
20145                    .collect::<Vec<String>>()
20146                    .join(",")
20147                    .to_string(),
20148            )]),
20149        };
20150    }
20151    if let Some(ref local_var_str) = tunnel_id__n {
20152        local_var_req_builder = match "multi" {
20153            "multi" => local_var_req_builder.query(
20154                &local_var_str
20155                    .into_iter()
20156                    .map(|p| ("tunnel_id__n".to_owned(), p.to_string()))
20157                    .collect::<Vec<(std::string::String, std::string::String)>>(),
20158            ),
20159            _ => local_var_req_builder.query(&[(
20160                "tunnel_id__n",
20161                &local_var_str
20162                    .into_iter()
20163                    .map(|p| p.to_string())
20164                    .collect::<Vec<String>>()
20165                    .join(",")
20166                    .to_string(),
20167            )]),
20168        };
20169    }
20170    if let Some(ref local_var_str) = updated_by_request {
20171        local_var_req_builder =
20172            local_var_req_builder.query(&[("updated_by_request", &local_var_str.to_string())]);
20173    }
20174    if let Some(ref local_var_str) = vminterface {
20175        local_var_req_builder = match "multi" {
20176            "multi" => local_var_req_builder.query(
20177                &local_var_str
20178                    .into_iter()
20179                    .map(|p| ("vminterface".to_owned(), p.to_string()))
20180                    .collect::<Vec<(std::string::String, std::string::String)>>(),
20181            ),
20182            _ => local_var_req_builder.query(&[(
20183                "vminterface",
20184                &local_var_str
20185                    .into_iter()
20186                    .map(|p| p.to_string())
20187                    .collect::<Vec<String>>()
20188                    .join(",")
20189                    .to_string(),
20190            )]),
20191        };
20192    }
20193    if let Some(ref local_var_str) = vminterface__n {
20194        local_var_req_builder = match "multi" {
20195            "multi" => local_var_req_builder.query(
20196                &local_var_str
20197                    .into_iter()
20198                    .map(|p| ("vminterface__n".to_owned(), p.to_string()))
20199                    .collect::<Vec<(std::string::String, std::string::String)>>(),
20200            ),
20201            _ => local_var_req_builder.query(&[(
20202                "vminterface__n",
20203                &local_var_str
20204                    .into_iter()
20205                    .map(|p| p.to_string())
20206                    .collect::<Vec<String>>()
20207                    .join(",")
20208                    .to_string(),
20209            )]),
20210        };
20211    }
20212    if let Some(ref local_var_str) = vminterface_id {
20213        local_var_req_builder = match "multi" {
20214            "multi" => local_var_req_builder.query(
20215                &local_var_str
20216                    .into_iter()
20217                    .map(|p| ("vminterface_id".to_owned(), p.to_string()))
20218                    .collect::<Vec<(std::string::String, std::string::String)>>(),
20219            ),
20220            _ => local_var_req_builder.query(&[(
20221                "vminterface_id",
20222                &local_var_str
20223                    .into_iter()
20224                    .map(|p| p.to_string())
20225                    .collect::<Vec<String>>()
20226                    .join(",")
20227                    .to_string(),
20228            )]),
20229        };
20230    }
20231    if let Some(ref local_var_str) = vminterface_id__n {
20232        local_var_req_builder = match "multi" {
20233            "multi" => local_var_req_builder.query(
20234                &local_var_str
20235                    .into_iter()
20236                    .map(|p| ("vminterface_id__n".to_owned(), p.to_string()))
20237                    .collect::<Vec<(std::string::String, std::string::String)>>(),
20238            ),
20239            _ => local_var_req_builder.query(&[(
20240                "vminterface_id__n",
20241                &local_var_str
20242                    .into_iter()
20243                    .map(|p| p.to_string())
20244                    .collect::<Vec<String>>()
20245                    .join(",")
20246                    .to_string(),
20247            )]),
20248        };
20249    }
20250    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
20251        local_var_req_builder =
20252            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
20253    }
20254    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
20255        let local_var_key = local_var_apikey.key.clone();
20256        let local_var_value = match local_var_apikey.prefix {
20257            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
20258            None => local_var_key,
20259        };
20260        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
20261    };
20262
20263    let local_var_req = local_var_req_builder.build()?;
20264    let local_var_resp = local_var_client.execute(local_var_req).await?;
20265
20266    let local_var_status = local_var_resp.status();
20267    let local_var_content = local_var_resp.text().await?;
20268
20269    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
20270        serde_json::from_str(&local_var_content).map_err(Error::from)
20271    } else {
20272        let local_var_entity: Option<VpnTunnelTerminationsListError> =
20273            serde_json::from_str(&local_var_content).ok();
20274        let local_var_error = ResponseContent {
20275            status: local_var_status,
20276            content: local_var_content,
20277            entity: local_var_entity,
20278        };
20279        Err(Error::ResponseError(local_var_error))
20280    }
20281}
20282
20283/// Patch a tunnel termination object.
20284pub async fn vpn_tunnel_terminations_partial_update(
20285    configuration: &configuration::Configuration,
20286    id: i32,
20287    patched_writable_tunnel_termination_request: Option<
20288        crate::models::PatchedWritableTunnelTerminationRequest,
20289    >,
20290) -> Result<crate::models::TunnelTermination, Error<VpnTunnelTerminationsPartialUpdateError>> {
20291    let local_var_configuration = configuration;
20292
20293    let local_var_client = &local_var_configuration.client;
20294
20295    let local_var_uri_str = format!(
20296        "{}/api/vpn/tunnel-terminations/{id}/",
20297        local_var_configuration.base_path,
20298        id = id
20299    );
20300    let mut local_var_req_builder =
20301        local_var_client.request(reqwest::Method::PATCH, local_var_uri_str.as_str());
20302
20303    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
20304        local_var_req_builder =
20305            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
20306    }
20307    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
20308        let local_var_key = local_var_apikey.key.clone();
20309        let local_var_value = match local_var_apikey.prefix {
20310            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
20311            None => local_var_key,
20312        };
20313        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
20314    };
20315    local_var_req_builder =
20316        local_var_req_builder.json(&patched_writable_tunnel_termination_request);
20317
20318    let local_var_req = local_var_req_builder.build()?;
20319    let local_var_resp = local_var_client.execute(local_var_req).await?;
20320
20321    let local_var_status = local_var_resp.status();
20322    let local_var_content = local_var_resp.text().await?;
20323
20324    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
20325        serde_json::from_str(&local_var_content).map_err(Error::from)
20326    } else {
20327        let local_var_entity: Option<VpnTunnelTerminationsPartialUpdateError> =
20328            serde_json::from_str(&local_var_content).ok();
20329        let local_var_error = ResponseContent {
20330            status: local_var_status,
20331            content: local_var_content,
20332            entity: local_var_entity,
20333        };
20334        Err(Error::ResponseError(local_var_error))
20335    }
20336}
20337
20338/// Get a tunnel termination object.
20339pub async fn vpn_tunnel_terminations_retrieve(
20340    configuration: &configuration::Configuration,
20341    id: i32,
20342) -> Result<crate::models::TunnelTermination, Error<VpnTunnelTerminationsRetrieveError>> {
20343    let local_var_configuration = configuration;
20344
20345    let local_var_client = &local_var_configuration.client;
20346
20347    let local_var_uri_str = format!(
20348        "{}/api/vpn/tunnel-terminations/{id}/",
20349        local_var_configuration.base_path,
20350        id = id
20351    );
20352    let mut local_var_req_builder =
20353        local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
20354
20355    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
20356        local_var_req_builder =
20357            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
20358    }
20359    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
20360        let local_var_key = local_var_apikey.key.clone();
20361        let local_var_value = match local_var_apikey.prefix {
20362            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
20363            None => local_var_key,
20364        };
20365        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
20366    };
20367
20368    let local_var_req = local_var_req_builder.build()?;
20369    let local_var_resp = local_var_client.execute(local_var_req).await?;
20370
20371    let local_var_status = local_var_resp.status();
20372    let local_var_content = local_var_resp.text().await?;
20373
20374    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
20375        serde_json::from_str(&local_var_content).map_err(Error::from)
20376    } else {
20377        let local_var_entity: Option<VpnTunnelTerminationsRetrieveError> =
20378            serde_json::from_str(&local_var_content).ok();
20379        let local_var_error = ResponseContent {
20380            status: local_var_status,
20381            content: local_var_content,
20382            entity: local_var_entity,
20383        };
20384        Err(Error::ResponseError(local_var_error))
20385    }
20386}
20387
20388/// Put a tunnel termination object.
20389pub async fn vpn_tunnel_terminations_update(
20390    configuration: &configuration::Configuration,
20391    id: i32,
20392    writable_tunnel_termination_request: crate::models::WritableTunnelTerminationRequest,
20393) -> Result<crate::models::TunnelTermination, Error<VpnTunnelTerminationsUpdateError>> {
20394    let local_var_configuration = configuration;
20395
20396    let local_var_client = &local_var_configuration.client;
20397
20398    let local_var_uri_str = format!(
20399        "{}/api/vpn/tunnel-terminations/{id}/",
20400        local_var_configuration.base_path,
20401        id = id
20402    );
20403    let mut local_var_req_builder =
20404        local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());
20405
20406    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
20407        local_var_req_builder =
20408            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
20409    }
20410    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
20411        let local_var_key = local_var_apikey.key.clone();
20412        let local_var_value = match local_var_apikey.prefix {
20413            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
20414            None => local_var_key,
20415        };
20416        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
20417    };
20418    local_var_req_builder = local_var_req_builder.json(&writable_tunnel_termination_request);
20419
20420    let local_var_req = local_var_req_builder.build()?;
20421    let local_var_resp = local_var_client.execute(local_var_req).await?;
20422
20423    let local_var_status = local_var_resp.status();
20424    let local_var_content = local_var_resp.text().await?;
20425
20426    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
20427        serde_json::from_str(&local_var_content).map_err(Error::from)
20428    } else {
20429        let local_var_entity: Option<VpnTunnelTerminationsUpdateError> =
20430            serde_json::from_str(&local_var_content).ok();
20431        let local_var_error = ResponseContent {
20432            status: local_var_status,
20433            content: local_var_content,
20434            entity: local_var_entity,
20435        };
20436        Err(Error::ResponseError(local_var_error))
20437    }
20438}
20439
20440/// Delete a list of tunnel objects.
20441pub async fn vpn_tunnels_bulk_destroy(
20442    configuration: &configuration::Configuration,
20443    tunnel_request: Vec<crate::models::TunnelRequest>,
20444) -> Result<(), Error<VpnTunnelsBulkDestroyError>> {
20445    let local_var_configuration = configuration;
20446
20447    let local_var_client = &local_var_configuration.client;
20448
20449    let local_var_uri_str = format!("{}/api/vpn/tunnels/", local_var_configuration.base_path);
20450    let mut local_var_req_builder =
20451        local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());
20452
20453    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
20454        local_var_req_builder =
20455            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
20456    }
20457    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
20458        let local_var_key = local_var_apikey.key.clone();
20459        let local_var_value = match local_var_apikey.prefix {
20460            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
20461            None => local_var_key,
20462        };
20463        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
20464    };
20465    local_var_req_builder = local_var_req_builder.json(&tunnel_request);
20466
20467    let local_var_req = local_var_req_builder.build()?;
20468    let local_var_resp = local_var_client.execute(local_var_req).await?;
20469
20470    let local_var_status = local_var_resp.status();
20471    let local_var_content = local_var_resp.text().await?;
20472
20473    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
20474        Ok(())
20475    } else {
20476        let local_var_entity: Option<VpnTunnelsBulkDestroyError> =
20477            serde_json::from_str(&local_var_content).ok();
20478        let local_var_error = ResponseContent {
20479            status: local_var_status,
20480            content: local_var_content,
20481            entity: local_var_entity,
20482        };
20483        Err(Error::ResponseError(local_var_error))
20484    }
20485}
20486
20487/// Patch a list of tunnel objects.
20488pub async fn vpn_tunnels_bulk_partial_update(
20489    configuration: &configuration::Configuration,
20490    tunnel_request: Vec<crate::models::TunnelRequest>,
20491) -> Result<Vec<crate::models::Tunnel>, Error<VpnTunnelsBulkPartialUpdateError>> {
20492    let local_var_configuration = configuration;
20493
20494    let local_var_client = &local_var_configuration.client;
20495
20496    let local_var_uri_str = format!("{}/api/vpn/tunnels/", local_var_configuration.base_path);
20497    let mut local_var_req_builder =
20498        local_var_client.request(reqwest::Method::PATCH, local_var_uri_str.as_str());
20499
20500    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
20501        local_var_req_builder =
20502            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
20503    }
20504    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
20505        let local_var_key = local_var_apikey.key.clone();
20506        let local_var_value = match local_var_apikey.prefix {
20507            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
20508            None => local_var_key,
20509        };
20510        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
20511    };
20512    local_var_req_builder = local_var_req_builder.json(&tunnel_request);
20513
20514    let local_var_req = local_var_req_builder.build()?;
20515    let local_var_resp = local_var_client.execute(local_var_req).await?;
20516
20517    let local_var_status = local_var_resp.status();
20518    let local_var_content = local_var_resp.text().await?;
20519
20520    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
20521        serde_json::from_str(&local_var_content).map_err(Error::from)
20522    } else {
20523        let local_var_entity: Option<VpnTunnelsBulkPartialUpdateError> =
20524            serde_json::from_str(&local_var_content).ok();
20525        let local_var_error = ResponseContent {
20526            status: local_var_status,
20527            content: local_var_content,
20528            entity: local_var_entity,
20529        };
20530        Err(Error::ResponseError(local_var_error))
20531    }
20532}
20533
20534/// Put a list of tunnel objects.
20535pub async fn vpn_tunnels_bulk_update(
20536    configuration: &configuration::Configuration,
20537    tunnel_request: Vec<crate::models::TunnelRequest>,
20538) -> Result<Vec<crate::models::Tunnel>, Error<VpnTunnelsBulkUpdateError>> {
20539    let local_var_configuration = configuration;
20540
20541    let local_var_client = &local_var_configuration.client;
20542
20543    let local_var_uri_str = format!("{}/api/vpn/tunnels/", local_var_configuration.base_path);
20544    let mut local_var_req_builder =
20545        local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());
20546
20547    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
20548        local_var_req_builder =
20549            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
20550    }
20551    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
20552        let local_var_key = local_var_apikey.key.clone();
20553        let local_var_value = match local_var_apikey.prefix {
20554            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
20555            None => local_var_key,
20556        };
20557        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
20558    };
20559    local_var_req_builder = local_var_req_builder.json(&tunnel_request);
20560
20561    let local_var_req = local_var_req_builder.build()?;
20562    let local_var_resp = local_var_client.execute(local_var_req).await?;
20563
20564    let local_var_status = local_var_resp.status();
20565    let local_var_content = local_var_resp.text().await?;
20566
20567    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
20568        serde_json::from_str(&local_var_content).map_err(Error::from)
20569    } else {
20570        let local_var_entity: Option<VpnTunnelsBulkUpdateError> =
20571            serde_json::from_str(&local_var_content).ok();
20572        let local_var_error = ResponseContent {
20573            status: local_var_status,
20574            content: local_var_content,
20575            entity: local_var_entity,
20576        };
20577        Err(Error::ResponseError(local_var_error))
20578    }
20579}
20580
20581/// Post a list of tunnel objects.
20582pub async fn vpn_tunnels_create(
20583    configuration: &configuration::Configuration,
20584    vpn_tunnels_create_request: crate::models::VpnTunnelsCreateRequest,
20585) -> Result<crate::models::Tunnel, Error<VpnTunnelsCreateError>> {
20586    let local_var_configuration = configuration;
20587
20588    let local_var_client = &local_var_configuration.client;
20589
20590    let local_var_uri_str = format!("{}/api/vpn/tunnels/", local_var_configuration.base_path);
20591    let mut local_var_req_builder =
20592        local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
20593
20594    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
20595        local_var_req_builder =
20596            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
20597    }
20598    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
20599        let local_var_key = local_var_apikey.key.clone();
20600        let local_var_value = match local_var_apikey.prefix {
20601            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
20602            None => local_var_key,
20603        };
20604        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
20605    };
20606    local_var_req_builder = local_var_req_builder.json(&vpn_tunnels_create_request);
20607
20608    let local_var_req = local_var_req_builder.build()?;
20609    let local_var_resp = local_var_client.execute(local_var_req).await?;
20610
20611    let local_var_status = local_var_resp.status();
20612    let local_var_content = local_var_resp.text().await?;
20613
20614    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
20615        serde_json::from_str(&local_var_content).map_err(Error::from)
20616    } else {
20617        let local_var_entity: Option<VpnTunnelsCreateError> =
20618            serde_json::from_str(&local_var_content).ok();
20619        let local_var_error = ResponseContent {
20620            status: local_var_status,
20621            content: local_var_content,
20622            entity: local_var_entity,
20623        };
20624        Err(Error::ResponseError(local_var_error))
20625    }
20626}
20627
20628/// Delete a tunnel object.
20629pub async fn vpn_tunnels_destroy(
20630    configuration: &configuration::Configuration,
20631    id: i32,
20632) -> Result<(), Error<VpnTunnelsDestroyError>> {
20633    let local_var_configuration = configuration;
20634
20635    let local_var_client = &local_var_configuration.client;
20636
20637    let local_var_uri_str = format!(
20638        "{}/api/vpn/tunnels/{id}/",
20639        local_var_configuration.base_path,
20640        id = id
20641    );
20642    let mut local_var_req_builder =
20643        local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());
20644
20645    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
20646        local_var_req_builder =
20647            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
20648    }
20649    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
20650        let local_var_key = local_var_apikey.key.clone();
20651        let local_var_value = match local_var_apikey.prefix {
20652            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
20653            None => local_var_key,
20654        };
20655        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
20656    };
20657
20658    let local_var_req = local_var_req_builder.build()?;
20659    let local_var_resp = local_var_client.execute(local_var_req).await?;
20660
20661    let local_var_status = local_var_resp.status();
20662    let local_var_content = local_var_resp.text().await?;
20663
20664    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
20665        Ok(())
20666    } else {
20667        let local_var_entity: Option<VpnTunnelsDestroyError> =
20668            serde_json::from_str(&local_var_content).ok();
20669        let local_var_error = ResponseContent {
20670            status: local_var_status,
20671            content: local_var_content,
20672            entity: local_var_entity,
20673        };
20674        Err(Error::ResponseError(local_var_error))
20675    }
20676}
20677
20678/// Get a list of tunnel objects.
20679pub async fn vpn_tunnels_list(
20680    configuration: &configuration::Configuration,
20681    contact: Option<Vec<i32>>,
20682    contact__n: Option<Vec<i32>>,
20683    contact_group: Option<Vec<String>>,
20684    contact_group__n: Option<Vec<String>>,
20685    contact_role: Option<Vec<i32>>,
20686    contact_role__n: Option<Vec<i32>>,
20687    created: Option<Vec<String>>,
20688    created__empty: Option<Vec<String>>,
20689    created__gt: Option<Vec<String>>,
20690    created__gte: Option<Vec<String>>,
20691    created__lt: Option<Vec<String>>,
20692    created__lte: Option<Vec<String>>,
20693    created__n: Option<Vec<String>>,
20694    created_by_request: Option<&str>,
20695    description: Option<Vec<String>>,
20696    description__empty: Option<bool>,
20697    description__ic: Option<Vec<String>>,
20698    description__ie: Option<Vec<String>>,
20699    description__iew: Option<Vec<String>>,
20700    description__iregex: Option<Vec<String>>,
20701    description__isw: Option<Vec<String>>,
20702    description__n: Option<Vec<String>>,
20703    description__nic: Option<Vec<String>>,
20704    description__nie: Option<Vec<String>>,
20705    description__niew: Option<Vec<String>>,
20706    description__nisw: Option<Vec<String>>,
20707    description__regex: Option<Vec<String>>,
20708    encapsulation: Option<Vec<String>>,
20709    encapsulation__empty: Option<bool>,
20710    encapsulation__ic: Option<Vec<String>>,
20711    encapsulation__ie: Option<Vec<String>>,
20712    encapsulation__iew: Option<Vec<String>>,
20713    encapsulation__iregex: Option<Vec<String>>,
20714    encapsulation__isw: Option<Vec<String>>,
20715    encapsulation__n: Option<Vec<String>>,
20716    encapsulation__nic: Option<Vec<String>>,
20717    encapsulation__nie: Option<Vec<String>>,
20718    encapsulation__niew: Option<Vec<String>>,
20719    encapsulation__nisw: Option<Vec<String>>,
20720    encapsulation__regex: Option<Vec<String>>,
20721    group: Option<Vec<String>>,
20722    group__n: Option<Vec<String>>,
20723    group_id: Option<Vec<i32>>,
20724    group_id__n: Option<Vec<i32>>,
20725    id: Option<Vec<i32>>,
20726    id__empty: Option<bool>,
20727    id__gt: Option<Vec<i32>>,
20728    id__gte: Option<Vec<i32>>,
20729    id__lt: Option<Vec<i32>>,
20730    id__lte: Option<Vec<i32>>,
20731    id__n: Option<Vec<i32>>,
20732    ipsec_profile: Option<Vec<String>>,
20733    ipsec_profile__n: Option<Vec<String>>,
20734    ipsec_profile_id: Option<Vec<i32>>,
20735    ipsec_profile_id__n: Option<Vec<i32>>,
20736    last_updated: Option<Vec<String>>,
20737    last_updated__empty: Option<Vec<String>>,
20738    last_updated__gt: Option<Vec<String>>,
20739    last_updated__gte: Option<Vec<String>>,
20740    last_updated__lt: Option<Vec<String>>,
20741    last_updated__lte: Option<Vec<String>>,
20742    last_updated__n: Option<Vec<String>>,
20743    limit: Option<i32>,
20744    modified_by_request: Option<&str>,
20745    name: Option<Vec<String>>,
20746    name__empty: Option<bool>,
20747    name__ic: Option<Vec<String>>,
20748    name__ie: Option<Vec<String>>,
20749    name__iew: Option<Vec<String>>,
20750    name__iregex: Option<Vec<String>>,
20751    name__isw: Option<Vec<String>>,
20752    name__n: Option<Vec<String>>,
20753    name__nic: Option<Vec<String>>,
20754    name__nie: Option<Vec<String>>,
20755    name__niew: Option<Vec<String>>,
20756    name__nisw: Option<Vec<String>>,
20757    name__regex: Option<Vec<String>>,
20758    offset: Option<i32>,
20759    ordering: Option<&str>,
20760    owner: Option<Vec<String>>,
20761    owner__n: Option<Vec<String>>,
20762    owner_group: Option<Vec<String>>,
20763    owner_group__n: Option<Vec<String>>,
20764    owner_group_id: Option<Vec<i32>>,
20765    owner_group_id__n: Option<Vec<i32>>,
20766    owner_id: Option<Vec<i32>>,
20767    owner_id__n: Option<Vec<i32>>,
20768    q: Option<&str>,
20769    status: Option<Vec<String>>,
20770    status__empty: Option<bool>,
20771    status__ic: Option<Vec<String>>,
20772    status__ie: Option<Vec<String>>,
20773    status__iew: Option<Vec<String>>,
20774    status__iregex: Option<Vec<String>>,
20775    status__isw: Option<Vec<String>>,
20776    status__n: Option<Vec<String>>,
20777    status__nic: Option<Vec<String>>,
20778    status__nie: Option<Vec<String>>,
20779    status__niew: Option<Vec<String>>,
20780    status__nisw: Option<Vec<String>>,
20781    status__regex: Option<Vec<String>>,
20782    tag: Option<Vec<String>>,
20783    tag__n: Option<Vec<String>>,
20784    tag_id: Option<Vec<i32>>,
20785    tag_id__n: Option<Vec<i32>>,
20786    tenant: Option<Vec<String>>,
20787    tenant__n: Option<Vec<String>>,
20788    tenant_group: Option<Vec<String>>,
20789    tenant_group__n: Option<Vec<String>>,
20790    tenant_group_id: Option<Vec<String>>,
20791    tenant_group_id__n: Option<Vec<String>>,
20792    tenant_id: Option<Vec<i32>>,
20793    tenant_id__n: Option<Vec<i32>>,
20794    tunnel_id: Option<Vec<i32>>,
20795    tunnel_id__empty: Option<bool>,
20796    tunnel_id__gt: Option<Vec<i32>>,
20797    tunnel_id__gte: Option<Vec<i32>>,
20798    tunnel_id__lt: Option<Vec<i32>>,
20799    tunnel_id__lte: Option<Vec<i32>>,
20800    tunnel_id__n: Option<Vec<i32>>,
20801    updated_by_request: Option<&str>,
20802) -> Result<crate::models::PaginatedTunnelList, Error<VpnTunnelsListError>> {
20803    let local_var_configuration = configuration;
20804
20805    let local_var_client = &local_var_configuration.client;
20806
20807    let local_var_uri_str = format!("{}/api/vpn/tunnels/", local_var_configuration.base_path);
20808    let mut local_var_req_builder =
20809        local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
20810
20811    if let Some(ref local_var_str) = contact {
20812        local_var_req_builder = match "multi" {
20813            "multi" => local_var_req_builder.query(
20814                &local_var_str
20815                    .into_iter()
20816                    .map(|p| ("contact".to_owned(), p.to_string()))
20817                    .collect::<Vec<(std::string::String, std::string::String)>>(),
20818            ),
20819            _ => local_var_req_builder.query(&[(
20820                "contact",
20821                &local_var_str
20822                    .into_iter()
20823                    .map(|p| p.to_string())
20824                    .collect::<Vec<String>>()
20825                    .join(",")
20826                    .to_string(),
20827            )]),
20828        };
20829    }
20830    if let Some(ref local_var_str) = contact__n {
20831        local_var_req_builder = match "multi" {
20832            "multi" => local_var_req_builder.query(
20833                &local_var_str
20834                    .into_iter()
20835                    .map(|p| ("contact__n".to_owned(), p.to_string()))
20836                    .collect::<Vec<(std::string::String, std::string::String)>>(),
20837            ),
20838            _ => local_var_req_builder.query(&[(
20839                "contact__n",
20840                &local_var_str
20841                    .into_iter()
20842                    .map(|p| p.to_string())
20843                    .collect::<Vec<String>>()
20844                    .join(",")
20845                    .to_string(),
20846            )]),
20847        };
20848    }
20849    if let Some(ref local_var_str) = contact_group {
20850        local_var_req_builder = match "multi" {
20851            "multi" => local_var_req_builder.query(
20852                &local_var_str
20853                    .into_iter()
20854                    .map(|p| ("contact_group".to_owned(), p.to_string()))
20855                    .collect::<Vec<(std::string::String, std::string::String)>>(),
20856            ),
20857            _ => local_var_req_builder.query(&[(
20858                "contact_group",
20859                &local_var_str
20860                    .into_iter()
20861                    .map(|p| p.to_string())
20862                    .collect::<Vec<String>>()
20863                    .join(",")
20864                    .to_string(),
20865            )]),
20866        };
20867    }
20868    if let Some(ref local_var_str) = contact_group__n {
20869        local_var_req_builder = match "multi" {
20870            "multi" => local_var_req_builder.query(
20871                &local_var_str
20872                    .into_iter()
20873                    .map(|p| ("contact_group__n".to_owned(), p.to_string()))
20874                    .collect::<Vec<(std::string::String, std::string::String)>>(),
20875            ),
20876            _ => local_var_req_builder.query(&[(
20877                "contact_group__n",
20878                &local_var_str
20879                    .into_iter()
20880                    .map(|p| p.to_string())
20881                    .collect::<Vec<String>>()
20882                    .join(",")
20883                    .to_string(),
20884            )]),
20885        };
20886    }
20887    if let Some(ref local_var_str) = contact_role {
20888        local_var_req_builder = match "multi" {
20889            "multi" => local_var_req_builder.query(
20890                &local_var_str
20891                    .into_iter()
20892                    .map(|p| ("contact_role".to_owned(), p.to_string()))
20893                    .collect::<Vec<(std::string::String, std::string::String)>>(),
20894            ),
20895            _ => local_var_req_builder.query(&[(
20896                "contact_role",
20897                &local_var_str
20898                    .into_iter()
20899                    .map(|p| p.to_string())
20900                    .collect::<Vec<String>>()
20901                    .join(",")
20902                    .to_string(),
20903            )]),
20904        };
20905    }
20906    if let Some(ref local_var_str) = contact_role__n {
20907        local_var_req_builder = match "multi" {
20908            "multi" => local_var_req_builder.query(
20909                &local_var_str
20910                    .into_iter()
20911                    .map(|p| ("contact_role__n".to_owned(), p.to_string()))
20912                    .collect::<Vec<(std::string::String, std::string::String)>>(),
20913            ),
20914            _ => local_var_req_builder.query(&[(
20915                "contact_role__n",
20916                &local_var_str
20917                    .into_iter()
20918                    .map(|p| p.to_string())
20919                    .collect::<Vec<String>>()
20920                    .join(",")
20921                    .to_string(),
20922            )]),
20923        };
20924    }
20925    if let Some(ref local_var_str) = created {
20926        local_var_req_builder = match "multi" {
20927            "multi" => local_var_req_builder.query(
20928                &local_var_str
20929                    .into_iter()
20930                    .map(|p| ("created".to_owned(), p.to_string()))
20931                    .collect::<Vec<(std::string::String, std::string::String)>>(),
20932            ),
20933            _ => local_var_req_builder.query(&[(
20934                "created",
20935                &local_var_str
20936                    .into_iter()
20937                    .map(|p| p.to_string())
20938                    .collect::<Vec<String>>()
20939                    .join(",")
20940                    .to_string(),
20941            )]),
20942        };
20943    }
20944    if let Some(ref local_var_str) = created__empty {
20945        local_var_req_builder = match "multi" {
20946            "multi" => local_var_req_builder.query(
20947                &local_var_str
20948                    .into_iter()
20949                    .map(|p| ("created__empty".to_owned(), p.to_string()))
20950                    .collect::<Vec<(std::string::String, std::string::String)>>(),
20951            ),
20952            _ => local_var_req_builder.query(&[(
20953                "created__empty",
20954                &local_var_str
20955                    .into_iter()
20956                    .map(|p| p.to_string())
20957                    .collect::<Vec<String>>()
20958                    .join(",")
20959                    .to_string(),
20960            )]),
20961        };
20962    }
20963    if let Some(ref local_var_str) = created__gt {
20964        local_var_req_builder = match "multi" {
20965            "multi" => local_var_req_builder.query(
20966                &local_var_str
20967                    .into_iter()
20968                    .map(|p| ("created__gt".to_owned(), p.to_string()))
20969                    .collect::<Vec<(std::string::String, std::string::String)>>(),
20970            ),
20971            _ => local_var_req_builder.query(&[(
20972                "created__gt",
20973                &local_var_str
20974                    .into_iter()
20975                    .map(|p| p.to_string())
20976                    .collect::<Vec<String>>()
20977                    .join(",")
20978                    .to_string(),
20979            )]),
20980        };
20981    }
20982    if let Some(ref local_var_str) = created__gte {
20983        local_var_req_builder = match "multi" {
20984            "multi" => local_var_req_builder.query(
20985                &local_var_str
20986                    .into_iter()
20987                    .map(|p| ("created__gte".to_owned(), p.to_string()))
20988                    .collect::<Vec<(std::string::String, std::string::String)>>(),
20989            ),
20990            _ => local_var_req_builder.query(&[(
20991                "created__gte",
20992                &local_var_str
20993                    .into_iter()
20994                    .map(|p| p.to_string())
20995                    .collect::<Vec<String>>()
20996                    .join(",")
20997                    .to_string(),
20998            )]),
20999        };
21000    }
21001    if let Some(ref local_var_str) = created__lt {
21002        local_var_req_builder = match "multi" {
21003            "multi" => local_var_req_builder.query(
21004                &local_var_str
21005                    .into_iter()
21006                    .map(|p| ("created__lt".to_owned(), p.to_string()))
21007                    .collect::<Vec<(std::string::String, std::string::String)>>(),
21008            ),
21009            _ => local_var_req_builder.query(&[(
21010                "created__lt",
21011                &local_var_str
21012                    .into_iter()
21013                    .map(|p| p.to_string())
21014                    .collect::<Vec<String>>()
21015                    .join(",")
21016                    .to_string(),
21017            )]),
21018        };
21019    }
21020    if let Some(ref local_var_str) = created__lte {
21021        local_var_req_builder = match "multi" {
21022            "multi" => local_var_req_builder.query(
21023                &local_var_str
21024                    .into_iter()
21025                    .map(|p| ("created__lte".to_owned(), p.to_string()))
21026                    .collect::<Vec<(std::string::String, std::string::String)>>(),
21027            ),
21028            _ => local_var_req_builder.query(&[(
21029                "created__lte",
21030                &local_var_str
21031                    .into_iter()
21032                    .map(|p| p.to_string())
21033                    .collect::<Vec<String>>()
21034                    .join(",")
21035                    .to_string(),
21036            )]),
21037        };
21038    }
21039    if let Some(ref local_var_str) = created__n {
21040        local_var_req_builder = match "multi" {
21041            "multi" => local_var_req_builder.query(
21042                &local_var_str
21043                    .into_iter()
21044                    .map(|p| ("created__n".to_owned(), p.to_string()))
21045                    .collect::<Vec<(std::string::String, std::string::String)>>(),
21046            ),
21047            _ => local_var_req_builder.query(&[(
21048                "created__n",
21049                &local_var_str
21050                    .into_iter()
21051                    .map(|p| p.to_string())
21052                    .collect::<Vec<String>>()
21053                    .join(",")
21054                    .to_string(),
21055            )]),
21056        };
21057    }
21058    if let Some(ref local_var_str) = created_by_request {
21059        local_var_req_builder =
21060            local_var_req_builder.query(&[("created_by_request", &local_var_str.to_string())]);
21061    }
21062    if let Some(ref local_var_str) = description {
21063        local_var_req_builder = match "multi" {
21064            "multi" => local_var_req_builder.query(
21065                &local_var_str
21066                    .into_iter()
21067                    .map(|p| ("description".to_owned(), p.to_string()))
21068                    .collect::<Vec<(std::string::String, std::string::String)>>(),
21069            ),
21070            _ => local_var_req_builder.query(&[(
21071                "description",
21072                &local_var_str
21073                    .into_iter()
21074                    .map(|p| p.to_string())
21075                    .collect::<Vec<String>>()
21076                    .join(",")
21077                    .to_string(),
21078            )]),
21079        };
21080    }
21081    if let Some(ref local_var_str) = description__empty {
21082        local_var_req_builder =
21083            local_var_req_builder.query(&[("description__empty", &local_var_str.to_string())]);
21084    }
21085    if let Some(ref local_var_str) = description__ic {
21086        local_var_req_builder = match "multi" {
21087            "multi" => local_var_req_builder.query(
21088                &local_var_str
21089                    .into_iter()
21090                    .map(|p| ("description__ic".to_owned(), p.to_string()))
21091                    .collect::<Vec<(std::string::String, std::string::String)>>(),
21092            ),
21093            _ => local_var_req_builder.query(&[(
21094                "description__ic",
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) = description__ie {
21105        local_var_req_builder = match "multi" {
21106            "multi" => local_var_req_builder.query(
21107                &local_var_str
21108                    .into_iter()
21109                    .map(|p| ("description__ie".to_owned(), p.to_string()))
21110                    .collect::<Vec<(std::string::String, std::string::String)>>(),
21111            ),
21112            _ => local_var_req_builder.query(&[(
21113                "description__ie",
21114                &local_var_str
21115                    .into_iter()
21116                    .map(|p| p.to_string())
21117                    .collect::<Vec<String>>()
21118                    .join(",")
21119                    .to_string(),
21120            )]),
21121        };
21122    }
21123    if let Some(ref local_var_str) = description__iew {
21124        local_var_req_builder = match "multi" {
21125            "multi" => local_var_req_builder.query(
21126                &local_var_str
21127                    .into_iter()
21128                    .map(|p| ("description__iew".to_owned(), p.to_string()))
21129                    .collect::<Vec<(std::string::String, std::string::String)>>(),
21130            ),
21131            _ => local_var_req_builder.query(&[(
21132                "description__iew",
21133                &local_var_str
21134                    .into_iter()
21135                    .map(|p| p.to_string())
21136                    .collect::<Vec<String>>()
21137                    .join(",")
21138                    .to_string(),
21139            )]),
21140        };
21141    }
21142    if let Some(ref local_var_str) = description__iregex {
21143        local_var_req_builder = match "multi" {
21144            "multi" => local_var_req_builder.query(
21145                &local_var_str
21146                    .into_iter()
21147                    .map(|p| ("description__iregex".to_owned(), p.to_string()))
21148                    .collect::<Vec<(std::string::String, std::string::String)>>(),
21149            ),
21150            _ => local_var_req_builder.query(&[(
21151                "description__iregex",
21152                &local_var_str
21153                    .into_iter()
21154                    .map(|p| p.to_string())
21155                    .collect::<Vec<String>>()
21156                    .join(",")
21157                    .to_string(),
21158            )]),
21159        };
21160    }
21161    if let Some(ref local_var_str) = description__isw {
21162        local_var_req_builder = match "multi" {
21163            "multi" => local_var_req_builder.query(
21164                &local_var_str
21165                    .into_iter()
21166                    .map(|p| ("description__isw".to_owned(), p.to_string()))
21167                    .collect::<Vec<(std::string::String, std::string::String)>>(),
21168            ),
21169            _ => local_var_req_builder.query(&[(
21170                "description__isw",
21171                &local_var_str
21172                    .into_iter()
21173                    .map(|p| p.to_string())
21174                    .collect::<Vec<String>>()
21175                    .join(",")
21176                    .to_string(),
21177            )]),
21178        };
21179    }
21180    if let Some(ref local_var_str) = description__n {
21181        local_var_req_builder = match "multi" {
21182            "multi" => local_var_req_builder.query(
21183                &local_var_str
21184                    .into_iter()
21185                    .map(|p| ("description__n".to_owned(), p.to_string()))
21186                    .collect::<Vec<(std::string::String, std::string::String)>>(),
21187            ),
21188            _ => local_var_req_builder.query(&[(
21189                "description__n",
21190                &local_var_str
21191                    .into_iter()
21192                    .map(|p| p.to_string())
21193                    .collect::<Vec<String>>()
21194                    .join(",")
21195                    .to_string(),
21196            )]),
21197        };
21198    }
21199    if let Some(ref local_var_str) = description__nic {
21200        local_var_req_builder = match "multi" {
21201            "multi" => local_var_req_builder.query(
21202                &local_var_str
21203                    .into_iter()
21204                    .map(|p| ("description__nic".to_owned(), p.to_string()))
21205                    .collect::<Vec<(std::string::String, std::string::String)>>(),
21206            ),
21207            _ => local_var_req_builder.query(&[(
21208                "description__nic",
21209                &local_var_str
21210                    .into_iter()
21211                    .map(|p| p.to_string())
21212                    .collect::<Vec<String>>()
21213                    .join(",")
21214                    .to_string(),
21215            )]),
21216        };
21217    }
21218    if let Some(ref local_var_str) = description__nie {
21219        local_var_req_builder = match "multi" {
21220            "multi" => local_var_req_builder.query(
21221                &local_var_str
21222                    .into_iter()
21223                    .map(|p| ("description__nie".to_owned(), p.to_string()))
21224                    .collect::<Vec<(std::string::String, std::string::String)>>(),
21225            ),
21226            _ => local_var_req_builder.query(&[(
21227                "description__nie",
21228                &local_var_str
21229                    .into_iter()
21230                    .map(|p| p.to_string())
21231                    .collect::<Vec<String>>()
21232                    .join(",")
21233                    .to_string(),
21234            )]),
21235        };
21236    }
21237    if let Some(ref local_var_str) = description__niew {
21238        local_var_req_builder = match "multi" {
21239            "multi" => local_var_req_builder.query(
21240                &local_var_str
21241                    .into_iter()
21242                    .map(|p| ("description__niew".to_owned(), p.to_string()))
21243                    .collect::<Vec<(std::string::String, std::string::String)>>(),
21244            ),
21245            _ => local_var_req_builder.query(&[(
21246                "description__niew",
21247                &local_var_str
21248                    .into_iter()
21249                    .map(|p| p.to_string())
21250                    .collect::<Vec<String>>()
21251                    .join(",")
21252                    .to_string(),
21253            )]),
21254        };
21255    }
21256    if let Some(ref local_var_str) = description__nisw {
21257        local_var_req_builder = match "multi" {
21258            "multi" => local_var_req_builder.query(
21259                &local_var_str
21260                    .into_iter()
21261                    .map(|p| ("description__nisw".to_owned(), p.to_string()))
21262                    .collect::<Vec<(std::string::String, std::string::String)>>(),
21263            ),
21264            _ => local_var_req_builder.query(&[(
21265                "description__nisw",
21266                &local_var_str
21267                    .into_iter()
21268                    .map(|p| p.to_string())
21269                    .collect::<Vec<String>>()
21270                    .join(",")
21271                    .to_string(),
21272            )]),
21273        };
21274    }
21275    if let Some(ref local_var_str) = description__regex {
21276        local_var_req_builder = match "multi" {
21277            "multi" => local_var_req_builder.query(
21278                &local_var_str
21279                    .into_iter()
21280                    .map(|p| ("description__regex".to_owned(), p.to_string()))
21281                    .collect::<Vec<(std::string::String, std::string::String)>>(),
21282            ),
21283            _ => local_var_req_builder.query(&[(
21284                "description__regex",
21285                &local_var_str
21286                    .into_iter()
21287                    .map(|p| p.to_string())
21288                    .collect::<Vec<String>>()
21289                    .join(",")
21290                    .to_string(),
21291            )]),
21292        };
21293    }
21294    if let Some(ref local_var_str) = encapsulation {
21295        local_var_req_builder = match "multi" {
21296            "multi" => local_var_req_builder.query(
21297                &local_var_str
21298                    .into_iter()
21299                    .map(|p| ("encapsulation".to_owned(), p.to_string()))
21300                    .collect::<Vec<(std::string::String, std::string::String)>>(),
21301            ),
21302            _ => local_var_req_builder.query(&[(
21303                "encapsulation",
21304                &local_var_str
21305                    .into_iter()
21306                    .map(|p| p.to_string())
21307                    .collect::<Vec<String>>()
21308                    .join(",")
21309                    .to_string(),
21310            )]),
21311        };
21312    }
21313    if let Some(ref local_var_str) = encapsulation__empty {
21314        local_var_req_builder =
21315            local_var_req_builder.query(&[("encapsulation__empty", &local_var_str.to_string())]);
21316    }
21317    if let Some(ref local_var_str) = encapsulation__ic {
21318        local_var_req_builder = match "multi" {
21319            "multi" => local_var_req_builder.query(
21320                &local_var_str
21321                    .into_iter()
21322                    .map(|p| ("encapsulation__ic".to_owned(), p.to_string()))
21323                    .collect::<Vec<(std::string::String, std::string::String)>>(),
21324            ),
21325            _ => local_var_req_builder.query(&[(
21326                "encapsulation__ic",
21327                &local_var_str
21328                    .into_iter()
21329                    .map(|p| p.to_string())
21330                    .collect::<Vec<String>>()
21331                    .join(",")
21332                    .to_string(),
21333            )]),
21334        };
21335    }
21336    if let Some(ref local_var_str) = encapsulation__ie {
21337        local_var_req_builder = match "multi" {
21338            "multi" => local_var_req_builder.query(
21339                &local_var_str
21340                    .into_iter()
21341                    .map(|p| ("encapsulation__ie".to_owned(), p.to_string()))
21342                    .collect::<Vec<(std::string::String, std::string::String)>>(),
21343            ),
21344            _ => local_var_req_builder.query(&[(
21345                "encapsulation__ie",
21346                &local_var_str
21347                    .into_iter()
21348                    .map(|p| p.to_string())
21349                    .collect::<Vec<String>>()
21350                    .join(",")
21351                    .to_string(),
21352            )]),
21353        };
21354    }
21355    if let Some(ref local_var_str) = encapsulation__iew {
21356        local_var_req_builder = match "multi" {
21357            "multi" => local_var_req_builder.query(
21358                &local_var_str
21359                    .into_iter()
21360                    .map(|p| ("encapsulation__iew".to_owned(), p.to_string()))
21361                    .collect::<Vec<(std::string::String, std::string::String)>>(),
21362            ),
21363            _ => local_var_req_builder.query(&[(
21364                "encapsulation__iew",
21365                &local_var_str
21366                    .into_iter()
21367                    .map(|p| p.to_string())
21368                    .collect::<Vec<String>>()
21369                    .join(",")
21370                    .to_string(),
21371            )]),
21372        };
21373    }
21374    if let Some(ref local_var_str) = encapsulation__iregex {
21375        local_var_req_builder = match "multi" {
21376            "multi" => local_var_req_builder.query(
21377                &local_var_str
21378                    .into_iter()
21379                    .map(|p| ("encapsulation__iregex".to_owned(), p.to_string()))
21380                    .collect::<Vec<(std::string::String, std::string::String)>>(),
21381            ),
21382            _ => local_var_req_builder.query(&[(
21383                "encapsulation__iregex",
21384                &local_var_str
21385                    .into_iter()
21386                    .map(|p| p.to_string())
21387                    .collect::<Vec<String>>()
21388                    .join(",")
21389                    .to_string(),
21390            )]),
21391        };
21392    }
21393    if let Some(ref local_var_str) = encapsulation__isw {
21394        local_var_req_builder = match "multi" {
21395            "multi" => local_var_req_builder.query(
21396                &local_var_str
21397                    .into_iter()
21398                    .map(|p| ("encapsulation__isw".to_owned(), p.to_string()))
21399                    .collect::<Vec<(std::string::String, std::string::String)>>(),
21400            ),
21401            _ => local_var_req_builder.query(&[(
21402                "encapsulation__isw",
21403                &local_var_str
21404                    .into_iter()
21405                    .map(|p| p.to_string())
21406                    .collect::<Vec<String>>()
21407                    .join(",")
21408                    .to_string(),
21409            )]),
21410        };
21411    }
21412    if let Some(ref local_var_str) = encapsulation__n {
21413        local_var_req_builder = match "multi" {
21414            "multi" => local_var_req_builder.query(
21415                &local_var_str
21416                    .into_iter()
21417                    .map(|p| ("encapsulation__n".to_owned(), p.to_string()))
21418                    .collect::<Vec<(std::string::String, std::string::String)>>(),
21419            ),
21420            _ => local_var_req_builder.query(&[(
21421                "encapsulation__n",
21422                &local_var_str
21423                    .into_iter()
21424                    .map(|p| p.to_string())
21425                    .collect::<Vec<String>>()
21426                    .join(",")
21427                    .to_string(),
21428            )]),
21429        };
21430    }
21431    if let Some(ref local_var_str) = encapsulation__nic {
21432        local_var_req_builder = match "multi" {
21433            "multi" => local_var_req_builder.query(
21434                &local_var_str
21435                    .into_iter()
21436                    .map(|p| ("encapsulation__nic".to_owned(), p.to_string()))
21437                    .collect::<Vec<(std::string::String, std::string::String)>>(),
21438            ),
21439            _ => local_var_req_builder.query(&[(
21440                "encapsulation__nic",
21441                &local_var_str
21442                    .into_iter()
21443                    .map(|p| p.to_string())
21444                    .collect::<Vec<String>>()
21445                    .join(",")
21446                    .to_string(),
21447            )]),
21448        };
21449    }
21450    if let Some(ref local_var_str) = encapsulation__nie {
21451        local_var_req_builder = match "multi" {
21452            "multi" => local_var_req_builder.query(
21453                &local_var_str
21454                    .into_iter()
21455                    .map(|p| ("encapsulation__nie".to_owned(), p.to_string()))
21456                    .collect::<Vec<(std::string::String, std::string::String)>>(),
21457            ),
21458            _ => local_var_req_builder.query(&[(
21459                "encapsulation__nie",
21460                &local_var_str
21461                    .into_iter()
21462                    .map(|p| p.to_string())
21463                    .collect::<Vec<String>>()
21464                    .join(",")
21465                    .to_string(),
21466            )]),
21467        };
21468    }
21469    if let Some(ref local_var_str) = encapsulation__niew {
21470        local_var_req_builder = match "multi" {
21471            "multi" => local_var_req_builder.query(
21472                &local_var_str
21473                    .into_iter()
21474                    .map(|p| ("encapsulation__niew".to_owned(), p.to_string()))
21475                    .collect::<Vec<(std::string::String, std::string::String)>>(),
21476            ),
21477            _ => local_var_req_builder.query(&[(
21478                "encapsulation__niew",
21479                &local_var_str
21480                    .into_iter()
21481                    .map(|p| p.to_string())
21482                    .collect::<Vec<String>>()
21483                    .join(",")
21484                    .to_string(),
21485            )]),
21486        };
21487    }
21488    if let Some(ref local_var_str) = encapsulation__nisw {
21489        local_var_req_builder = match "multi" {
21490            "multi" => local_var_req_builder.query(
21491                &local_var_str
21492                    .into_iter()
21493                    .map(|p| ("encapsulation__nisw".to_owned(), p.to_string()))
21494                    .collect::<Vec<(std::string::String, std::string::String)>>(),
21495            ),
21496            _ => local_var_req_builder.query(&[(
21497                "encapsulation__nisw",
21498                &local_var_str
21499                    .into_iter()
21500                    .map(|p| p.to_string())
21501                    .collect::<Vec<String>>()
21502                    .join(",")
21503                    .to_string(),
21504            )]),
21505        };
21506    }
21507    if let Some(ref local_var_str) = encapsulation__regex {
21508        local_var_req_builder = match "multi" {
21509            "multi" => local_var_req_builder.query(
21510                &local_var_str
21511                    .into_iter()
21512                    .map(|p| ("encapsulation__regex".to_owned(), p.to_string()))
21513                    .collect::<Vec<(std::string::String, std::string::String)>>(),
21514            ),
21515            _ => local_var_req_builder.query(&[(
21516                "encapsulation__regex",
21517                &local_var_str
21518                    .into_iter()
21519                    .map(|p| p.to_string())
21520                    .collect::<Vec<String>>()
21521                    .join(",")
21522                    .to_string(),
21523            )]),
21524        };
21525    }
21526    if let Some(ref local_var_str) = group {
21527        local_var_req_builder = match "multi" {
21528            "multi" => local_var_req_builder.query(
21529                &local_var_str
21530                    .into_iter()
21531                    .map(|p| ("group".to_owned(), p.to_string()))
21532                    .collect::<Vec<(std::string::String, std::string::String)>>(),
21533            ),
21534            _ => local_var_req_builder.query(&[(
21535                "group",
21536                &local_var_str
21537                    .into_iter()
21538                    .map(|p| p.to_string())
21539                    .collect::<Vec<String>>()
21540                    .join(",")
21541                    .to_string(),
21542            )]),
21543        };
21544    }
21545    if let Some(ref local_var_str) = group__n {
21546        local_var_req_builder = match "multi" {
21547            "multi" => local_var_req_builder.query(
21548                &local_var_str
21549                    .into_iter()
21550                    .map(|p| ("group__n".to_owned(), p.to_string()))
21551                    .collect::<Vec<(std::string::String, std::string::String)>>(),
21552            ),
21553            _ => local_var_req_builder.query(&[(
21554                "group__n",
21555                &local_var_str
21556                    .into_iter()
21557                    .map(|p| p.to_string())
21558                    .collect::<Vec<String>>()
21559                    .join(",")
21560                    .to_string(),
21561            )]),
21562        };
21563    }
21564    if let Some(ref local_var_str) = group_id {
21565        local_var_req_builder = match "multi" {
21566            "multi" => local_var_req_builder.query(
21567                &local_var_str
21568                    .into_iter()
21569                    .map(|p| ("group_id".to_owned(), p.to_string()))
21570                    .collect::<Vec<(std::string::String, std::string::String)>>(),
21571            ),
21572            _ => local_var_req_builder.query(&[(
21573                "group_id",
21574                &local_var_str
21575                    .into_iter()
21576                    .map(|p| p.to_string())
21577                    .collect::<Vec<String>>()
21578                    .join(",")
21579                    .to_string(),
21580            )]),
21581        };
21582    }
21583    if let Some(ref local_var_str) = group_id__n {
21584        local_var_req_builder = match "multi" {
21585            "multi" => local_var_req_builder.query(
21586                &local_var_str
21587                    .into_iter()
21588                    .map(|p| ("group_id__n".to_owned(), p.to_string()))
21589                    .collect::<Vec<(std::string::String, std::string::String)>>(),
21590            ),
21591            _ => local_var_req_builder.query(&[(
21592                "group_id__n",
21593                &local_var_str
21594                    .into_iter()
21595                    .map(|p| p.to_string())
21596                    .collect::<Vec<String>>()
21597                    .join(",")
21598                    .to_string(),
21599            )]),
21600        };
21601    }
21602    if let Some(ref local_var_str) = id {
21603        local_var_req_builder = match "multi" {
21604            "multi" => local_var_req_builder.query(
21605                &local_var_str
21606                    .into_iter()
21607                    .map(|p| ("id".to_owned(), p.to_string()))
21608                    .collect::<Vec<(std::string::String, std::string::String)>>(),
21609            ),
21610            _ => local_var_req_builder.query(&[(
21611                "id",
21612                &local_var_str
21613                    .into_iter()
21614                    .map(|p| p.to_string())
21615                    .collect::<Vec<String>>()
21616                    .join(",")
21617                    .to_string(),
21618            )]),
21619        };
21620    }
21621    if let Some(ref local_var_str) = id__empty {
21622        local_var_req_builder =
21623            local_var_req_builder.query(&[("id__empty", &local_var_str.to_string())]);
21624    }
21625    if let Some(ref local_var_str) = id__gt {
21626        local_var_req_builder = match "multi" {
21627            "multi" => local_var_req_builder.query(
21628                &local_var_str
21629                    .into_iter()
21630                    .map(|p| ("id__gt".to_owned(), p.to_string()))
21631                    .collect::<Vec<(std::string::String, std::string::String)>>(),
21632            ),
21633            _ => local_var_req_builder.query(&[(
21634                "id__gt",
21635                &local_var_str
21636                    .into_iter()
21637                    .map(|p| p.to_string())
21638                    .collect::<Vec<String>>()
21639                    .join(",")
21640                    .to_string(),
21641            )]),
21642        };
21643    }
21644    if let Some(ref local_var_str) = id__gte {
21645        local_var_req_builder = match "multi" {
21646            "multi" => local_var_req_builder.query(
21647                &local_var_str
21648                    .into_iter()
21649                    .map(|p| ("id__gte".to_owned(), p.to_string()))
21650                    .collect::<Vec<(std::string::String, std::string::String)>>(),
21651            ),
21652            _ => local_var_req_builder.query(&[(
21653                "id__gte",
21654                &local_var_str
21655                    .into_iter()
21656                    .map(|p| p.to_string())
21657                    .collect::<Vec<String>>()
21658                    .join(",")
21659                    .to_string(),
21660            )]),
21661        };
21662    }
21663    if let Some(ref local_var_str) = id__lt {
21664        local_var_req_builder = match "multi" {
21665            "multi" => local_var_req_builder.query(
21666                &local_var_str
21667                    .into_iter()
21668                    .map(|p| ("id__lt".to_owned(), p.to_string()))
21669                    .collect::<Vec<(std::string::String, std::string::String)>>(),
21670            ),
21671            _ => local_var_req_builder.query(&[(
21672                "id__lt",
21673                &local_var_str
21674                    .into_iter()
21675                    .map(|p| p.to_string())
21676                    .collect::<Vec<String>>()
21677                    .join(",")
21678                    .to_string(),
21679            )]),
21680        };
21681    }
21682    if let Some(ref local_var_str) = id__lte {
21683        local_var_req_builder = match "multi" {
21684            "multi" => local_var_req_builder.query(
21685                &local_var_str
21686                    .into_iter()
21687                    .map(|p| ("id__lte".to_owned(), p.to_string()))
21688                    .collect::<Vec<(std::string::String, std::string::String)>>(),
21689            ),
21690            _ => local_var_req_builder.query(&[(
21691                "id__lte",
21692                &local_var_str
21693                    .into_iter()
21694                    .map(|p| p.to_string())
21695                    .collect::<Vec<String>>()
21696                    .join(",")
21697                    .to_string(),
21698            )]),
21699        };
21700    }
21701    if let Some(ref local_var_str) = id__n {
21702        local_var_req_builder = match "multi" {
21703            "multi" => local_var_req_builder.query(
21704                &local_var_str
21705                    .into_iter()
21706                    .map(|p| ("id__n".to_owned(), p.to_string()))
21707                    .collect::<Vec<(std::string::String, std::string::String)>>(),
21708            ),
21709            _ => local_var_req_builder.query(&[(
21710                "id__n",
21711                &local_var_str
21712                    .into_iter()
21713                    .map(|p| p.to_string())
21714                    .collect::<Vec<String>>()
21715                    .join(",")
21716                    .to_string(),
21717            )]),
21718        };
21719    }
21720    if let Some(ref local_var_str) = ipsec_profile {
21721        local_var_req_builder = match "multi" {
21722            "multi" => local_var_req_builder.query(
21723                &local_var_str
21724                    .into_iter()
21725                    .map(|p| ("ipsec_profile".to_owned(), p.to_string()))
21726                    .collect::<Vec<(std::string::String, std::string::String)>>(),
21727            ),
21728            _ => local_var_req_builder.query(&[(
21729                "ipsec_profile",
21730                &local_var_str
21731                    .into_iter()
21732                    .map(|p| p.to_string())
21733                    .collect::<Vec<String>>()
21734                    .join(",")
21735                    .to_string(),
21736            )]),
21737        };
21738    }
21739    if let Some(ref local_var_str) = ipsec_profile__n {
21740        local_var_req_builder = match "multi" {
21741            "multi" => local_var_req_builder.query(
21742                &local_var_str
21743                    .into_iter()
21744                    .map(|p| ("ipsec_profile__n".to_owned(), p.to_string()))
21745                    .collect::<Vec<(std::string::String, std::string::String)>>(),
21746            ),
21747            _ => local_var_req_builder.query(&[(
21748                "ipsec_profile__n",
21749                &local_var_str
21750                    .into_iter()
21751                    .map(|p| p.to_string())
21752                    .collect::<Vec<String>>()
21753                    .join(",")
21754                    .to_string(),
21755            )]),
21756        };
21757    }
21758    if let Some(ref local_var_str) = ipsec_profile_id {
21759        local_var_req_builder = match "multi" {
21760            "multi" => local_var_req_builder.query(
21761                &local_var_str
21762                    .into_iter()
21763                    .map(|p| ("ipsec_profile_id".to_owned(), p.to_string()))
21764                    .collect::<Vec<(std::string::String, std::string::String)>>(),
21765            ),
21766            _ => local_var_req_builder.query(&[(
21767                "ipsec_profile_id",
21768                &local_var_str
21769                    .into_iter()
21770                    .map(|p| p.to_string())
21771                    .collect::<Vec<String>>()
21772                    .join(",")
21773                    .to_string(),
21774            )]),
21775        };
21776    }
21777    if let Some(ref local_var_str) = ipsec_profile_id__n {
21778        local_var_req_builder = match "multi" {
21779            "multi" => local_var_req_builder.query(
21780                &local_var_str
21781                    .into_iter()
21782                    .map(|p| ("ipsec_profile_id__n".to_owned(), p.to_string()))
21783                    .collect::<Vec<(std::string::String, std::string::String)>>(),
21784            ),
21785            _ => local_var_req_builder.query(&[(
21786                "ipsec_profile_id__n",
21787                &local_var_str
21788                    .into_iter()
21789                    .map(|p| p.to_string())
21790                    .collect::<Vec<String>>()
21791                    .join(",")
21792                    .to_string(),
21793            )]),
21794        };
21795    }
21796    if let Some(ref local_var_str) = last_updated {
21797        local_var_req_builder = match "multi" {
21798            "multi" => local_var_req_builder.query(
21799                &local_var_str
21800                    .into_iter()
21801                    .map(|p| ("last_updated".to_owned(), p.to_string()))
21802                    .collect::<Vec<(std::string::String, std::string::String)>>(),
21803            ),
21804            _ => local_var_req_builder.query(&[(
21805                "last_updated",
21806                &local_var_str
21807                    .into_iter()
21808                    .map(|p| p.to_string())
21809                    .collect::<Vec<String>>()
21810                    .join(",")
21811                    .to_string(),
21812            )]),
21813        };
21814    }
21815    if let Some(ref local_var_str) = last_updated__empty {
21816        local_var_req_builder = match "multi" {
21817            "multi" => local_var_req_builder.query(
21818                &local_var_str
21819                    .into_iter()
21820                    .map(|p| ("last_updated__empty".to_owned(), p.to_string()))
21821                    .collect::<Vec<(std::string::String, std::string::String)>>(),
21822            ),
21823            _ => local_var_req_builder.query(&[(
21824                "last_updated__empty",
21825                &local_var_str
21826                    .into_iter()
21827                    .map(|p| p.to_string())
21828                    .collect::<Vec<String>>()
21829                    .join(",")
21830                    .to_string(),
21831            )]),
21832        };
21833    }
21834    if let Some(ref local_var_str) = last_updated__gt {
21835        local_var_req_builder = match "multi" {
21836            "multi" => local_var_req_builder.query(
21837                &local_var_str
21838                    .into_iter()
21839                    .map(|p| ("last_updated__gt".to_owned(), p.to_string()))
21840                    .collect::<Vec<(std::string::String, std::string::String)>>(),
21841            ),
21842            _ => local_var_req_builder.query(&[(
21843                "last_updated__gt",
21844                &local_var_str
21845                    .into_iter()
21846                    .map(|p| p.to_string())
21847                    .collect::<Vec<String>>()
21848                    .join(",")
21849                    .to_string(),
21850            )]),
21851        };
21852    }
21853    if let Some(ref local_var_str) = last_updated__gte {
21854        local_var_req_builder = match "multi" {
21855            "multi" => local_var_req_builder.query(
21856                &local_var_str
21857                    .into_iter()
21858                    .map(|p| ("last_updated__gte".to_owned(), p.to_string()))
21859                    .collect::<Vec<(std::string::String, std::string::String)>>(),
21860            ),
21861            _ => local_var_req_builder.query(&[(
21862                "last_updated__gte",
21863                &local_var_str
21864                    .into_iter()
21865                    .map(|p| p.to_string())
21866                    .collect::<Vec<String>>()
21867                    .join(",")
21868                    .to_string(),
21869            )]),
21870        };
21871    }
21872    if let Some(ref local_var_str) = last_updated__lt {
21873        local_var_req_builder = match "multi" {
21874            "multi" => local_var_req_builder.query(
21875                &local_var_str
21876                    .into_iter()
21877                    .map(|p| ("last_updated__lt".to_owned(), p.to_string()))
21878                    .collect::<Vec<(std::string::String, std::string::String)>>(),
21879            ),
21880            _ => local_var_req_builder.query(&[(
21881                "last_updated__lt",
21882                &local_var_str
21883                    .into_iter()
21884                    .map(|p| p.to_string())
21885                    .collect::<Vec<String>>()
21886                    .join(",")
21887                    .to_string(),
21888            )]),
21889        };
21890    }
21891    if let Some(ref local_var_str) = last_updated__lte {
21892        local_var_req_builder = match "multi" {
21893            "multi" => local_var_req_builder.query(
21894                &local_var_str
21895                    .into_iter()
21896                    .map(|p| ("last_updated__lte".to_owned(), p.to_string()))
21897                    .collect::<Vec<(std::string::String, std::string::String)>>(),
21898            ),
21899            _ => local_var_req_builder.query(&[(
21900                "last_updated__lte",
21901                &local_var_str
21902                    .into_iter()
21903                    .map(|p| p.to_string())
21904                    .collect::<Vec<String>>()
21905                    .join(",")
21906                    .to_string(),
21907            )]),
21908        };
21909    }
21910    if let Some(ref local_var_str) = last_updated__n {
21911        local_var_req_builder = match "multi" {
21912            "multi" => local_var_req_builder.query(
21913                &local_var_str
21914                    .into_iter()
21915                    .map(|p| ("last_updated__n".to_owned(), p.to_string()))
21916                    .collect::<Vec<(std::string::String, std::string::String)>>(),
21917            ),
21918            _ => local_var_req_builder.query(&[(
21919                "last_updated__n",
21920                &local_var_str
21921                    .into_iter()
21922                    .map(|p| p.to_string())
21923                    .collect::<Vec<String>>()
21924                    .join(",")
21925                    .to_string(),
21926            )]),
21927        };
21928    }
21929    if let Some(ref local_var_str) = limit {
21930        local_var_req_builder =
21931            local_var_req_builder.query(&[("limit", &local_var_str.to_string())]);
21932    }
21933    if let Some(ref local_var_str) = modified_by_request {
21934        local_var_req_builder =
21935            local_var_req_builder.query(&[("modified_by_request", &local_var_str.to_string())]);
21936    }
21937    if let Some(ref local_var_str) = name {
21938        local_var_req_builder = match "multi" {
21939            "multi" => local_var_req_builder.query(
21940                &local_var_str
21941                    .into_iter()
21942                    .map(|p| ("name".to_owned(), p.to_string()))
21943                    .collect::<Vec<(std::string::String, std::string::String)>>(),
21944            ),
21945            _ => local_var_req_builder.query(&[(
21946                "name",
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) = name__empty {
21957        local_var_req_builder =
21958            local_var_req_builder.query(&[("name__empty", &local_var_str.to_string())]);
21959    }
21960    if let Some(ref local_var_str) = name__ic {
21961        local_var_req_builder = match "multi" {
21962            "multi" => local_var_req_builder.query(
21963                &local_var_str
21964                    .into_iter()
21965                    .map(|p| ("name__ic".to_owned(), p.to_string()))
21966                    .collect::<Vec<(std::string::String, std::string::String)>>(),
21967            ),
21968            _ => local_var_req_builder.query(&[(
21969                "name__ic",
21970                &local_var_str
21971                    .into_iter()
21972                    .map(|p| p.to_string())
21973                    .collect::<Vec<String>>()
21974                    .join(",")
21975                    .to_string(),
21976            )]),
21977        };
21978    }
21979    if let Some(ref local_var_str) = name__ie {
21980        local_var_req_builder = match "multi" {
21981            "multi" => local_var_req_builder.query(
21982                &local_var_str
21983                    .into_iter()
21984                    .map(|p| ("name__ie".to_owned(), p.to_string()))
21985                    .collect::<Vec<(std::string::String, std::string::String)>>(),
21986            ),
21987            _ => local_var_req_builder.query(&[(
21988                "name__ie",
21989                &local_var_str
21990                    .into_iter()
21991                    .map(|p| p.to_string())
21992                    .collect::<Vec<String>>()
21993                    .join(",")
21994                    .to_string(),
21995            )]),
21996        };
21997    }
21998    if let Some(ref local_var_str) = name__iew {
21999        local_var_req_builder = match "multi" {
22000            "multi" => local_var_req_builder.query(
22001                &local_var_str
22002                    .into_iter()
22003                    .map(|p| ("name__iew".to_owned(), p.to_string()))
22004                    .collect::<Vec<(std::string::String, std::string::String)>>(),
22005            ),
22006            _ => local_var_req_builder.query(&[(
22007                "name__iew",
22008                &local_var_str
22009                    .into_iter()
22010                    .map(|p| p.to_string())
22011                    .collect::<Vec<String>>()
22012                    .join(",")
22013                    .to_string(),
22014            )]),
22015        };
22016    }
22017    if let Some(ref local_var_str) = name__iregex {
22018        local_var_req_builder = match "multi" {
22019            "multi" => local_var_req_builder.query(
22020                &local_var_str
22021                    .into_iter()
22022                    .map(|p| ("name__iregex".to_owned(), p.to_string()))
22023                    .collect::<Vec<(std::string::String, std::string::String)>>(),
22024            ),
22025            _ => local_var_req_builder.query(&[(
22026                "name__iregex",
22027                &local_var_str
22028                    .into_iter()
22029                    .map(|p| p.to_string())
22030                    .collect::<Vec<String>>()
22031                    .join(",")
22032                    .to_string(),
22033            )]),
22034        };
22035    }
22036    if let Some(ref local_var_str) = name__isw {
22037        local_var_req_builder = match "multi" {
22038            "multi" => local_var_req_builder.query(
22039                &local_var_str
22040                    .into_iter()
22041                    .map(|p| ("name__isw".to_owned(), p.to_string()))
22042                    .collect::<Vec<(std::string::String, std::string::String)>>(),
22043            ),
22044            _ => local_var_req_builder.query(&[(
22045                "name__isw",
22046                &local_var_str
22047                    .into_iter()
22048                    .map(|p| p.to_string())
22049                    .collect::<Vec<String>>()
22050                    .join(",")
22051                    .to_string(),
22052            )]),
22053        };
22054    }
22055    if let Some(ref local_var_str) = name__n {
22056        local_var_req_builder = match "multi" {
22057            "multi" => local_var_req_builder.query(
22058                &local_var_str
22059                    .into_iter()
22060                    .map(|p| ("name__n".to_owned(), p.to_string()))
22061                    .collect::<Vec<(std::string::String, std::string::String)>>(),
22062            ),
22063            _ => local_var_req_builder.query(&[(
22064                "name__n",
22065                &local_var_str
22066                    .into_iter()
22067                    .map(|p| p.to_string())
22068                    .collect::<Vec<String>>()
22069                    .join(",")
22070                    .to_string(),
22071            )]),
22072        };
22073    }
22074    if let Some(ref local_var_str) = name__nic {
22075        local_var_req_builder = match "multi" {
22076            "multi" => local_var_req_builder.query(
22077                &local_var_str
22078                    .into_iter()
22079                    .map(|p| ("name__nic".to_owned(), p.to_string()))
22080                    .collect::<Vec<(std::string::String, std::string::String)>>(),
22081            ),
22082            _ => local_var_req_builder.query(&[(
22083                "name__nic",
22084                &local_var_str
22085                    .into_iter()
22086                    .map(|p| p.to_string())
22087                    .collect::<Vec<String>>()
22088                    .join(",")
22089                    .to_string(),
22090            )]),
22091        };
22092    }
22093    if let Some(ref local_var_str) = name__nie {
22094        local_var_req_builder = match "multi" {
22095            "multi" => local_var_req_builder.query(
22096                &local_var_str
22097                    .into_iter()
22098                    .map(|p| ("name__nie".to_owned(), p.to_string()))
22099                    .collect::<Vec<(std::string::String, std::string::String)>>(),
22100            ),
22101            _ => local_var_req_builder.query(&[(
22102                "name__nie",
22103                &local_var_str
22104                    .into_iter()
22105                    .map(|p| p.to_string())
22106                    .collect::<Vec<String>>()
22107                    .join(",")
22108                    .to_string(),
22109            )]),
22110        };
22111    }
22112    if let Some(ref local_var_str) = name__niew {
22113        local_var_req_builder = match "multi" {
22114            "multi" => local_var_req_builder.query(
22115                &local_var_str
22116                    .into_iter()
22117                    .map(|p| ("name__niew".to_owned(), p.to_string()))
22118                    .collect::<Vec<(std::string::String, std::string::String)>>(),
22119            ),
22120            _ => local_var_req_builder.query(&[(
22121                "name__niew",
22122                &local_var_str
22123                    .into_iter()
22124                    .map(|p| p.to_string())
22125                    .collect::<Vec<String>>()
22126                    .join(",")
22127                    .to_string(),
22128            )]),
22129        };
22130    }
22131    if let Some(ref local_var_str) = name__nisw {
22132        local_var_req_builder = match "multi" {
22133            "multi" => local_var_req_builder.query(
22134                &local_var_str
22135                    .into_iter()
22136                    .map(|p| ("name__nisw".to_owned(), p.to_string()))
22137                    .collect::<Vec<(std::string::String, std::string::String)>>(),
22138            ),
22139            _ => local_var_req_builder.query(&[(
22140                "name__nisw",
22141                &local_var_str
22142                    .into_iter()
22143                    .map(|p| p.to_string())
22144                    .collect::<Vec<String>>()
22145                    .join(",")
22146                    .to_string(),
22147            )]),
22148        };
22149    }
22150    if let Some(ref local_var_str) = name__regex {
22151        local_var_req_builder = match "multi" {
22152            "multi" => local_var_req_builder.query(
22153                &local_var_str
22154                    .into_iter()
22155                    .map(|p| ("name__regex".to_owned(), p.to_string()))
22156                    .collect::<Vec<(std::string::String, std::string::String)>>(),
22157            ),
22158            _ => local_var_req_builder.query(&[(
22159                "name__regex",
22160                &local_var_str
22161                    .into_iter()
22162                    .map(|p| p.to_string())
22163                    .collect::<Vec<String>>()
22164                    .join(",")
22165                    .to_string(),
22166            )]),
22167        };
22168    }
22169    if let Some(ref local_var_str) = offset {
22170        local_var_req_builder =
22171            local_var_req_builder.query(&[("offset", &local_var_str.to_string())]);
22172    }
22173    if let Some(ref local_var_str) = ordering {
22174        local_var_req_builder =
22175            local_var_req_builder.query(&[("ordering", &local_var_str.to_string())]);
22176    }
22177    if let Some(ref local_var_str) = owner {
22178        local_var_req_builder = match "multi" {
22179            "multi" => local_var_req_builder.query(
22180                &local_var_str
22181                    .into_iter()
22182                    .map(|p| ("owner".to_owned(), p.to_string()))
22183                    .collect::<Vec<(std::string::String, std::string::String)>>(),
22184            ),
22185            _ => local_var_req_builder.query(&[(
22186                "owner",
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) = owner__n {
22197        local_var_req_builder = match "multi" {
22198            "multi" => local_var_req_builder.query(
22199                &local_var_str
22200                    .into_iter()
22201                    .map(|p| ("owner__n".to_owned(), p.to_string()))
22202                    .collect::<Vec<(std::string::String, std::string::String)>>(),
22203            ),
22204            _ => local_var_req_builder.query(&[(
22205                "owner__n",
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) = owner_group {
22216        local_var_req_builder = match "multi" {
22217            "multi" => local_var_req_builder.query(
22218                &local_var_str
22219                    .into_iter()
22220                    .map(|p| ("owner_group".to_owned(), p.to_string()))
22221                    .collect::<Vec<(std::string::String, std::string::String)>>(),
22222            ),
22223            _ => local_var_req_builder.query(&[(
22224                "owner_group",
22225                &local_var_str
22226                    .into_iter()
22227                    .map(|p| p.to_string())
22228                    .collect::<Vec<String>>()
22229                    .join(",")
22230                    .to_string(),
22231            )]),
22232        };
22233    }
22234    if let Some(ref local_var_str) = owner_group__n {
22235        local_var_req_builder = match "multi" {
22236            "multi" => local_var_req_builder.query(
22237                &local_var_str
22238                    .into_iter()
22239                    .map(|p| ("owner_group__n".to_owned(), p.to_string()))
22240                    .collect::<Vec<(std::string::String, std::string::String)>>(),
22241            ),
22242            _ => local_var_req_builder.query(&[(
22243                "owner_group__n",
22244                &local_var_str
22245                    .into_iter()
22246                    .map(|p| p.to_string())
22247                    .collect::<Vec<String>>()
22248                    .join(",")
22249                    .to_string(),
22250            )]),
22251        };
22252    }
22253    if let Some(ref local_var_str) = owner_group_id {
22254        local_var_req_builder = match "multi" {
22255            "multi" => local_var_req_builder.query(
22256                &local_var_str
22257                    .into_iter()
22258                    .map(|p| ("owner_group_id".to_owned(), p.to_string()))
22259                    .collect::<Vec<(std::string::String, std::string::String)>>(),
22260            ),
22261            _ => local_var_req_builder.query(&[(
22262                "owner_group_id",
22263                &local_var_str
22264                    .into_iter()
22265                    .map(|p| p.to_string())
22266                    .collect::<Vec<String>>()
22267                    .join(",")
22268                    .to_string(),
22269            )]),
22270        };
22271    }
22272    if let Some(ref local_var_str) = owner_group_id__n {
22273        local_var_req_builder = match "multi" {
22274            "multi" => local_var_req_builder.query(
22275                &local_var_str
22276                    .into_iter()
22277                    .map(|p| ("owner_group_id__n".to_owned(), p.to_string()))
22278                    .collect::<Vec<(std::string::String, std::string::String)>>(),
22279            ),
22280            _ => local_var_req_builder.query(&[(
22281                "owner_group_id__n",
22282                &local_var_str
22283                    .into_iter()
22284                    .map(|p| p.to_string())
22285                    .collect::<Vec<String>>()
22286                    .join(",")
22287                    .to_string(),
22288            )]),
22289        };
22290    }
22291    if let Some(ref local_var_str) = owner_id {
22292        local_var_req_builder = match "multi" {
22293            "multi" => local_var_req_builder.query(
22294                &local_var_str
22295                    .into_iter()
22296                    .map(|p| ("owner_id".to_owned(), p.to_string()))
22297                    .collect::<Vec<(std::string::String, std::string::String)>>(),
22298            ),
22299            _ => local_var_req_builder.query(&[(
22300                "owner_id",
22301                &local_var_str
22302                    .into_iter()
22303                    .map(|p| p.to_string())
22304                    .collect::<Vec<String>>()
22305                    .join(",")
22306                    .to_string(),
22307            )]),
22308        };
22309    }
22310    if let Some(ref local_var_str) = owner_id__n {
22311        local_var_req_builder = match "multi" {
22312            "multi" => local_var_req_builder.query(
22313                &local_var_str
22314                    .into_iter()
22315                    .map(|p| ("owner_id__n".to_owned(), p.to_string()))
22316                    .collect::<Vec<(std::string::String, std::string::String)>>(),
22317            ),
22318            _ => local_var_req_builder.query(&[(
22319                "owner_id__n",
22320                &local_var_str
22321                    .into_iter()
22322                    .map(|p| p.to_string())
22323                    .collect::<Vec<String>>()
22324                    .join(",")
22325                    .to_string(),
22326            )]),
22327        };
22328    }
22329    if let Some(ref local_var_str) = q {
22330        local_var_req_builder = local_var_req_builder.query(&[("q", &local_var_str.to_string())]);
22331    }
22332    if let Some(ref local_var_str) = status {
22333        local_var_req_builder = match "multi" {
22334            "multi" => local_var_req_builder.query(
22335                &local_var_str
22336                    .into_iter()
22337                    .map(|p| ("status".to_owned(), p.to_string()))
22338                    .collect::<Vec<(std::string::String, std::string::String)>>(),
22339            ),
22340            _ => local_var_req_builder.query(&[(
22341                "status",
22342                &local_var_str
22343                    .into_iter()
22344                    .map(|p| p.to_string())
22345                    .collect::<Vec<String>>()
22346                    .join(",")
22347                    .to_string(),
22348            )]),
22349        };
22350    }
22351    if let Some(ref local_var_str) = status__empty {
22352        local_var_req_builder =
22353            local_var_req_builder.query(&[("status__empty", &local_var_str.to_string())]);
22354    }
22355    if let Some(ref local_var_str) = status__ic {
22356        local_var_req_builder = match "multi" {
22357            "multi" => local_var_req_builder.query(
22358                &local_var_str
22359                    .into_iter()
22360                    .map(|p| ("status__ic".to_owned(), p.to_string()))
22361                    .collect::<Vec<(std::string::String, std::string::String)>>(),
22362            ),
22363            _ => local_var_req_builder.query(&[(
22364                "status__ic",
22365                &local_var_str
22366                    .into_iter()
22367                    .map(|p| p.to_string())
22368                    .collect::<Vec<String>>()
22369                    .join(",")
22370                    .to_string(),
22371            )]),
22372        };
22373    }
22374    if let Some(ref local_var_str) = status__ie {
22375        local_var_req_builder = match "multi" {
22376            "multi" => local_var_req_builder.query(
22377                &local_var_str
22378                    .into_iter()
22379                    .map(|p| ("status__ie".to_owned(), p.to_string()))
22380                    .collect::<Vec<(std::string::String, std::string::String)>>(),
22381            ),
22382            _ => local_var_req_builder.query(&[(
22383                "status__ie",
22384                &local_var_str
22385                    .into_iter()
22386                    .map(|p| p.to_string())
22387                    .collect::<Vec<String>>()
22388                    .join(",")
22389                    .to_string(),
22390            )]),
22391        };
22392    }
22393    if let Some(ref local_var_str) = status__iew {
22394        local_var_req_builder = match "multi" {
22395            "multi" => local_var_req_builder.query(
22396                &local_var_str
22397                    .into_iter()
22398                    .map(|p| ("status__iew".to_owned(), p.to_string()))
22399                    .collect::<Vec<(std::string::String, std::string::String)>>(),
22400            ),
22401            _ => local_var_req_builder.query(&[(
22402                "status__iew",
22403                &local_var_str
22404                    .into_iter()
22405                    .map(|p| p.to_string())
22406                    .collect::<Vec<String>>()
22407                    .join(",")
22408                    .to_string(),
22409            )]),
22410        };
22411    }
22412    if let Some(ref local_var_str) = status__iregex {
22413        local_var_req_builder = match "multi" {
22414            "multi" => local_var_req_builder.query(
22415                &local_var_str
22416                    .into_iter()
22417                    .map(|p| ("status__iregex".to_owned(), p.to_string()))
22418                    .collect::<Vec<(std::string::String, std::string::String)>>(),
22419            ),
22420            _ => local_var_req_builder.query(&[(
22421                "status__iregex",
22422                &local_var_str
22423                    .into_iter()
22424                    .map(|p| p.to_string())
22425                    .collect::<Vec<String>>()
22426                    .join(",")
22427                    .to_string(),
22428            )]),
22429        };
22430    }
22431    if let Some(ref local_var_str) = status__isw {
22432        local_var_req_builder = match "multi" {
22433            "multi" => local_var_req_builder.query(
22434                &local_var_str
22435                    .into_iter()
22436                    .map(|p| ("status__isw".to_owned(), p.to_string()))
22437                    .collect::<Vec<(std::string::String, std::string::String)>>(),
22438            ),
22439            _ => local_var_req_builder.query(&[(
22440                "status__isw",
22441                &local_var_str
22442                    .into_iter()
22443                    .map(|p| p.to_string())
22444                    .collect::<Vec<String>>()
22445                    .join(",")
22446                    .to_string(),
22447            )]),
22448        };
22449    }
22450    if let Some(ref local_var_str) = status__n {
22451        local_var_req_builder = match "multi" {
22452            "multi" => local_var_req_builder.query(
22453                &local_var_str
22454                    .into_iter()
22455                    .map(|p| ("status__n".to_owned(), p.to_string()))
22456                    .collect::<Vec<(std::string::String, std::string::String)>>(),
22457            ),
22458            _ => local_var_req_builder.query(&[(
22459                "status__n",
22460                &local_var_str
22461                    .into_iter()
22462                    .map(|p| p.to_string())
22463                    .collect::<Vec<String>>()
22464                    .join(",")
22465                    .to_string(),
22466            )]),
22467        };
22468    }
22469    if let Some(ref local_var_str) = status__nic {
22470        local_var_req_builder = match "multi" {
22471            "multi" => local_var_req_builder.query(
22472                &local_var_str
22473                    .into_iter()
22474                    .map(|p| ("status__nic".to_owned(), p.to_string()))
22475                    .collect::<Vec<(std::string::String, std::string::String)>>(),
22476            ),
22477            _ => local_var_req_builder.query(&[(
22478                "status__nic",
22479                &local_var_str
22480                    .into_iter()
22481                    .map(|p| p.to_string())
22482                    .collect::<Vec<String>>()
22483                    .join(",")
22484                    .to_string(),
22485            )]),
22486        };
22487    }
22488    if let Some(ref local_var_str) = status__nie {
22489        local_var_req_builder = match "multi" {
22490            "multi" => local_var_req_builder.query(
22491                &local_var_str
22492                    .into_iter()
22493                    .map(|p| ("status__nie".to_owned(), p.to_string()))
22494                    .collect::<Vec<(std::string::String, std::string::String)>>(),
22495            ),
22496            _ => local_var_req_builder.query(&[(
22497                "status__nie",
22498                &local_var_str
22499                    .into_iter()
22500                    .map(|p| p.to_string())
22501                    .collect::<Vec<String>>()
22502                    .join(",")
22503                    .to_string(),
22504            )]),
22505        };
22506    }
22507    if let Some(ref local_var_str) = status__niew {
22508        local_var_req_builder = match "multi" {
22509            "multi" => local_var_req_builder.query(
22510                &local_var_str
22511                    .into_iter()
22512                    .map(|p| ("status__niew".to_owned(), p.to_string()))
22513                    .collect::<Vec<(std::string::String, std::string::String)>>(),
22514            ),
22515            _ => local_var_req_builder.query(&[(
22516                "status__niew",
22517                &local_var_str
22518                    .into_iter()
22519                    .map(|p| p.to_string())
22520                    .collect::<Vec<String>>()
22521                    .join(",")
22522                    .to_string(),
22523            )]),
22524        };
22525    }
22526    if let Some(ref local_var_str) = status__nisw {
22527        local_var_req_builder = match "multi" {
22528            "multi" => local_var_req_builder.query(
22529                &local_var_str
22530                    .into_iter()
22531                    .map(|p| ("status__nisw".to_owned(), p.to_string()))
22532                    .collect::<Vec<(std::string::String, std::string::String)>>(),
22533            ),
22534            _ => local_var_req_builder.query(&[(
22535                "status__nisw",
22536                &local_var_str
22537                    .into_iter()
22538                    .map(|p| p.to_string())
22539                    .collect::<Vec<String>>()
22540                    .join(",")
22541                    .to_string(),
22542            )]),
22543        };
22544    }
22545    if let Some(ref local_var_str) = status__regex {
22546        local_var_req_builder = match "multi" {
22547            "multi" => local_var_req_builder.query(
22548                &local_var_str
22549                    .into_iter()
22550                    .map(|p| ("status__regex".to_owned(), p.to_string()))
22551                    .collect::<Vec<(std::string::String, std::string::String)>>(),
22552            ),
22553            _ => local_var_req_builder.query(&[(
22554                "status__regex",
22555                &local_var_str
22556                    .into_iter()
22557                    .map(|p| p.to_string())
22558                    .collect::<Vec<String>>()
22559                    .join(",")
22560                    .to_string(),
22561            )]),
22562        };
22563    }
22564    if let Some(ref local_var_str) = tag {
22565        local_var_req_builder = match "multi" {
22566            "multi" => local_var_req_builder.query(
22567                &local_var_str
22568                    .into_iter()
22569                    .map(|p| ("tag".to_owned(), p.to_string()))
22570                    .collect::<Vec<(std::string::String, std::string::String)>>(),
22571            ),
22572            _ => local_var_req_builder.query(&[(
22573                "tag",
22574                &local_var_str
22575                    .into_iter()
22576                    .map(|p| p.to_string())
22577                    .collect::<Vec<String>>()
22578                    .join(",")
22579                    .to_string(),
22580            )]),
22581        };
22582    }
22583    if let Some(ref local_var_str) = tag__n {
22584        local_var_req_builder = match "multi" {
22585            "multi" => local_var_req_builder.query(
22586                &local_var_str
22587                    .into_iter()
22588                    .map(|p| ("tag__n".to_owned(), p.to_string()))
22589                    .collect::<Vec<(std::string::String, std::string::String)>>(),
22590            ),
22591            _ => local_var_req_builder.query(&[(
22592                "tag__n",
22593                &local_var_str
22594                    .into_iter()
22595                    .map(|p| p.to_string())
22596                    .collect::<Vec<String>>()
22597                    .join(",")
22598                    .to_string(),
22599            )]),
22600        };
22601    }
22602    if let Some(ref local_var_str) = tag_id {
22603        local_var_req_builder = match "multi" {
22604            "multi" => local_var_req_builder.query(
22605                &local_var_str
22606                    .into_iter()
22607                    .map(|p| ("tag_id".to_owned(), p.to_string()))
22608                    .collect::<Vec<(std::string::String, std::string::String)>>(),
22609            ),
22610            _ => local_var_req_builder.query(&[(
22611                "tag_id",
22612                &local_var_str
22613                    .into_iter()
22614                    .map(|p| p.to_string())
22615                    .collect::<Vec<String>>()
22616                    .join(",")
22617                    .to_string(),
22618            )]),
22619        };
22620    }
22621    if let Some(ref local_var_str) = tag_id__n {
22622        local_var_req_builder = match "multi" {
22623            "multi" => local_var_req_builder.query(
22624                &local_var_str
22625                    .into_iter()
22626                    .map(|p| ("tag_id__n".to_owned(), p.to_string()))
22627                    .collect::<Vec<(std::string::String, std::string::String)>>(),
22628            ),
22629            _ => local_var_req_builder.query(&[(
22630                "tag_id__n",
22631                &local_var_str
22632                    .into_iter()
22633                    .map(|p| p.to_string())
22634                    .collect::<Vec<String>>()
22635                    .join(",")
22636                    .to_string(),
22637            )]),
22638        };
22639    }
22640    if let Some(ref local_var_str) = tenant {
22641        local_var_req_builder = match "multi" {
22642            "multi" => local_var_req_builder.query(
22643                &local_var_str
22644                    .into_iter()
22645                    .map(|p| ("tenant".to_owned(), p.to_string()))
22646                    .collect::<Vec<(std::string::String, std::string::String)>>(),
22647            ),
22648            _ => local_var_req_builder.query(&[(
22649                "tenant",
22650                &local_var_str
22651                    .into_iter()
22652                    .map(|p| p.to_string())
22653                    .collect::<Vec<String>>()
22654                    .join(",")
22655                    .to_string(),
22656            )]),
22657        };
22658    }
22659    if let Some(ref local_var_str) = tenant__n {
22660        local_var_req_builder = match "multi" {
22661            "multi" => local_var_req_builder.query(
22662                &local_var_str
22663                    .into_iter()
22664                    .map(|p| ("tenant__n".to_owned(), p.to_string()))
22665                    .collect::<Vec<(std::string::String, std::string::String)>>(),
22666            ),
22667            _ => local_var_req_builder.query(&[(
22668                "tenant__n",
22669                &local_var_str
22670                    .into_iter()
22671                    .map(|p| p.to_string())
22672                    .collect::<Vec<String>>()
22673                    .join(",")
22674                    .to_string(),
22675            )]),
22676        };
22677    }
22678    if let Some(ref local_var_str) = tenant_group {
22679        local_var_req_builder = match "multi" {
22680            "multi" => local_var_req_builder.query(
22681                &local_var_str
22682                    .into_iter()
22683                    .map(|p| ("tenant_group".to_owned(), p.to_string()))
22684                    .collect::<Vec<(std::string::String, std::string::String)>>(),
22685            ),
22686            _ => local_var_req_builder.query(&[(
22687                "tenant_group",
22688                &local_var_str
22689                    .into_iter()
22690                    .map(|p| p.to_string())
22691                    .collect::<Vec<String>>()
22692                    .join(",")
22693                    .to_string(),
22694            )]),
22695        };
22696    }
22697    if let Some(ref local_var_str) = tenant_group__n {
22698        local_var_req_builder = match "multi" {
22699            "multi" => local_var_req_builder.query(
22700                &local_var_str
22701                    .into_iter()
22702                    .map(|p| ("tenant_group__n".to_owned(), p.to_string()))
22703                    .collect::<Vec<(std::string::String, std::string::String)>>(),
22704            ),
22705            _ => local_var_req_builder.query(&[(
22706                "tenant_group__n",
22707                &local_var_str
22708                    .into_iter()
22709                    .map(|p| p.to_string())
22710                    .collect::<Vec<String>>()
22711                    .join(",")
22712                    .to_string(),
22713            )]),
22714        };
22715    }
22716    if let Some(ref local_var_str) = tenant_group_id {
22717        local_var_req_builder = match "multi" {
22718            "multi" => local_var_req_builder.query(
22719                &local_var_str
22720                    .into_iter()
22721                    .map(|p| ("tenant_group_id".to_owned(), p.to_string()))
22722                    .collect::<Vec<(std::string::String, std::string::String)>>(),
22723            ),
22724            _ => local_var_req_builder.query(&[(
22725                "tenant_group_id",
22726                &local_var_str
22727                    .into_iter()
22728                    .map(|p| p.to_string())
22729                    .collect::<Vec<String>>()
22730                    .join(",")
22731                    .to_string(),
22732            )]),
22733        };
22734    }
22735    if let Some(ref local_var_str) = tenant_group_id__n {
22736        local_var_req_builder = match "multi" {
22737            "multi" => local_var_req_builder.query(
22738                &local_var_str
22739                    .into_iter()
22740                    .map(|p| ("tenant_group_id__n".to_owned(), p.to_string()))
22741                    .collect::<Vec<(std::string::String, std::string::String)>>(),
22742            ),
22743            _ => local_var_req_builder.query(&[(
22744                "tenant_group_id__n",
22745                &local_var_str
22746                    .into_iter()
22747                    .map(|p| p.to_string())
22748                    .collect::<Vec<String>>()
22749                    .join(",")
22750                    .to_string(),
22751            )]),
22752        };
22753    }
22754    if let Some(ref local_var_str) = tenant_id {
22755        local_var_req_builder = match "multi" {
22756            "multi" => local_var_req_builder.query(
22757                &local_var_str
22758                    .into_iter()
22759                    .map(|p| ("tenant_id".to_owned(), p.to_string()))
22760                    .collect::<Vec<(std::string::String, std::string::String)>>(),
22761            ),
22762            _ => local_var_req_builder.query(&[(
22763                "tenant_id",
22764                &local_var_str
22765                    .into_iter()
22766                    .map(|p| p.to_string())
22767                    .collect::<Vec<String>>()
22768                    .join(",")
22769                    .to_string(),
22770            )]),
22771        };
22772    }
22773    if let Some(ref local_var_str) = tenant_id__n {
22774        local_var_req_builder = match "multi" {
22775            "multi" => local_var_req_builder.query(
22776                &local_var_str
22777                    .into_iter()
22778                    .map(|p| ("tenant_id__n".to_owned(), p.to_string()))
22779                    .collect::<Vec<(std::string::String, std::string::String)>>(),
22780            ),
22781            _ => local_var_req_builder.query(&[(
22782                "tenant_id__n",
22783                &local_var_str
22784                    .into_iter()
22785                    .map(|p| p.to_string())
22786                    .collect::<Vec<String>>()
22787                    .join(",")
22788                    .to_string(),
22789            )]),
22790        };
22791    }
22792    if let Some(ref local_var_str) = tunnel_id {
22793        local_var_req_builder = match "multi" {
22794            "multi" => local_var_req_builder.query(
22795                &local_var_str
22796                    .into_iter()
22797                    .map(|p| ("tunnel_id".to_owned(), p.to_string()))
22798                    .collect::<Vec<(std::string::String, std::string::String)>>(),
22799            ),
22800            _ => local_var_req_builder.query(&[(
22801                "tunnel_id",
22802                &local_var_str
22803                    .into_iter()
22804                    .map(|p| p.to_string())
22805                    .collect::<Vec<String>>()
22806                    .join(",")
22807                    .to_string(),
22808            )]),
22809        };
22810    }
22811    if let Some(ref local_var_str) = tunnel_id__empty {
22812        local_var_req_builder =
22813            local_var_req_builder.query(&[("tunnel_id__empty", &local_var_str.to_string())]);
22814    }
22815    if let Some(ref local_var_str) = tunnel_id__gt {
22816        local_var_req_builder = match "multi" {
22817            "multi" => local_var_req_builder.query(
22818                &local_var_str
22819                    .into_iter()
22820                    .map(|p| ("tunnel_id__gt".to_owned(), p.to_string()))
22821                    .collect::<Vec<(std::string::String, std::string::String)>>(),
22822            ),
22823            _ => local_var_req_builder.query(&[(
22824                "tunnel_id__gt",
22825                &local_var_str
22826                    .into_iter()
22827                    .map(|p| p.to_string())
22828                    .collect::<Vec<String>>()
22829                    .join(",")
22830                    .to_string(),
22831            )]),
22832        };
22833    }
22834    if let Some(ref local_var_str) = tunnel_id__gte {
22835        local_var_req_builder = match "multi" {
22836            "multi" => local_var_req_builder.query(
22837                &local_var_str
22838                    .into_iter()
22839                    .map(|p| ("tunnel_id__gte".to_owned(), p.to_string()))
22840                    .collect::<Vec<(std::string::String, std::string::String)>>(),
22841            ),
22842            _ => local_var_req_builder.query(&[(
22843                "tunnel_id__gte",
22844                &local_var_str
22845                    .into_iter()
22846                    .map(|p| p.to_string())
22847                    .collect::<Vec<String>>()
22848                    .join(",")
22849                    .to_string(),
22850            )]),
22851        };
22852    }
22853    if let Some(ref local_var_str) = tunnel_id__lt {
22854        local_var_req_builder = match "multi" {
22855            "multi" => local_var_req_builder.query(
22856                &local_var_str
22857                    .into_iter()
22858                    .map(|p| ("tunnel_id__lt".to_owned(), p.to_string()))
22859                    .collect::<Vec<(std::string::String, std::string::String)>>(),
22860            ),
22861            _ => local_var_req_builder.query(&[(
22862                "tunnel_id__lt",
22863                &local_var_str
22864                    .into_iter()
22865                    .map(|p| p.to_string())
22866                    .collect::<Vec<String>>()
22867                    .join(",")
22868                    .to_string(),
22869            )]),
22870        };
22871    }
22872    if let Some(ref local_var_str) = tunnel_id__lte {
22873        local_var_req_builder = match "multi" {
22874            "multi" => local_var_req_builder.query(
22875                &local_var_str
22876                    .into_iter()
22877                    .map(|p| ("tunnel_id__lte".to_owned(), p.to_string()))
22878                    .collect::<Vec<(std::string::String, std::string::String)>>(),
22879            ),
22880            _ => local_var_req_builder.query(&[(
22881                "tunnel_id__lte",
22882                &local_var_str
22883                    .into_iter()
22884                    .map(|p| p.to_string())
22885                    .collect::<Vec<String>>()
22886                    .join(",")
22887                    .to_string(),
22888            )]),
22889        };
22890    }
22891    if let Some(ref local_var_str) = tunnel_id__n {
22892        local_var_req_builder = match "multi" {
22893            "multi" => local_var_req_builder.query(
22894                &local_var_str
22895                    .into_iter()
22896                    .map(|p| ("tunnel_id__n".to_owned(), p.to_string()))
22897                    .collect::<Vec<(std::string::String, std::string::String)>>(),
22898            ),
22899            _ => local_var_req_builder.query(&[(
22900                "tunnel_id__n",
22901                &local_var_str
22902                    .into_iter()
22903                    .map(|p| p.to_string())
22904                    .collect::<Vec<String>>()
22905                    .join(",")
22906                    .to_string(),
22907            )]),
22908        };
22909    }
22910    if let Some(ref local_var_str) = updated_by_request {
22911        local_var_req_builder =
22912            local_var_req_builder.query(&[("updated_by_request", &local_var_str.to_string())]);
22913    }
22914    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
22915        local_var_req_builder =
22916            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
22917    }
22918    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
22919        let local_var_key = local_var_apikey.key.clone();
22920        let local_var_value = match local_var_apikey.prefix {
22921            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
22922            None => local_var_key,
22923        };
22924        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
22925    };
22926
22927    let local_var_req = local_var_req_builder.build()?;
22928    let local_var_resp = local_var_client.execute(local_var_req).await?;
22929
22930    let local_var_status = local_var_resp.status();
22931    let local_var_content = local_var_resp.text().await?;
22932
22933    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
22934        serde_json::from_str(&local_var_content).map_err(Error::from)
22935    } else {
22936        let local_var_entity: Option<VpnTunnelsListError> =
22937            serde_json::from_str(&local_var_content).ok();
22938        let local_var_error = ResponseContent {
22939            status: local_var_status,
22940            content: local_var_content,
22941            entity: local_var_entity,
22942        };
22943        Err(Error::ResponseError(local_var_error))
22944    }
22945}
22946
22947/// Patch a tunnel object.
22948pub async fn vpn_tunnels_partial_update(
22949    configuration: &configuration::Configuration,
22950    id: i32,
22951    patched_writable_tunnel_request: Option<crate::models::PatchedWritableTunnelRequest>,
22952) -> Result<crate::models::Tunnel, Error<VpnTunnelsPartialUpdateError>> {
22953    let local_var_configuration = configuration;
22954
22955    let local_var_client = &local_var_configuration.client;
22956
22957    let local_var_uri_str = format!(
22958        "{}/api/vpn/tunnels/{id}/",
22959        local_var_configuration.base_path,
22960        id = id
22961    );
22962    let mut local_var_req_builder =
22963        local_var_client.request(reqwest::Method::PATCH, local_var_uri_str.as_str());
22964
22965    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
22966        local_var_req_builder =
22967            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
22968    }
22969    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
22970        let local_var_key = local_var_apikey.key.clone();
22971        let local_var_value = match local_var_apikey.prefix {
22972            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
22973            None => local_var_key,
22974        };
22975        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
22976    };
22977    local_var_req_builder = local_var_req_builder.json(&patched_writable_tunnel_request);
22978
22979    let local_var_req = local_var_req_builder.build()?;
22980    let local_var_resp = local_var_client.execute(local_var_req).await?;
22981
22982    let local_var_status = local_var_resp.status();
22983    let local_var_content = local_var_resp.text().await?;
22984
22985    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
22986        serde_json::from_str(&local_var_content).map_err(Error::from)
22987    } else {
22988        let local_var_entity: Option<VpnTunnelsPartialUpdateError> =
22989            serde_json::from_str(&local_var_content).ok();
22990        let local_var_error = ResponseContent {
22991            status: local_var_status,
22992            content: local_var_content,
22993            entity: local_var_entity,
22994        };
22995        Err(Error::ResponseError(local_var_error))
22996    }
22997}
22998
22999/// Get a tunnel object.
23000pub async fn vpn_tunnels_retrieve(
23001    configuration: &configuration::Configuration,
23002    id: i32,
23003) -> Result<crate::models::Tunnel, Error<VpnTunnelsRetrieveError>> {
23004    let local_var_configuration = configuration;
23005
23006    let local_var_client = &local_var_configuration.client;
23007
23008    let local_var_uri_str = format!(
23009        "{}/api/vpn/tunnels/{id}/",
23010        local_var_configuration.base_path,
23011        id = id
23012    );
23013    let mut local_var_req_builder =
23014        local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
23015
23016    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
23017        local_var_req_builder =
23018            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
23019    }
23020    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
23021        let local_var_key = local_var_apikey.key.clone();
23022        let local_var_value = match local_var_apikey.prefix {
23023            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
23024            None => local_var_key,
23025        };
23026        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
23027    };
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<VpnTunnelsRetrieveError> =
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/// Put a tunnel object.
23050pub async fn vpn_tunnels_update(
23051    configuration: &configuration::Configuration,
23052    id: i32,
23053    writable_tunnel_request: crate::models::WritableTunnelRequest,
23054) -> Result<crate::models::Tunnel, Error<VpnTunnelsUpdateError>> {
23055    let local_var_configuration = configuration;
23056
23057    let local_var_client = &local_var_configuration.client;
23058
23059    let local_var_uri_str = format!(
23060        "{}/api/vpn/tunnels/{id}/",
23061        local_var_configuration.base_path,
23062        id = id
23063    );
23064    let mut local_var_req_builder =
23065        local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());
23066
23067    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
23068        local_var_req_builder =
23069            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
23070    }
23071    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
23072        let local_var_key = local_var_apikey.key.clone();
23073        let local_var_value = match local_var_apikey.prefix {
23074            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
23075            None => local_var_key,
23076        };
23077        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
23078    };
23079    local_var_req_builder = local_var_req_builder.json(&writable_tunnel_request);
23080
23081    let local_var_req = local_var_req_builder.build()?;
23082    let local_var_resp = local_var_client.execute(local_var_req).await?;
23083
23084    let local_var_status = local_var_resp.status();
23085    let local_var_content = local_var_resp.text().await?;
23086
23087    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
23088        serde_json::from_str(&local_var_content).map_err(Error::from)
23089    } else {
23090        let local_var_entity: Option<VpnTunnelsUpdateError> =
23091            serde_json::from_str(&local_var_content).ok();
23092        let local_var_error = ResponseContent {
23093            status: local_var_status,
23094            content: local_var_content,
23095            entity: local_var_entity,
23096        };
23097        Err(Error::ResponseError(local_var_error))
23098    }
23099}
netbox_openapi/apis/vpn_api.rs

netbox_openapi/apis/
vpn_api.rs
