nautobot_openapi/apis/
vpn_api.rs

1/*
2 * API Documentation
3 *
4 * Source of truth and network automation platform
5 *
6 * The version of the OpenAPI document: 3.1.0 (3.1)
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_vpn_phase1_policies_bulk_destroy`]
17#[derive(Debug, Clone, Serialize, Deserialize)]
18#[serde(untagged)]
19pub enum VpnVpnPhase1PoliciesBulkDestroyError {
20    UnknownValue(serde_json::Value),
21}
22
23/// struct for typed errors of method [`vpn_vpn_phase1_policies_bulk_partial_update`]
24#[derive(Debug, Clone, Serialize, Deserialize)]
25#[serde(untagged)]
26pub enum VpnVpnPhase1PoliciesBulkPartialUpdateError {
27    UnknownValue(serde_json::Value),
28}
29
30/// struct for typed errors of method [`vpn_vpn_phase1_policies_bulk_update`]
31#[derive(Debug, Clone, Serialize, Deserialize)]
32#[serde(untagged)]
33pub enum VpnVpnPhase1PoliciesBulkUpdateError {
34    UnknownValue(serde_json::Value),
35}
36
37/// struct for typed errors of method [`vpn_vpn_phase1_policies_create`]
38#[derive(Debug, Clone, Serialize, Deserialize)]
39#[serde(untagged)]
40pub enum VpnVpnPhase1PoliciesCreateError {
41    UnknownValue(serde_json::Value),
42}
43
44/// struct for typed errors of method [`vpn_vpn_phase1_policies_destroy`]
45#[derive(Debug, Clone, Serialize, Deserialize)]
46#[serde(untagged)]
47pub enum VpnVpnPhase1PoliciesDestroyError {
48    UnknownValue(serde_json::Value),
49}
50
51/// struct for typed errors of method [`vpn_vpn_phase1_policies_list`]
52#[derive(Debug, Clone, Serialize, Deserialize)]
53#[serde(untagged)]
54pub enum VpnVpnPhase1PoliciesListError {
55    UnknownValue(serde_json::Value),
56}
57
58/// struct for typed errors of method [`vpn_vpn_phase1_policies_notes_create`]
59#[derive(Debug, Clone, Serialize, Deserialize)]
60#[serde(untagged)]
61pub enum VpnVpnPhase1PoliciesNotesCreateError {
62    UnknownValue(serde_json::Value),
63}
64
65/// struct for typed errors of method [`vpn_vpn_phase1_policies_notes_list`]
66#[derive(Debug, Clone, Serialize, Deserialize)]
67#[serde(untagged)]
68pub enum VpnVpnPhase1PoliciesNotesListError {
69    UnknownValue(serde_json::Value),
70}
71
72/// struct for typed errors of method [`vpn_vpn_phase1_policies_partial_update`]
73#[derive(Debug, Clone, Serialize, Deserialize)]
74#[serde(untagged)]
75pub enum VpnVpnPhase1PoliciesPartialUpdateError {
76    UnknownValue(serde_json::Value),
77}
78
79/// struct for typed errors of method [`vpn_vpn_phase1_policies_retrieve`]
80#[derive(Debug, Clone, Serialize, Deserialize)]
81#[serde(untagged)]
82pub enum VpnVpnPhase1PoliciesRetrieveError {
83    UnknownValue(serde_json::Value),
84}
85
86/// struct for typed errors of method [`vpn_vpn_phase1_policies_update`]
87#[derive(Debug, Clone, Serialize, Deserialize)]
88#[serde(untagged)]
89pub enum VpnVpnPhase1PoliciesUpdateError {
90    UnknownValue(serde_json::Value),
91}
92
93/// struct for typed errors of method [`vpn_vpn_phase2_policies_bulk_destroy`]
94#[derive(Debug, Clone, Serialize, Deserialize)]
95#[serde(untagged)]
96pub enum VpnVpnPhase2PoliciesBulkDestroyError {
97    UnknownValue(serde_json::Value),
98}
99
100/// struct for typed errors of method [`vpn_vpn_phase2_policies_bulk_partial_update`]
101#[derive(Debug, Clone, Serialize, Deserialize)]
102#[serde(untagged)]
103pub enum VpnVpnPhase2PoliciesBulkPartialUpdateError {
104    UnknownValue(serde_json::Value),
105}
106
107/// struct for typed errors of method [`vpn_vpn_phase2_policies_bulk_update`]
108#[derive(Debug, Clone, Serialize, Deserialize)]
109#[serde(untagged)]
110pub enum VpnVpnPhase2PoliciesBulkUpdateError {
111    UnknownValue(serde_json::Value),
112}
113
114/// struct for typed errors of method [`vpn_vpn_phase2_policies_create`]
115#[derive(Debug, Clone, Serialize, Deserialize)]
116#[serde(untagged)]
117pub enum VpnVpnPhase2PoliciesCreateError {
118    UnknownValue(serde_json::Value),
119}
120
121/// struct for typed errors of method [`vpn_vpn_phase2_policies_destroy`]
122#[derive(Debug, Clone, Serialize, Deserialize)]
123#[serde(untagged)]
124pub enum VpnVpnPhase2PoliciesDestroyError {
125    UnknownValue(serde_json::Value),
126}
127
128/// struct for typed errors of method [`vpn_vpn_phase2_policies_list`]
129#[derive(Debug, Clone, Serialize, Deserialize)]
130#[serde(untagged)]
131pub enum VpnVpnPhase2PoliciesListError {
132    UnknownValue(serde_json::Value),
133}
134
135/// struct for typed errors of method [`vpn_vpn_phase2_policies_notes_create`]
136#[derive(Debug, Clone, Serialize, Deserialize)]
137#[serde(untagged)]
138pub enum VpnVpnPhase2PoliciesNotesCreateError {
139    UnknownValue(serde_json::Value),
140}
141
142/// struct for typed errors of method [`vpn_vpn_phase2_policies_notes_list`]
143#[derive(Debug, Clone, Serialize, Deserialize)]
144#[serde(untagged)]
145pub enum VpnVpnPhase2PoliciesNotesListError {
146    UnknownValue(serde_json::Value),
147}
148
149/// struct for typed errors of method [`vpn_vpn_phase2_policies_partial_update`]
150#[derive(Debug, Clone, Serialize, Deserialize)]
151#[serde(untagged)]
152pub enum VpnVpnPhase2PoliciesPartialUpdateError {
153    UnknownValue(serde_json::Value),
154}
155
156/// struct for typed errors of method [`vpn_vpn_phase2_policies_retrieve`]
157#[derive(Debug, Clone, Serialize, Deserialize)]
158#[serde(untagged)]
159pub enum VpnVpnPhase2PoliciesRetrieveError {
160    UnknownValue(serde_json::Value),
161}
162
163/// struct for typed errors of method [`vpn_vpn_phase2_policies_update`]
164#[derive(Debug, Clone, Serialize, Deserialize)]
165#[serde(untagged)]
166pub enum VpnVpnPhase2PoliciesUpdateError {
167    UnknownValue(serde_json::Value),
168}
169
170/// struct for typed errors of method [`vpn_vpn_profile_phase1_policy_assignments_bulk_destroy`]
171#[derive(Debug, Clone, Serialize, Deserialize)]
172#[serde(untagged)]
173pub enum VpnVpnProfilePhase1PolicyAssignmentsBulkDestroyError {
174    UnknownValue(serde_json::Value),
175}
176
177/// struct for typed errors of method [`vpn_vpn_profile_phase1_policy_assignments_bulk_partial_update`]
178#[derive(Debug, Clone, Serialize, Deserialize)]
179#[serde(untagged)]
180pub enum VpnVpnProfilePhase1PolicyAssignmentsBulkPartialUpdateError {
181    UnknownValue(serde_json::Value),
182}
183
184/// struct for typed errors of method [`vpn_vpn_profile_phase1_policy_assignments_bulk_update`]
185#[derive(Debug, Clone, Serialize, Deserialize)]
186#[serde(untagged)]
187pub enum VpnVpnProfilePhase1PolicyAssignmentsBulkUpdateError {
188    UnknownValue(serde_json::Value),
189}
190
191/// struct for typed errors of method [`vpn_vpn_profile_phase1_policy_assignments_create`]
192#[derive(Debug, Clone, Serialize, Deserialize)]
193#[serde(untagged)]
194pub enum VpnVpnProfilePhase1PolicyAssignmentsCreateError {
195    UnknownValue(serde_json::Value),
196}
197
198/// struct for typed errors of method [`vpn_vpn_profile_phase1_policy_assignments_destroy`]
199#[derive(Debug, Clone, Serialize, Deserialize)]
200#[serde(untagged)]
201pub enum VpnVpnProfilePhase1PolicyAssignmentsDestroyError {
202    UnknownValue(serde_json::Value),
203}
204
205/// struct for typed errors of method [`vpn_vpn_profile_phase1_policy_assignments_list`]
206#[derive(Debug, Clone, Serialize, Deserialize)]
207#[serde(untagged)]
208pub enum VpnVpnProfilePhase1PolicyAssignmentsListError {
209    UnknownValue(serde_json::Value),
210}
211
212/// struct for typed errors of method [`vpn_vpn_profile_phase1_policy_assignments_partial_update`]
213#[derive(Debug, Clone, Serialize, Deserialize)]
214#[serde(untagged)]
215pub enum VpnVpnProfilePhase1PolicyAssignmentsPartialUpdateError {
216    UnknownValue(serde_json::Value),
217}
218
219/// struct for typed errors of method [`vpn_vpn_profile_phase1_policy_assignments_retrieve`]
220#[derive(Debug, Clone, Serialize, Deserialize)]
221#[serde(untagged)]
222pub enum VpnVpnProfilePhase1PolicyAssignmentsRetrieveError {
223    UnknownValue(serde_json::Value),
224}
225
226/// struct for typed errors of method [`vpn_vpn_profile_phase1_policy_assignments_update`]
227#[derive(Debug, Clone, Serialize, Deserialize)]
228#[serde(untagged)]
229pub enum VpnVpnProfilePhase1PolicyAssignmentsUpdateError {
230    UnknownValue(serde_json::Value),
231}
232
233/// struct for typed errors of method [`vpn_vpn_profile_phase2_policy_assignments_bulk_destroy`]
234#[derive(Debug, Clone, Serialize, Deserialize)]
235#[serde(untagged)]
236pub enum VpnVpnProfilePhase2PolicyAssignmentsBulkDestroyError {
237    UnknownValue(serde_json::Value),
238}
239
240/// struct for typed errors of method [`vpn_vpn_profile_phase2_policy_assignments_bulk_partial_update`]
241#[derive(Debug, Clone, Serialize, Deserialize)]
242#[serde(untagged)]
243pub enum VpnVpnProfilePhase2PolicyAssignmentsBulkPartialUpdateError {
244    UnknownValue(serde_json::Value),
245}
246
247/// struct for typed errors of method [`vpn_vpn_profile_phase2_policy_assignments_bulk_update`]
248#[derive(Debug, Clone, Serialize, Deserialize)]
249#[serde(untagged)]
250pub enum VpnVpnProfilePhase2PolicyAssignmentsBulkUpdateError {
251    UnknownValue(serde_json::Value),
252}
253
254/// struct for typed errors of method [`vpn_vpn_profile_phase2_policy_assignments_create`]
255#[derive(Debug, Clone, Serialize, Deserialize)]
256#[serde(untagged)]
257pub enum VpnVpnProfilePhase2PolicyAssignmentsCreateError {
258    UnknownValue(serde_json::Value),
259}
260
261/// struct for typed errors of method [`vpn_vpn_profile_phase2_policy_assignments_destroy`]
262#[derive(Debug, Clone, Serialize, Deserialize)]
263#[serde(untagged)]
264pub enum VpnVpnProfilePhase2PolicyAssignmentsDestroyError {
265    UnknownValue(serde_json::Value),
266}
267
268/// struct for typed errors of method [`vpn_vpn_profile_phase2_policy_assignments_list`]
269#[derive(Debug, Clone, Serialize, Deserialize)]
270#[serde(untagged)]
271pub enum VpnVpnProfilePhase2PolicyAssignmentsListError {
272    UnknownValue(serde_json::Value),
273}
274
275/// struct for typed errors of method [`vpn_vpn_profile_phase2_policy_assignments_partial_update`]
276#[derive(Debug, Clone, Serialize, Deserialize)]
277#[serde(untagged)]
278pub enum VpnVpnProfilePhase2PolicyAssignmentsPartialUpdateError {
279    UnknownValue(serde_json::Value),
280}
281
282/// struct for typed errors of method [`vpn_vpn_profile_phase2_policy_assignments_retrieve`]
283#[derive(Debug, Clone, Serialize, Deserialize)]
284#[serde(untagged)]
285pub enum VpnVpnProfilePhase2PolicyAssignmentsRetrieveError {
286    UnknownValue(serde_json::Value),
287}
288
289/// struct for typed errors of method [`vpn_vpn_profile_phase2_policy_assignments_update`]
290#[derive(Debug, Clone, Serialize, Deserialize)]
291#[serde(untagged)]
292pub enum VpnVpnProfilePhase2PolicyAssignmentsUpdateError {
293    UnknownValue(serde_json::Value),
294}
295
296/// struct for typed errors of method [`vpn_vpn_profiles_bulk_destroy`]
297#[derive(Debug, Clone, Serialize, Deserialize)]
298#[serde(untagged)]
299pub enum VpnVpnProfilesBulkDestroyError {
300    UnknownValue(serde_json::Value),
301}
302
303/// struct for typed errors of method [`vpn_vpn_profiles_bulk_partial_update`]
304#[derive(Debug, Clone, Serialize, Deserialize)]
305#[serde(untagged)]
306pub enum VpnVpnProfilesBulkPartialUpdateError {
307    UnknownValue(serde_json::Value),
308}
309
310/// struct for typed errors of method [`vpn_vpn_profiles_bulk_update`]
311#[derive(Debug, Clone, Serialize, Deserialize)]
312#[serde(untagged)]
313pub enum VpnVpnProfilesBulkUpdateError {
314    UnknownValue(serde_json::Value),
315}
316
317/// struct for typed errors of method [`vpn_vpn_profiles_create`]
318#[derive(Debug, Clone, Serialize, Deserialize)]
319#[serde(untagged)]
320pub enum VpnVpnProfilesCreateError {
321    UnknownValue(serde_json::Value),
322}
323
324/// struct for typed errors of method [`vpn_vpn_profiles_destroy`]
325#[derive(Debug, Clone, Serialize, Deserialize)]
326#[serde(untagged)]
327pub enum VpnVpnProfilesDestroyError {
328    UnknownValue(serde_json::Value),
329}
330
331/// struct for typed errors of method [`vpn_vpn_profiles_list`]
332#[derive(Debug, Clone, Serialize, Deserialize)]
333#[serde(untagged)]
334pub enum VpnVpnProfilesListError {
335    UnknownValue(serde_json::Value),
336}
337
338/// struct for typed errors of method [`vpn_vpn_profiles_notes_create`]
339#[derive(Debug, Clone, Serialize, Deserialize)]
340#[serde(untagged)]
341pub enum VpnVpnProfilesNotesCreateError {
342    UnknownValue(serde_json::Value),
343}
344
345/// struct for typed errors of method [`vpn_vpn_profiles_notes_list`]
346#[derive(Debug, Clone, Serialize, Deserialize)]
347#[serde(untagged)]
348pub enum VpnVpnProfilesNotesListError {
349    UnknownValue(serde_json::Value),
350}
351
352/// struct for typed errors of method [`vpn_vpn_profiles_partial_update`]
353#[derive(Debug, Clone, Serialize, Deserialize)]
354#[serde(untagged)]
355pub enum VpnVpnProfilesPartialUpdateError {
356    UnknownValue(serde_json::Value),
357}
358
359/// struct for typed errors of method [`vpn_vpn_profiles_retrieve`]
360#[derive(Debug, Clone, Serialize, Deserialize)]
361#[serde(untagged)]
362pub enum VpnVpnProfilesRetrieveError {
363    UnknownValue(serde_json::Value),
364}
365
366/// struct for typed errors of method [`vpn_vpn_profiles_update`]
367#[derive(Debug, Clone, Serialize, Deserialize)]
368#[serde(untagged)]
369pub enum VpnVpnProfilesUpdateError {
370    UnknownValue(serde_json::Value),
371}
372
373/// struct for typed errors of method [`vpn_vpn_terminations_bulk_destroy`]
374#[derive(Debug, Clone, Serialize, Deserialize)]
375#[serde(untagged)]
376pub enum VpnVpnTerminationsBulkDestroyError {
377    UnknownValue(serde_json::Value),
378}
379
380/// struct for typed errors of method [`vpn_vpn_terminations_bulk_partial_update`]
381#[derive(Debug, Clone, Serialize, Deserialize)]
382#[serde(untagged)]
383pub enum VpnVpnTerminationsBulkPartialUpdateError {
384    UnknownValue(serde_json::Value),
385}
386
387/// struct for typed errors of method [`vpn_vpn_terminations_bulk_update`]
388#[derive(Debug, Clone, Serialize, Deserialize)]
389#[serde(untagged)]
390pub enum VpnVpnTerminationsBulkUpdateError {
391    UnknownValue(serde_json::Value),
392}
393
394/// struct for typed errors of method [`vpn_vpn_terminations_create`]
395#[derive(Debug, Clone, Serialize, Deserialize)]
396#[serde(untagged)]
397pub enum VpnVpnTerminationsCreateError {
398    UnknownValue(serde_json::Value),
399}
400
401/// struct for typed errors of method [`vpn_vpn_terminations_destroy`]
402#[derive(Debug, Clone, Serialize, Deserialize)]
403#[serde(untagged)]
404pub enum VpnVpnTerminationsDestroyError {
405    UnknownValue(serde_json::Value),
406}
407
408/// struct for typed errors of method [`vpn_vpn_terminations_list`]
409#[derive(Debug, Clone, Serialize, Deserialize)]
410#[serde(untagged)]
411pub enum VpnVpnTerminationsListError {
412    UnknownValue(serde_json::Value),
413}
414
415/// struct for typed errors of method [`vpn_vpn_terminations_notes_create`]
416#[derive(Debug, Clone, Serialize, Deserialize)]
417#[serde(untagged)]
418pub enum VpnVpnTerminationsNotesCreateError {
419    UnknownValue(serde_json::Value),
420}
421
422/// struct for typed errors of method [`vpn_vpn_terminations_notes_list`]
423#[derive(Debug, Clone, Serialize, Deserialize)]
424#[serde(untagged)]
425pub enum VpnVpnTerminationsNotesListError {
426    UnknownValue(serde_json::Value),
427}
428
429/// struct for typed errors of method [`vpn_vpn_terminations_partial_update`]
430#[derive(Debug, Clone, Serialize, Deserialize)]
431#[serde(untagged)]
432pub enum VpnVpnTerminationsPartialUpdateError {
433    UnknownValue(serde_json::Value),
434}
435
436/// struct for typed errors of method [`vpn_vpn_terminations_retrieve`]
437#[derive(Debug, Clone, Serialize, Deserialize)]
438#[serde(untagged)]
439pub enum VpnVpnTerminationsRetrieveError {
440    UnknownValue(serde_json::Value),
441}
442
443/// struct for typed errors of method [`vpn_vpn_terminations_update`]
444#[derive(Debug, Clone, Serialize, Deserialize)]
445#[serde(untagged)]
446pub enum VpnVpnTerminationsUpdateError {
447    UnknownValue(serde_json::Value),
448}
449
450/// struct for typed errors of method [`vpn_vpn_tunnel_endpoints_bulk_destroy`]
451#[derive(Debug, Clone, Serialize, Deserialize)]
452#[serde(untagged)]
453pub enum VpnVpnTunnelEndpointsBulkDestroyError {
454    UnknownValue(serde_json::Value),
455}
456
457/// struct for typed errors of method [`vpn_vpn_tunnel_endpoints_bulk_partial_update`]
458#[derive(Debug, Clone, Serialize, Deserialize)]
459#[serde(untagged)]
460pub enum VpnVpnTunnelEndpointsBulkPartialUpdateError {
461    UnknownValue(serde_json::Value),
462}
463
464/// struct for typed errors of method [`vpn_vpn_tunnel_endpoints_bulk_update`]
465#[derive(Debug, Clone, Serialize, Deserialize)]
466#[serde(untagged)]
467pub enum VpnVpnTunnelEndpointsBulkUpdateError {
468    UnknownValue(serde_json::Value),
469}
470
471/// struct for typed errors of method [`vpn_vpn_tunnel_endpoints_create`]
472#[derive(Debug, Clone, Serialize, Deserialize)]
473#[serde(untagged)]
474pub enum VpnVpnTunnelEndpointsCreateError {
475    UnknownValue(serde_json::Value),
476}
477
478/// struct for typed errors of method [`vpn_vpn_tunnel_endpoints_destroy`]
479#[derive(Debug, Clone, Serialize, Deserialize)]
480#[serde(untagged)]
481pub enum VpnVpnTunnelEndpointsDestroyError {
482    UnknownValue(serde_json::Value),
483}
484
485/// struct for typed errors of method [`vpn_vpn_tunnel_endpoints_list`]
486#[derive(Debug, Clone, Serialize, Deserialize)]
487#[serde(untagged)]
488pub enum VpnVpnTunnelEndpointsListError {
489    UnknownValue(serde_json::Value),
490}
491
492/// struct for typed errors of method [`vpn_vpn_tunnel_endpoints_notes_create`]
493#[derive(Debug, Clone, Serialize, Deserialize)]
494#[serde(untagged)]
495pub enum VpnVpnTunnelEndpointsNotesCreateError {
496    UnknownValue(serde_json::Value),
497}
498
499/// struct for typed errors of method [`vpn_vpn_tunnel_endpoints_notes_list`]
500#[derive(Debug, Clone, Serialize, Deserialize)]
501#[serde(untagged)]
502pub enum VpnVpnTunnelEndpointsNotesListError {
503    UnknownValue(serde_json::Value),
504}
505
506/// struct for typed errors of method [`vpn_vpn_tunnel_endpoints_partial_update`]
507#[derive(Debug, Clone, Serialize, Deserialize)]
508#[serde(untagged)]
509pub enum VpnVpnTunnelEndpointsPartialUpdateError {
510    UnknownValue(serde_json::Value),
511}
512
513/// struct for typed errors of method [`vpn_vpn_tunnel_endpoints_retrieve`]
514#[derive(Debug, Clone, Serialize, Deserialize)]
515#[serde(untagged)]
516pub enum VpnVpnTunnelEndpointsRetrieveError {
517    UnknownValue(serde_json::Value),
518}
519
520/// struct for typed errors of method [`vpn_vpn_tunnel_endpoints_update`]
521#[derive(Debug, Clone, Serialize, Deserialize)]
522#[serde(untagged)]
523pub enum VpnVpnTunnelEndpointsUpdateError {
524    UnknownValue(serde_json::Value),
525}
526
527/// struct for typed errors of method [`vpn_vpn_tunnels_bulk_destroy`]
528#[derive(Debug, Clone, Serialize, Deserialize)]
529#[serde(untagged)]
530pub enum VpnVpnTunnelsBulkDestroyError {
531    UnknownValue(serde_json::Value),
532}
533
534/// struct for typed errors of method [`vpn_vpn_tunnels_bulk_partial_update`]
535#[derive(Debug, Clone, Serialize, Deserialize)]
536#[serde(untagged)]
537pub enum VpnVpnTunnelsBulkPartialUpdateError {
538    UnknownValue(serde_json::Value),
539}
540
541/// struct for typed errors of method [`vpn_vpn_tunnels_bulk_update`]
542#[derive(Debug, Clone, Serialize, Deserialize)]
543#[serde(untagged)]
544pub enum VpnVpnTunnelsBulkUpdateError {
545    UnknownValue(serde_json::Value),
546}
547
548/// struct for typed errors of method [`vpn_vpn_tunnels_create`]
549#[derive(Debug, Clone, Serialize, Deserialize)]
550#[serde(untagged)]
551pub enum VpnVpnTunnelsCreateError {
552    UnknownValue(serde_json::Value),
553}
554
555/// struct for typed errors of method [`vpn_vpn_tunnels_destroy`]
556#[derive(Debug, Clone, Serialize, Deserialize)]
557#[serde(untagged)]
558pub enum VpnVpnTunnelsDestroyError {
559    UnknownValue(serde_json::Value),
560}
561
562/// struct for typed errors of method [`vpn_vpn_tunnels_list`]
563#[derive(Debug, Clone, Serialize, Deserialize)]
564#[serde(untagged)]
565pub enum VpnVpnTunnelsListError {
566    UnknownValue(serde_json::Value),
567}
568
569/// struct for typed errors of method [`vpn_vpn_tunnels_notes_create`]
570#[derive(Debug, Clone, Serialize, Deserialize)]
571#[serde(untagged)]
572pub enum VpnVpnTunnelsNotesCreateError {
573    UnknownValue(serde_json::Value),
574}
575
576/// struct for typed errors of method [`vpn_vpn_tunnels_notes_list`]
577#[derive(Debug, Clone, Serialize, Deserialize)]
578#[serde(untagged)]
579pub enum VpnVpnTunnelsNotesListError {
580    UnknownValue(serde_json::Value),
581}
582
583/// struct for typed errors of method [`vpn_vpn_tunnels_partial_update`]
584#[derive(Debug, Clone, Serialize, Deserialize)]
585#[serde(untagged)]
586pub enum VpnVpnTunnelsPartialUpdateError {
587    UnknownValue(serde_json::Value),
588}
589
590/// struct for typed errors of method [`vpn_vpn_tunnels_retrieve`]
591#[derive(Debug, Clone, Serialize, Deserialize)]
592#[serde(untagged)]
593pub enum VpnVpnTunnelsRetrieveError {
594    UnknownValue(serde_json::Value),
595}
596
597/// struct for typed errors of method [`vpn_vpn_tunnels_update`]
598#[derive(Debug, Clone, Serialize, Deserialize)]
599#[serde(untagged)]
600pub enum VpnVpnTunnelsUpdateError {
601    UnknownValue(serde_json::Value),
602}
603
604/// struct for typed errors of method [`vpn_vpns_bulk_destroy`]
605#[derive(Debug, Clone, Serialize, Deserialize)]
606#[serde(untagged)]
607pub enum VpnVpnsBulkDestroyError {
608    UnknownValue(serde_json::Value),
609}
610
611/// struct for typed errors of method [`vpn_vpns_bulk_partial_update`]
612#[derive(Debug, Clone, Serialize, Deserialize)]
613#[serde(untagged)]
614pub enum VpnVpnsBulkPartialUpdateError {
615    UnknownValue(serde_json::Value),
616}
617
618/// struct for typed errors of method [`vpn_vpns_bulk_update`]
619#[derive(Debug, Clone, Serialize, Deserialize)]
620#[serde(untagged)]
621pub enum VpnVpnsBulkUpdateError {
622    UnknownValue(serde_json::Value),
623}
624
625/// struct for typed errors of method [`vpn_vpns_create`]
626#[derive(Debug, Clone, Serialize, Deserialize)]
627#[serde(untagged)]
628pub enum VpnVpnsCreateError {
629    UnknownValue(serde_json::Value),
630}
631
632/// struct for typed errors of method [`vpn_vpns_destroy`]
633#[derive(Debug, Clone, Serialize, Deserialize)]
634#[serde(untagged)]
635pub enum VpnVpnsDestroyError {
636    UnknownValue(serde_json::Value),
637}
638
639/// struct for typed errors of method [`vpn_vpns_list`]
640#[derive(Debug, Clone, Serialize, Deserialize)]
641#[serde(untagged)]
642pub enum VpnVpnsListError {
643    UnknownValue(serde_json::Value),
644}
645
646/// struct for typed errors of method [`vpn_vpns_notes_create`]
647#[derive(Debug, Clone, Serialize, Deserialize)]
648#[serde(untagged)]
649pub enum VpnVpnsNotesCreateError {
650    UnknownValue(serde_json::Value),
651}
652
653/// struct for typed errors of method [`vpn_vpns_notes_list`]
654#[derive(Debug, Clone, Serialize, Deserialize)]
655#[serde(untagged)]
656pub enum VpnVpnsNotesListError {
657    UnknownValue(serde_json::Value),
658}
659
660/// struct for typed errors of method [`vpn_vpns_partial_update`]
661#[derive(Debug, Clone, Serialize, Deserialize)]
662#[serde(untagged)]
663pub enum VpnVpnsPartialUpdateError {
664    UnknownValue(serde_json::Value),
665}
666
667/// struct for typed errors of method [`vpn_vpns_retrieve`]
668#[derive(Debug, Clone, Serialize, Deserialize)]
669#[serde(untagged)]
670pub enum VpnVpnsRetrieveError {
671    UnknownValue(serde_json::Value),
672}
673
674/// struct for typed errors of method [`vpn_vpns_update`]
675#[derive(Debug, Clone, Serialize, Deserialize)]
676#[serde(untagged)]
677pub enum VpnVpnsUpdateError {
678    UnknownValue(serde_json::Value),
679}
680
681/// VPNPhase1Policy viewset.
682pub async fn vpn_vpn_phase1_policies_bulk_destroy(
683    configuration: &configuration::Configuration,
684    bulk_operation_request: Vec<crate::models::BulkOperationRequest>,
685    format: Option<&str>,
686) -> Result<(), Error<VpnVpnPhase1PoliciesBulkDestroyError>> {
687    let local_var_configuration = configuration;
688
689    let local_var_client = &local_var_configuration.client;
690
691    let local_var_uri_str = format!(
692        "{}/vpn/vpn-phase-1-policies/",
693        local_var_configuration.base_path
694    );
695    let mut local_var_req_builder =
696        local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());
697
698    if let Some(ref local_var_str) = format {
699        local_var_req_builder =
700            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
701    }
702    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
703        local_var_req_builder =
704            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
705    }
706    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
707        let local_var_key = local_var_apikey.key.clone();
708        let local_var_value = match local_var_apikey.prefix {
709            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
710            None => local_var_key,
711        };
712        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
713    };
714    local_var_req_builder = local_var_req_builder.json(&bulk_operation_request);
715
716    let local_var_req = local_var_req_builder.build()?;
717    let local_var_resp = local_var_client.execute(local_var_req).await?;
718
719    let local_var_status = local_var_resp.status();
720    let local_var_content = local_var_resp.text().await?;
721
722    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
723        Ok(())
724    } else {
725        let local_var_entity: Option<VpnVpnPhase1PoliciesBulkDestroyError> =
726            serde_json::from_str(&local_var_content).ok();
727        let local_var_error = ResponseContent {
728            status: local_var_status,
729            content: local_var_content,
730            entity: local_var_entity,
731        };
732        Err(Error::ResponseError(local_var_error))
733    }
734}
735
736/// VPNPhase1Policy viewset.
737pub async fn vpn_vpn_phase1_policies_bulk_partial_update(
738    configuration: &configuration::Configuration,
739    patched_bulk_writable_vpn_phase1_policy_request: Vec<
740        crate::models::PatchedBulkWritableVpnPhase1PolicyRequest,
741    >,
742    format: Option<&str>,
743) -> Result<Vec<crate::models::VpnPhase1Policy>, Error<VpnVpnPhase1PoliciesBulkPartialUpdateError>>
744{
745    let local_var_configuration = configuration;
746
747    let local_var_client = &local_var_configuration.client;
748
749    let local_var_uri_str = format!(
750        "{}/vpn/vpn-phase-1-policies/",
751        local_var_configuration.base_path
752    );
753    let mut local_var_req_builder =
754        local_var_client.request(reqwest::Method::PATCH, local_var_uri_str.as_str());
755
756    if let Some(ref local_var_str) = format {
757        local_var_req_builder =
758            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
759    }
760    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
761        local_var_req_builder =
762            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
763    }
764    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
765        let local_var_key = local_var_apikey.key.clone();
766        let local_var_value = match local_var_apikey.prefix {
767            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
768            None => local_var_key,
769        };
770        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
771    };
772    local_var_req_builder =
773        local_var_req_builder.json(&patched_bulk_writable_vpn_phase1_policy_request);
774
775    let local_var_req = local_var_req_builder.build()?;
776    let local_var_resp = local_var_client.execute(local_var_req).await?;
777
778    let local_var_status = local_var_resp.status();
779    let local_var_content = local_var_resp.text().await?;
780
781    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
782        serde_json::from_str(&local_var_content).map_err(Error::from)
783    } else {
784        let local_var_entity: Option<VpnVpnPhase1PoliciesBulkPartialUpdateError> =
785            serde_json::from_str(&local_var_content).ok();
786        let local_var_error = ResponseContent {
787            status: local_var_status,
788            content: local_var_content,
789            entity: local_var_entity,
790        };
791        Err(Error::ResponseError(local_var_error))
792    }
793}
794
795/// VPNPhase1Policy viewset.
796pub async fn vpn_vpn_phase1_policies_bulk_update(
797    configuration: &configuration::Configuration,
798    bulk_writable_vpn_phase1_policy_request: Vec<crate::models::BulkWritableVpnPhase1PolicyRequest>,
799    format: Option<&str>,
800) -> Result<Vec<crate::models::VpnPhase1Policy>, Error<VpnVpnPhase1PoliciesBulkUpdateError>> {
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        "{}/vpn/vpn-phase-1-policies/",
807        local_var_configuration.base_path
808    );
809    let mut local_var_req_builder =
810        local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());
811
812    if let Some(ref local_var_str) = format {
813        local_var_req_builder =
814            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
815    }
816    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
817        local_var_req_builder =
818            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
819    }
820    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
821        let local_var_key = local_var_apikey.key.clone();
822        let local_var_value = match local_var_apikey.prefix {
823            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
824            None => local_var_key,
825        };
826        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
827    };
828    local_var_req_builder = local_var_req_builder.json(&bulk_writable_vpn_phase1_policy_request);
829
830    let local_var_req = local_var_req_builder.build()?;
831    let local_var_resp = local_var_client.execute(local_var_req).await?;
832
833    let local_var_status = local_var_resp.status();
834    let local_var_content = local_var_resp.text().await?;
835
836    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
837        serde_json::from_str(&local_var_content).map_err(Error::from)
838    } else {
839        let local_var_entity: Option<VpnVpnPhase1PoliciesBulkUpdateError> =
840            serde_json::from_str(&local_var_content).ok();
841        let local_var_error = ResponseContent {
842            status: local_var_status,
843            content: local_var_content,
844            entity: local_var_entity,
845        };
846        Err(Error::ResponseError(local_var_error))
847    }
848}
849
850/// VPNPhase1Policy viewset.
851pub async fn vpn_vpn_phase1_policies_create(
852    configuration: &configuration::Configuration,
853    vpn_phase1_policy_request: crate::models::VpnPhase1PolicyRequest,
854    format: Option<&str>,
855) -> Result<crate::models::VpnPhase1Policy, Error<VpnVpnPhase1PoliciesCreateError>> {
856    let local_var_configuration = configuration;
857
858    let local_var_client = &local_var_configuration.client;
859
860    let local_var_uri_str = format!(
861        "{}/vpn/vpn-phase-1-policies/",
862        local_var_configuration.base_path
863    );
864    let mut local_var_req_builder =
865        local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
866
867    if let Some(ref local_var_str) = format {
868        local_var_req_builder =
869            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
870    }
871    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
872        local_var_req_builder =
873            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
874    }
875    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
876        let local_var_key = local_var_apikey.key.clone();
877        let local_var_value = match local_var_apikey.prefix {
878            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
879            None => local_var_key,
880        };
881        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
882    };
883    local_var_req_builder = local_var_req_builder.json(&vpn_phase1_policy_request);
884
885    let local_var_req = local_var_req_builder.build()?;
886    let local_var_resp = local_var_client.execute(local_var_req).await?;
887
888    let local_var_status = local_var_resp.status();
889    let local_var_content = local_var_resp.text().await?;
890
891    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
892        serde_json::from_str(&local_var_content).map_err(Error::from)
893    } else {
894        let local_var_entity: Option<VpnVpnPhase1PoliciesCreateError> =
895            serde_json::from_str(&local_var_content).ok();
896        let local_var_error = ResponseContent {
897            status: local_var_status,
898            content: local_var_content,
899            entity: local_var_entity,
900        };
901        Err(Error::ResponseError(local_var_error))
902    }
903}
904
905/// VPNPhase1Policy viewset.
906pub async fn vpn_vpn_phase1_policies_destroy(
907    configuration: &configuration::Configuration,
908    id: &str,
909    format: Option<&str>,
910) -> Result<(), Error<VpnVpnPhase1PoliciesDestroyError>> {
911    let local_var_configuration = configuration;
912
913    let local_var_client = &local_var_configuration.client;
914
915    let local_var_uri_str = format!(
916        "{}/vpn/vpn-phase-1-policies/{id}/",
917        local_var_configuration.base_path,
918        id = crate::apis::urlencode(id)
919    );
920    let mut local_var_req_builder =
921        local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());
922
923    if let Some(ref local_var_str) = format {
924        local_var_req_builder =
925            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
926    }
927    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
928        local_var_req_builder =
929            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
930    }
931    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
932        let local_var_key = local_var_apikey.key.clone();
933        let local_var_value = match local_var_apikey.prefix {
934            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
935            None => local_var_key,
936        };
937        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
938    };
939
940    let local_var_req = local_var_req_builder.build()?;
941    let local_var_resp = local_var_client.execute(local_var_req).await?;
942
943    let local_var_status = local_var_resp.status();
944    let local_var_content = local_var_resp.text().await?;
945
946    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
947        Ok(())
948    } else {
949        let local_var_entity: Option<VpnVpnPhase1PoliciesDestroyError> =
950            serde_json::from_str(&local_var_content).ok();
951        let local_var_error = ResponseContent {
952            status: local_var_status,
953            content: local_var_content,
954            entity: local_var_entity,
955        };
956        Err(Error::ResponseError(local_var_error))
957    }
958}
959
960/// VPNPhase1Policy viewset.
961pub async fn vpn_vpn_phase1_policies_list(
962    configuration: &configuration::Configuration,
963    aggressive_mode: Option<bool>,
964    authentication_method: Option<Vec<String>>,
965    authentication_method__ic: Option<Vec<String>>,
966    authentication_method__ie: Option<Vec<String>>,
967    authentication_method__iew: Option<Vec<String>>,
968    authentication_method__ire: Option<Vec<String>>,
969    authentication_method__isw: Option<Vec<String>>,
970    authentication_method__n: Option<Vec<String>>,
971    authentication_method__nic: Option<Vec<String>>,
972    authentication_method__nie: Option<Vec<String>>,
973    authentication_method__niew: Option<Vec<String>>,
974    authentication_method__nire: Option<Vec<String>>,
975    authentication_method__nisw: Option<Vec<String>>,
976    authentication_method__nre: Option<Vec<String>>,
977    authentication_method__re: Option<Vec<String>>,
978    contacts: Option<Vec<String>>,
979    contacts__isnull: Option<bool>,
980    contacts__n: Option<Vec<String>>,
981    created: Option<Vec<String>>,
982    created__gt: Option<Vec<String>>,
983    created__gte: Option<Vec<String>>,
984    created__isnull: Option<bool>,
985    created__lt: Option<Vec<String>>,
986    created__lte: Option<Vec<String>>,
987    created__n: Option<Vec<String>>,
988    description: Option<Vec<String>>,
989    description__ic: Option<Vec<String>>,
990    description__ie: Option<Vec<String>>,
991    description__iew: Option<Vec<String>>,
992    description__ire: Option<Vec<String>>,
993    description__isw: Option<Vec<String>>,
994    description__n: Option<Vec<String>>,
995    description__nic: Option<Vec<String>>,
996    description__nie: Option<Vec<String>>,
997    description__niew: Option<Vec<String>>,
998    description__nire: Option<Vec<String>>,
999    description__nisw: Option<Vec<String>>,
1000    description__nre: Option<Vec<String>>,
1001    description__re: Option<Vec<String>>,
1002    dh_group: Option<Vec<String>>,
1003    dynamic_groups: Option<Vec<String>>,
1004    dynamic_groups__n: Option<Vec<String>>,
1005    encryption_algorithm: Option<Vec<String>>,
1006    format: Option<&str>,
1007    id: Option<Vec<uuid::Uuid>>,
1008    id__n: Option<Vec<uuid::Uuid>>,
1009    ike_version: Option<Vec<String>>,
1010    ike_version__ic: Option<Vec<String>>,
1011    ike_version__ie: Option<Vec<String>>,
1012    ike_version__iew: Option<Vec<String>>,
1013    ike_version__ire: Option<Vec<String>>,
1014    ike_version__isw: Option<Vec<String>>,
1015    ike_version__n: Option<Vec<String>>,
1016    ike_version__nic: Option<Vec<String>>,
1017    ike_version__nie: Option<Vec<String>>,
1018    ike_version__niew: Option<Vec<String>>,
1019    ike_version__nire: Option<Vec<String>>,
1020    ike_version__nisw: Option<Vec<String>>,
1021    ike_version__nre: Option<Vec<String>>,
1022    ike_version__re: Option<Vec<String>>,
1023    integrity_algorithm: Option<Vec<String>>,
1024    last_updated: Option<Vec<String>>,
1025    last_updated__gt: Option<Vec<String>>,
1026    last_updated__gte: Option<Vec<String>>,
1027    last_updated__isnull: Option<bool>,
1028    last_updated__lt: Option<Vec<String>>,
1029    last_updated__lte: Option<Vec<String>>,
1030    last_updated__n: Option<Vec<String>>,
1031    lifetime_kb: Option<Vec<i32>>,
1032    lifetime_kb__gt: Option<Vec<i32>>,
1033    lifetime_kb__gte: Option<Vec<i32>>,
1034    lifetime_kb__isnull: Option<bool>,
1035    lifetime_kb__lt: Option<Vec<i32>>,
1036    lifetime_kb__lte: Option<Vec<i32>>,
1037    lifetime_kb__n: Option<Vec<i32>>,
1038    lifetime_seconds: Option<Vec<i32>>,
1039    lifetime_seconds__gt: Option<Vec<i32>>,
1040    lifetime_seconds__gte: Option<Vec<i32>>,
1041    lifetime_seconds__isnull: Option<bool>,
1042    lifetime_seconds__lt: Option<Vec<i32>>,
1043    lifetime_seconds__lte: Option<Vec<i32>>,
1044    lifetime_seconds__n: Option<Vec<i32>>,
1045    limit: Option<i32>,
1046    name: Option<Vec<String>>,
1047    name__ic: Option<Vec<String>>,
1048    name__ie: Option<Vec<String>>,
1049    name__iew: Option<Vec<String>>,
1050    name__ire: Option<Vec<String>>,
1051    name__isw: Option<Vec<String>>,
1052    name__n: Option<Vec<String>>,
1053    name__nic: Option<Vec<String>>,
1054    name__nie: Option<Vec<String>>,
1055    name__niew: Option<Vec<String>>,
1056    name__nire: Option<Vec<String>>,
1057    name__nisw: Option<Vec<String>>,
1058    name__nre: Option<Vec<String>>,
1059    name__re: Option<Vec<String>>,
1060    offset: Option<i32>,
1061    q: Option<&str>,
1062    sort: Option<&str>,
1063    tags: Option<Vec<String>>,
1064    tags__isnull: Option<bool>,
1065    tags__n: Option<Vec<String>>,
1066    teams: Option<Vec<String>>,
1067    teams__isnull: Option<bool>,
1068    teams__n: Option<Vec<String>>,
1069    tenant: Option<Vec<String>>,
1070    tenant__isnull: Option<bool>,
1071    tenant__n: Option<Vec<String>>,
1072    tenant_group: Option<Vec<String>>,
1073    tenant_group__isnull: Option<bool>,
1074    tenant_group__n: Option<Vec<String>>,
1075    tenant_id: Option<Vec<uuid::Uuid>>,
1076    tenant_id__isnull: Option<bool>,
1077    tenant_id__n: Option<Vec<uuid::Uuid>>,
1078    vpn_profiles: Option<Vec<String>>,
1079    vpn_profiles__isnull: Option<bool>,
1080    vpn_profiles__n: Option<Vec<String>>,
1081    depth: Option<i32>,
1082    exclude_m2m: Option<bool>,
1083) -> Result<crate::models::PaginatedVpnPhase1PolicyList, Error<VpnVpnPhase1PoliciesListError>> {
1084    let local_var_configuration = configuration;
1085
1086    let local_var_client = &local_var_configuration.client;
1087
1088    let local_var_uri_str = format!(
1089        "{}/vpn/vpn-phase-1-policies/",
1090        local_var_configuration.base_path
1091    );
1092    let mut local_var_req_builder =
1093        local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
1094
1095    if let Some(ref local_var_str) = aggressive_mode {
1096        local_var_req_builder =
1097            local_var_req_builder.query(&[("aggressive_mode", &local_var_str.to_string())]);
1098    }
1099    if let Some(ref local_var_str) = authentication_method {
1100        local_var_req_builder = match "multi" {
1101            "multi" => local_var_req_builder.query(
1102                &local_var_str
1103                    .into_iter()
1104                    .map(|p| ("authentication_method".to_owned(), p.to_string()))
1105                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1106            ),
1107            _ => local_var_req_builder.query(&[(
1108                "authentication_method",
1109                &local_var_str
1110                    .into_iter()
1111                    .map(|p| p.to_string())
1112                    .collect::<Vec<String>>()
1113                    .join(",")
1114                    .to_string(),
1115            )]),
1116        };
1117    }
1118    if let Some(ref local_var_str) = authentication_method__ic {
1119        local_var_req_builder = match "multi" {
1120            "multi" => local_var_req_builder.query(
1121                &local_var_str
1122                    .into_iter()
1123                    .map(|p| ("authentication_method__ic".to_owned(), p.to_string()))
1124                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1125            ),
1126            _ => local_var_req_builder.query(&[(
1127                "authentication_method__ic",
1128                &local_var_str
1129                    .into_iter()
1130                    .map(|p| p.to_string())
1131                    .collect::<Vec<String>>()
1132                    .join(",")
1133                    .to_string(),
1134            )]),
1135        };
1136    }
1137    if let Some(ref local_var_str) = authentication_method__ie {
1138        local_var_req_builder = match "multi" {
1139            "multi" => local_var_req_builder.query(
1140                &local_var_str
1141                    .into_iter()
1142                    .map(|p| ("authentication_method__ie".to_owned(), p.to_string()))
1143                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1144            ),
1145            _ => local_var_req_builder.query(&[(
1146                "authentication_method__ie",
1147                &local_var_str
1148                    .into_iter()
1149                    .map(|p| p.to_string())
1150                    .collect::<Vec<String>>()
1151                    .join(",")
1152                    .to_string(),
1153            )]),
1154        };
1155    }
1156    if let Some(ref local_var_str) = authentication_method__iew {
1157        local_var_req_builder = match "multi" {
1158            "multi" => local_var_req_builder.query(
1159                &local_var_str
1160                    .into_iter()
1161                    .map(|p| ("authentication_method__iew".to_owned(), p.to_string()))
1162                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1163            ),
1164            _ => local_var_req_builder.query(&[(
1165                "authentication_method__iew",
1166                &local_var_str
1167                    .into_iter()
1168                    .map(|p| p.to_string())
1169                    .collect::<Vec<String>>()
1170                    .join(",")
1171                    .to_string(),
1172            )]),
1173        };
1174    }
1175    if let Some(ref local_var_str) = authentication_method__ire {
1176        local_var_req_builder = match "multi" {
1177            "multi" => local_var_req_builder.query(
1178                &local_var_str
1179                    .into_iter()
1180                    .map(|p| ("authentication_method__ire".to_owned(), p.to_string()))
1181                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1182            ),
1183            _ => local_var_req_builder.query(&[(
1184                "authentication_method__ire",
1185                &local_var_str
1186                    .into_iter()
1187                    .map(|p| p.to_string())
1188                    .collect::<Vec<String>>()
1189                    .join(",")
1190                    .to_string(),
1191            )]),
1192        };
1193    }
1194    if let Some(ref local_var_str) = authentication_method__isw {
1195        local_var_req_builder = match "multi" {
1196            "multi" => local_var_req_builder.query(
1197                &local_var_str
1198                    .into_iter()
1199                    .map(|p| ("authentication_method__isw".to_owned(), p.to_string()))
1200                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1201            ),
1202            _ => local_var_req_builder.query(&[(
1203                "authentication_method__isw",
1204                &local_var_str
1205                    .into_iter()
1206                    .map(|p| p.to_string())
1207                    .collect::<Vec<String>>()
1208                    .join(",")
1209                    .to_string(),
1210            )]),
1211        };
1212    }
1213    if let Some(ref local_var_str) = authentication_method__n {
1214        local_var_req_builder = match "multi" {
1215            "multi" => local_var_req_builder.query(
1216                &local_var_str
1217                    .into_iter()
1218                    .map(|p| ("authentication_method__n".to_owned(), p.to_string()))
1219                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1220            ),
1221            _ => local_var_req_builder.query(&[(
1222                "authentication_method__n",
1223                &local_var_str
1224                    .into_iter()
1225                    .map(|p| p.to_string())
1226                    .collect::<Vec<String>>()
1227                    .join(",")
1228                    .to_string(),
1229            )]),
1230        };
1231    }
1232    if let Some(ref local_var_str) = authentication_method__nic {
1233        local_var_req_builder = match "multi" {
1234            "multi" => local_var_req_builder.query(
1235                &local_var_str
1236                    .into_iter()
1237                    .map(|p| ("authentication_method__nic".to_owned(), p.to_string()))
1238                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1239            ),
1240            _ => local_var_req_builder.query(&[(
1241                "authentication_method__nic",
1242                &local_var_str
1243                    .into_iter()
1244                    .map(|p| p.to_string())
1245                    .collect::<Vec<String>>()
1246                    .join(",")
1247                    .to_string(),
1248            )]),
1249        };
1250    }
1251    if let Some(ref local_var_str) = authentication_method__nie {
1252        local_var_req_builder = match "multi" {
1253            "multi" => local_var_req_builder.query(
1254                &local_var_str
1255                    .into_iter()
1256                    .map(|p| ("authentication_method__nie".to_owned(), p.to_string()))
1257                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1258            ),
1259            _ => local_var_req_builder.query(&[(
1260                "authentication_method__nie",
1261                &local_var_str
1262                    .into_iter()
1263                    .map(|p| p.to_string())
1264                    .collect::<Vec<String>>()
1265                    .join(",")
1266                    .to_string(),
1267            )]),
1268        };
1269    }
1270    if let Some(ref local_var_str) = authentication_method__niew {
1271        local_var_req_builder = match "multi" {
1272            "multi" => local_var_req_builder.query(
1273                &local_var_str
1274                    .into_iter()
1275                    .map(|p| ("authentication_method__niew".to_owned(), p.to_string()))
1276                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1277            ),
1278            _ => local_var_req_builder.query(&[(
1279                "authentication_method__niew",
1280                &local_var_str
1281                    .into_iter()
1282                    .map(|p| p.to_string())
1283                    .collect::<Vec<String>>()
1284                    .join(",")
1285                    .to_string(),
1286            )]),
1287        };
1288    }
1289    if let Some(ref local_var_str) = authentication_method__nire {
1290        local_var_req_builder = match "multi" {
1291            "multi" => local_var_req_builder.query(
1292                &local_var_str
1293                    .into_iter()
1294                    .map(|p| ("authentication_method__nire".to_owned(), p.to_string()))
1295                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1296            ),
1297            _ => local_var_req_builder.query(&[(
1298                "authentication_method__nire",
1299                &local_var_str
1300                    .into_iter()
1301                    .map(|p| p.to_string())
1302                    .collect::<Vec<String>>()
1303                    .join(",")
1304                    .to_string(),
1305            )]),
1306        };
1307    }
1308    if let Some(ref local_var_str) = authentication_method__nisw {
1309        local_var_req_builder = match "multi" {
1310            "multi" => local_var_req_builder.query(
1311                &local_var_str
1312                    .into_iter()
1313                    .map(|p| ("authentication_method__nisw".to_owned(), p.to_string()))
1314                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1315            ),
1316            _ => local_var_req_builder.query(&[(
1317                "authentication_method__nisw",
1318                &local_var_str
1319                    .into_iter()
1320                    .map(|p| p.to_string())
1321                    .collect::<Vec<String>>()
1322                    .join(",")
1323                    .to_string(),
1324            )]),
1325        };
1326    }
1327    if let Some(ref local_var_str) = authentication_method__nre {
1328        local_var_req_builder = match "multi" {
1329            "multi" => local_var_req_builder.query(
1330                &local_var_str
1331                    .into_iter()
1332                    .map(|p| ("authentication_method__nre".to_owned(), p.to_string()))
1333                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1334            ),
1335            _ => local_var_req_builder.query(&[(
1336                "authentication_method__nre",
1337                &local_var_str
1338                    .into_iter()
1339                    .map(|p| p.to_string())
1340                    .collect::<Vec<String>>()
1341                    .join(",")
1342                    .to_string(),
1343            )]),
1344        };
1345    }
1346    if let Some(ref local_var_str) = authentication_method__re {
1347        local_var_req_builder = match "multi" {
1348            "multi" => local_var_req_builder.query(
1349                &local_var_str
1350                    .into_iter()
1351                    .map(|p| ("authentication_method__re".to_owned(), p.to_string()))
1352                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1353            ),
1354            _ => local_var_req_builder.query(&[(
1355                "authentication_method__re",
1356                &local_var_str
1357                    .into_iter()
1358                    .map(|p| p.to_string())
1359                    .collect::<Vec<String>>()
1360                    .join(",")
1361                    .to_string(),
1362            )]),
1363        };
1364    }
1365    if let Some(ref local_var_str) = contacts {
1366        local_var_req_builder = match "multi" {
1367            "multi" => local_var_req_builder.query(
1368                &local_var_str
1369                    .into_iter()
1370                    .map(|p| ("contacts".to_owned(), p.to_string()))
1371                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1372            ),
1373            _ => local_var_req_builder.query(&[(
1374                "contacts",
1375                &local_var_str
1376                    .into_iter()
1377                    .map(|p| p.to_string())
1378                    .collect::<Vec<String>>()
1379                    .join(",")
1380                    .to_string(),
1381            )]),
1382        };
1383    }
1384    if let Some(ref local_var_str) = contacts__isnull {
1385        local_var_req_builder =
1386            local_var_req_builder.query(&[("contacts__isnull", &local_var_str.to_string())]);
1387    }
1388    if let Some(ref local_var_str) = contacts__n {
1389        local_var_req_builder = match "multi" {
1390            "multi" => local_var_req_builder.query(
1391                &local_var_str
1392                    .into_iter()
1393                    .map(|p| ("contacts__n".to_owned(), p.to_string()))
1394                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1395            ),
1396            _ => local_var_req_builder.query(&[(
1397                "contacts__n",
1398                &local_var_str
1399                    .into_iter()
1400                    .map(|p| p.to_string())
1401                    .collect::<Vec<String>>()
1402                    .join(",")
1403                    .to_string(),
1404            )]),
1405        };
1406    }
1407    if let Some(ref local_var_str) = created {
1408        local_var_req_builder = match "multi" {
1409            "multi" => local_var_req_builder.query(
1410                &local_var_str
1411                    .into_iter()
1412                    .map(|p| ("created".to_owned(), p.to_string()))
1413                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1414            ),
1415            _ => local_var_req_builder.query(&[(
1416                "created",
1417                &local_var_str
1418                    .into_iter()
1419                    .map(|p| p.to_string())
1420                    .collect::<Vec<String>>()
1421                    .join(",")
1422                    .to_string(),
1423            )]),
1424        };
1425    }
1426    if let Some(ref local_var_str) = created__gt {
1427        local_var_req_builder = match "multi" {
1428            "multi" => local_var_req_builder.query(
1429                &local_var_str
1430                    .into_iter()
1431                    .map(|p| ("created__gt".to_owned(), p.to_string()))
1432                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1433            ),
1434            _ => local_var_req_builder.query(&[(
1435                "created__gt",
1436                &local_var_str
1437                    .into_iter()
1438                    .map(|p| p.to_string())
1439                    .collect::<Vec<String>>()
1440                    .join(",")
1441                    .to_string(),
1442            )]),
1443        };
1444    }
1445    if let Some(ref local_var_str) = created__gte {
1446        local_var_req_builder = match "multi" {
1447            "multi" => local_var_req_builder.query(
1448                &local_var_str
1449                    .into_iter()
1450                    .map(|p| ("created__gte".to_owned(), p.to_string()))
1451                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1452            ),
1453            _ => local_var_req_builder.query(&[(
1454                "created__gte",
1455                &local_var_str
1456                    .into_iter()
1457                    .map(|p| p.to_string())
1458                    .collect::<Vec<String>>()
1459                    .join(",")
1460                    .to_string(),
1461            )]),
1462        };
1463    }
1464    if let Some(ref local_var_str) = created__isnull {
1465        local_var_req_builder =
1466            local_var_req_builder.query(&[("created__isnull", &local_var_str.to_string())]);
1467    }
1468    if let Some(ref local_var_str) = created__lt {
1469        local_var_req_builder = match "multi" {
1470            "multi" => local_var_req_builder.query(
1471                &local_var_str
1472                    .into_iter()
1473                    .map(|p| ("created__lt".to_owned(), p.to_string()))
1474                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1475            ),
1476            _ => local_var_req_builder.query(&[(
1477                "created__lt",
1478                &local_var_str
1479                    .into_iter()
1480                    .map(|p| p.to_string())
1481                    .collect::<Vec<String>>()
1482                    .join(",")
1483                    .to_string(),
1484            )]),
1485        };
1486    }
1487    if let Some(ref local_var_str) = created__lte {
1488        local_var_req_builder = match "multi" {
1489            "multi" => local_var_req_builder.query(
1490                &local_var_str
1491                    .into_iter()
1492                    .map(|p| ("created__lte".to_owned(), p.to_string()))
1493                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1494            ),
1495            _ => local_var_req_builder.query(&[(
1496                "created__lte",
1497                &local_var_str
1498                    .into_iter()
1499                    .map(|p| p.to_string())
1500                    .collect::<Vec<String>>()
1501                    .join(",")
1502                    .to_string(),
1503            )]),
1504        };
1505    }
1506    if let Some(ref local_var_str) = created__n {
1507        local_var_req_builder = match "multi" {
1508            "multi" => local_var_req_builder.query(
1509                &local_var_str
1510                    .into_iter()
1511                    .map(|p| ("created__n".to_owned(), p.to_string()))
1512                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1513            ),
1514            _ => local_var_req_builder.query(&[(
1515                "created__n",
1516                &local_var_str
1517                    .into_iter()
1518                    .map(|p| p.to_string())
1519                    .collect::<Vec<String>>()
1520                    .join(",")
1521                    .to_string(),
1522            )]),
1523        };
1524    }
1525    if let Some(ref local_var_str) = description {
1526        local_var_req_builder = match "multi" {
1527            "multi" => local_var_req_builder.query(
1528                &local_var_str
1529                    .into_iter()
1530                    .map(|p| ("description".to_owned(), p.to_string()))
1531                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1532            ),
1533            _ => local_var_req_builder.query(&[(
1534                "description",
1535                &local_var_str
1536                    .into_iter()
1537                    .map(|p| p.to_string())
1538                    .collect::<Vec<String>>()
1539                    .join(",")
1540                    .to_string(),
1541            )]),
1542        };
1543    }
1544    if let Some(ref local_var_str) = description__ic {
1545        local_var_req_builder = match "multi" {
1546            "multi" => local_var_req_builder.query(
1547                &local_var_str
1548                    .into_iter()
1549                    .map(|p| ("description__ic".to_owned(), p.to_string()))
1550                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1551            ),
1552            _ => local_var_req_builder.query(&[(
1553                "description__ic",
1554                &local_var_str
1555                    .into_iter()
1556                    .map(|p| p.to_string())
1557                    .collect::<Vec<String>>()
1558                    .join(",")
1559                    .to_string(),
1560            )]),
1561        };
1562    }
1563    if let Some(ref local_var_str) = description__ie {
1564        local_var_req_builder = match "multi" {
1565            "multi" => local_var_req_builder.query(
1566                &local_var_str
1567                    .into_iter()
1568                    .map(|p| ("description__ie".to_owned(), p.to_string()))
1569                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1570            ),
1571            _ => local_var_req_builder.query(&[(
1572                "description__ie",
1573                &local_var_str
1574                    .into_iter()
1575                    .map(|p| p.to_string())
1576                    .collect::<Vec<String>>()
1577                    .join(",")
1578                    .to_string(),
1579            )]),
1580        };
1581    }
1582    if let Some(ref local_var_str) = description__iew {
1583        local_var_req_builder = match "multi" {
1584            "multi" => local_var_req_builder.query(
1585                &local_var_str
1586                    .into_iter()
1587                    .map(|p| ("description__iew".to_owned(), p.to_string()))
1588                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1589            ),
1590            _ => local_var_req_builder.query(&[(
1591                "description__iew",
1592                &local_var_str
1593                    .into_iter()
1594                    .map(|p| p.to_string())
1595                    .collect::<Vec<String>>()
1596                    .join(",")
1597                    .to_string(),
1598            )]),
1599        };
1600    }
1601    if let Some(ref local_var_str) = description__ire {
1602        local_var_req_builder = match "multi" {
1603            "multi" => local_var_req_builder.query(
1604                &local_var_str
1605                    .into_iter()
1606                    .map(|p| ("description__ire".to_owned(), p.to_string()))
1607                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1608            ),
1609            _ => local_var_req_builder.query(&[(
1610                "description__ire",
1611                &local_var_str
1612                    .into_iter()
1613                    .map(|p| p.to_string())
1614                    .collect::<Vec<String>>()
1615                    .join(",")
1616                    .to_string(),
1617            )]),
1618        };
1619    }
1620    if let Some(ref local_var_str) = description__isw {
1621        local_var_req_builder = match "multi" {
1622            "multi" => local_var_req_builder.query(
1623                &local_var_str
1624                    .into_iter()
1625                    .map(|p| ("description__isw".to_owned(), p.to_string()))
1626                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1627            ),
1628            _ => local_var_req_builder.query(&[(
1629                "description__isw",
1630                &local_var_str
1631                    .into_iter()
1632                    .map(|p| p.to_string())
1633                    .collect::<Vec<String>>()
1634                    .join(",")
1635                    .to_string(),
1636            )]),
1637        };
1638    }
1639    if let Some(ref local_var_str) = description__n {
1640        local_var_req_builder = match "multi" {
1641            "multi" => local_var_req_builder.query(
1642                &local_var_str
1643                    .into_iter()
1644                    .map(|p| ("description__n".to_owned(), p.to_string()))
1645                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1646            ),
1647            _ => local_var_req_builder.query(&[(
1648                "description__n",
1649                &local_var_str
1650                    .into_iter()
1651                    .map(|p| p.to_string())
1652                    .collect::<Vec<String>>()
1653                    .join(",")
1654                    .to_string(),
1655            )]),
1656        };
1657    }
1658    if let Some(ref local_var_str) = description__nic {
1659        local_var_req_builder = match "multi" {
1660            "multi" => local_var_req_builder.query(
1661                &local_var_str
1662                    .into_iter()
1663                    .map(|p| ("description__nic".to_owned(), p.to_string()))
1664                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1665            ),
1666            _ => local_var_req_builder.query(&[(
1667                "description__nic",
1668                &local_var_str
1669                    .into_iter()
1670                    .map(|p| p.to_string())
1671                    .collect::<Vec<String>>()
1672                    .join(",")
1673                    .to_string(),
1674            )]),
1675        };
1676    }
1677    if let Some(ref local_var_str) = description__nie {
1678        local_var_req_builder = match "multi" {
1679            "multi" => local_var_req_builder.query(
1680                &local_var_str
1681                    .into_iter()
1682                    .map(|p| ("description__nie".to_owned(), p.to_string()))
1683                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1684            ),
1685            _ => local_var_req_builder.query(&[(
1686                "description__nie",
1687                &local_var_str
1688                    .into_iter()
1689                    .map(|p| p.to_string())
1690                    .collect::<Vec<String>>()
1691                    .join(",")
1692                    .to_string(),
1693            )]),
1694        };
1695    }
1696    if let Some(ref local_var_str) = description__niew {
1697        local_var_req_builder = match "multi" {
1698            "multi" => local_var_req_builder.query(
1699                &local_var_str
1700                    .into_iter()
1701                    .map(|p| ("description__niew".to_owned(), p.to_string()))
1702                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1703            ),
1704            _ => local_var_req_builder.query(&[(
1705                "description__niew",
1706                &local_var_str
1707                    .into_iter()
1708                    .map(|p| p.to_string())
1709                    .collect::<Vec<String>>()
1710                    .join(",")
1711                    .to_string(),
1712            )]),
1713        };
1714    }
1715    if let Some(ref local_var_str) = description__nire {
1716        local_var_req_builder = match "multi" {
1717            "multi" => local_var_req_builder.query(
1718                &local_var_str
1719                    .into_iter()
1720                    .map(|p| ("description__nire".to_owned(), p.to_string()))
1721                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1722            ),
1723            _ => local_var_req_builder.query(&[(
1724                "description__nire",
1725                &local_var_str
1726                    .into_iter()
1727                    .map(|p| p.to_string())
1728                    .collect::<Vec<String>>()
1729                    .join(",")
1730                    .to_string(),
1731            )]),
1732        };
1733    }
1734    if let Some(ref local_var_str) = description__nisw {
1735        local_var_req_builder = match "multi" {
1736            "multi" => local_var_req_builder.query(
1737                &local_var_str
1738                    .into_iter()
1739                    .map(|p| ("description__nisw".to_owned(), p.to_string()))
1740                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1741            ),
1742            _ => local_var_req_builder.query(&[(
1743                "description__nisw",
1744                &local_var_str
1745                    .into_iter()
1746                    .map(|p| p.to_string())
1747                    .collect::<Vec<String>>()
1748                    .join(",")
1749                    .to_string(),
1750            )]),
1751        };
1752    }
1753    if let Some(ref local_var_str) = description__nre {
1754        local_var_req_builder = match "multi" {
1755            "multi" => local_var_req_builder.query(
1756                &local_var_str
1757                    .into_iter()
1758                    .map(|p| ("description__nre".to_owned(), p.to_string()))
1759                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1760            ),
1761            _ => local_var_req_builder.query(&[(
1762                "description__nre",
1763                &local_var_str
1764                    .into_iter()
1765                    .map(|p| p.to_string())
1766                    .collect::<Vec<String>>()
1767                    .join(",")
1768                    .to_string(),
1769            )]),
1770        };
1771    }
1772    if let Some(ref local_var_str) = description__re {
1773        local_var_req_builder = match "multi" {
1774            "multi" => local_var_req_builder.query(
1775                &local_var_str
1776                    .into_iter()
1777                    .map(|p| ("description__re".to_owned(), p.to_string()))
1778                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1779            ),
1780            _ => local_var_req_builder.query(&[(
1781                "description__re",
1782                &local_var_str
1783                    .into_iter()
1784                    .map(|p| p.to_string())
1785                    .collect::<Vec<String>>()
1786                    .join(",")
1787                    .to_string(),
1788            )]),
1789        };
1790    }
1791    if let Some(ref local_var_str) = dh_group {
1792        local_var_req_builder = match "multi" {
1793            "multi" => local_var_req_builder.query(
1794                &local_var_str
1795                    .into_iter()
1796                    .map(|p| ("dh_group".to_owned(), p.to_string()))
1797                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1798            ),
1799            _ => local_var_req_builder.query(&[(
1800                "dh_group",
1801                &local_var_str
1802                    .into_iter()
1803                    .map(|p| p.to_string())
1804                    .collect::<Vec<String>>()
1805                    .join(",")
1806                    .to_string(),
1807            )]),
1808        };
1809    }
1810    if let Some(ref local_var_str) = dynamic_groups {
1811        local_var_req_builder = match "multi" {
1812            "multi" => local_var_req_builder.query(
1813                &local_var_str
1814                    .into_iter()
1815                    .map(|p| ("dynamic_groups".to_owned(), p.to_string()))
1816                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1817            ),
1818            _ => local_var_req_builder.query(&[(
1819                "dynamic_groups",
1820                &local_var_str
1821                    .into_iter()
1822                    .map(|p| p.to_string())
1823                    .collect::<Vec<String>>()
1824                    .join(",")
1825                    .to_string(),
1826            )]),
1827        };
1828    }
1829    if let Some(ref local_var_str) = dynamic_groups__n {
1830        local_var_req_builder = match "multi" {
1831            "multi" => local_var_req_builder.query(
1832                &local_var_str
1833                    .into_iter()
1834                    .map(|p| ("dynamic_groups__n".to_owned(), p.to_string()))
1835                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1836            ),
1837            _ => local_var_req_builder.query(&[(
1838                "dynamic_groups__n",
1839                &local_var_str
1840                    .into_iter()
1841                    .map(|p| p.to_string())
1842                    .collect::<Vec<String>>()
1843                    .join(",")
1844                    .to_string(),
1845            )]),
1846        };
1847    }
1848    if let Some(ref local_var_str) = encryption_algorithm {
1849        local_var_req_builder = match "multi" {
1850            "multi" => local_var_req_builder.query(
1851                &local_var_str
1852                    .into_iter()
1853                    .map(|p| ("encryption_algorithm".to_owned(), p.to_string()))
1854                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1855            ),
1856            _ => local_var_req_builder.query(&[(
1857                "encryption_algorithm",
1858                &local_var_str
1859                    .into_iter()
1860                    .map(|p| p.to_string())
1861                    .collect::<Vec<String>>()
1862                    .join(",")
1863                    .to_string(),
1864            )]),
1865        };
1866    }
1867    if let Some(ref local_var_str) = format {
1868        local_var_req_builder =
1869            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
1870    }
1871    if let Some(ref local_var_str) = id {
1872        local_var_req_builder = match "multi" {
1873            "multi" => local_var_req_builder.query(
1874                &local_var_str
1875                    .into_iter()
1876                    .map(|p| ("id".to_owned(), p.to_string()))
1877                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1878            ),
1879            _ => local_var_req_builder.query(&[(
1880                "id",
1881                &local_var_str
1882                    .into_iter()
1883                    .map(|p| p.to_string())
1884                    .collect::<Vec<String>>()
1885                    .join(",")
1886                    .to_string(),
1887            )]),
1888        };
1889    }
1890    if let Some(ref local_var_str) = id__n {
1891        local_var_req_builder = match "multi" {
1892            "multi" => local_var_req_builder.query(
1893                &local_var_str
1894                    .into_iter()
1895                    .map(|p| ("id__n".to_owned(), p.to_string()))
1896                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1897            ),
1898            _ => local_var_req_builder.query(&[(
1899                "id__n",
1900                &local_var_str
1901                    .into_iter()
1902                    .map(|p| p.to_string())
1903                    .collect::<Vec<String>>()
1904                    .join(",")
1905                    .to_string(),
1906            )]),
1907        };
1908    }
1909    if let Some(ref local_var_str) = ike_version {
1910        local_var_req_builder = match "multi" {
1911            "multi" => local_var_req_builder.query(
1912                &local_var_str
1913                    .into_iter()
1914                    .map(|p| ("ike_version".to_owned(), p.to_string()))
1915                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1916            ),
1917            _ => local_var_req_builder.query(&[(
1918                "ike_version",
1919                &local_var_str
1920                    .into_iter()
1921                    .map(|p| p.to_string())
1922                    .collect::<Vec<String>>()
1923                    .join(",")
1924                    .to_string(),
1925            )]),
1926        };
1927    }
1928    if let Some(ref local_var_str) = ike_version__ic {
1929        local_var_req_builder = match "multi" {
1930            "multi" => local_var_req_builder.query(
1931                &local_var_str
1932                    .into_iter()
1933                    .map(|p| ("ike_version__ic".to_owned(), p.to_string()))
1934                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1935            ),
1936            _ => local_var_req_builder.query(&[(
1937                "ike_version__ic",
1938                &local_var_str
1939                    .into_iter()
1940                    .map(|p| p.to_string())
1941                    .collect::<Vec<String>>()
1942                    .join(",")
1943                    .to_string(),
1944            )]),
1945        };
1946    }
1947    if let Some(ref local_var_str) = ike_version__ie {
1948        local_var_req_builder = match "multi" {
1949            "multi" => local_var_req_builder.query(
1950                &local_var_str
1951                    .into_iter()
1952                    .map(|p| ("ike_version__ie".to_owned(), p.to_string()))
1953                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1954            ),
1955            _ => local_var_req_builder.query(&[(
1956                "ike_version__ie",
1957                &local_var_str
1958                    .into_iter()
1959                    .map(|p| p.to_string())
1960                    .collect::<Vec<String>>()
1961                    .join(",")
1962                    .to_string(),
1963            )]),
1964        };
1965    }
1966    if let Some(ref local_var_str) = ike_version__iew {
1967        local_var_req_builder = match "multi" {
1968            "multi" => local_var_req_builder.query(
1969                &local_var_str
1970                    .into_iter()
1971                    .map(|p| ("ike_version__iew".to_owned(), p.to_string()))
1972                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1973            ),
1974            _ => local_var_req_builder.query(&[(
1975                "ike_version__iew",
1976                &local_var_str
1977                    .into_iter()
1978                    .map(|p| p.to_string())
1979                    .collect::<Vec<String>>()
1980                    .join(",")
1981                    .to_string(),
1982            )]),
1983        };
1984    }
1985    if let Some(ref local_var_str) = ike_version__ire {
1986        local_var_req_builder = match "multi" {
1987            "multi" => local_var_req_builder.query(
1988                &local_var_str
1989                    .into_iter()
1990                    .map(|p| ("ike_version__ire".to_owned(), p.to_string()))
1991                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1992            ),
1993            _ => local_var_req_builder.query(&[(
1994                "ike_version__ire",
1995                &local_var_str
1996                    .into_iter()
1997                    .map(|p| p.to_string())
1998                    .collect::<Vec<String>>()
1999                    .join(",")
2000                    .to_string(),
2001            )]),
2002        };
2003    }
2004    if let Some(ref local_var_str) = ike_version__isw {
2005        local_var_req_builder = match "multi" {
2006            "multi" => local_var_req_builder.query(
2007                &local_var_str
2008                    .into_iter()
2009                    .map(|p| ("ike_version__isw".to_owned(), p.to_string()))
2010                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2011            ),
2012            _ => local_var_req_builder.query(&[(
2013                "ike_version__isw",
2014                &local_var_str
2015                    .into_iter()
2016                    .map(|p| p.to_string())
2017                    .collect::<Vec<String>>()
2018                    .join(",")
2019                    .to_string(),
2020            )]),
2021        };
2022    }
2023    if let Some(ref local_var_str) = ike_version__n {
2024        local_var_req_builder = match "multi" {
2025            "multi" => local_var_req_builder.query(
2026                &local_var_str
2027                    .into_iter()
2028                    .map(|p| ("ike_version__n".to_owned(), p.to_string()))
2029                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2030            ),
2031            _ => local_var_req_builder.query(&[(
2032                "ike_version__n",
2033                &local_var_str
2034                    .into_iter()
2035                    .map(|p| p.to_string())
2036                    .collect::<Vec<String>>()
2037                    .join(",")
2038                    .to_string(),
2039            )]),
2040        };
2041    }
2042    if let Some(ref local_var_str) = ike_version__nic {
2043        local_var_req_builder = match "multi" {
2044            "multi" => local_var_req_builder.query(
2045                &local_var_str
2046                    .into_iter()
2047                    .map(|p| ("ike_version__nic".to_owned(), p.to_string()))
2048                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2049            ),
2050            _ => local_var_req_builder.query(&[(
2051                "ike_version__nic",
2052                &local_var_str
2053                    .into_iter()
2054                    .map(|p| p.to_string())
2055                    .collect::<Vec<String>>()
2056                    .join(",")
2057                    .to_string(),
2058            )]),
2059        };
2060    }
2061    if let Some(ref local_var_str) = ike_version__nie {
2062        local_var_req_builder = match "multi" {
2063            "multi" => local_var_req_builder.query(
2064                &local_var_str
2065                    .into_iter()
2066                    .map(|p| ("ike_version__nie".to_owned(), p.to_string()))
2067                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2068            ),
2069            _ => local_var_req_builder.query(&[(
2070                "ike_version__nie",
2071                &local_var_str
2072                    .into_iter()
2073                    .map(|p| p.to_string())
2074                    .collect::<Vec<String>>()
2075                    .join(",")
2076                    .to_string(),
2077            )]),
2078        };
2079    }
2080    if let Some(ref local_var_str) = ike_version__niew {
2081        local_var_req_builder = match "multi" {
2082            "multi" => local_var_req_builder.query(
2083                &local_var_str
2084                    .into_iter()
2085                    .map(|p| ("ike_version__niew".to_owned(), p.to_string()))
2086                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2087            ),
2088            _ => local_var_req_builder.query(&[(
2089                "ike_version__niew",
2090                &local_var_str
2091                    .into_iter()
2092                    .map(|p| p.to_string())
2093                    .collect::<Vec<String>>()
2094                    .join(",")
2095                    .to_string(),
2096            )]),
2097        };
2098    }
2099    if let Some(ref local_var_str) = ike_version__nire {
2100        local_var_req_builder = match "multi" {
2101            "multi" => local_var_req_builder.query(
2102                &local_var_str
2103                    .into_iter()
2104                    .map(|p| ("ike_version__nire".to_owned(), p.to_string()))
2105                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2106            ),
2107            _ => local_var_req_builder.query(&[(
2108                "ike_version__nire",
2109                &local_var_str
2110                    .into_iter()
2111                    .map(|p| p.to_string())
2112                    .collect::<Vec<String>>()
2113                    .join(",")
2114                    .to_string(),
2115            )]),
2116        };
2117    }
2118    if let Some(ref local_var_str) = ike_version__nisw {
2119        local_var_req_builder = match "multi" {
2120            "multi" => local_var_req_builder.query(
2121                &local_var_str
2122                    .into_iter()
2123                    .map(|p| ("ike_version__nisw".to_owned(), p.to_string()))
2124                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2125            ),
2126            _ => local_var_req_builder.query(&[(
2127                "ike_version__nisw",
2128                &local_var_str
2129                    .into_iter()
2130                    .map(|p| p.to_string())
2131                    .collect::<Vec<String>>()
2132                    .join(",")
2133                    .to_string(),
2134            )]),
2135        };
2136    }
2137    if let Some(ref local_var_str) = ike_version__nre {
2138        local_var_req_builder = match "multi" {
2139            "multi" => local_var_req_builder.query(
2140                &local_var_str
2141                    .into_iter()
2142                    .map(|p| ("ike_version__nre".to_owned(), p.to_string()))
2143                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2144            ),
2145            _ => local_var_req_builder.query(&[(
2146                "ike_version__nre",
2147                &local_var_str
2148                    .into_iter()
2149                    .map(|p| p.to_string())
2150                    .collect::<Vec<String>>()
2151                    .join(",")
2152                    .to_string(),
2153            )]),
2154        };
2155    }
2156    if let Some(ref local_var_str) = ike_version__re {
2157        local_var_req_builder = match "multi" {
2158            "multi" => local_var_req_builder.query(
2159                &local_var_str
2160                    .into_iter()
2161                    .map(|p| ("ike_version__re".to_owned(), p.to_string()))
2162                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2163            ),
2164            _ => local_var_req_builder.query(&[(
2165                "ike_version__re",
2166                &local_var_str
2167                    .into_iter()
2168                    .map(|p| p.to_string())
2169                    .collect::<Vec<String>>()
2170                    .join(",")
2171                    .to_string(),
2172            )]),
2173        };
2174    }
2175    if let Some(ref local_var_str) = integrity_algorithm {
2176        local_var_req_builder = match "multi" {
2177            "multi" => local_var_req_builder.query(
2178                &local_var_str
2179                    .into_iter()
2180                    .map(|p| ("integrity_algorithm".to_owned(), p.to_string()))
2181                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2182            ),
2183            _ => local_var_req_builder.query(&[(
2184                "integrity_algorithm",
2185                &local_var_str
2186                    .into_iter()
2187                    .map(|p| p.to_string())
2188                    .collect::<Vec<String>>()
2189                    .join(",")
2190                    .to_string(),
2191            )]),
2192        };
2193    }
2194    if let Some(ref local_var_str) = last_updated {
2195        local_var_req_builder = match "multi" {
2196            "multi" => local_var_req_builder.query(
2197                &local_var_str
2198                    .into_iter()
2199                    .map(|p| ("last_updated".to_owned(), p.to_string()))
2200                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2201            ),
2202            _ => local_var_req_builder.query(&[(
2203                "last_updated",
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) = last_updated__gt {
2214        local_var_req_builder = match "multi" {
2215            "multi" => local_var_req_builder.query(
2216                &local_var_str
2217                    .into_iter()
2218                    .map(|p| ("last_updated__gt".to_owned(), p.to_string()))
2219                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2220            ),
2221            _ => local_var_req_builder.query(&[(
2222                "last_updated__gt",
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) = last_updated__gte {
2233        local_var_req_builder = match "multi" {
2234            "multi" => local_var_req_builder.query(
2235                &local_var_str
2236                    .into_iter()
2237                    .map(|p| ("last_updated__gte".to_owned(), p.to_string()))
2238                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2239            ),
2240            _ => local_var_req_builder.query(&[(
2241                "last_updated__gte",
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) = last_updated__isnull {
2252        local_var_req_builder =
2253            local_var_req_builder.query(&[("last_updated__isnull", &local_var_str.to_string())]);
2254    }
2255    if let Some(ref local_var_str) = last_updated__lt {
2256        local_var_req_builder = match "multi" {
2257            "multi" => local_var_req_builder.query(
2258                &local_var_str
2259                    .into_iter()
2260                    .map(|p| ("last_updated__lt".to_owned(), p.to_string()))
2261                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2262            ),
2263            _ => local_var_req_builder.query(&[(
2264                "last_updated__lt",
2265                &local_var_str
2266                    .into_iter()
2267                    .map(|p| p.to_string())
2268                    .collect::<Vec<String>>()
2269                    .join(",")
2270                    .to_string(),
2271            )]),
2272        };
2273    }
2274    if let Some(ref local_var_str) = last_updated__lte {
2275        local_var_req_builder = match "multi" {
2276            "multi" => local_var_req_builder.query(
2277                &local_var_str
2278                    .into_iter()
2279                    .map(|p| ("last_updated__lte".to_owned(), p.to_string()))
2280                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2281            ),
2282            _ => local_var_req_builder.query(&[(
2283                "last_updated__lte",
2284                &local_var_str
2285                    .into_iter()
2286                    .map(|p| p.to_string())
2287                    .collect::<Vec<String>>()
2288                    .join(",")
2289                    .to_string(),
2290            )]),
2291        };
2292    }
2293    if let Some(ref local_var_str) = last_updated__n {
2294        local_var_req_builder = match "multi" {
2295            "multi" => local_var_req_builder.query(
2296                &local_var_str
2297                    .into_iter()
2298                    .map(|p| ("last_updated__n".to_owned(), p.to_string()))
2299                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2300            ),
2301            _ => local_var_req_builder.query(&[(
2302                "last_updated__n",
2303                &local_var_str
2304                    .into_iter()
2305                    .map(|p| p.to_string())
2306                    .collect::<Vec<String>>()
2307                    .join(",")
2308                    .to_string(),
2309            )]),
2310        };
2311    }
2312    if let Some(ref local_var_str) = lifetime_kb {
2313        local_var_req_builder = match "multi" {
2314            "multi" => local_var_req_builder.query(
2315                &local_var_str
2316                    .into_iter()
2317                    .map(|p| ("lifetime_kb".to_owned(), p.to_string()))
2318                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2319            ),
2320            _ => local_var_req_builder.query(&[(
2321                "lifetime_kb",
2322                &local_var_str
2323                    .into_iter()
2324                    .map(|p| p.to_string())
2325                    .collect::<Vec<String>>()
2326                    .join(",")
2327                    .to_string(),
2328            )]),
2329        };
2330    }
2331    if let Some(ref local_var_str) = lifetime_kb__gt {
2332        local_var_req_builder = match "multi" {
2333            "multi" => local_var_req_builder.query(
2334                &local_var_str
2335                    .into_iter()
2336                    .map(|p| ("lifetime_kb__gt".to_owned(), p.to_string()))
2337                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2338            ),
2339            _ => local_var_req_builder.query(&[(
2340                "lifetime_kb__gt",
2341                &local_var_str
2342                    .into_iter()
2343                    .map(|p| p.to_string())
2344                    .collect::<Vec<String>>()
2345                    .join(",")
2346                    .to_string(),
2347            )]),
2348        };
2349    }
2350    if let Some(ref local_var_str) = lifetime_kb__gte {
2351        local_var_req_builder = match "multi" {
2352            "multi" => local_var_req_builder.query(
2353                &local_var_str
2354                    .into_iter()
2355                    .map(|p| ("lifetime_kb__gte".to_owned(), p.to_string()))
2356                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2357            ),
2358            _ => local_var_req_builder.query(&[(
2359                "lifetime_kb__gte",
2360                &local_var_str
2361                    .into_iter()
2362                    .map(|p| p.to_string())
2363                    .collect::<Vec<String>>()
2364                    .join(",")
2365                    .to_string(),
2366            )]),
2367        };
2368    }
2369    if let Some(ref local_var_str) = lifetime_kb__isnull {
2370        local_var_req_builder =
2371            local_var_req_builder.query(&[("lifetime_kb__isnull", &local_var_str.to_string())]);
2372    }
2373    if let Some(ref local_var_str) = lifetime_kb__lt {
2374        local_var_req_builder = match "multi" {
2375            "multi" => local_var_req_builder.query(
2376                &local_var_str
2377                    .into_iter()
2378                    .map(|p| ("lifetime_kb__lt".to_owned(), p.to_string()))
2379                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2380            ),
2381            _ => local_var_req_builder.query(&[(
2382                "lifetime_kb__lt",
2383                &local_var_str
2384                    .into_iter()
2385                    .map(|p| p.to_string())
2386                    .collect::<Vec<String>>()
2387                    .join(",")
2388                    .to_string(),
2389            )]),
2390        };
2391    }
2392    if let Some(ref local_var_str) = lifetime_kb__lte {
2393        local_var_req_builder = match "multi" {
2394            "multi" => local_var_req_builder.query(
2395                &local_var_str
2396                    .into_iter()
2397                    .map(|p| ("lifetime_kb__lte".to_owned(), p.to_string()))
2398                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2399            ),
2400            _ => local_var_req_builder.query(&[(
2401                "lifetime_kb__lte",
2402                &local_var_str
2403                    .into_iter()
2404                    .map(|p| p.to_string())
2405                    .collect::<Vec<String>>()
2406                    .join(",")
2407                    .to_string(),
2408            )]),
2409        };
2410    }
2411    if let Some(ref local_var_str) = lifetime_kb__n {
2412        local_var_req_builder = match "multi" {
2413            "multi" => local_var_req_builder.query(
2414                &local_var_str
2415                    .into_iter()
2416                    .map(|p| ("lifetime_kb__n".to_owned(), p.to_string()))
2417                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2418            ),
2419            _ => local_var_req_builder.query(&[(
2420                "lifetime_kb__n",
2421                &local_var_str
2422                    .into_iter()
2423                    .map(|p| p.to_string())
2424                    .collect::<Vec<String>>()
2425                    .join(",")
2426                    .to_string(),
2427            )]),
2428        };
2429    }
2430    if let Some(ref local_var_str) = lifetime_seconds {
2431        local_var_req_builder = match "multi" {
2432            "multi" => local_var_req_builder.query(
2433                &local_var_str
2434                    .into_iter()
2435                    .map(|p| ("lifetime_seconds".to_owned(), p.to_string()))
2436                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2437            ),
2438            _ => local_var_req_builder.query(&[(
2439                "lifetime_seconds",
2440                &local_var_str
2441                    .into_iter()
2442                    .map(|p| p.to_string())
2443                    .collect::<Vec<String>>()
2444                    .join(",")
2445                    .to_string(),
2446            )]),
2447        };
2448    }
2449    if let Some(ref local_var_str) = lifetime_seconds__gt {
2450        local_var_req_builder = match "multi" {
2451            "multi" => local_var_req_builder.query(
2452                &local_var_str
2453                    .into_iter()
2454                    .map(|p| ("lifetime_seconds__gt".to_owned(), p.to_string()))
2455                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2456            ),
2457            _ => local_var_req_builder.query(&[(
2458                "lifetime_seconds__gt",
2459                &local_var_str
2460                    .into_iter()
2461                    .map(|p| p.to_string())
2462                    .collect::<Vec<String>>()
2463                    .join(",")
2464                    .to_string(),
2465            )]),
2466        };
2467    }
2468    if let Some(ref local_var_str) = lifetime_seconds__gte {
2469        local_var_req_builder = match "multi" {
2470            "multi" => local_var_req_builder.query(
2471                &local_var_str
2472                    .into_iter()
2473                    .map(|p| ("lifetime_seconds__gte".to_owned(), p.to_string()))
2474                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2475            ),
2476            _ => local_var_req_builder.query(&[(
2477                "lifetime_seconds__gte",
2478                &local_var_str
2479                    .into_iter()
2480                    .map(|p| p.to_string())
2481                    .collect::<Vec<String>>()
2482                    .join(",")
2483                    .to_string(),
2484            )]),
2485        };
2486    }
2487    if let Some(ref local_var_str) = lifetime_seconds__isnull {
2488        local_var_req_builder = local_var_req_builder
2489            .query(&[("lifetime_seconds__isnull", &local_var_str.to_string())]);
2490    }
2491    if let Some(ref local_var_str) = lifetime_seconds__lt {
2492        local_var_req_builder = match "multi" {
2493            "multi" => local_var_req_builder.query(
2494                &local_var_str
2495                    .into_iter()
2496                    .map(|p| ("lifetime_seconds__lt".to_owned(), p.to_string()))
2497                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2498            ),
2499            _ => local_var_req_builder.query(&[(
2500                "lifetime_seconds__lt",
2501                &local_var_str
2502                    .into_iter()
2503                    .map(|p| p.to_string())
2504                    .collect::<Vec<String>>()
2505                    .join(",")
2506                    .to_string(),
2507            )]),
2508        };
2509    }
2510    if let Some(ref local_var_str) = lifetime_seconds__lte {
2511        local_var_req_builder = match "multi" {
2512            "multi" => local_var_req_builder.query(
2513                &local_var_str
2514                    .into_iter()
2515                    .map(|p| ("lifetime_seconds__lte".to_owned(), p.to_string()))
2516                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2517            ),
2518            _ => local_var_req_builder.query(&[(
2519                "lifetime_seconds__lte",
2520                &local_var_str
2521                    .into_iter()
2522                    .map(|p| p.to_string())
2523                    .collect::<Vec<String>>()
2524                    .join(",")
2525                    .to_string(),
2526            )]),
2527        };
2528    }
2529    if let Some(ref local_var_str) = lifetime_seconds__n {
2530        local_var_req_builder = match "multi" {
2531            "multi" => local_var_req_builder.query(
2532                &local_var_str
2533                    .into_iter()
2534                    .map(|p| ("lifetime_seconds__n".to_owned(), p.to_string()))
2535                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2536            ),
2537            _ => local_var_req_builder.query(&[(
2538                "lifetime_seconds__n",
2539                &local_var_str
2540                    .into_iter()
2541                    .map(|p| p.to_string())
2542                    .collect::<Vec<String>>()
2543                    .join(",")
2544                    .to_string(),
2545            )]),
2546        };
2547    }
2548    if let Some(ref local_var_str) = limit {
2549        local_var_req_builder =
2550            local_var_req_builder.query(&[("limit", &local_var_str.to_string())]);
2551    }
2552    if let Some(ref local_var_str) = name {
2553        local_var_req_builder = match "multi" {
2554            "multi" => local_var_req_builder.query(
2555                &local_var_str
2556                    .into_iter()
2557                    .map(|p| ("name".to_owned(), p.to_string()))
2558                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2559            ),
2560            _ => local_var_req_builder.query(&[(
2561                "name",
2562                &local_var_str
2563                    .into_iter()
2564                    .map(|p| p.to_string())
2565                    .collect::<Vec<String>>()
2566                    .join(",")
2567                    .to_string(),
2568            )]),
2569        };
2570    }
2571    if let Some(ref local_var_str) = name__ic {
2572        local_var_req_builder = match "multi" {
2573            "multi" => local_var_req_builder.query(
2574                &local_var_str
2575                    .into_iter()
2576                    .map(|p| ("name__ic".to_owned(), p.to_string()))
2577                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2578            ),
2579            _ => local_var_req_builder.query(&[(
2580                "name__ic",
2581                &local_var_str
2582                    .into_iter()
2583                    .map(|p| p.to_string())
2584                    .collect::<Vec<String>>()
2585                    .join(",")
2586                    .to_string(),
2587            )]),
2588        };
2589    }
2590    if let Some(ref local_var_str) = name__ie {
2591        local_var_req_builder = match "multi" {
2592            "multi" => local_var_req_builder.query(
2593                &local_var_str
2594                    .into_iter()
2595                    .map(|p| ("name__ie".to_owned(), p.to_string()))
2596                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2597            ),
2598            _ => local_var_req_builder.query(&[(
2599                "name__ie",
2600                &local_var_str
2601                    .into_iter()
2602                    .map(|p| p.to_string())
2603                    .collect::<Vec<String>>()
2604                    .join(",")
2605                    .to_string(),
2606            )]),
2607        };
2608    }
2609    if let Some(ref local_var_str) = name__iew {
2610        local_var_req_builder = match "multi" {
2611            "multi" => local_var_req_builder.query(
2612                &local_var_str
2613                    .into_iter()
2614                    .map(|p| ("name__iew".to_owned(), p.to_string()))
2615                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2616            ),
2617            _ => local_var_req_builder.query(&[(
2618                "name__iew",
2619                &local_var_str
2620                    .into_iter()
2621                    .map(|p| p.to_string())
2622                    .collect::<Vec<String>>()
2623                    .join(",")
2624                    .to_string(),
2625            )]),
2626        };
2627    }
2628    if let Some(ref local_var_str) = name__ire {
2629        local_var_req_builder = match "multi" {
2630            "multi" => local_var_req_builder.query(
2631                &local_var_str
2632                    .into_iter()
2633                    .map(|p| ("name__ire".to_owned(), p.to_string()))
2634                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2635            ),
2636            _ => local_var_req_builder.query(&[(
2637                "name__ire",
2638                &local_var_str
2639                    .into_iter()
2640                    .map(|p| p.to_string())
2641                    .collect::<Vec<String>>()
2642                    .join(",")
2643                    .to_string(),
2644            )]),
2645        };
2646    }
2647    if let Some(ref local_var_str) = name__isw {
2648        local_var_req_builder = match "multi" {
2649            "multi" => local_var_req_builder.query(
2650                &local_var_str
2651                    .into_iter()
2652                    .map(|p| ("name__isw".to_owned(), p.to_string()))
2653                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2654            ),
2655            _ => local_var_req_builder.query(&[(
2656                "name__isw",
2657                &local_var_str
2658                    .into_iter()
2659                    .map(|p| p.to_string())
2660                    .collect::<Vec<String>>()
2661                    .join(",")
2662                    .to_string(),
2663            )]),
2664        };
2665    }
2666    if let Some(ref local_var_str) = name__n {
2667        local_var_req_builder = match "multi" {
2668            "multi" => local_var_req_builder.query(
2669                &local_var_str
2670                    .into_iter()
2671                    .map(|p| ("name__n".to_owned(), p.to_string()))
2672                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2673            ),
2674            _ => local_var_req_builder.query(&[(
2675                "name__n",
2676                &local_var_str
2677                    .into_iter()
2678                    .map(|p| p.to_string())
2679                    .collect::<Vec<String>>()
2680                    .join(",")
2681                    .to_string(),
2682            )]),
2683        };
2684    }
2685    if let Some(ref local_var_str) = name__nic {
2686        local_var_req_builder = match "multi" {
2687            "multi" => local_var_req_builder.query(
2688                &local_var_str
2689                    .into_iter()
2690                    .map(|p| ("name__nic".to_owned(), p.to_string()))
2691                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2692            ),
2693            _ => local_var_req_builder.query(&[(
2694                "name__nic",
2695                &local_var_str
2696                    .into_iter()
2697                    .map(|p| p.to_string())
2698                    .collect::<Vec<String>>()
2699                    .join(",")
2700                    .to_string(),
2701            )]),
2702        };
2703    }
2704    if let Some(ref local_var_str) = name__nie {
2705        local_var_req_builder = match "multi" {
2706            "multi" => local_var_req_builder.query(
2707                &local_var_str
2708                    .into_iter()
2709                    .map(|p| ("name__nie".to_owned(), p.to_string()))
2710                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2711            ),
2712            _ => local_var_req_builder.query(&[(
2713                "name__nie",
2714                &local_var_str
2715                    .into_iter()
2716                    .map(|p| p.to_string())
2717                    .collect::<Vec<String>>()
2718                    .join(",")
2719                    .to_string(),
2720            )]),
2721        };
2722    }
2723    if let Some(ref local_var_str) = name__niew {
2724        local_var_req_builder = match "multi" {
2725            "multi" => local_var_req_builder.query(
2726                &local_var_str
2727                    .into_iter()
2728                    .map(|p| ("name__niew".to_owned(), p.to_string()))
2729                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2730            ),
2731            _ => local_var_req_builder.query(&[(
2732                "name__niew",
2733                &local_var_str
2734                    .into_iter()
2735                    .map(|p| p.to_string())
2736                    .collect::<Vec<String>>()
2737                    .join(",")
2738                    .to_string(),
2739            )]),
2740        };
2741    }
2742    if let Some(ref local_var_str) = name__nire {
2743        local_var_req_builder = match "multi" {
2744            "multi" => local_var_req_builder.query(
2745                &local_var_str
2746                    .into_iter()
2747                    .map(|p| ("name__nire".to_owned(), p.to_string()))
2748                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2749            ),
2750            _ => local_var_req_builder.query(&[(
2751                "name__nire",
2752                &local_var_str
2753                    .into_iter()
2754                    .map(|p| p.to_string())
2755                    .collect::<Vec<String>>()
2756                    .join(",")
2757                    .to_string(),
2758            )]),
2759        };
2760    }
2761    if let Some(ref local_var_str) = name__nisw {
2762        local_var_req_builder = match "multi" {
2763            "multi" => local_var_req_builder.query(
2764                &local_var_str
2765                    .into_iter()
2766                    .map(|p| ("name__nisw".to_owned(), p.to_string()))
2767                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2768            ),
2769            _ => local_var_req_builder.query(&[(
2770                "name__nisw",
2771                &local_var_str
2772                    .into_iter()
2773                    .map(|p| p.to_string())
2774                    .collect::<Vec<String>>()
2775                    .join(",")
2776                    .to_string(),
2777            )]),
2778        };
2779    }
2780    if let Some(ref local_var_str) = name__nre {
2781        local_var_req_builder = match "multi" {
2782            "multi" => local_var_req_builder.query(
2783                &local_var_str
2784                    .into_iter()
2785                    .map(|p| ("name__nre".to_owned(), p.to_string()))
2786                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2787            ),
2788            _ => local_var_req_builder.query(&[(
2789                "name__nre",
2790                &local_var_str
2791                    .into_iter()
2792                    .map(|p| p.to_string())
2793                    .collect::<Vec<String>>()
2794                    .join(",")
2795                    .to_string(),
2796            )]),
2797        };
2798    }
2799    if let Some(ref local_var_str) = name__re {
2800        local_var_req_builder = match "multi" {
2801            "multi" => local_var_req_builder.query(
2802                &local_var_str
2803                    .into_iter()
2804                    .map(|p| ("name__re".to_owned(), p.to_string()))
2805                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2806            ),
2807            _ => local_var_req_builder.query(&[(
2808                "name__re",
2809                &local_var_str
2810                    .into_iter()
2811                    .map(|p| p.to_string())
2812                    .collect::<Vec<String>>()
2813                    .join(",")
2814                    .to_string(),
2815            )]),
2816        };
2817    }
2818    if let Some(ref local_var_str) = offset {
2819        local_var_req_builder =
2820            local_var_req_builder.query(&[("offset", &local_var_str.to_string())]);
2821    }
2822    if let Some(ref local_var_str) = q {
2823        local_var_req_builder = local_var_req_builder.query(&[("q", &local_var_str.to_string())]);
2824    }
2825    if let Some(ref local_var_str) = sort {
2826        local_var_req_builder =
2827            local_var_req_builder.query(&[("sort", &local_var_str.to_string())]);
2828    }
2829    if let Some(ref local_var_str) = tags {
2830        local_var_req_builder = match "multi" {
2831            "multi" => local_var_req_builder.query(
2832                &local_var_str
2833                    .into_iter()
2834                    .map(|p| ("tags".to_owned(), p.to_string()))
2835                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2836            ),
2837            _ => local_var_req_builder.query(&[(
2838                "tags",
2839                &local_var_str
2840                    .into_iter()
2841                    .map(|p| p.to_string())
2842                    .collect::<Vec<String>>()
2843                    .join(",")
2844                    .to_string(),
2845            )]),
2846        };
2847    }
2848    if let Some(ref local_var_str) = tags__isnull {
2849        local_var_req_builder =
2850            local_var_req_builder.query(&[("tags__isnull", &local_var_str.to_string())]);
2851    }
2852    if let Some(ref local_var_str) = tags__n {
2853        local_var_req_builder = match "multi" {
2854            "multi" => local_var_req_builder.query(
2855                &local_var_str
2856                    .into_iter()
2857                    .map(|p| ("tags__n".to_owned(), p.to_string()))
2858                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2859            ),
2860            _ => local_var_req_builder.query(&[(
2861                "tags__n",
2862                &local_var_str
2863                    .into_iter()
2864                    .map(|p| p.to_string())
2865                    .collect::<Vec<String>>()
2866                    .join(",")
2867                    .to_string(),
2868            )]),
2869        };
2870    }
2871    if let Some(ref local_var_str) = teams {
2872        local_var_req_builder = match "multi" {
2873            "multi" => local_var_req_builder.query(
2874                &local_var_str
2875                    .into_iter()
2876                    .map(|p| ("teams".to_owned(), p.to_string()))
2877                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2878            ),
2879            _ => local_var_req_builder.query(&[(
2880                "teams",
2881                &local_var_str
2882                    .into_iter()
2883                    .map(|p| p.to_string())
2884                    .collect::<Vec<String>>()
2885                    .join(",")
2886                    .to_string(),
2887            )]),
2888        };
2889    }
2890    if let Some(ref local_var_str) = teams__isnull {
2891        local_var_req_builder =
2892            local_var_req_builder.query(&[("teams__isnull", &local_var_str.to_string())]);
2893    }
2894    if let Some(ref local_var_str) = teams__n {
2895        local_var_req_builder = match "multi" {
2896            "multi" => local_var_req_builder.query(
2897                &local_var_str
2898                    .into_iter()
2899                    .map(|p| ("teams__n".to_owned(), p.to_string()))
2900                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2901            ),
2902            _ => local_var_req_builder.query(&[(
2903                "teams__n",
2904                &local_var_str
2905                    .into_iter()
2906                    .map(|p| p.to_string())
2907                    .collect::<Vec<String>>()
2908                    .join(",")
2909                    .to_string(),
2910            )]),
2911        };
2912    }
2913    if let Some(ref local_var_str) = tenant {
2914        local_var_req_builder = match "multi" {
2915            "multi" => local_var_req_builder.query(
2916                &local_var_str
2917                    .into_iter()
2918                    .map(|p| ("tenant".to_owned(), p.to_string()))
2919                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2920            ),
2921            _ => local_var_req_builder.query(&[(
2922                "tenant",
2923                &local_var_str
2924                    .into_iter()
2925                    .map(|p| p.to_string())
2926                    .collect::<Vec<String>>()
2927                    .join(",")
2928                    .to_string(),
2929            )]),
2930        };
2931    }
2932    if let Some(ref local_var_str) = tenant__isnull {
2933        local_var_req_builder =
2934            local_var_req_builder.query(&[("tenant__isnull", &local_var_str.to_string())]);
2935    }
2936    if let Some(ref local_var_str) = tenant__n {
2937        local_var_req_builder = match "multi" {
2938            "multi" => local_var_req_builder.query(
2939                &local_var_str
2940                    .into_iter()
2941                    .map(|p| ("tenant__n".to_owned(), p.to_string()))
2942                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2943            ),
2944            _ => local_var_req_builder.query(&[(
2945                "tenant__n",
2946                &local_var_str
2947                    .into_iter()
2948                    .map(|p| p.to_string())
2949                    .collect::<Vec<String>>()
2950                    .join(",")
2951                    .to_string(),
2952            )]),
2953        };
2954    }
2955    if let Some(ref local_var_str) = tenant_group {
2956        local_var_req_builder = match "multi" {
2957            "multi" => local_var_req_builder.query(
2958                &local_var_str
2959                    .into_iter()
2960                    .map(|p| ("tenant_group".to_owned(), p.to_string()))
2961                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2962            ),
2963            _ => local_var_req_builder.query(&[(
2964                "tenant_group",
2965                &local_var_str
2966                    .into_iter()
2967                    .map(|p| p.to_string())
2968                    .collect::<Vec<String>>()
2969                    .join(",")
2970                    .to_string(),
2971            )]),
2972        };
2973    }
2974    if let Some(ref local_var_str) = tenant_group__isnull {
2975        local_var_req_builder =
2976            local_var_req_builder.query(&[("tenant_group__isnull", &local_var_str.to_string())]);
2977    }
2978    if let Some(ref local_var_str) = tenant_group__n {
2979        local_var_req_builder = match "multi" {
2980            "multi" => local_var_req_builder.query(
2981                &local_var_str
2982                    .into_iter()
2983                    .map(|p| ("tenant_group__n".to_owned(), p.to_string()))
2984                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2985            ),
2986            _ => local_var_req_builder.query(&[(
2987                "tenant_group__n",
2988                &local_var_str
2989                    .into_iter()
2990                    .map(|p| p.to_string())
2991                    .collect::<Vec<String>>()
2992                    .join(",")
2993                    .to_string(),
2994            )]),
2995        };
2996    }
2997    if let Some(ref local_var_str) = tenant_id {
2998        local_var_req_builder = match "multi" {
2999            "multi" => local_var_req_builder.query(
3000                &local_var_str
3001                    .into_iter()
3002                    .map(|p| ("tenant_id".to_owned(), p.to_string()))
3003                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3004            ),
3005            _ => local_var_req_builder.query(&[(
3006                "tenant_id",
3007                &local_var_str
3008                    .into_iter()
3009                    .map(|p| p.to_string())
3010                    .collect::<Vec<String>>()
3011                    .join(",")
3012                    .to_string(),
3013            )]),
3014        };
3015    }
3016    if let Some(ref local_var_str) = tenant_id__isnull {
3017        local_var_req_builder =
3018            local_var_req_builder.query(&[("tenant_id__isnull", &local_var_str.to_string())]);
3019    }
3020    if let Some(ref local_var_str) = tenant_id__n {
3021        local_var_req_builder = match "multi" {
3022            "multi" => local_var_req_builder.query(
3023                &local_var_str
3024                    .into_iter()
3025                    .map(|p| ("tenant_id__n".to_owned(), p.to_string()))
3026                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3027            ),
3028            _ => local_var_req_builder.query(&[(
3029                "tenant_id__n",
3030                &local_var_str
3031                    .into_iter()
3032                    .map(|p| p.to_string())
3033                    .collect::<Vec<String>>()
3034                    .join(",")
3035                    .to_string(),
3036            )]),
3037        };
3038    }
3039    if let Some(ref local_var_str) = vpn_profiles {
3040        local_var_req_builder = match "multi" {
3041            "multi" => local_var_req_builder.query(
3042                &local_var_str
3043                    .into_iter()
3044                    .map(|p| ("vpn_profiles".to_owned(), p.to_string()))
3045                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3046            ),
3047            _ => local_var_req_builder.query(&[(
3048                "vpn_profiles",
3049                &local_var_str
3050                    .into_iter()
3051                    .map(|p| p.to_string())
3052                    .collect::<Vec<String>>()
3053                    .join(",")
3054                    .to_string(),
3055            )]),
3056        };
3057    }
3058    if let Some(ref local_var_str) = vpn_profiles__isnull {
3059        local_var_req_builder =
3060            local_var_req_builder.query(&[("vpn_profiles__isnull", &local_var_str.to_string())]);
3061    }
3062    if let Some(ref local_var_str) = vpn_profiles__n {
3063        local_var_req_builder = match "multi" {
3064            "multi" => local_var_req_builder.query(
3065                &local_var_str
3066                    .into_iter()
3067                    .map(|p| ("vpn_profiles__n".to_owned(), p.to_string()))
3068                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3069            ),
3070            _ => local_var_req_builder.query(&[(
3071                "vpn_profiles__n",
3072                &local_var_str
3073                    .into_iter()
3074                    .map(|p| p.to_string())
3075                    .collect::<Vec<String>>()
3076                    .join(",")
3077                    .to_string(),
3078            )]),
3079        };
3080    }
3081    if let Some(ref local_var_str) = depth {
3082        local_var_req_builder =
3083            local_var_req_builder.query(&[("depth", &local_var_str.to_string())]);
3084    }
3085    if let Some(ref local_var_str) = exclude_m2m {
3086        local_var_req_builder =
3087            local_var_req_builder.query(&[("exclude_m2m", &local_var_str.to_string())]);
3088    }
3089    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
3090        local_var_req_builder =
3091            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
3092    }
3093    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
3094        let local_var_key = local_var_apikey.key.clone();
3095        let local_var_value = match local_var_apikey.prefix {
3096            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
3097            None => local_var_key,
3098        };
3099        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
3100    };
3101
3102    let local_var_req = local_var_req_builder.build()?;
3103    let local_var_resp = local_var_client.execute(local_var_req).await?;
3104
3105    let local_var_status = local_var_resp.status();
3106    let local_var_content = local_var_resp.text().await?;
3107
3108    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
3109        serde_json::from_str(&local_var_content).map_err(Error::from)
3110    } else {
3111        let local_var_entity: Option<VpnVpnPhase1PoliciesListError> =
3112            serde_json::from_str(&local_var_content).ok();
3113        let local_var_error = ResponseContent {
3114            status: local_var_status,
3115            content: local_var_content,
3116            entity: local_var_entity,
3117        };
3118        Err(Error::ResponseError(local_var_error))
3119    }
3120}
3121
3122/// API methods for returning or creating notes on an object.
3123pub async fn vpn_vpn_phase1_policies_notes_create(
3124    configuration: &configuration::Configuration,
3125    id: &str,
3126    note_input_request: crate::models::NoteInputRequest,
3127    format: Option<&str>,
3128) -> Result<crate::models::Note, Error<VpnVpnPhase1PoliciesNotesCreateError>> {
3129    let local_var_configuration = configuration;
3130
3131    let local_var_client = &local_var_configuration.client;
3132
3133    let local_var_uri_str = format!(
3134        "{}/vpn/vpn-phase-1-policies/{id}/notes/",
3135        local_var_configuration.base_path,
3136        id = crate::apis::urlencode(id)
3137    );
3138    let mut local_var_req_builder =
3139        local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
3140
3141    if let Some(ref local_var_str) = format {
3142        local_var_req_builder =
3143            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
3144    }
3145    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
3146        local_var_req_builder =
3147            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
3148    }
3149    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
3150        let local_var_key = local_var_apikey.key.clone();
3151        let local_var_value = match local_var_apikey.prefix {
3152            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
3153            None => local_var_key,
3154        };
3155        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
3156    };
3157    local_var_req_builder = local_var_req_builder.json(&note_input_request);
3158
3159    let local_var_req = local_var_req_builder.build()?;
3160    let local_var_resp = local_var_client.execute(local_var_req).await?;
3161
3162    let local_var_status = local_var_resp.status();
3163    let local_var_content = local_var_resp.text().await?;
3164
3165    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
3166        serde_json::from_str(&local_var_content).map_err(Error::from)
3167    } else {
3168        let local_var_entity: Option<VpnVpnPhase1PoliciesNotesCreateError> =
3169            serde_json::from_str(&local_var_content).ok();
3170        let local_var_error = ResponseContent {
3171            status: local_var_status,
3172            content: local_var_content,
3173            entity: local_var_entity,
3174        };
3175        Err(Error::ResponseError(local_var_error))
3176    }
3177}
3178
3179/// API methods for returning or creating notes on an object.
3180pub async fn vpn_vpn_phase1_policies_notes_list(
3181    configuration: &configuration::Configuration,
3182    id: &str,
3183    format: Option<&str>,
3184    limit: Option<i32>,
3185    offset: Option<i32>,
3186    depth: Option<i32>,
3187    exclude_m2m: Option<bool>,
3188) -> Result<crate::models::PaginatedNoteList, Error<VpnVpnPhase1PoliciesNotesListError>> {
3189    let local_var_configuration = configuration;
3190
3191    let local_var_client = &local_var_configuration.client;
3192
3193    let local_var_uri_str = format!(
3194        "{}/vpn/vpn-phase-1-policies/{id}/notes/",
3195        local_var_configuration.base_path,
3196        id = crate::apis::urlencode(id)
3197    );
3198    let mut local_var_req_builder =
3199        local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
3200
3201    if let Some(ref local_var_str) = format {
3202        local_var_req_builder =
3203            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
3204    }
3205    if let Some(ref local_var_str) = limit {
3206        local_var_req_builder =
3207            local_var_req_builder.query(&[("limit", &local_var_str.to_string())]);
3208    }
3209    if let Some(ref local_var_str) = offset {
3210        local_var_req_builder =
3211            local_var_req_builder.query(&[("offset", &local_var_str.to_string())]);
3212    }
3213    if let Some(ref local_var_str) = depth {
3214        local_var_req_builder =
3215            local_var_req_builder.query(&[("depth", &local_var_str.to_string())]);
3216    }
3217    if let Some(ref local_var_str) = exclude_m2m {
3218        local_var_req_builder =
3219            local_var_req_builder.query(&[("exclude_m2m", &local_var_str.to_string())]);
3220    }
3221    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
3222        local_var_req_builder =
3223            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
3224    }
3225    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
3226        let local_var_key = local_var_apikey.key.clone();
3227        let local_var_value = match local_var_apikey.prefix {
3228            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
3229            None => local_var_key,
3230        };
3231        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
3232    };
3233
3234    let local_var_req = local_var_req_builder.build()?;
3235    let local_var_resp = local_var_client.execute(local_var_req).await?;
3236
3237    let local_var_status = local_var_resp.status();
3238    let local_var_content = local_var_resp.text().await?;
3239
3240    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
3241        serde_json::from_str(&local_var_content).map_err(Error::from)
3242    } else {
3243        let local_var_entity: Option<VpnVpnPhase1PoliciesNotesListError> =
3244            serde_json::from_str(&local_var_content).ok();
3245        let local_var_error = ResponseContent {
3246            status: local_var_status,
3247            content: local_var_content,
3248            entity: local_var_entity,
3249        };
3250        Err(Error::ResponseError(local_var_error))
3251    }
3252}
3253
3254/// VPNPhase1Policy viewset.
3255pub async fn vpn_vpn_phase1_policies_partial_update(
3256    configuration: &configuration::Configuration,
3257    id: &str,
3258    format: Option<&str>,
3259    patched_vpn_phase1_policy_request: Option<crate::models::PatchedVpnPhase1PolicyRequest>,
3260) -> Result<crate::models::VpnPhase1Policy, Error<VpnVpnPhase1PoliciesPartialUpdateError>> {
3261    let local_var_configuration = configuration;
3262
3263    let local_var_client = &local_var_configuration.client;
3264
3265    let local_var_uri_str = format!(
3266        "{}/vpn/vpn-phase-1-policies/{id}/",
3267        local_var_configuration.base_path,
3268        id = crate::apis::urlencode(id)
3269    );
3270    let mut local_var_req_builder =
3271        local_var_client.request(reqwest::Method::PATCH, local_var_uri_str.as_str());
3272
3273    if let Some(ref local_var_str) = format {
3274        local_var_req_builder =
3275            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
3276    }
3277    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
3278        local_var_req_builder =
3279            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
3280    }
3281    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
3282        let local_var_key = local_var_apikey.key.clone();
3283        let local_var_value = match local_var_apikey.prefix {
3284            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
3285            None => local_var_key,
3286        };
3287        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
3288    };
3289    local_var_req_builder = local_var_req_builder.json(&patched_vpn_phase1_policy_request);
3290
3291    let local_var_req = local_var_req_builder.build()?;
3292    let local_var_resp = local_var_client.execute(local_var_req).await?;
3293
3294    let local_var_status = local_var_resp.status();
3295    let local_var_content = local_var_resp.text().await?;
3296
3297    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
3298        serde_json::from_str(&local_var_content).map_err(Error::from)
3299    } else {
3300        let local_var_entity: Option<VpnVpnPhase1PoliciesPartialUpdateError> =
3301            serde_json::from_str(&local_var_content).ok();
3302        let local_var_error = ResponseContent {
3303            status: local_var_status,
3304            content: local_var_content,
3305            entity: local_var_entity,
3306        };
3307        Err(Error::ResponseError(local_var_error))
3308    }
3309}
3310
3311/// VPNPhase1Policy viewset.
3312pub async fn vpn_vpn_phase1_policies_retrieve(
3313    configuration: &configuration::Configuration,
3314    id: &str,
3315    format: Option<&str>,
3316    depth: Option<i32>,
3317    exclude_m2m: Option<bool>,
3318) -> Result<crate::models::VpnPhase1Policy, Error<VpnVpnPhase1PoliciesRetrieveError>> {
3319    let local_var_configuration = configuration;
3320
3321    let local_var_client = &local_var_configuration.client;
3322
3323    let local_var_uri_str = format!(
3324        "{}/vpn/vpn-phase-1-policies/{id}/",
3325        local_var_configuration.base_path,
3326        id = crate::apis::urlencode(id)
3327    );
3328    let mut local_var_req_builder =
3329        local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
3330
3331    if let Some(ref local_var_str) = format {
3332        local_var_req_builder =
3333            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
3334    }
3335    if let Some(ref local_var_str) = depth {
3336        local_var_req_builder =
3337            local_var_req_builder.query(&[("depth", &local_var_str.to_string())]);
3338    }
3339    if let Some(ref local_var_str) = exclude_m2m {
3340        local_var_req_builder =
3341            local_var_req_builder.query(&[("exclude_m2m", &local_var_str.to_string())]);
3342    }
3343    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
3344        local_var_req_builder =
3345            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
3346    }
3347    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
3348        let local_var_key = local_var_apikey.key.clone();
3349        let local_var_value = match local_var_apikey.prefix {
3350            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
3351            None => local_var_key,
3352        };
3353        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
3354    };
3355
3356    let local_var_req = local_var_req_builder.build()?;
3357    let local_var_resp = local_var_client.execute(local_var_req).await?;
3358
3359    let local_var_status = local_var_resp.status();
3360    let local_var_content = local_var_resp.text().await?;
3361
3362    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
3363        serde_json::from_str(&local_var_content).map_err(Error::from)
3364    } else {
3365        let local_var_entity: Option<VpnVpnPhase1PoliciesRetrieveError> =
3366            serde_json::from_str(&local_var_content).ok();
3367        let local_var_error = ResponseContent {
3368            status: local_var_status,
3369            content: local_var_content,
3370            entity: local_var_entity,
3371        };
3372        Err(Error::ResponseError(local_var_error))
3373    }
3374}
3375
3376/// VPNPhase1Policy viewset.
3377pub async fn vpn_vpn_phase1_policies_update(
3378    configuration: &configuration::Configuration,
3379    id: &str,
3380    vpn_phase1_policy_request: crate::models::VpnPhase1PolicyRequest,
3381    format: Option<&str>,
3382) -> Result<crate::models::VpnPhase1Policy, Error<VpnVpnPhase1PoliciesUpdateError>> {
3383    let local_var_configuration = configuration;
3384
3385    let local_var_client = &local_var_configuration.client;
3386
3387    let local_var_uri_str = format!(
3388        "{}/vpn/vpn-phase-1-policies/{id}/",
3389        local_var_configuration.base_path,
3390        id = crate::apis::urlencode(id)
3391    );
3392    let mut local_var_req_builder =
3393        local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());
3394
3395    if let Some(ref local_var_str) = format {
3396        local_var_req_builder =
3397            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
3398    }
3399    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
3400        local_var_req_builder =
3401            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
3402    }
3403    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
3404        let local_var_key = local_var_apikey.key.clone();
3405        let local_var_value = match local_var_apikey.prefix {
3406            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
3407            None => local_var_key,
3408        };
3409        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
3410    };
3411    local_var_req_builder = local_var_req_builder.json(&vpn_phase1_policy_request);
3412
3413    let local_var_req = local_var_req_builder.build()?;
3414    let local_var_resp = local_var_client.execute(local_var_req).await?;
3415
3416    let local_var_status = local_var_resp.status();
3417    let local_var_content = local_var_resp.text().await?;
3418
3419    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
3420        serde_json::from_str(&local_var_content).map_err(Error::from)
3421    } else {
3422        let local_var_entity: Option<VpnVpnPhase1PoliciesUpdateError> =
3423            serde_json::from_str(&local_var_content).ok();
3424        let local_var_error = ResponseContent {
3425            status: local_var_status,
3426            content: local_var_content,
3427            entity: local_var_entity,
3428        };
3429        Err(Error::ResponseError(local_var_error))
3430    }
3431}
3432
3433/// VPNPhase2Policy viewset.
3434pub async fn vpn_vpn_phase2_policies_bulk_destroy(
3435    configuration: &configuration::Configuration,
3436    bulk_operation_request: Vec<crate::models::BulkOperationRequest>,
3437    format: Option<&str>,
3438) -> Result<(), Error<VpnVpnPhase2PoliciesBulkDestroyError>> {
3439    let local_var_configuration = configuration;
3440
3441    let local_var_client = &local_var_configuration.client;
3442
3443    let local_var_uri_str = format!(
3444        "{}/vpn/vpn-phase-2-policies/",
3445        local_var_configuration.base_path
3446    );
3447    let mut local_var_req_builder =
3448        local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());
3449
3450    if let Some(ref local_var_str) = format {
3451        local_var_req_builder =
3452            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
3453    }
3454    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
3455        local_var_req_builder =
3456            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
3457    }
3458    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
3459        let local_var_key = local_var_apikey.key.clone();
3460        let local_var_value = match local_var_apikey.prefix {
3461            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
3462            None => local_var_key,
3463        };
3464        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
3465    };
3466    local_var_req_builder = local_var_req_builder.json(&bulk_operation_request);
3467
3468    let local_var_req = local_var_req_builder.build()?;
3469    let local_var_resp = local_var_client.execute(local_var_req).await?;
3470
3471    let local_var_status = local_var_resp.status();
3472    let local_var_content = local_var_resp.text().await?;
3473
3474    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
3475        Ok(())
3476    } else {
3477        let local_var_entity: Option<VpnVpnPhase2PoliciesBulkDestroyError> =
3478            serde_json::from_str(&local_var_content).ok();
3479        let local_var_error = ResponseContent {
3480            status: local_var_status,
3481            content: local_var_content,
3482            entity: local_var_entity,
3483        };
3484        Err(Error::ResponseError(local_var_error))
3485    }
3486}
3487
3488/// VPNPhase2Policy viewset.
3489pub async fn vpn_vpn_phase2_policies_bulk_partial_update(
3490    configuration: &configuration::Configuration,
3491    patched_bulk_writable_vpn_phase2_policy_request: Vec<
3492        crate::models::PatchedBulkWritableVpnPhase2PolicyRequest,
3493    >,
3494    format: Option<&str>,
3495) -> Result<Vec<crate::models::VpnPhase2Policy>, Error<VpnVpnPhase2PoliciesBulkPartialUpdateError>>
3496{
3497    let local_var_configuration = configuration;
3498
3499    let local_var_client = &local_var_configuration.client;
3500
3501    let local_var_uri_str = format!(
3502        "{}/vpn/vpn-phase-2-policies/",
3503        local_var_configuration.base_path
3504    );
3505    let mut local_var_req_builder =
3506        local_var_client.request(reqwest::Method::PATCH, local_var_uri_str.as_str());
3507
3508    if let Some(ref local_var_str) = format {
3509        local_var_req_builder =
3510            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
3511    }
3512    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
3513        local_var_req_builder =
3514            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
3515    }
3516    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
3517        let local_var_key = local_var_apikey.key.clone();
3518        let local_var_value = match local_var_apikey.prefix {
3519            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
3520            None => local_var_key,
3521        };
3522        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
3523    };
3524    local_var_req_builder =
3525        local_var_req_builder.json(&patched_bulk_writable_vpn_phase2_policy_request);
3526
3527    let local_var_req = local_var_req_builder.build()?;
3528    let local_var_resp = local_var_client.execute(local_var_req).await?;
3529
3530    let local_var_status = local_var_resp.status();
3531    let local_var_content = local_var_resp.text().await?;
3532
3533    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
3534        serde_json::from_str(&local_var_content).map_err(Error::from)
3535    } else {
3536        let local_var_entity: Option<VpnVpnPhase2PoliciesBulkPartialUpdateError> =
3537            serde_json::from_str(&local_var_content).ok();
3538        let local_var_error = ResponseContent {
3539            status: local_var_status,
3540            content: local_var_content,
3541            entity: local_var_entity,
3542        };
3543        Err(Error::ResponseError(local_var_error))
3544    }
3545}
3546
3547/// VPNPhase2Policy viewset.
3548pub async fn vpn_vpn_phase2_policies_bulk_update(
3549    configuration: &configuration::Configuration,
3550    bulk_writable_vpn_phase2_policy_request: Vec<crate::models::BulkWritableVpnPhase2PolicyRequest>,
3551    format: Option<&str>,
3552) -> Result<Vec<crate::models::VpnPhase2Policy>, Error<VpnVpnPhase2PoliciesBulkUpdateError>> {
3553    let local_var_configuration = configuration;
3554
3555    let local_var_client = &local_var_configuration.client;
3556
3557    let local_var_uri_str = format!(
3558        "{}/vpn/vpn-phase-2-policies/",
3559        local_var_configuration.base_path
3560    );
3561    let mut local_var_req_builder =
3562        local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());
3563
3564    if let Some(ref local_var_str) = format {
3565        local_var_req_builder =
3566            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
3567    }
3568    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
3569        local_var_req_builder =
3570            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
3571    }
3572    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
3573        let local_var_key = local_var_apikey.key.clone();
3574        let local_var_value = match local_var_apikey.prefix {
3575            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
3576            None => local_var_key,
3577        };
3578        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
3579    };
3580    local_var_req_builder = local_var_req_builder.json(&bulk_writable_vpn_phase2_policy_request);
3581
3582    let local_var_req = local_var_req_builder.build()?;
3583    let local_var_resp = local_var_client.execute(local_var_req).await?;
3584
3585    let local_var_status = local_var_resp.status();
3586    let local_var_content = local_var_resp.text().await?;
3587
3588    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
3589        serde_json::from_str(&local_var_content).map_err(Error::from)
3590    } else {
3591        let local_var_entity: Option<VpnVpnPhase2PoliciesBulkUpdateError> =
3592            serde_json::from_str(&local_var_content).ok();
3593        let local_var_error = ResponseContent {
3594            status: local_var_status,
3595            content: local_var_content,
3596            entity: local_var_entity,
3597        };
3598        Err(Error::ResponseError(local_var_error))
3599    }
3600}
3601
3602/// VPNPhase2Policy viewset.
3603pub async fn vpn_vpn_phase2_policies_create(
3604    configuration: &configuration::Configuration,
3605    vpn_phase2_policy_request: crate::models::VpnPhase2PolicyRequest,
3606    format: Option<&str>,
3607) -> Result<crate::models::VpnPhase2Policy, Error<VpnVpnPhase2PoliciesCreateError>> {
3608    let local_var_configuration = configuration;
3609
3610    let local_var_client = &local_var_configuration.client;
3611
3612    let local_var_uri_str = format!(
3613        "{}/vpn/vpn-phase-2-policies/",
3614        local_var_configuration.base_path
3615    );
3616    let mut local_var_req_builder =
3617        local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
3618
3619    if let Some(ref local_var_str) = format {
3620        local_var_req_builder =
3621            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
3622    }
3623    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
3624        local_var_req_builder =
3625            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
3626    }
3627    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
3628        let local_var_key = local_var_apikey.key.clone();
3629        let local_var_value = match local_var_apikey.prefix {
3630            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
3631            None => local_var_key,
3632        };
3633        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
3634    };
3635    local_var_req_builder = local_var_req_builder.json(&vpn_phase2_policy_request);
3636
3637    let local_var_req = local_var_req_builder.build()?;
3638    let local_var_resp = local_var_client.execute(local_var_req).await?;
3639
3640    let local_var_status = local_var_resp.status();
3641    let local_var_content = local_var_resp.text().await?;
3642
3643    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
3644        serde_json::from_str(&local_var_content).map_err(Error::from)
3645    } else {
3646        let local_var_entity: Option<VpnVpnPhase2PoliciesCreateError> =
3647            serde_json::from_str(&local_var_content).ok();
3648        let local_var_error = ResponseContent {
3649            status: local_var_status,
3650            content: local_var_content,
3651            entity: local_var_entity,
3652        };
3653        Err(Error::ResponseError(local_var_error))
3654    }
3655}
3656
3657/// VPNPhase2Policy viewset.
3658pub async fn vpn_vpn_phase2_policies_destroy(
3659    configuration: &configuration::Configuration,
3660    id: &str,
3661    format: Option<&str>,
3662) -> Result<(), Error<VpnVpnPhase2PoliciesDestroyError>> {
3663    let local_var_configuration = configuration;
3664
3665    let local_var_client = &local_var_configuration.client;
3666
3667    let local_var_uri_str = format!(
3668        "{}/vpn/vpn-phase-2-policies/{id}/",
3669        local_var_configuration.base_path,
3670        id = crate::apis::urlencode(id)
3671    );
3672    let mut local_var_req_builder =
3673        local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());
3674
3675    if let Some(ref local_var_str) = format {
3676        local_var_req_builder =
3677            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
3678    }
3679    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
3680        local_var_req_builder =
3681            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
3682    }
3683    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
3684        let local_var_key = local_var_apikey.key.clone();
3685        let local_var_value = match local_var_apikey.prefix {
3686            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
3687            None => local_var_key,
3688        };
3689        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
3690    };
3691
3692    let local_var_req = local_var_req_builder.build()?;
3693    let local_var_resp = local_var_client.execute(local_var_req).await?;
3694
3695    let local_var_status = local_var_resp.status();
3696    let local_var_content = local_var_resp.text().await?;
3697
3698    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
3699        Ok(())
3700    } else {
3701        let local_var_entity: Option<VpnVpnPhase2PoliciesDestroyError> =
3702            serde_json::from_str(&local_var_content).ok();
3703        let local_var_error = ResponseContent {
3704            status: local_var_status,
3705            content: local_var_content,
3706            entity: local_var_entity,
3707        };
3708        Err(Error::ResponseError(local_var_error))
3709    }
3710}
3711
3712/// VPNPhase2Policy viewset.
3713pub async fn vpn_vpn_phase2_policies_list(
3714    configuration: &configuration::Configuration,
3715    contacts: Option<Vec<String>>,
3716    contacts__isnull: Option<bool>,
3717    contacts__n: Option<Vec<String>>,
3718    created: Option<Vec<String>>,
3719    created__gt: Option<Vec<String>>,
3720    created__gte: Option<Vec<String>>,
3721    created__isnull: Option<bool>,
3722    created__lt: Option<Vec<String>>,
3723    created__lte: Option<Vec<String>>,
3724    created__n: Option<Vec<String>>,
3725    description: Option<Vec<String>>,
3726    description__ic: Option<Vec<String>>,
3727    description__ie: Option<Vec<String>>,
3728    description__iew: Option<Vec<String>>,
3729    description__ire: Option<Vec<String>>,
3730    description__isw: Option<Vec<String>>,
3731    description__n: Option<Vec<String>>,
3732    description__nic: Option<Vec<String>>,
3733    description__nie: Option<Vec<String>>,
3734    description__niew: Option<Vec<String>>,
3735    description__nire: Option<Vec<String>>,
3736    description__nisw: Option<Vec<String>>,
3737    description__nre: Option<Vec<String>>,
3738    description__re: Option<Vec<String>>,
3739    dynamic_groups: Option<Vec<String>>,
3740    dynamic_groups__n: Option<Vec<String>>,
3741    encryption_algorithm: Option<Vec<String>>,
3742    format: Option<&str>,
3743    id: Option<Vec<uuid::Uuid>>,
3744    id__n: Option<Vec<uuid::Uuid>>,
3745    integrity_algorithm: Option<Vec<String>>,
3746    last_updated: Option<Vec<String>>,
3747    last_updated__gt: Option<Vec<String>>,
3748    last_updated__gte: Option<Vec<String>>,
3749    last_updated__isnull: Option<bool>,
3750    last_updated__lt: Option<Vec<String>>,
3751    last_updated__lte: Option<Vec<String>>,
3752    last_updated__n: Option<Vec<String>>,
3753    lifetime: Option<Vec<i32>>,
3754    lifetime__gt: Option<Vec<i32>>,
3755    lifetime__gte: Option<Vec<i32>>,
3756    lifetime__isnull: Option<bool>,
3757    lifetime__lt: Option<Vec<i32>>,
3758    lifetime__lte: Option<Vec<i32>>,
3759    lifetime__n: Option<Vec<i32>>,
3760    limit: Option<i32>,
3761    name: Option<Vec<String>>,
3762    name__ic: Option<Vec<String>>,
3763    name__ie: Option<Vec<String>>,
3764    name__iew: Option<Vec<String>>,
3765    name__ire: Option<Vec<String>>,
3766    name__isw: Option<Vec<String>>,
3767    name__n: Option<Vec<String>>,
3768    name__nic: Option<Vec<String>>,
3769    name__nie: Option<Vec<String>>,
3770    name__niew: Option<Vec<String>>,
3771    name__nire: Option<Vec<String>>,
3772    name__nisw: Option<Vec<String>>,
3773    name__nre: Option<Vec<String>>,
3774    name__re: Option<Vec<String>>,
3775    offset: Option<i32>,
3776    pfs_group: Option<Vec<String>>,
3777    q: Option<&str>,
3778    sort: Option<&str>,
3779    tags: Option<Vec<String>>,
3780    tags__isnull: Option<bool>,
3781    tags__n: Option<Vec<String>>,
3782    teams: Option<Vec<String>>,
3783    teams__isnull: Option<bool>,
3784    teams__n: Option<Vec<String>>,
3785    tenant: Option<Vec<String>>,
3786    tenant__isnull: Option<bool>,
3787    tenant__n: Option<Vec<String>>,
3788    tenant_group: Option<Vec<String>>,
3789    tenant_group__isnull: Option<bool>,
3790    tenant_group__n: Option<Vec<String>>,
3791    tenant_id: Option<Vec<uuid::Uuid>>,
3792    tenant_id__isnull: Option<bool>,
3793    tenant_id__n: Option<Vec<uuid::Uuid>>,
3794    vpn_profiles: Option<Vec<String>>,
3795    vpn_profiles__isnull: Option<bool>,
3796    vpn_profiles__n: Option<Vec<String>>,
3797    depth: Option<i32>,
3798    exclude_m2m: Option<bool>,
3799) -> Result<crate::models::PaginatedVpnPhase2PolicyList, Error<VpnVpnPhase2PoliciesListError>> {
3800    let local_var_configuration = configuration;
3801
3802    let local_var_client = &local_var_configuration.client;
3803
3804    let local_var_uri_str = format!(
3805        "{}/vpn/vpn-phase-2-policies/",
3806        local_var_configuration.base_path
3807    );
3808    let mut local_var_req_builder =
3809        local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
3810
3811    if let Some(ref local_var_str) = contacts {
3812        local_var_req_builder = match "multi" {
3813            "multi" => local_var_req_builder.query(
3814                &local_var_str
3815                    .into_iter()
3816                    .map(|p| ("contacts".to_owned(), p.to_string()))
3817                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3818            ),
3819            _ => local_var_req_builder.query(&[(
3820                "contacts",
3821                &local_var_str
3822                    .into_iter()
3823                    .map(|p| p.to_string())
3824                    .collect::<Vec<String>>()
3825                    .join(",")
3826                    .to_string(),
3827            )]),
3828        };
3829    }
3830    if let Some(ref local_var_str) = contacts__isnull {
3831        local_var_req_builder =
3832            local_var_req_builder.query(&[("contacts__isnull", &local_var_str.to_string())]);
3833    }
3834    if let Some(ref local_var_str) = contacts__n {
3835        local_var_req_builder = match "multi" {
3836            "multi" => local_var_req_builder.query(
3837                &local_var_str
3838                    .into_iter()
3839                    .map(|p| ("contacts__n".to_owned(), p.to_string()))
3840                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3841            ),
3842            _ => local_var_req_builder.query(&[(
3843                "contacts__n",
3844                &local_var_str
3845                    .into_iter()
3846                    .map(|p| p.to_string())
3847                    .collect::<Vec<String>>()
3848                    .join(",")
3849                    .to_string(),
3850            )]),
3851        };
3852    }
3853    if let Some(ref local_var_str) = created {
3854        local_var_req_builder = match "multi" {
3855            "multi" => local_var_req_builder.query(
3856                &local_var_str
3857                    .into_iter()
3858                    .map(|p| ("created".to_owned(), p.to_string()))
3859                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3860            ),
3861            _ => local_var_req_builder.query(&[(
3862                "created",
3863                &local_var_str
3864                    .into_iter()
3865                    .map(|p| p.to_string())
3866                    .collect::<Vec<String>>()
3867                    .join(",")
3868                    .to_string(),
3869            )]),
3870        };
3871    }
3872    if let Some(ref local_var_str) = created__gt {
3873        local_var_req_builder = match "multi" {
3874            "multi" => local_var_req_builder.query(
3875                &local_var_str
3876                    .into_iter()
3877                    .map(|p| ("created__gt".to_owned(), p.to_string()))
3878                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3879            ),
3880            _ => local_var_req_builder.query(&[(
3881                "created__gt",
3882                &local_var_str
3883                    .into_iter()
3884                    .map(|p| p.to_string())
3885                    .collect::<Vec<String>>()
3886                    .join(",")
3887                    .to_string(),
3888            )]),
3889        };
3890    }
3891    if let Some(ref local_var_str) = created__gte {
3892        local_var_req_builder = match "multi" {
3893            "multi" => local_var_req_builder.query(
3894                &local_var_str
3895                    .into_iter()
3896                    .map(|p| ("created__gte".to_owned(), p.to_string()))
3897                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3898            ),
3899            _ => local_var_req_builder.query(&[(
3900                "created__gte",
3901                &local_var_str
3902                    .into_iter()
3903                    .map(|p| p.to_string())
3904                    .collect::<Vec<String>>()
3905                    .join(",")
3906                    .to_string(),
3907            )]),
3908        };
3909    }
3910    if let Some(ref local_var_str) = created__isnull {
3911        local_var_req_builder =
3912            local_var_req_builder.query(&[("created__isnull", &local_var_str.to_string())]);
3913    }
3914    if let Some(ref local_var_str) = created__lt {
3915        local_var_req_builder = match "multi" {
3916            "multi" => local_var_req_builder.query(
3917                &local_var_str
3918                    .into_iter()
3919                    .map(|p| ("created__lt".to_owned(), p.to_string()))
3920                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3921            ),
3922            _ => local_var_req_builder.query(&[(
3923                "created__lt",
3924                &local_var_str
3925                    .into_iter()
3926                    .map(|p| p.to_string())
3927                    .collect::<Vec<String>>()
3928                    .join(",")
3929                    .to_string(),
3930            )]),
3931        };
3932    }
3933    if let Some(ref local_var_str) = created__lte {
3934        local_var_req_builder = match "multi" {
3935            "multi" => local_var_req_builder.query(
3936                &local_var_str
3937                    .into_iter()
3938                    .map(|p| ("created__lte".to_owned(), p.to_string()))
3939                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3940            ),
3941            _ => local_var_req_builder.query(&[(
3942                "created__lte",
3943                &local_var_str
3944                    .into_iter()
3945                    .map(|p| p.to_string())
3946                    .collect::<Vec<String>>()
3947                    .join(",")
3948                    .to_string(),
3949            )]),
3950        };
3951    }
3952    if let Some(ref local_var_str) = created__n {
3953        local_var_req_builder = match "multi" {
3954            "multi" => local_var_req_builder.query(
3955                &local_var_str
3956                    .into_iter()
3957                    .map(|p| ("created__n".to_owned(), p.to_string()))
3958                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3959            ),
3960            _ => local_var_req_builder.query(&[(
3961                "created__n",
3962                &local_var_str
3963                    .into_iter()
3964                    .map(|p| p.to_string())
3965                    .collect::<Vec<String>>()
3966                    .join(",")
3967                    .to_string(),
3968            )]),
3969        };
3970    }
3971    if let Some(ref local_var_str) = description {
3972        local_var_req_builder = match "multi" {
3973            "multi" => local_var_req_builder.query(
3974                &local_var_str
3975                    .into_iter()
3976                    .map(|p| ("description".to_owned(), p.to_string()))
3977                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3978            ),
3979            _ => local_var_req_builder.query(&[(
3980                "description",
3981                &local_var_str
3982                    .into_iter()
3983                    .map(|p| p.to_string())
3984                    .collect::<Vec<String>>()
3985                    .join(",")
3986                    .to_string(),
3987            )]),
3988        };
3989    }
3990    if let Some(ref local_var_str) = description__ic {
3991        local_var_req_builder = match "multi" {
3992            "multi" => local_var_req_builder.query(
3993                &local_var_str
3994                    .into_iter()
3995                    .map(|p| ("description__ic".to_owned(), p.to_string()))
3996                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3997            ),
3998            _ => local_var_req_builder.query(&[(
3999                "description__ic",
4000                &local_var_str
4001                    .into_iter()
4002                    .map(|p| p.to_string())
4003                    .collect::<Vec<String>>()
4004                    .join(",")
4005                    .to_string(),
4006            )]),
4007        };
4008    }
4009    if let Some(ref local_var_str) = description__ie {
4010        local_var_req_builder = match "multi" {
4011            "multi" => local_var_req_builder.query(
4012                &local_var_str
4013                    .into_iter()
4014                    .map(|p| ("description__ie".to_owned(), p.to_string()))
4015                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4016            ),
4017            _ => local_var_req_builder.query(&[(
4018                "description__ie",
4019                &local_var_str
4020                    .into_iter()
4021                    .map(|p| p.to_string())
4022                    .collect::<Vec<String>>()
4023                    .join(",")
4024                    .to_string(),
4025            )]),
4026        };
4027    }
4028    if let Some(ref local_var_str) = description__iew {
4029        local_var_req_builder = match "multi" {
4030            "multi" => local_var_req_builder.query(
4031                &local_var_str
4032                    .into_iter()
4033                    .map(|p| ("description__iew".to_owned(), p.to_string()))
4034                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4035            ),
4036            _ => local_var_req_builder.query(&[(
4037                "description__iew",
4038                &local_var_str
4039                    .into_iter()
4040                    .map(|p| p.to_string())
4041                    .collect::<Vec<String>>()
4042                    .join(",")
4043                    .to_string(),
4044            )]),
4045        };
4046    }
4047    if let Some(ref local_var_str) = description__ire {
4048        local_var_req_builder = match "multi" {
4049            "multi" => local_var_req_builder.query(
4050                &local_var_str
4051                    .into_iter()
4052                    .map(|p| ("description__ire".to_owned(), p.to_string()))
4053                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4054            ),
4055            _ => local_var_req_builder.query(&[(
4056                "description__ire",
4057                &local_var_str
4058                    .into_iter()
4059                    .map(|p| p.to_string())
4060                    .collect::<Vec<String>>()
4061                    .join(",")
4062                    .to_string(),
4063            )]),
4064        };
4065    }
4066    if let Some(ref local_var_str) = description__isw {
4067        local_var_req_builder = match "multi" {
4068            "multi" => local_var_req_builder.query(
4069                &local_var_str
4070                    .into_iter()
4071                    .map(|p| ("description__isw".to_owned(), p.to_string()))
4072                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4073            ),
4074            _ => local_var_req_builder.query(&[(
4075                "description__isw",
4076                &local_var_str
4077                    .into_iter()
4078                    .map(|p| p.to_string())
4079                    .collect::<Vec<String>>()
4080                    .join(",")
4081                    .to_string(),
4082            )]),
4083        };
4084    }
4085    if let Some(ref local_var_str) = description__n {
4086        local_var_req_builder = match "multi" {
4087            "multi" => local_var_req_builder.query(
4088                &local_var_str
4089                    .into_iter()
4090                    .map(|p| ("description__n".to_owned(), p.to_string()))
4091                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4092            ),
4093            _ => local_var_req_builder.query(&[(
4094                "description__n",
4095                &local_var_str
4096                    .into_iter()
4097                    .map(|p| p.to_string())
4098                    .collect::<Vec<String>>()
4099                    .join(",")
4100                    .to_string(),
4101            )]),
4102        };
4103    }
4104    if let Some(ref local_var_str) = description__nic {
4105        local_var_req_builder = match "multi" {
4106            "multi" => local_var_req_builder.query(
4107                &local_var_str
4108                    .into_iter()
4109                    .map(|p| ("description__nic".to_owned(), p.to_string()))
4110                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4111            ),
4112            _ => local_var_req_builder.query(&[(
4113                "description__nic",
4114                &local_var_str
4115                    .into_iter()
4116                    .map(|p| p.to_string())
4117                    .collect::<Vec<String>>()
4118                    .join(",")
4119                    .to_string(),
4120            )]),
4121        };
4122    }
4123    if let Some(ref local_var_str) = description__nie {
4124        local_var_req_builder = match "multi" {
4125            "multi" => local_var_req_builder.query(
4126                &local_var_str
4127                    .into_iter()
4128                    .map(|p| ("description__nie".to_owned(), p.to_string()))
4129                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4130            ),
4131            _ => local_var_req_builder.query(&[(
4132                "description__nie",
4133                &local_var_str
4134                    .into_iter()
4135                    .map(|p| p.to_string())
4136                    .collect::<Vec<String>>()
4137                    .join(",")
4138                    .to_string(),
4139            )]),
4140        };
4141    }
4142    if let Some(ref local_var_str) = description__niew {
4143        local_var_req_builder = match "multi" {
4144            "multi" => local_var_req_builder.query(
4145                &local_var_str
4146                    .into_iter()
4147                    .map(|p| ("description__niew".to_owned(), p.to_string()))
4148                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4149            ),
4150            _ => local_var_req_builder.query(&[(
4151                "description__niew",
4152                &local_var_str
4153                    .into_iter()
4154                    .map(|p| p.to_string())
4155                    .collect::<Vec<String>>()
4156                    .join(",")
4157                    .to_string(),
4158            )]),
4159        };
4160    }
4161    if let Some(ref local_var_str) = description__nire {
4162        local_var_req_builder = match "multi" {
4163            "multi" => local_var_req_builder.query(
4164                &local_var_str
4165                    .into_iter()
4166                    .map(|p| ("description__nire".to_owned(), p.to_string()))
4167                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4168            ),
4169            _ => local_var_req_builder.query(&[(
4170                "description__nire",
4171                &local_var_str
4172                    .into_iter()
4173                    .map(|p| p.to_string())
4174                    .collect::<Vec<String>>()
4175                    .join(",")
4176                    .to_string(),
4177            )]),
4178        };
4179    }
4180    if let Some(ref local_var_str) = description__nisw {
4181        local_var_req_builder = match "multi" {
4182            "multi" => local_var_req_builder.query(
4183                &local_var_str
4184                    .into_iter()
4185                    .map(|p| ("description__nisw".to_owned(), p.to_string()))
4186                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4187            ),
4188            _ => local_var_req_builder.query(&[(
4189                "description__nisw",
4190                &local_var_str
4191                    .into_iter()
4192                    .map(|p| p.to_string())
4193                    .collect::<Vec<String>>()
4194                    .join(",")
4195                    .to_string(),
4196            )]),
4197        };
4198    }
4199    if let Some(ref local_var_str) = description__nre {
4200        local_var_req_builder = match "multi" {
4201            "multi" => local_var_req_builder.query(
4202                &local_var_str
4203                    .into_iter()
4204                    .map(|p| ("description__nre".to_owned(), p.to_string()))
4205                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4206            ),
4207            _ => local_var_req_builder.query(&[(
4208                "description__nre",
4209                &local_var_str
4210                    .into_iter()
4211                    .map(|p| p.to_string())
4212                    .collect::<Vec<String>>()
4213                    .join(",")
4214                    .to_string(),
4215            )]),
4216        };
4217    }
4218    if let Some(ref local_var_str) = description__re {
4219        local_var_req_builder = match "multi" {
4220            "multi" => local_var_req_builder.query(
4221                &local_var_str
4222                    .into_iter()
4223                    .map(|p| ("description__re".to_owned(), p.to_string()))
4224                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4225            ),
4226            _ => local_var_req_builder.query(&[(
4227                "description__re",
4228                &local_var_str
4229                    .into_iter()
4230                    .map(|p| p.to_string())
4231                    .collect::<Vec<String>>()
4232                    .join(",")
4233                    .to_string(),
4234            )]),
4235        };
4236    }
4237    if let Some(ref local_var_str) = dynamic_groups {
4238        local_var_req_builder = match "multi" {
4239            "multi" => local_var_req_builder.query(
4240                &local_var_str
4241                    .into_iter()
4242                    .map(|p| ("dynamic_groups".to_owned(), p.to_string()))
4243                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4244            ),
4245            _ => local_var_req_builder.query(&[(
4246                "dynamic_groups",
4247                &local_var_str
4248                    .into_iter()
4249                    .map(|p| p.to_string())
4250                    .collect::<Vec<String>>()
4251                    .join(",")
4252                    .to_string(),
4253            )]),
4254        };
4255    }
4256    if let Some(ref local_var_str) = dynamic_groups__n {
4257        local_var_req_builder = match "multi" {
4258            "multi" => local_var_req_builder.query(
4259                &local_var_str
4260                    .into_iter()
4261                    .map(|p| ("dynamic_groups__n".to_owned(), p.to_string()))
4262                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4263            ),
4264            _ => local_var_req_builder.query(&[(
4265                "dynamic_groups__n",
4266                &local_var_str
4267                    .into_iter()
4268                    .map(|p| p.to_string())
4269                    .collect::<Vec<String>>()
4270                    .join(",")
4271                    .to_string(),
4272            )]),
4273        };
4274    }
4275    if let Some(ref local_var_str) = encryption_algorithm {
4276        local_var_req_builder = match "multi" {
4277            "multi" => local_var_req_builder.query(
4278                &local_var_str
4279                    .into_iter()
4280                    .map(|p| ("encryption_algorithm".to_owned(), p.to_string()))
4281                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4282            ),
4283            _ => local_var_req_builder.query(&[(
4284                "encryption_algorithm",
4285                &local_var_str
4286                    .into_iter()
4287                    .map(|p| p.to_string())
4288                    .collect::<Vec<String>>()
4289                    .join(",")
4290                    .to_string(),
4291            )]),
4292        };
4293    }
4294    if let Some(ref local_var_str) = format {
4295        local_var_req_builder =
4296            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
4297    }
4298    if let Some(ref local_var_str) = id {
4299        local_var_req_builder = match "multi" {
4300            "multi" => local_var_req_builder.query(
4301                &local_var_str
4302                    .into_iter()
4303                    .map(|p| ("id".to_owned(), p.to_string()))
4304                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4305            ),
4306            _ => local_var_req_builder.query(&[(
4307                "id",
4308                &local_var_str
4309                    .into_iter()
4310                    .map(|p| p.to_string())
4311                    .collect::<Vec<String>>()
4312                    .join(",")
4313                    .to_string(),
4314            )]),
4315        };
4316    }
4317    if let Some(ref local_var_str) = id__n {
4318        local_var_req_builder = match "multi" {
4319            "multi" => local_var_req_builder.query(
4320                &local_var_str
4321                    .into_iter()
4322                    .map(|p| ("id__n".to_owned(), p.to_string()))
4323                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4324            ),
4325            _ => local_var_req_builder.query(&[(
4326                "id__n",
4327                &local_var_str
4328                    .into_iter()
4329                    .map(|p| p.to_string())
4330                    .collect::<Vec<String>>()
4331                    .join(",")
4332                    .to_string(),
4333            )]),
4334        };
4335    }
4336    if let Some(ref local_var_str) = integrity_algorithm {
4337        local_var_req_builder = match "multi" {
4338            "multi" => local_var_req_builder.query(
4339                &local_var_str
4340                    .into_iter()
4341                    .map(|p| ("integrity_algorithm".to_owned(), p.to_string()))
4342                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4343            ),
4344            _ => local_var_req_builder.query(&[(
4345                "integrity_algorithm",
4346                &local_var_str
4347                    .into_iter()
4348                    .map(|p| p.to_string())
4349                    .collect::<Vec<String>>()
4350                    .join(",")
4351                    .to_string(),
4352            )]),
4353        };
4354    }
4355    if let Some(ref local_var_str) = last_updated {
4356        local_var_req_builder = match "multi" {
4357            "multi" => local_var_req_builder.query(
4358                &local_var_str
4359                    .into_iter()
4360                    .map(|p| ("last_updated".to_owned(), p.to_string()))
4361                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4362            ),
4363            _ => local_var_req_builder.query(&[(
4364                "last_updated",
4365                &local_var_str
4366                    .into_iter()
4367                    .map(|p| p.to_string())
4368                    .collect::<Vec<String>>()
4369                    .join(",")
4370                    .to_string(),
4371            )]),
4372        };
4373    }
4374    if let Some(ref local_var_str) = last_updated__gt {
4375        local_var_req_builder = match "multi" {
4376            "multi" => local_var_req_builder.query(
4377                &local_var_str
4378                    .into_iter()
4379                    .map(|p| ("last_updated__gt".to_owned(), p.to_string()))
4380                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4381            ),
4382            _ => local_var_req_builder.query(&[(
4383                "last_updated__gt",
4384                &local_var_str
4385                    .into_iter()
4386                    .map(|p| p.to_string())
4387                    .collect::<Vec<String>>()
4388                    .join(",")
4389                    .to_string(),
4390            )]),
4391        };
4392    }
4393    if let Some(ref local_var_str) = last_updated__gte {
4394        local_var_req_builder = match "multi" {
4395            "multi" => local_var_req_builder.query(
4396                &local_var_str
4397                    .into_iter()
4398                    .map(|p| ("last_updated__gte".to_owned(), p.to_string()))
4399                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4400            ),
4401            _ => local_var_req_builder.query(&[(
4402                "last_updated__gte",
4403                &local_var_str
4404                    .into_iter()
4405                    .map(|p| p.to_string())
4406                    .collect::<Vec<String>>()
4407                    .join(",")
4408                    .to_string(),
4409            )]),
4410        };
4411    }
4412    if let Some(ref local_var_str) = last_updated__isnull {
4413        local_var_req_builder =
4414            local_var_req_builder.query(&[("last_updated__isnull", &local_var_str.to_string())]);
4415    }
4416    if let Some(ref local_var_str) = last_updated__lt {
4417        local_var_req_builder = match "multi" {
4418            "multi" => local_var_req_builder.query(
4419                &local_var_str
4420                    .into_iter()
4421                    .map(|p| ("last_updated__lt".to_owned(), p.to_string()))
4422                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4423            ),
4424            _ => local_var_req_builder.query(&[(
4425                "last_updated__lt",
4426                &local_var_str
4427                    .into_iter()
4428                    .map(|p| p.to_string())
4429                    .collect::<Vec<String>>()
4430                    .join(",")
4431                    .to_string(),
4432            )]),
4433        };
4434    }
4435    if let Some(ref local_var_str) = last_updated__lte {
4436        local_var_req_builder = match "multi" {
4437            "multi" => local_var_req_builder.query(
4438                &local_var_str
4439                    .into_iter()
4440                    .map(|p| ("last_updated__lte".to_owned(), p.to_string()))
4441                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4442            ),
4443            _ => local_var_req_builder.query(&[(
4444                "last_updated__lte",
4445                &local_var_str
4446                    .into_iter()
4447                    .map(|p| p.to_string())
4448                    .collect::<Vec<String>>()
4449                    .join(",")
4450                    .to_string(),
4451            )]),
4452        };
4453    }
4454    if let Some(ref local_var_str) = last_updated__n {
4455        local_var_req_builder = match "multi" {
4456            "multi" => local_var_req_builder.query(
4457                &local_var_str
4458                    .into_iter()
4459                    .map(|p| ("last_updated__n".to_owned(), p.to_string()))
4460                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4461            ),
4462            _ => local_var_req_builder.query(&[(
4463                "last_updated__n",
4464                &local_var_str
4465                    .into_iter()
4466                    .map(|p| p.to_string())
4467                    .collect::<Vec<String>>()
4468                    .join(",")
4469                    .to_string(),
4470            )]),
4471        };
4472    }
4473    if let Some(ref local_var_str) = lifetime {
4474        local_var_req_builder = match "multi" {
4475            "multi" => local_var_req_builder.query(
4476                &local_var_str
4477                    .into_iter()
4478                    .map(|p| ("lifetime".to_owned(), p.to_string()))
4479                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4480            ),
4481            _ => local_var_req_builder.query(&[(
4482                "lifetime",
4483                &local_var_str
4484                    .into_iter()
4485                    .map(|p| p.to_string())
4486                    .collect::<Vec<String>>()
4487                    .join(",")
4488                    .to_string(),
4489            )]),
4490        };
4491    }
4492    if let Some(ref local_var_str) = lifetime__gt {
4493        local_var_req_builder = match "multi" {
4494            "multi" => local_var_req_builder.query(
4495                &local_var_str
4496                    .into_iter()
4497                    .map(|p| ("lifetime__gt".to_owned(), p.to_string()))
4498                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4499            ),
4500            _ => local_var_req_builder.query(&[(
4501                "lifetime__gt",
4502                &local_var_str
4503                    .into_iter()
4504                    .map(|p| p.to_string())
4505                    .collect::<Vec<String>>()
4506                    .join(",")
4507                    .to_string(),
4508            )]),
4509        };
4510    }
4511    if let Some(ref local_var_str) = lifetime__gte {
4512        local_var_req_builder = match "multi" {
4513            "multi" => local_var_req_builder.query(
4514                &local_var_str
4515                    .into_iter()
4516                    .map(|p| ("lifetime__gte".to_owned(), p.to_string()))
4517                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4518            ),
4519            _ => local_var_req_builder.query(&[(
4520                "lifetime__gte",
4521                &local_var_str
4522                    .into_iter()
4523                    .map(|p| p.to_string())
4524                    .collect::<Vec<String>>()
4525                    .join(",")
4526                    .to_string(),
4527            )]),
4528        };
4529    }
4530    if let Some(ref local_var_str) = lifetime__isnull {
4531        local_var_req_builder =
4532            local_var_req_builder.query(&[("lifetime__isnull", &local_var_str.to_string())]);
4533    }
4534    if let Some(ref local_var_str) = lifetime__lt {
4535        local_var_req_builder = match "multi" {
4536            "multi" => local_var_req_builder.query(
4537                &local_var_str
4538                    .into_iter()
4539                    .map(|p| ("lifetime__lt".to_owned(), p.to_string()))
4540                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4541            ),
4542            _ => local_var_req_builder.query(&[(
4543                "lifetime__lt",
4544                &local_var_str
4545                    .into_iter()
4546                    .map(|p| p.to_string())
4547                    .collect::<Vec<String>>()
4548                    .join(",")
4549                    .to_string(),
4550            )]),
4551        };
4552    }
4553    if let Some(ref local_var_str) = lifetime__lte {
4554        local_var_req_builder = match "multi" {
4555            "multi" => local_var_req_builder.query(
4556                &local_var_str
4557                    .into_iter()
4558                    .map(|p| ("lifetime__lte".to_owned(), p.to_string()))
4559                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4560            ),
4561            _ => local_var_req_builder.query(&[(
4562                "lifetime__lte",
4563                &local_var_str
4564                    .into_iter()
4565                    .map(|p| p.to_string())
4566                    .collect::<Vec<String>>()
4567                    .join(",")
4568                    .to_string(),
4569            )]),
4570        };
4571    }
4572    if let Some(ref local_var_str) = lifetime__n {
4573        local_var_req_builder = match "multi" {
4574            "multi" => local_var_req_builder.query(
4575                &local_var_str
4576                    .into_iter()
4577                    .map(|p| ("lifetime__n".to_owned(), p.to_string()))
4578                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4579            ),
4580            _ => local_var_req_builder.query(&[(
4581                "lifetime__n",
4582                &local_var_str
4583                    .into_iter()
4584                    .map(|p| p.to_string())
4585                    .collect::<Vec<String>>()
4586                    .join(",")
4587                    .to_string(),
4588            )]),
4589        };
4590    }
4591    if let Some(ref local_var_str) = limit {
4592        local_var_req_builder =
4593            local_var_req_builder.query(&[("limit", &local_var_str.to_string())]);
4594    }
4595    if let Some(ref local_var_str) = name {
4596        local_var_req_builder = match "multi" {
4597            "multi" => local_var_req_builder.query(
4598                &local_var_str
4599                    .into_iter()
4600                    .map(|p| ("name".to_owned(), p.to_string()))
4601                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4602            ),
4603            _ => local_var_req_builder.query(&[(
4604                "name",
4605                &local_var_str
4606                    .into_iter()
4607                    .map(|p| p.to_string())
4608                    .collect::<Vec<String>>()
4609                    .join(",")
4610                    .to_string(),
4611            )]),
4612        };
4613    }
4614    if let Some(ref local_var_str) = name__ic {
4615        local_var_req_builder = match "multi" {
4616            "multi" => local_var_req_builder.query(
4617                &local_var_str
4618                    .into_iter()
4619                    .map(|p| ("name__ic".to_owned(), p.to_string()))
4620                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4621            ),
4622            _ => local_var_req_builder.query(&[(
4623                "name__ic",
4624                &local_var_str
4625                    .into_iter()
4626                    .map(|p| p.to_string())
4627                    .collect::<Vec<String>>()
4628                    .join(",")
4629                    .to_string(),
4630            )]),
4631        };
4632    }
4633    if let Some(ref local_var_str) = name__ie {
4634        local_var_req_builder = match "multi" {
4635            "multi" => local_var_req_builder.query(
4636                &local_var_str
4637                    .into_iter()
4638                    .map(|p| ("name__ie".to_owned(), p.to_string()))
4639                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4640            ),
4641            _ => local_var_req_builder.query(&[(
4642                "name__ie",
4643                &local_var_str
4644                    .into_iter()
4645                    .map(|p| p.to_string())
4646                    .collect::<Vec<String>>()
4647                    .join(",")
4648                    .to_string(),
4649            )]),
4650        };
4651    }
4652    if let Some(ref local_var_str) = name__iew {
4653        local_var_req_builder = match "multi" {
4654            "multi" => local_var_req_builder.query(
4655                &local_var_str
4656                    .into_iter()
4657                    .map(|p| ("name__iew".to_owned(), p.to_string()))
4658                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4659            ),
4660            _ => local_var_req_builder.query(&[(
4661                "name__iew",
4662                &local_var_str
4663                    .into_iter()
4664                    .map(|p| p.to_string())
4665                    .collect::<Vec<String>>()
4666                    .join(",")
4667                    .to_string(),
4668            )]),
4669        };
4670    }
4671    if let Some(ref local_var_str) = name__ire {
4672        local_var_req_builder = match "multi" {
4673            "multi" => local_var_req_builder.query(
4674                &local_var_str
4675                    .into_iter()
4676                    .map(|p| ("name__ire".to_owned(), p.to_string()))
4677                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4678            ),
4679            _ => local_var_req_builder.query(&[(
4680                "name__ire",
4681                &local_var_str
4682                    .into_iter()
4683                    .map(|p| p.to_string())
4684                    .collect::<Vec<String>>()
4685                    .join(",")
4686                    .to_string(),
4687            )]),
4688        };
4689    }
4690    if let Some(ref local_var_str) = name__isw {
4691        local_var_req_builder = match "multi" {
4692            "multi" => local_var_req_builder.query(
4693                &local_var_str
4694                    .into_iter()
4695                    .map(|p| ("name__isw".to_owned(), p.to_string()))
4696                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4697            ),
4698            _ => local_var_req_builder.query(&[(
4699                "name__isw",
4700                &local_var_str
4701                    .into_iter()
4702                    .map(|p| p.to_string())
4703                    .collect::<Vec<String>>()
4704                    .join(",")
4705                    .to_string(),
4706            )]),
4707        };
4708    }
4709    if let Some(ref local_var_str) = name__n {
4710        local_var_req_builder = match "multi" {
4711            "multi" => local_var_req_builder.query(
4712                &local_var_str
4713                    .into_iter()
4714                    .map(|p| ("name__n".to_owned(), p.to_string()))
4715                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4716            ),
4717            _ => local_var_req_builder.query(&[(
4718                "name__n",
4719                &local_var_str
4720                    .into_iter()
4721                    .map(|p| p.to_string())
4722                    .collect::<Vec<String>>()
4723                    .join(",")
4724                    .to_string(),
4725            )]),
4726        };
4727    }
4728    if let Some(ref local_var_str) = name__nic {
4729        local_var_req_builder = match "multi" {
4730            "multi" => local_var_req_builder.query(
4731                &local_var_str
4732                    .into_iter()
4733                    .map(|p| ("name__nic".to_owned(), p.to_string()))
4734                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4735            ),
4736            _ => local_var_req_builder.query(&[(
4737                "name__nic",
4738                &local_var_str
4739                    .into_iter()
4740                    .map(|p| p.to_string())
4741                    .collect::<Vec<String>>()
4742                    .join(",")
4743                    .to_string(),
4744            )]),
4745        };
4746    }
4747    if let Some(ref local_var_str) = name__nie {
4748        local_var_req_builder = match "multi" {
4749            "multi" => local_var_req_builder.query(
4750                &local_var_str
4751                    .into_iter()
4752                    .map(|p| ("name__nie".to_owned(), p.to_string()))
4753                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4754            ),
4755            _ => local_var_req_builder.query(&[(
4756                "name__nie",
4757                &local_var_str
4758                    .into_iter()
4759                    .map(|p| p.to_string())
4760                    .collect::<Vec<String>>()
4761                    .join(",")
4762                    .to_string(),
4763            )]),
4764        };
4765    }
4766    if let Some(ref local_var_str) = name__niew {
4767        local_var_req_builder = match "multi" {
4768            "multi" => local_var_req_builder.query(
4769                &local_var_str
4770                    .into_iter()
4771                    .map(|p| ("name__niew".to_owned(), p.to_string()))
4772                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4773            ),
4774            _ => local_var_req_builder.query(&[(
4775                "name__niew",
4776                &local_var_str
4777                    .into_iter()
4778                    .map(|p| p.to_string())
4779                    .collect::<Vec<String>>()
4780                    .join(",")
4781                    .to_string(),
4782            )]),
4783        };
4784    }
4785    if let Some(ref local_var_str) = name__nire {
4786        local_var_req_builder = match "multi" {
4787            "multi" => local_var_req_builder.query(
4788                &local_var_str
4789                    .into_iter()
4790                    .map(|p| ("name__nire".to_owned(), p.to_string()))
4791                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4792            ),
4793            _ => local_var_req_builder.query(&[(
4794                "name__nire",
4795                &local_var_str
4796                    .into_iter()
4797                    .map(|p| p.to_string())
4798                    .collect::<Vec<String>>()
4799                    .join(",")
4800                    .to_string(),
4801            )]),
4802        };
4803    }
4804    if let Some(ref local_var_str) = name__nisw {
4805        local_var_req_builder = match "multi" {
4806            "multi" => local_var_req_builder.query(
4807                &local_var_str
4808                    .into_iter()
4809                    .map(|p| ("name__nisw".to_owned(), p.to_string()))
4810                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4811            ),
4812            _ => local_var_req_builder.query(&[(
4813                "name__nisw",
4814                &local_var_str
4815                    .into_iter()
4816                    .map(|p| p.to_string())
4817                    .collect::<Vec<String>>()
4818                    .join(",")
4819                    .to_string(),
4820            )]),
4821        };
4822    }
4823    if let Some(ref local_var_str) = name__nre {
4824        local_var_req_builder = match "multi" {
4825            "multi" => local_var_req_builder.query(
4826                &local_var_str
4827                    .into_iter()
4828                    .map(|p| ("name__nre".to_owned(), p.to_string()))
4829                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4830            ),
4831            _ => local_var_req_builder.query(&[(
4832                "name__nre",
4833                &local_var_str
4834                    .into_iter()
4835                    .map(|p| p.to_string())
4836                    .collect::<Vec<String>>()
4837                    .join(",")
4838                    .to_string(),
4839            )]),
4840        };
4841    }
4842    if let Some(ref local_var_str) = name__re {
4843        local_var_req_builder = match "multi" {
4844            "multi" => local_var_req_builder.query(
4845                &local_var_str
4846                    .into_iter()
4847                    .map(|p| ("name__re".to_owned(), p.to_string()))
4848                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4849            ),
4850            _ => local_var_req_builder.query(&[(
4851                "name__re",
4852                &local_var_str
4853                    .into_iter()
4854                    .map(|p| p.to_string())
4855                    .collect::<Vec<String>>()
4856                    .join(",")
4857                    .to_string(),
4858            )]),
4859        };
4860    }
4861    if let Some(ref local_var_str) = offset {
4862        local_var_req_builder =
4863            local_var_req_builder.query(&[("offset", &local_var_str.to_string())]);
4864    }
4865    if let Some(ref local_var_str) = pfs_group {
4866        local_var_req_builder = match "multi" {
4867            "multi" => local_var_req_builder.query(
4868                &local_var_str
4869                    .into_iter()
4870                    .map(|p| ("pfs_group".to_owned(), p.to_string()))
4871                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4872            ),
4873            _ => local_var_req_builder.query(&[(
4874                "pfs_group",
4875                &local_var_str
4876                    .into_iter()
4877                    .map(|p| p.to_string())
4878                    .collect::<Vec<String>>()
4879                    .join(",")
4880                    .to_string(),
4881            )]),
4882        };
4883    }
4884    if let Some(ref local_var_str) = q {
4885        local_var_req_builder = local_var_req_builder.query(&[("q", &local_var_str.to_string())]);
4886    }
4887    if let Some(ref local_var_str) = sort {
4888        local_var_req_builder =
4889            local_var_req_builder.query(&[("sort", &local_var_str.to_string())]);
4890    }
4891    if let Some(ref local_var_str) = tags {
4892        local_var_req_builder = match "multi" {
4893            "multi" => local_var_req_builder.query(
4894                &local_var_str
4895                    .into_iter()
4896                    .map(|p| ("tags".to_owned(), p.to_string()))
4897                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4898            ),
4899            _ => local_var_req_builder.query(&[(
4900                "tags",
4901                &local_var_str
4902                    .into_iter()
4903                    .map(|p| p.to_string())
4904                    .collect::<Vec<String>>()
4905                    .join(",")
4906                    .to_string(),
4907            )]),
4908        };
4909    }
4910    if let Some(ref local_var_str) = tags__isnull {
4911        local_var_req_builder =
4912            local_var_req_builder.query(&[("tags__isnull", &local_var_str.to_string())]);
4913    }
4914    if let Some(ref local_var_str) = tags__n {
4915        local_var_req_builder = match "multi" {
4916            "multi" => local_var_req_builder.query(
4917                &local_var_str
4918                    .into_iter()
4919                    .map(|p| ("tags__n".to_owned(), p.to_string()))
4920                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4921            ),
4922            _ => local_var_req_builder.query(&[(
4923                "tags__n",
4924                &local_var_str
4925                    .into_iter()
4926                    .map(|p| p.to_string())
4927                    .collect::<Vec<String>>()
4928                    .join(",")
4929                    .to_string(),
4930            )]),
4931        };
4932    }
4933    if let Some(ref local_var_str) = teams {
4934        local_var_req_builder = match "multi" {
4935            "multi" => local_var_req_builder.query(
4936                &local_var_str
4937                    .into_iter()
4938                    .map(|p| ("teams".to_owned(), p.to_string()))
4939                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4940            ),
4941            _ => local_var_req_builder.query(&[(
4942                "teams",
4943                &local_var_str
4944                    .into_iter()
4945                    .map(|p| p.to_string())
4946                    .collect::<Vec<String>>()
4947                    .join(",")
4948                    .to_string(),
4949            )]),
4950        };
4951    }
4952    if let Some(ref local_var_str) = teams__isnull {
4953        local_var_req_builder =
4954            local_var_req_builder.query(&[("teams__isnull", &local_var_str.to_string())]);
4955    }
4956    if let Some(ref local_var_str) = teams__n {
4957        local_var_req_builder = match "multi" {
4958            "multi" => local_var_req_builder.query(
4959                &local_var_str
4960                    .into_iter()
4961                    .map(|p| ("teams__n".to_owned(), p.to_string()))
4962                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4963            ),
4964            _ => local_var_req_builder.query(&[(
4965                "teams__n",
4966                &local_var_str
4967                    .into_iter()
4968                    .map(|p| p.to_string())
4969                    .collect::<Vec<String>>()
4970                    .join(",")
4971                    .to_string(),
4972            )]),
4973        };
4974    }
4975    if let Some(ref local_var_str) = tenant {
4976        local_var_req_builder = match "multi" {
4977            "multi" => local_var_req_builder.query(
4978                &local_var_str
4979                    .into_iter()
4980                    .map(|p| ("tenant".to_owned(), p.to_string()))
4981                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4982            ),
4983            _ => local_var_req_builder.query(&[(
4984                "tenant",
4985                &local_var_str
4986                    .into_iter()
4987                    .map(|p| p.to_string())
4988                    .collect::<Vec<String>>()
4989                    .join(",")
4990                    .to_string(),
4991            )]),
4992        };
4993    }
4994    if let Some(ref local_var_str) = tenant__isnull {
4995        local_var_req_builder =
4996            local_var_req_builder.query(&[("tenant__isnull", &local_var_str.to_string())]);
4997    }
4998    if let Some(ref local_var_str) = tenant__n {
4999        local_var_req_builder = match "multi" {
5000            "multi" => local_var_req_builder.query(
5001                &local_var_str
5002                    .into_iter()
5003                    .map(|p| ("tenant__n".to_owned(), p.to_string()))
5004                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5005            ),
5006            _ => local_var_req_builder.query(&[(
5007                "tenant__n",
5008                &local_var_str
5009                    .into_iter()
5010                    .map(|p| p.to_string())
5011                    .collect::<Vec<String>>()
5012                    .join(",")
5013                    .to_string(),
5014            )]),
5015        };
5016    }
5017    if let Some(ref local_var_str) = tenant_group {
5018        local_var_req_builder = match "multi" {
5019            "multi" => local_var_req_builder.query(
5020                &local_var_str
5021                    .into_iter()
5022                    .map(|p| ("tenant_group".to_owned(), p.to_string()))
5023                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5024            ),
5025            _ => local_var_req_builder.query(&[(
5026                "tenant_group",
5027                &local_var_str
5028                    .into_iter()
5029                    .map(|p| p.to_string())
5030                    .collect::<Vec<String>>()
5031                    .join(",")
5032                    .to_string(),
5033            )]),
5034        };
5035    }
5036    if let Some(ref local_var_str) = tenant_group__isnull {
5037        local_var_req_builder =
5038            local_var_req_builder.query(&[("tenant_group__isnull", &local_var_str.to_string())]);
5039    }
5040    if let Some(ref local_var_str) = tenant_group__n {
5041        local_var_req_builder = match "multi" {
5042            "multi" => local_var_req_builder.query(
5043                &local_var_str
5044                    .into_iter()
5045                    .map(|p| ("tenant_group__n".to_owned(), p.to_string()))
5046                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5047            ),
5048            _ => local_var_req_builder.query(&[(
5049                "tenant_group__n",
5050                &local_var_str
5051                    .into_iter()
5052                    .map(|p| p.to_string())
5053                    .collect::<Vec<String>>()
5054                    .join(",")
5055                    .to_string(),
5056            )]),
5057        };
5058    }
5059    if let Some(ref local_var_str) = tenant_id {
5060        local_var_req_builder = match "multi" {
5061            "multi" => local_var_req_builder.query(
5062                &local_var_str
5063                    .into_iter()
5064                    .map(|p| ("tenant_id".to_owned(), p.to_string()))
5065                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5066            ),
5067            _ => local_var_req_builder.query(&[(
5068                "tenant_id",
5069                &local_var_str
5070                    .into_iter()
5071                    .map(|p| p.to_string())
5072                    .collect::<Vec<String>>()
5073                    .join(",")
5074                    .to_string(),
5075            )]),
5076        };
5077    }
5078    if let Some(ref local_var_str) = tenant_id__isnull {
5079        local_var_req_builder =
5080            local_var_req_builder.query(&[("tenant_id__isnull", &local_var_str.to_string())]);
5081    }
5082    if let Some(ref local_var_str) = tenant_id__n {
5083        local_var_req_builder = match "multi" {
5084            "multi" => local_var_req_builder.query(
5085                &local_var_str
5086                    .into_iter()
5087                    .map(|p| ("tenant_id__n".to_owned(), p.to_string()))
5088                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5089            ),
5090            _ => local_var_req_builder.query(&[(
5091                "tenant_id__n",
5092                &local_var_str
5093                    .into_iter()
5094                    .map(|p| p.to_string())
5095                    .collect::<Vec<String>>()
5096                    .join(",")
5097                    .to_string(),
5098            )]),
5099        };
5100    }
5101    if let Some(ref local_var_str) = vpn_profiles {
5102        local_var_req_builder = match "multi" {
5103            "multi" => local_var_req_builder.query(
5104                &local_var_str
5105                    .into_iter()
5106                    .map(|p| ("vpn_profiles".to_owned(), p.to_string()))
5107                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5108            ),
5109            _ => local_var_req_builder.query(&[(
5110                "vpn_profiles",
5111                &local_var_str
5112                    .into_iter()
5113                    .map(|p| p.to_string())
5114                    .collect::<Vec<String>>()
5115                    .join(",")
5116                    .to_string(),
5117            )]),
5118        };
5119    }
5120    if let Some(ref local_var_str) = vpn_profiles__isnull {
5121        local_var_req_builder =
5122            local_var_req_builder.query(&[("vpn_profiles__isnull", &local_var_str.to_string())]);
5123    }
5124    if let Some(ref local_var_str) = vpn_profiles__n {
5125        local_var_req_builder = match "multi" {
5126            "multi" => local_var_req_builder.query(
5127                &local_var_str
5128                    .into_iter()
5129                    .map(|p| ("vpn_profiles__n".to_owned(), p.to_string()))
5130                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5131            ),
5132            _ => local_var_req_builder.query(&[(
5133                "vpn_profiles__n",
5134                &local_var_str
5135                    .into_iter()
5136                    .map(|p| p.to_string())
5137                    .collect::<Vec<String>>()
5138                    .join(",")
5139                    .to_string(),
5140            )]),
5141        };
5142    }
5143    if let Some(ref local_var_str) = depth {
5144        local_var_req_builder =
5145            local_var_req_builder.query(&[("depth", &local_var_str.to_string())]);
5146    }
5147    if let Some(ref local_var_str) = exclude_m2m {
5148        local_var_req_builder =
5149            local_var_req_builder.query(&[("exclude_m2m", &local_var_str.to_string())]);
5150    }
5151    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
5152        local_var_req_builder =
5153            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
5154    }
5155    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
5156        let local_var_key = local_var_apikey.key.clone();
5157        let local_var_value = match local_var_apikey.prefix {
5158            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
5159            None => local_var_key,
5160        };
5161        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
5162    };
5163
5164    let local_var_req = local_var_req_builder.build()?;
5165    let local_var_resp = local_var_client.execute(local_var_req).await?;
5166
5167    let local_var_status = local_var_resp.status();
5168    let local_var_content = local_var_resp.text().await?;
5169
5170    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
5171        serde_json::from_str(&local_var_content).map_err(Error::from)
5172    } else {
5173        let local_var_entity: Option<VpnVpnPhase2PoliciesListError> =
5174            serde_json::from_str(&local_var_content).ok();
5175        let local_var_error = ResponseContent {
5176            status: local_var_status,
5177            content: local_var_content,
5178            entity: local_var_entity,
5179        };
5180        Err(Error::ResponseError(local_var_error))
5181    }
5182}
5183
5184/// API methods for returning or creating notes on an object.
5185pub async fn vpn_vpn_phase2_policies_notes_create(
5186    configuration: &configuration::Configuration,
5187    id: &str,
5188    note_input_request: crate::models::NoteInputRequest,
5189    format: Option<&str>,
5190) -> Result<crate::models::Note, Error<VpnVpnPhase2PoliciesNotesCreateError>> {
5191    let local_var_configuration = configuration;
5192
5193    let local_var_client = &local_var_configuration.client;
5194
5195    let local_var_uri_str = format!(
5196        "{}/vpn/vpn-phase-2-policies/{id}/notes/",
5197        local_var_configuration.base_path,
5198        id = crate::apis::urlencode(id)
5199    );
5200    let mut local_var_req_builder =
5201        local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
5202
5203    if let Some(ref local_var_str) = format {
5204        local_var_req_builder =
5205            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
5206    }
5207    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
5208        local_var_req_builder =
5209            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
5210    }
5211    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
5212        let local_var_key = local_var_apikey.key.clone();
5213        let local_var_value = match local_var_apikey.prefix {
5214            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
5215            None => local_var_key,
5216        };
5217        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
5218    };
5219    local_var_req_builder = local_var_req_builder.json(&note_input_request);
5220
5221    let local_var_req = local_var_req_builder.build()?;
5222    let local_var_resp = local_var_client.execute(local_var_req).await?;
5223
5224    let local_var_status = local_var_resp.status();
5225    let local_var_content = local_var_resp.text().await?;
5226
5227    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
5228        serde_json::from_str(&local_var_content).map_err(Error::from)
5229    } else {
5230        let local_var_entity: Option<VpnVpnPhase2PoliciesNotesCreateError> =
5231            serde_json::from_str(&local_var_content).ok();
5232        let local_var_error = ResponseContent {
5233            status: local_var_status,
5234            content: local_var_content,
5235            entity: local_var_entity,
5236        };
5237        Err(Error::ResponseError(local_var_error))
5238    }
5239}
5240
5241/// API methods for returning or creating notes on an object.
5242pub async fn vpn_vpn_phase2_policies_notes_list(
5243    configuration: &configuration::Configuration,
5244    id: &str,
5245    format: Option<&str>,
5246    limit: Option<i32>,
5247    offset: Option<i32>,
5248    depth: Option<i32>,
5249    exclude_m2m: Option<bool>,
5250) -> Result<crate::models::PaginatedNoteList, Error<VpnVpnPhase2PoliciesNotesListError>> {
5251    let local_var_configuration = configuration;
5252
5253    let local_var_client = &local_var_configuration.client;
5254
5255    let local_var_uri_str = format!(
5256        "{}/vpn/vpn-phase-2-policies/{id}/notes/",
5257        local_var_configuration.base_path,
5258        id = crate::apis::urlencode(id)
5259    );
5260    let mut local_var_req_builder =
5261        local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
5262
5263    if let Some(ref local_var_str) = format {
5264        local_var_req_builder =
5265            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
5266    }
5267    if let Some(ref local_var_str) = limit {
5268        local_var_req_builder =
5269            local_var_req_builder.query(&[("limit", &local_var_str.to_string())]);
5270    }
5271    if let Some(ref local_var_str) = offset {
5272        local_var_req_builder =
5273            local_var_req_builder.query(&[("offset", &local_var_str.to_string())]);
5274    }
5275    if let Some(ref local_var_str) = depth {
5276        local_var_req_builder =
5277            local_var_req_builder.query(&[("depth", &local_var_str.to_string())]);
5278    }
5279    if let Some(ref local_var_str) = exclude_m2m {
5280        local_var_req_builder =
5281            local_var_req_builder.query(&[("exclude_m2m", &local_var_str.to_string())]);
5282    }
5283    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
5284        local_var_req_builder =
5285            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
5286    }
5287    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
5288        let local_var_key = local_var_apikey.key.clone();
5289        let local_var_value = match local_var_apikey.prefix {
5290            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
5291            None => local_var_key,
5292        };
5293        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
5294    };
5295
5296    let local_var_req = local_var_req_builder.build()?;
5297    let local_var_resp = local_var_client.execute(local_var_req).await?;
5298
5299    let local_var_status = local_var_resp.status();
5300    let local_var_content = local_var_resp.text().await?;
5301
5302    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
5303        serde_json::from_str(&local_var_content).map_err(Error::from)
5304    } else {
5305        let local_var_entity: Option<VpnVpnPhase2PoliciesNotesListError> =
5306            serde_json::from_str(&local_var_content).ok();
5307        let local_var_error = ResponseContent {
5308            status: local_var_status,
5309            content: local_var_content,
5310            entity: local_var_entity,
5311        };
5312        Err(Error::ResponseError(local_var_error))
5313    }
5314}
5315
5316/// VPNPhase2Policy viewset.
5317pub async fn vpn_vpn_phase2_policies_partial_update(
5318    configuration: &configuration::Configuration,
5319    id: &str,
5320    format: Option<&str>,
5321    patched_vpn_phase2_policy_request: Option<crate::models::PatchedVpnPhase2PolicyRequest>,
5322) -> Result<crate::models::VpnPhase2Policy, Error<VpnVpnPhase2PoliciesPartialUpdateError>> {
5323    let local_var_configuration = configuration;
5324
5325    let local_var_client = &local_var_configuration.client;
5326
5327    let local_var_uri_str = format!(
5328        "{}/vpn/vpn-phase-2-policies/{id}/",
5329        local_var_configuration.base_path,
5330        id = crate::apis::urlencode(id)
5331    );
5332    let mut local_var_req_builder =
5333        local_var_client.request(reqwest::Method::PATCH, local_var_uri_str.as_str());
5334
5335    if let Some(ref local_var_str) = format {
5336        local_var_req_builder =
5337            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
5338    }
5339    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
5340        local_var_req_builder =
5341            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
5342    }
5343    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
5344        let local_var_key = local_var_apikey.key.clone();
5345        let local_var_value = match local_var_apikey.prefix {
5346            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
5347            None => local_var_key,
5348        };
5349        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
5350    };
5351    local_var_req_builder = local_var_req_builder.json(&patched_vpn_phase2_policy_request);
5352
5353    let local_var_req = local_var_req_builder.build()?;
5354    let local_var_resp = local_var_client.execute(local_var_req).await?;
5355
5356    let local_var_status = local_var_resp.status();
5357    let local_var_content = local_var_resp.text().await?;
5358
5359    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
5360        serde_json::from_str(&local_var_content).map_err(Error::from)
5361    } else {
5362        let local_var_entity: Option<VpnVpnPhase2PoliciesPartialUpdateError> =
5363            serde_json::from_str(&local_var_content).ok();
5364        let local_var_error = ResponseContent {
5365            status: local_var_status,
5366            content: local_var_content,
5367            entity: local_var_entity,
5368        };
5369        Err(Error::ResponseError(local_var_error))
5370    }
5371}
5372
5373/// VPNPhase2Policy viewset.
5374pub async fn vpn_vpn_phase2_policies_retrieve(
5375    configuration: &configuration::Configuration,
5376    id: &str,
5377    format: Option<&str>,
5378    depth: Option<i32>,
5379    exclude_m2m: Option<bool>,
5380) -> Result<crate::models::VpnPhase2Policy, Error<VpnVpnPhase2PoliciesRetrieveError>> {
5381    let local_var_configuration = configuration;
5382
5383    let local_var_client = &local_var_configuration.client;
5384
5385    let local_var_uri_str = format!(
5386        "{}/vpn/vpn-phase-2-policies/{id}/",
5387        local_var_configuration.base_path,
5388        id = crate::apis::urlencode(id)
5389    );
5390    let mut local_var_req_builder =
5391        local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
5392
5393    if let Some(ref local_var_str) = format {
5394        local_var_req_builder =
5395            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
5396    }
5397    if let Some(ref local_var_str) = depth {
5398        local_var_req_builder =
5399            local_var_req_builder.query(&[("depth", &local_var_str.to_string())]);
5400    }
5401    if let Some(ref local_var_str) = exclude_m2m {
5402        local_var_req_builder =
5403            local_var_req_builder.query(&[("exclude_m2m", &local_var_str.to_string())]);
5404    }
5405    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
5406        local_var_req_builder =
5407            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
5408    }
5409    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
5410        let local_var_key = local_var_apikey.key.clone();
5411        let local_var_value = match local_var_apikey.prefix {
5412            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
5413            None => local_var_key,
5414        };
5415        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
5416    };
5417
5418    let local_var_req = local_var_req_builder.build()?;
5419    let local_var_resp = local_var_client.execute(local_var_req).await?;
5420
5421    let local_var_status = local_var_resp.status();
5422    let local_var_content = local_var_resp.text().await?;
5423
5424    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
5425        serde_json::from_str(&local_var_content).map_err(Error::from)
5426    } else {
5427        let local_var_entity: Option<VpnVpnPhase2PoliciesRetrieveError> =
5428            serde_json::from_str(&local_var_content).ok();
5429        let local_var_error = ResponseContent {
5430            status: local_var_status,
5431            content: local_var_content,
5432            entity: local_var_entity,
5433        };
5434        Err(Error::ResponseError(local_var_error))
5435    }
5436}
5437
5438/// VPNPhase2Policy viewset.
5439pub async fn vpn_vpn_phase2_policies_update(
5440    configuration: &configuration::Configuration,
5441    id: &str,
5442    vpn_phase2_policy_request: crate::models::VpnPhase2PolicyRequest,
5443    format: Option<&str>,
5444) -> Result<crate::models::VpnPhase2Policy, Error<VpnVpnPhase2PoliciesUpdateError>> {
5445    let local_var_configuration = configuration;
5446
5447    let local_var_client = &local_var_configuration.client;
5448
5449    let local_var_uri_str = format!(
5450        "{}/vpn/vpn-phase-2-policies/{id}/",
5451        local_var_configuration.base_path,
5452        id = crate::apis::urlencode(id)
5453    );
5454    let mut local_var_req_builder =
5455        local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());
5456
5457    if let Some(ref local_var_str) = format {
5458        local_var_req_builder =
5459            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
5460    }
5461    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
5462        local_var_req_builder =
5463            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
5464    }
5465    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
5466        let local_var_key = local_var_apikey.key.clone();
5467        let local_var_value = match local_var_apikey.prefix {
5468            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
5469            None => local_var_key,
5470        };
5471        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
5472    };
5473    local_var_req_builder = local_var_req_builder.json(&vpn_phase2_policy_request);
5474
5475    let local_var_req = local_var_req_builder.build()?;
5476    let local_var_resp = local_var_client.execute(local_var_req).await?;
5477
5478    let local_var_status = local_var_resp.status();
5479    let local_var_content = local_var_resp.text().await?;
5480
5481    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
5482        serde_json::from_str(&local_var_content).map_err(Error::from)
5483    } else {
5484        let local_var_entity: Option<VpnVpnPhase2PoliciesUpdateError> =
5485            serde_json::from_str(&local_var_content).ok();
5486        let local_var_error = ResponseContent {
5487            status: local_var_status,
5488            content: local_var_content,
5489            entity: local_var_entity,
5490        };
5491        Err(Error::ResponseError(local_var_error))
5492    }
5493}
5494
5495/// VPNProfilePhase1PolicyAssignment viewset.
5496pub async fn vpn_vpn_profile_phase1_policy_assignments_bulk_destroy(
5497    configuration: &configuration::Configuration,
5498    bulk_operation_request: Vec<crate::models::BulkOperationRequest>,
5499    format: Option<&str>,
5500) -> Result<(), Error<VpnVpnProfilePhase1PolicyAssignmentsBulkDestroyError>> {
5501    let local_var_configuration = configuration;
5502
5503    let local_var_client = &local_var_configuration.client;
5504
5505    let local_var_uri_str = format!(
5506        "{}/vpn/vpn-profile-phase-1-policy-assignments/",
5507        local_var_configuration.base_path
5508    );
5509    let mut local_var_req_builder =
5510        local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());
5511
5512    if let Some(ref local_var_str) = format {
5513        local_var_req_builder =
5514            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
5515    }
5516    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
5517        local_var_req_builder =
5518            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
5519    }
5520    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
5521        let local_var_key = local_var_apikey.key.clone();
5522        let local_var_value = match local_var_apikey.prefix {
5523            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
5524            None => local_var_key,
5525        };
5526        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
5527    };
5528    local_var_req_builder = local_var_req_builder.json(&bulk_operation_request);
5529
5530    let local_var_req = local_var_req_builder.build()?;
5531    let local_var_resp = local_var_client.execute(local_var_req).await?;
5532
5533    let local_var_status = local_var_resp.status();
5534    let local_var_content = local_var_resp.text().await?;
5535
5536    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
5537        Ok(())
5538    } else {
5539        let local_var_entity: Option<VpnVpnProfilePhase1PolicyAssignmentsBulkDestroyError> =
5540            serde_json::from_str(&local_var_content).ok();
5541        let local_var_error = ResponseContent {
5542            status: local_var_status,
5543            content: local_var_content,
5544            entity: local_var_entity,
5545        };
5546        Err(Error::ResponseError(local_var_error))
5547    }
5548}
5549
5550/// VPNProfilePhase1PolicyAssignment viewset.
5551pub async fn vpn_vpn_profile_phase1_policy_assignments_bulk_partial_update(
5552    configuration: &configuration::Configuration,
5553    patched_bulk_writable_vpn_profile_phase1_policy_assignment_request: Vec<
5554        crate::models::PatchedBulkWritableVpnProfilePhase1PolicyAssignmentRequest,
5555    >,
5556    format: Option<&str>,
5557) -> Result<
5558    Vec<crate::models::VpnProfilePhase1PolicyAssignment>,
5559    Error<VpnVpnProfilePhase1PolicyAssignmentsBulkPartialUpdateError>,
5560> {
5561    let local_var_configuration = configuration;
5562
5563    let local_var_client = &local_var_configuration.client;
5564
5565    let local_var_uri_str = format!(
5566        "{}/vpn/vpn-profile-phase-1-policy-assignments/",
5567        local_var_configuration.base_path
5568    );
5569    let mut local_var_req_builder =
5570        local_var_client.request(reqwest::Method::PATCH, local_var_uri_str.as_str());
5571
5572    if let Some(ref local_var_str) = format {
5573        local_var_req_builder =
5574            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
5575    }
5576    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
5577        local_var_req_builder =
5578            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
5579    }
5580    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
5581        let local_var_key = local_var_apikey.key.clone();
5582        let local_var_value = match local_var_apikey.prefix {
5583            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
5584            None => local_var_key,
5585        };
5586        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
5587    };
5588    local_var_req_builder = local_var_req_builder
5589        .json(&patched_bulk_writable_vpn_profile_phase1_policy_assignment_request);
5590
5591    let local_var_req = local_var_req_builder.build()?;
5592    let local_var_resp = local_var_client.execute(local_var_req).await?;
5593
5594    let local_var_status = local_var_resp.status();
5595    let local_var_content = local_var_resp.text().await?;
5596
5597    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
5598        serde_json::from_str(&local_var_content).map_err(Error::from)
5599    } else {
5600        let local_var_entity: Option<VpnVpnProfilePhase1PolicyAssignmentsBulkPartialUpdateError> =
5601            serde_json::from_str(&local_var_content).ok();
5602        let local_var_error = ResponseContent {
5603            status: local_var_status,
5604            content: local_var_content,
5605            entity: local_var_entity,
5606        };
5607        Err(Error::ResponseError(local_var_error))
5608    }
5609}
5610
5611/// VPNProfilePhase1PolicyAssignment viewset.
5612pub async fn vpn_vpn_profile_phase1_policy_assignments_bulk_update(
5613    configuration: &configuration::Configuration,
5614    bulk_writable_vpn_profile_phase1_policy_assignment_request: Vec<
5615        crate::models::BulkWritableVpnProfilePhase1PolicyAssignmentRequest,
5616    >,
5617    format: Option<&str>,
5618) -> Result<
5619    Vec<crate::models::VpnProfilePhase1PolicyAssignment>,
5620    Error<VpnVpnProfilePhase1PolicyAssignmentsBulkUpdateError>,
5621> {
5622    let local_var_configuration = configuration;
5623
5624    let local_var_client = &local_var_configuration.client;
5625
5626    let local_var_uri_str = format!(
5627        "{}/vpn/vpn-profile-phase-1-policy-assignments/",
5628        local_var_configuration.base_path
5629    );
5630    let mut local_var_req_builder =
5631        local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());
5632
5633    if let Some(ref local_var_str) = format {
5634        local_var_req_builder =
5635            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
5636    }
5637    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
5638        local_var_req_builder =
5639            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
5640    }
5641    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
5642        let local_var_key = local_var_apikey.key.clone();
5643        let local_var_value = match local_var_apikey.prefix {
5644            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
5645            None => local_var_key,
5646        };
5647        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
5648    };
5649    local_var_req_builder =
5650        local_var_req_builder.json(&bulk_writable_vpn_profile_phase1_policy_assignment_request);
5651
5652    let local_var_req = local_var_req_builder.build()?;
5653    let local_var_resp = local_var_client.execute(local_var_req).await?;
5654
5655    let local_var_status = local_var_resp.status();
5656    let local_var_content = local_var_resp.text().await?;
5657
5658    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
5659        serde_json::from_str(&local_var_content).map_err(Error::from)
5660    } else {
5661        let local_var_entity: Option<VpnVpnProfilePhase1PolicyAssignmentsBulkUpdateError> =
5662            serde_json::from_str(&local_var_content).ok();
5663        let local_var_error = ResponseContent {
5664            status: local_var_status,
5665            content: local_var_content,
5666            entity: local_var_entity,
5667        };
5668        Err(Error::ResponseError(local_var_error))
5669    }
5670}
5671
5672/// VPNProfilePhase1PolicyAssignment viewset.
5673pub async fn vpn_vpn_profile_phase1_policy_assignments_create(
5674    configuration: &configuration::Configuration,
5675    vpn_profile_phase1_policy_assignment_request: crate::models::VpnProfilePhase1PolicyAssignmentRequest,
5676    format: Option<&str>,
5677) -> Result<
5678    crate::models::VpnProfilePhase1PolicyAssignment,
5679    Error<VpnVpnProfilePhase1PolicyAssignmentsCreateError>,
5680> {
5681    let local_var_configuration = configuration;
5682
5683    let local_var_client = &local_var_configuration.client;
5684
5685    let local_var_uri_str = format!(
5686        "{}/vpn/vpn-profile-phase-1-policy-assignments/",
5687        local_var_configuration.base_path
5688    );
5689    let mut local_var_req_builder =
5690        local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
5691
5692    if let Some(ref local_var_str) = format {
5693        local_var_req_builder =
5694            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
5695    }
5696    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
5697        local_var_req_builder =
5698            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
5699    }
5700    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
5701        let local_var_key = local_var_apikey.key.clone();
5702        let local_var_value = match local_var_apikey.prefix {
5703            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
5704            None => local_var_key,
5705        };
5706        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
5707    };
5708    local_var_req_builder =
5709        local_var_req_builder.json(&vpn_profile_phase1_policy_assignment_request);
5710
5711    let local_var_req = local_var_req_builder.build()?;
5712    let local_var_resp = local_var_client.execute(local_var_req).await?;
5713
5714    let local_var_status = local_var_resp.status();
5715    let local_var_content = local_var_resp.text().await?;
5716
5717    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
5718        serde_json::from_str(&local_var_content).map_err(Error::from)
5719    } else {
5720        let local_var_entity: Option<VpnVpnProfilePhase1PolicyAssignmentsCreateError> =
5721            serde_json::from_str(&local_var_content).ok();
5722        let local_var_error = ResponseContent {
5723            status: local_var_status,
5724            content: local_var_content,
5725            entity: local_var_entity,
5726        };
5727        Err(Error::ResponseError(local_var_error))
5728    }
5729}
5730
5731/// VPNProfilePhase1PolicyAssignment viewset.
5732pub async fn vpn_vpn_profile_phase1_policy_assignments_destroy(
5733    configuration: &configuration::Configuration,
5734    id: &str,
5735    format: Option<&str>,
5736) -> Result<(), Error<VpnVpnProfilePhase1PolicyAssignmentsDestroyError>> {
5737    let local_var_configuration = configuration;
5738
5739    let local_var_client = &local_var_configuration.client;
5740
5741    let local_var_uri_str = format!(
5742        "{}/vpn/vpn-profile-phase-1-policy-assignments/{id}/",
5743        local_var_configuration.base_path,
5744        id = crate::apis::urlencode(id)
5745    );
5746    let mut local_var_req_builder =
5747        local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());
5748
5749    if let Some(ref local_var_str) = format {
5750        local_var_req_builder =
5751            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
5752    }
5753    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
5754        local_var_req_builder =
5755            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
5756    }
5757    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
5758        let local_var_key = local_var_apikey.key.clone();
5759        let local_var_value = match local_var_apikey.prefix {
5760            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
5761            None => local_var_key,
5762        };
5763        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
5764    };
5765
5766    let local_var_req = local_var_req_builder.build()?;
5767    let local_var_resp = local_var_client.execute(local_var_req).await?;
5768
5769    let local_var_status = local_var_resp.status();
5770    let local_var_content = local_var_resp.text().await?;
5771
5772    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
5773        Ok(())
5774    } else {
5775        let local_var_entity: Option<VpnVpnProfilePhase1PolicyAssignmentsDestroyError> =
5776            serde_json::from_str(&local_var_content).ok();
5777        let local_var_error = ResponseContent {
5778            status: local_var_status,
5779            content: local_var_content,
5780            entity: local_var_entity,
5781        };
5782        Err(Error::ResponseError(local_var_error))
5783    }
5784}
5785
5786/// VPNProfilePhase1PolicyAssignment viewset.
5787pub async fn vpn_vpn_profile_phase1_policy_assignments_list(
5788    configuration: &configuration::Configuration,
5789    format: Option<&str>,
5790    id: Option<Vec<uuid::Uuid>>,
5791    id__n: Option<Vec<uuid::Uuid>>,
5792    limit: Option<i32>,
5793    offset: Option<i32>,
5794    q: Option<&str>,
5795    sort: Option<&str>,
5796    vpn_phase1_policy: Option<Vec<String>>,
5797    vpn_phase1_policy__n: Option<Vec<String>>,
5798    vpn_profile: Option<Vec<String>>,
5799    vpn_profile__n: Option<Vec<String>>,
5800    weight: Option<Vec<i32>>,
5801    weight__gt: Option<Vec<i32>>,
5802    weight__gte: Option<Vec<i32>>,
5803    weight__lt: Option<Vec<i32>>,
5804    weight__lte: Option<Vec<i32>>,
5805    weight__n: Option<Vec<i32>>,
5806    depth: Option<i32>,
5807    exclude_m2m: Option<bool>,
5808) -> Result<
5809    crate::models::PaginatedVpnProfilePhase1PolicyAssignmentList,
5810    Error<VpnVpnProfilePhase1PolicyAssignmentsListError>,
5811> {
5812    let local_var_configuration = configuration;
5813
5814    let local_var_client = &local_var_configuration.client;
5815
5816    let local_var_uri_str = format!(
5817        "{}/vpn/vpn-profile-phase-1-policy-assignments/",
5818        local_var_configuration.base_path
5819    );
5820    let mut local_var_req_builder =
5821        local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
5822
5823    if let Some(ref local_var_str) = format {
5824        local_var_req_builder =
5825            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
5826    }
5827    if let Some(ref local_var_str) = id {
5828        local_var_req_builder = match "multi" {
5829            "multi" => local_var_req_builder.query(
5830                &local_var_str
5831                    .into_iter()
5832                    .map(|p| ("id".to_owned(), p.to_string()))
5833                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5834            ),
5835            _ => local_var_req_builder.query(&[(
5836                "id",
5837                &local_var_str
5838                    .into_iter()
5839                    .map(|p| p.to_string())
5840                    .collect::<Vec<String>>()
5841                    .join(",")
5842                    .to_string(),
5843            )]),
5844        };
5845    }
5846    if let Some(ref local_var_str) = id__n {
5847        local_var_req_builder = match "multi" {
5848            "multi" => local_var_req_builder.query(
5849                &local_var_str
5850                    .into_iter()
5851                    .map(|p| ("id__n".to_owned(), p.to_string()))
5852                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5853            ),
5854            _ => local_var_req_builder.query(&[(
5855                "id__n",
5856                &local_var_str
5857                    .into_iter()
5858                    .map(|p| p.to_string())
5859                    .collect::<Vec<String>>()
5860                    .join(",")
5861                    .to_string(),
5862            )]),
5863        };
5864    }
5865    if let Some(ref local_var_str) = limit {
5866        local_var_req_builder =
5867            local_var_req_builder.query(&[("limit", &local_var_str.to_string())]);
5868    }
5869    if let Some(ref local_var_str) = offset {
5870        local_var_req_builder =
5871            local_var_req_builder.query(&[("offset", &local_var_str.to_string())]);
5872    }
5873    if let Some(ref local_var_str) = q {
5874        local_var_req_builder = local_var_req_builder.query(&[("q", &local_var_str.to_string())]);
5875    }
5876    if let Some(ref local_var_str) = sort {
5877        local_var_req_builder =
5878            local_var_req_builder.query(&[("sort", &local_var_str.to_string())]);
5879    }
5880    if let Some(ref local_var_str) = vpn_phase1_policy {
5881        local_var_req_builder = match "multi" {
5882            "multi" => local_var_req_builder.query(
5883                &local_var_str
5884                    .into_iter()
5885                    .map(|p| ("vpn_phase1_policy".to_owned(), p.to_string()))
5886                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5887            ),
5888            _ => local_var_req_builder.query(&[(
5889                "vpn_phase1_policy",
5890                &local_var_str
5891                    .into_iter()
5892                    .map(|p| p.to_string())
5893                    .collect::<Vec<String>>()
5894                    .join(",")
5895                    .to_string(),
5896            )]),
5897        };
5898    }
5899    if let Some(ref local_var_str) = vpn_phase1_policy__n {
5900        local_var_req_builder = match "multi" {
5901            "multi" => local_var_req_builder.query(
5902                &local_var_str
5903                    .into_iter()
5904                    .map(|p| ("vpn_phase1_policy__n".to_owned(), p.to_string()))
5905                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5906            ),
5907            _ => local_var_req_builder.query(&[(
5908                "vpn_phase1_policy__n",
5909                &local_var_str
5910                    .into_iter()
5911                    .map(|p| p.to_string())
5912                    .collect::<Vec<String>>()
5913                    .join(",")
5914                    .to_string(),
5915            )]),
5916        };
5917    }
5918    if let Some(ref local_var_str) = vpn_profile {
5919        local_var_req_builder = match "multi" {
5920            "multi" => local_var_req_builder.query(
5921                &local_var_str
5922                    .into_iter()
5923                    .map(|p| ("vpn_profile".to_owned(), p.to_string()))
5924                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5925            ),
5926            _ => local_var_req_builder.query(&[(
5927                "vpn_profile",
5928                &local_var_str
5929                    .into_iter()
5930                    .map(|p| p.to_string())
5931                    .collect::<Vec<String>>()
5932                    .join(",")
5933                    .to_string(),
5934            )]),
5935        };
5936    }
5937    if let Some(ref local_var_str) = vpn_profile__n {
5938        local_var_req_builder = match "multi" {
5939            "multi" => local_var_req_builder.query(
5940                &local_var_str
5941                    .into_iter()
5942                    .map(|p| ("vpn_profile__n".to_owned(), p.to_string()))
5943                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5944            ),
5945            _ => local_var_req_builder.query(&[(
5946                "vpn_profile__n",
5947                &local_var_str
5948                    .into_iter()
5949                    .map(|p| p.to_string())
5950                    .collect::<Vec<String>>()
5951                    .join(",")
5952                    .to_string(),
5953            )]),
5954        };
5955    }
5956    if let Some(ref local_var_str) = weight {
5957        local_var_req_builder = match "multi" {
5958            "multi" => local_var_req_builder.query(
5959                &local_var_str
5960                    .into_iter()
5961                    .map(|p| ("weight".to_owned(), p.to_string()))
5962                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5963            ),
5964            _ => local_var_req_builder.query(&[(
5965                "weight",
5966                &local_var_str
5967                    .into_iter()
5968                    .map(|p| p.to_string())
5969                    .collect::<Vec<String>>()
5970                    .join(",")
5971                    .to_string(),
5972            )]),
5973        };
5974    }
5975    if let Some(ref local_var_str) = weight__gt {
5976        local_var_req_builder = match "multi" {
5977            "multi" => local_var_req_builder.query(
5978                &local_var_str
5979                    .into_iter()
5980                    .map(|p| ("weight__gt".to_owned(), p.to_string()))
5981                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5982            ),
5983            _ => local_var_req_builder.query(&[(
5984                "weight__gt",
5985                &local_var_str
5986                    .into_iter()
5987                    .map(|p| p.to_string())
5988                    .collect::<Vec<String>>()
5989                    .join(",")
5990                    .to_string(),
5991            )]),
5992        };
5993    }
5994    if let Some(ref local_var_str) = weight__gte {
5995        local_var_req_builder = match "multi" {
5996            "multi" => local_var_req_builder.query(
5997                &local_var_str
5998                    .into_iter()
5999                    .map(|p| ("weight__gte".to_owned(), p.to_string()))
6000                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6001            ),
6002            _ => local_var_req_builder.query(&[(
6003                "weight__gte",
6004                &local_var_str
6005                    .into_iter()
6006                    .map(|p| p.to_string())
6007                    .collect::<Vec<String>>()
6008                    .join(",")
6009                    .to_string(),
6010            )]),
6011        };
6012    }
6013    if let Some(ref local_var_str) = weight__lt {
6014        local_var_req_builder = match "multi" {
6015            "multi" => local_var_req_builder.query(
6016                &local_var_str
6017                    .into_iter()
6018                    .map(|p| ("weight__lt".to_owned(), p.to_string()))
6019                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6020            ),
6021            _ => local_var_req_builder.query(&[(
6022                "weight__lt",
6023                &local_var_str
6024                    .into_iter()
6025                    .map(|p| p.to_string())
6026                    .collect::<Vec<String>>()
6027                    .join(",")
6028                    .to_string(),
6029            )]),
6030        };
6031    }
6032    if let Some(ref local_var_str) = weight__lte {
6033        local_var_req_builder = match "multi" {
6034            "multi" => local_var_req_builder.query(
6035                &local_var_str
6036                    .into_iter()
6037                    .map(|p| ("weight__lte".to_owned(), p.to_string()))
6038                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6039            ),
6040            _ => local_var_req_builder.query(&[(
6041                "weight__lte",
6042                &local_var_str
6043                    .into_iter()
6044                    .map(|p| p.to_string())
6045                    .collect::<Vec<String>>()
6046                    .join(",")
6047                    .to_string(),
6048            )]),
6049        };
6050    }
6051    if let Some(ref local_var_str) = weight__n {
6052        local_var_req_builder = match "multi" {
6053            "multi" => local_var_req_builder.query(
6054                &local_var_str
6055                    .into_iter()
6056                    .map(|p| ("weight__n".to_owned(), p.to_string()))
6057                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6058            ),
6059            _ => local_var_req_builder.query(&[(
6060                "weight__n",
6061                &local_var_str
6062                    .into_iter()
6063                    .map(|p| p.to_string())
6064                    .collect::<Vec<String>>()
6065                    .join(",")
6066                    .to_string(),
6067            )]),
6068        };
6069    }
6070    if let Some(ref local_var_str) = depth {
6071        local_var_req_builder =
6072            local_var_req_builder.query(&[("depth", &local_var_str.to_string())]);
6073    }
6074    if let Some(ref local_var_str) = exclude_m2m {
6075        local_var_req_builder =
6076            local_var_req_builder.query(&[("exclude_m2m", &local_var_str.to_string())]);
6077    }
6078    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
6079        local_var_req_builder =
6080            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
6081    }
6082    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
6083        let local_var_key = local_var_apikey.key.clone();
6084        let local_var_value = match local_var_apikey.prefix {
6085            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
6086            None => local_var_key,
6087        };
6088        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
6089    };
6090
6091    let local_var_req = local_var_req_builder.build()?;
6092    let local_var_resp = local_var_client.execute(local_var_req).await?;
6093
6094    let local_var_status = local_var_resp.status();
6095    let local_var_content = local_var_resp.text().await?;
6096
6097    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
6098        serde_json::from_str(&local_var_content).map_err(Error::from)
6099    } else {
6100        let local_var_entity: Option<VpnVpnProfilePhase1PolicyAssignmentsListError> =
6101            serde_json::from_str(&local_var_content).ok();
6102        let local_var_error = ResponseContent {
6103            status: local_var_status,
6104            content: local_var_content,
6105            entity: local_var_entity,
6106        };
6107        Err(Error::ResponseError(local_var_error))
6108    }
6109}
6110
6111/// VPNProfilePhase1PolicyAssignment viewset.
6112pub async fn vpn_vpn_profile_phase1_policy_assignments_partial_update(
6113    configuration: &configuration::Configuration,
6114    id: &str,
6115    format: Option<&str>,
6116    patched_vpn_profile_phase1_policy_assignment_request: Option<
6117        crate::models::PatchedVpnProfilePhase1PolicyAssignmentRequest,
6118    >,
6119) -> Result<
6120    crate::models::VpnProfilePhase1PolicyAssignment,
6121    Error<VpnVpnProfilePhase1PolicyAssignmentsPartialUpdateError>,
6122> {
6123    let local_var_configuration = configuration;
6124
6125    let local_var_client = &local_var_configuration.client;
6126
6127    let local_var_uri_str = format!(
6128        "{}/vpn/vpn-profile-phase-1-policy-assignments/{id}/",
6129        local_var_configuration.base_path,
6130        id = crate::apis::urlencode(id)
6131    );
6132    let mut local_var_req_builder =
6133        local_var_client.request(reqwest::Method::PATCH, local_var_uri_str.as_str());
6134
6135    if let Some(ref local_var_str) = format {
6136        local_var_req_builder =
6137            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
6138    }
6139    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
6140        local_var_req_builder =
6141            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
6142    }
6143    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
6144        let local_var_key = local_var_apikey.key.clone();
6145        let local_var_value = match local_var_apikey.prefix {
6146            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
6147            None => local_var_key,
6148        };
6149        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
6150    };
6151    local_var_req_builder =
6152        local_var_req_builder.json(&patched_vpn_profile_phase1_policy_assignment_request);
6153
6154    let local_var_req = local_var_req_builder.build()?;
6155    let local_var_resp = local_var_client.execute(local_var_req).await?;
6156
6157    let local_var_status = local_var_resp.status();
6158    let local_var_content = local_var_resp.text().await?;
6159
6160    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
6161        serde_json::from_str(&local_var_content).map_err(Error::from)
6162    } else {
6163        let local_var_entity: Option<VpnVpnProfilePhase1PolicyAssignmentsPartialUpdateError> =
6164            serde_json::from_str(&local_var_content).ok();
6165        let local_var_error = ResponseContent {
6166            status: local_var_status,
6167            content: local_var_content,
6168            entity: local_var_entity,
6169        };
6170        Err(Error::ResponseError(local_var_error))
6171    }
6172}
6173
6174/// VPNProfilePhase1PolicyAssignment viewset.
6175pub async fn vpn_vpn_profile_phase1_policy_assignments_retrieve(
6176    configuration: &configuration::Configuration,
6177    id: &str,
6178    format: Option<&str>,
6179    depth: Option<i32>,
6180    exclude_m2m: Option<bool>,
6181) -> Result<
6182    crate::models::VpnProfilePhase1PolicyAssignment,
6183    Error<VpnVpnProfilePhase1PolicyAssignmentsRetrieveError>,
6184> {
6185    let local_var_configuration = configuration;
6186
6187    let local_var_client = &local_var_configuration.client;
6188
6189    let local_var_uri_str = format!(
6190        "{}/vpn/vpn-profile-phase-1-policy-assignments/{id}/",
6191        local_var_configuration.base_path,
6192        id = crate::apis::urlencode(id)
6193    );
6194    let mut local_var_req_builder =
6195        local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
6196
6197    if let Some(ref local_var_str) = format {
6198        local_var_req_builder =
6199            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
6200    }
6201    if let Some(ref local_var_str) = depth {
6202        local_var_req_builder =
6203            local_var_req_builder.query(&[("depth", &local_var_str.to_string())]);
6204    }
6205    if let Some(ref local_var_str) = exclude_m2m {
6206        local_var_req_builder =
6207            local_var_req_builder.query(&[("exclude_m2m", &local_var_str.to_string())]);
6208    }
6209    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
6210        local_var_req_builder =
6211            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
6212    }
6213    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
6214        let local_var_key = local_var_apikey.key.clone();
6215        let local_var_value = match local_var_apikey.prefix {
6216            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
6217            None => local_var_key,
6218        };
6219        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
6220    };
6221
6222    let local_var_req = local_var_req_builder.build()?;
6223    let local_var_resp = local_var_client.execute(local_var_req).await?;
6224
6225    let local_var_status = local_var_resp.status();
6226    let local_var_content = local_var_resp.text().await?;
6227
6228    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
6229        serde_json::from_str(&local_var_content).map_err(Error::from)
6230    } else {
6231        let local_var_entity: Option<VpnVpnProfilePhase1PolicyAssignmentsRetrieveError> =
6232            serde_json::from_str(&local_var_content).ok();
6233        let local_var_error = ResponseContent {
6234            status: local_var_status,
6235            content: local_var_content,
6236            entity: local_var_entity,
6237        };
6238        Err(Error::ResponseError(local_var_error))
6239    }
6240}
6241
6242/// VPNProfilePhase1PolicyAssignment viewset.
6243pub async fn vpn_vpn_profile_phase1_policy_assignments_update(
6244    configuration: &configuration::Configuration,
6245    id: &str,
6246    vpn_profile_phase1_policy_assignment_request: crate::models::VpnProfilePhase1PolicyAssignmentRequest,
6247    format: Option<&str>,
6248) -> Result<
6249    crate::models::VpnProfilePhase1PolicyAssignment,
6250    Error<VpnVpnProfilePhase1PolicyAssignmentsUpdateError>,
6251> {
6252    let local_var_configuration = configuration;
6253
6254    let local_var_client = &local_var_configuration.client;
6255
6256    let local_var_uri_str = format!(
6257        "{}/vpn/vpn-profile-phase-1-policy-assignments/{id}/",
6258        local_var_configuration.base_path,
6259        id = crate::apis::urlencode(id)
6260    );
6261    let mut local_var_req_builder =
6262        local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());
6263
6264    if let Some(ref local_var_str) = format {
6265        local_var_req_builder =
6266            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
6267    }
6268    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
6269        local_var_req_builder =
6270            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
6271    }
6272    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
6273        let local_var_key = local_var_apikey.key.clone();
6274        let local_var_value = match local_var_apikey.prefix {
6275            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
6276            None => local_var_key,
6277        };
6278        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
6279    };
6280    local_var_req_builder =
6281        local_var_req_builder.json(&vpn_profile_phase1_policy_assignment_request);
6282
6283    let local_var_req = local_var_req_builder.build()?;
6284    let local_var_resp = local_var_client.execute(local_var_req).await?;
6285
6286    let local_var_status = local_var_resp.status();
6287    let local_var_content = local_var_resp.text().await?;
6288
6289    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
6290        serde_json::from_str(&local_var_content).map_err(Error::from)
6291    } else {
6292        let local_var_entity: Option<VpnVpnProfilePhase1PolicyAssignmentsUpdateError> =
6293            serde_json::from_str(&local_var_content).ok();
6294        let local_var_error = ResponseContent {
6295            status: local_var_status,
6296            content: local_var_content,
6297            entity: local_var_entity,
6298        };
6299        Err(Error::ResponseError(local_var_error))
6300    }
6301}
6302
6303/// VPNProfilePhase2PolicyAssignment viewset.
6304pub async fn vpn_vpn_profile_phase2_policy_assignments_bulk_destroy(
6305    configuration: &configuration::Configuration,
6306    bulk_operation_request: Vec<crate::models::BulkOperationRequest>,
6307    format: Option<&str>,
6308) -> Result<(), Error<VpnVpnProfilePhase2PolicyAssignmentsBulkDestroyError>> {
6309    let local_var_configuration = configuration;
6310
6311    let local_var_client = &local_var_configuration.client;
6312
6313    let local_var_uri_str = format!(
6314        "{}/vpn/vpn-profile-phase-2-policy-assignments/",
6315        local_var_configuration.base_path
6316    );
6317    let mut local_var_req_builder =
6318        local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());
6319
6320    if let Some(ref local_var_str) = format {
6321        local_var_req_builder =
6322            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
6323    }
6324    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
6325        local_var_req_builder =
6326            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
6327    }
6328    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
6329        let local_var_key = local_var_apikey.key.clone();
6330        let local_var_value = match local_var_apikey.prefix {
6331            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
6332            None => local_var_key,
6333        };
6334        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
6335    };
6336    local_var_req_builder = local_var_req_builder.json(&bulk_operation_request);
6337
6338    let local_var_req = local_var_req_builder.build()?;
6339    let local_var_resp = local_var_client.execute(local_var_req).await?;
6340
6341    let local_var_status = local_var_resp.status();
6342    let local_var_content = local_var_resp.text().await?;
6343
6344    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
6345        Ok(())
6346    } else {
6347        let local_var_entity: Option<VpnVpnProfilePhase2PolicyAssignmentsBulkDestroyError> =
6348            serde_json::from_str(&local_var_content).ok();
6349        let local_var_error = ResponseContent {
6350            status: local_var_status,
6351            content: local_var_content,
6352            entity: local_var_entity,
6353        };
6354        Err(Error::ResponseError(local_var_error))
6355    }
6356}
6357
6358/// VPNProfilePhase2PolicyAssignment viewset.
6359pub async fn vpn_vpn_profile_phase2_policy_assignments_bulk_partial_update(
6360    configuration: &configuration::Configuration,
6361    patched_bulk_writable_vpn_profile_phase2_policy_assignment_request: Vec<
6362        crate::models::PatchedBulkWritableVpnProfilePhase2PolicyAssignmentRequest,
6363    >,
6364    format: Option<&str>,
6365) -> Result<
6366    Vec<crate::models::VpnProfilePhase2PolicyAssignment>,
6367    Error<VpnVpnProfilePhase2PolicyAssignmentsBulkPartialUpdateError>,
6368> {
6369    let local_var_configuration = configuration;
6370
6371    let local_var_client = &local_var_configuration.client;
6372
6373    let local_var_uri_str = format!(
6374        "{}/vpn/vpn-profile-phase-2-policy-assignments/",
6375        local_var_configuration.base_path
6376    );
6377    let mut local_var_req_builder =
6378        local_var_client.request(reqwest::Method::PATCH, local_var_uri_str.as_str());
6379
6380    if let Some(ref local_var_str) = format {
6381        local_var_req_builder =
6382            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
6383    }
6384    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
6385        local_var_req_builder =
6386            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
6387    }
6388    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
6389        let local_var_key = local_var_apikey.key.clone();
6390        let local_var_value = match local_var_apikey.prefix {
6391            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
6392            None => local_var_key,
6393        };
6394        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
6395    };
6396    local_var_req_builder = local_var_req_builder
6397        .json(&patched_bulk_writable_vpn_profile_phase2_policy_assignment_request);
6398
6399    let local_var_req = local_var_req_builder.build()?;
6400    let local_var_resp = local_var_client.execute(local_var_req).await?;
6401
6402    let local_var_status = local_var_resp.status();
6403    let local_var_content = local_var_resp.text().await?;
6404
6405    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
6406        serde_json::from_str(&local_var_content).map_err(Error::from)
6407    } else {
6408        let local_var_entity: Option<VpnVpnProfilePhase2PolicyAssignmentsBulkPartialUpdateError> =
6409            serde_json::from_str(&local_var_content).ok();
6410        let local_var_error = ResponseContent {
6411            status: local_var_status,
6412            content: local_var_content,
6413            entity: local_var_entity,
6414        };
6415        Err(Error::ResponseError(local_var_error))
6416    }
6417}
6418
6419/// VPNProfilePhase2PolicyAssignment viewset.
6420pub async fn vpn_vpn_profile_phase2_policy_assignments_bulk_update(
6421    configuration: &configuration::Configuration,
6422    bulk_writable_vpn_profile_phase2_policy_assignment_request: Vec<
6423        crate::models::BulkWritableVpnProfilePhase2PolicyAssignmentRequest,
6424    >,
6425    format: Option<&str>,
6426) -> Result<
6427    Vec<crate::models::VpnProfilePhase2PolicyAssignment>,
6428    Error<VpnVpnProfilePhase2PolicyAssignmentsBulkUpdateError>,
6429> {
6430    let local_var_configuration = configuration;
6431
6432    let local_var_client = &local_var_configuration.client;
6433
6434    let local_var_uri_str = format!(
6435        "{}/vpn/vpn-profile-phase-2-policy-assignments/",
6436        local_var_configuration.base_path
6437    );
6438    let mut local_var_req_builder =
6439        local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());
6440
6441    if let Some(ref local_var_str) = format {
6442        local_var_req_builder =
6443            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
6444    }
6445    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
6446        local_var_req_builder =
6447            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
6448    }
6449    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
6450        let local_var_key = local_var_apikey.key.clone();
6451        let local_var_value = match local_var_apikey.prefix {
6452            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
6453            None => local_var_key,
6454        };
6455        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
6456    };
6457    local_var_req_builder =
6458        local_var_req_builder.json(&bulk_writable_vpn_profile_phase2_policy_assignment_request);
6459
6460    let local_var_req = local_var_req_builder.build()?;
6461    let local_var_resp = local_var_client.execute(local_var_req).await?;
6462
6463    let local_var_status = local_var_resp.status();
6464    let local_var_content = local_var_resp.text().await?;
6465
6466    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
6467        serde_json::from_str(&local_var_content).map_err(Error::from)
6468    } else {
6469        let local_var_entity: Option<VpnVpnProfilePhase2PolicyAssignmentsBulkUpdateError> =
6470            serde_json::from_str(&local_var_content).ok();
6471        let local_var_error = ResponseContent {
6472            status: local_var_status,
6473            content: local_var_content,
6474            entity: local_var_entity,
6475        };
6476        Err(Error::ResponseError(local_var_error))
6477    }
6478}
6479
6480/// VPNProfilePhase2PolicyAssignment viewset.
6481pub async fn vpn_vpn_profile_phase2_policy_assignments_create(
6482    configuration: &configuration::Configuration,
6483    vpn_profile_phase2_policy_assignment_request: crate::models::VpnProfilePhase2PolicyAssignmentRequest,
6484    format: Option<&str>,
6485) -> Result<
6486    crate::models::VpnProfilePhase2PolicyAssignment,
6487    Error<VpnVpnProfilePhase2PolicyAssignmentsCreateError>,
6488> {
6489    let local_var_configuration = configuration;
6490
6491    let local_var_client = &local_var_configuration.client;
6492
6493    let local_var_uri_str = format!(
6494        "{}/vpn/vpn-profile-phase-2-policy-assignments/",
6495        local_var_configuration.base_path
6496    );
6497    let mut local_var_req_builder =
6498        local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
6499
6500    if let Some(ref local_var_str) = format {
6501        local_var_req_builder =
6502            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
6503    }
6504    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
6505        local_var_req_builder =
6506            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
6507    }
6508    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
6509        let local_var_key = local_var_apikey.key.clone();
6510        let local_var_value = match local_var_apikey.prefix {
6511            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
6512            None => local_var_key,
6513        };
6514        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
6515    };
6516    local_var_req_builder =
6517        local_var_req_builder.json(&vpn_profile_phase2_policy_assignment_request);
6518
6519    let local_var_req = local_var_req_builder.build()?;
6520    let local_var_resp = local_var_client.execute(local_var_req).await?;
6521
6522    let local_var_status = local_var_resp.status();
6523    let local_var_content = local_var_resp.text().await?;
6524
6525    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
6526        serde_json::from_str(&local_var_content).map_err(Error::from)
6527    } else {
6528        let local_var_entity: Option<VpnVpnProfilePhase2PolicyAssignmentsCreateError> =
6529            serde_json::from_str(&local_var_content).ok();
6530        let local_var_error = ResponseContent {
6531            status: local_var_status,
6532            content: local_var_content,
6533            entity: local_var_entity,
6534        };
6535        Err(Error::ResponseError(local_var_error))
6536    }
6537}
6538
6539/// VPNProfilePhase2PolicyAssignment viewset.
6540pub async fn vpn_vpn_profile_phase2_policy_assignments_destroy(
6541    configuration: &configuration::Configuration,
6542    id: &str,
6543    format: Option<&str>,
6544) -> Result<(), Error<VpnVpnProfilePhase2PolicyAssignmentsDestroyError>> {
6545    let local_var_configuration = configuration;
6546
6547    let local_var_client = &local_var_configuration.client;
6548
6549    let local_var_uri_str = format!(
6550        "{}/vpn/vpn-profile-phase-2-policy-assignments/{id}/",
6551        local_var_configuration.base_path,
6552        id = crate::apis::urlencode(id)
6553    );
6554    let mut local_var_req_builder =
6555        local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());
6556
6557    if let Some(ref local_var_str) = format {
6558        local_var_req_builder =
6559            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
6560    }
6561    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
6562        local_var_req_builder =
6563            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
6564    }
6565    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
6566        let local_var_key = local_var_apikey.key.clone();
6567        let local_var_value = match local_var_apikey.prefix {
6568            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
6569            None => local_var_key,
6570        };
6571        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
6572    };
6573
6574    let local_var_req = local_var_req_builder.build()?;
6575    let local_var_resp = local_var_client.execute(local_var_req).await?;
6576
6577    let local_var_status = local_var_resp.status();
6578    let local_var_content = local_var_resp.text().await?;
6579
6580    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
6581        Ok(())
6582    } else {
6583        let local_var_entity: Option<VpnVpnProfilePhase2PolicyAssignmentsDestroyError> =
6584            serde_json::from_str(&local_var_content).ok();
6585        let local_var_error = ResponseContent {
6586            status: local_var_status,
6587            content: local_var_content,
6588            entity: local_var_entity,
6589        };
6590        Err(Error::ResponseError(local_var_error))
6591    }
6592}
6593
6594/// VPNProfilePhase2PolicyAssignment viewset.
6595pub async fn vpn_vpn_profile_phase2_policy_assignments_list(
6596    configuration: &configuration::Configuration,
6597    format: Option<&str>,
6598    id: Option<Vec<uuid::Uuid>>,
6599    id__n: Option<Vec<uuid::Uuid>>,
6600    limit: Option<i32>,
6601    offset: Option<i32>,
6602    q: Option<&str>,
6603    sort: Option<&str>,
6604    vpn_phase2_policy: Option<Vec<String>>,
6605    vpn_phase2_policy__n: Option<Vec<String>>,
6606    vpn_profile: Option<Vec<String>>,
6607    vpn_profile__n: Option<Vec<String>>,
6608    weight: Option<Vec<i32>>,
6609    weight__gt: Option<Vec<i32>>,
6610    weight__gte: Option<Vec<i32>>,
6611    weight__lt: Option<Vec<i32>>,
6612    weight__lte: Option<Vec<i32>>,
6613    weight__n: Option<Vec<i32>>,
6614    depth: Option<i32>,
6615    exclude_m2m: Option<bool>,
6616) -> Result<
6617    crate::models::PaginatedVpnProfilePhase2PolicyAssignmentList,
6618    Error<VpnVpnProfilePhase2PolicyAssignmentsListError>,
6619> {
6620    let local_var_configuration = configuration;
6621
6622    let local_var_client = &local_var_configuration.client;
6623
6624    let local_var_uri_str = format!(
6625        "{}/vpn/vpn-profile-phase-2-policy-assignments/",
6626        local_var_configuration.base_path
6627    );
6628    let mut local_var_req_builder =
6629        local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
6630
6631    if let Some(ref local_var_str) = format {
6632        local_var_req_builder =
6633            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
6634    }
6635    if let Some(ref local_var_str) = id {
6636        local_var_req_builder = match "multi" {
6637            "multi" => local_var_req_builder.query(
6638                &local_var_str
6639                    .into_iter()
6640                    .map(|p| ("id".to_owned(), p.to_string()))
6641                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6642            ),
6643            _ => local_var_req_builder.query(&[(
6644                "id",
6645                &local_var_str
6646                    .into_iter()
6647                    .map(|p| p.to_string())
6648                    .collect::<Vec<String>>()
6649                    .join(",")
6650                    .to_string(),
6651            )]),
6652        };
6653    }
6654    if let Some(ref local_var_str) = id__n {
6655        local_var_req_builder = match "multi" {
6656            "multi" => local_var_req_builder.query(
6657                &local_var_str
6658                    .into_iter()
6659                    .map(|p| ("id__n".to_owned(), p.to_string()))
6660                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6661            ),
6662            _ => local_var_req_builder.query(&[(
6663                "id__n",
6664                &local_var_str
6665                    .into_iter()
6666                    .map(|p| p.to_string())
6667                    .collect::<Vec<String>>()
6668                    .join(",")
6669                    .to_string(),
6670            )]),
6671        };
6672    }
6673    if let Some(ref local_var_str) = limit {
6674        local_var_req_builder =
6675            local_var_req_builder.query(&[("limit", &local_var_str.to_string())]);
6676    }
6677    if let Some(ref local_var_str) = offset {
6678        local_var_req_builder =
6679            local_var_req_builder.query(&[("offset", &local_var_str.to_string())]);
6680    }
6681    if let Some(ref local_var_str) = q {
6682        local_var_req_builder = local_var_req_builder.query(&[("q", &local_var_str.to_string())]);
6683    }
6684    if let Some(ref local_var_str) = sort {
6685        local_var_req_builder =
6686            local_var_req_builder.query(&[("sort", &local_var_str.to_string())]);
6687    }
6688    if let Some(ref local_var_str) = vpn_phase2_policy {
6689        local_var_req_builder = match "multi" {
6690            "multi" => local_var_req_builder.query(
6691                &local_var_str
6692                    .into_iter()
6693                    .map(|p| ("vpn_phase2_policy".to_owned(), p.to_string()))
6694                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6695            ),
6696            _ => local_var_req_builder.query(&[(
6697                "vpn_phase2_policy",
6698                &local_var_str
6699                    .into_iter()
6700                    .map(|p| p.to_string())
6701                    .collect::<Vec<String>>()
6702                    .join(",")
6703                    .to_string(),
6704            )]),
6705        };
6706    }
6707    if let Some(ref local_var_str) = vpn_phase2_policy__n {
6708        local_var_req_builder = match "multi" {
6709            "multi" => local_var_req_builder.query(
6710                &local_var_str
6711                    .into_iter()
6712                    .map(|p| ("vpn_phase2_policy__n".to_owned(), p.to_string()))
6713                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6714            ),
6715            _ => local_var_req_builder.query(&[(
6716                "vpn_phase2_policy__n",
6717                &local_var_str
6718                    .into_iter()
6719                    .map(|p| p.to_string())
6720                    .collect::<Vec<String>>()
6721                    .join(",")
6722                    .to_string(),
6723            )]),
6724        };
6725    }
6726    if let Some(ref local_var_str) = vpn_profile {
6727        local_var_req_builder = match "multi" {
6728            "multi" => local_var_req_builder.query(
6729                &local_var_str
6730                    .into_iter()
6731                    .map(|p| ("vpn_profile".to_owned(), p.to_string()))
6732                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6733            ),
6734            _ => local_var_req_builder.query(&[(
6735                "vpn_profile",
6736                &local_var_str
6737                    .into_iter()
6738                    .map(|p| p.to_string())
6739                    .collect::<Vec<String>>()
6740                    .join(",")
6741                    .to_string(),
6742            )]),
6743        };
6744    }
6745    if let Some(ref local_var_str) = vpn_profile__n {
6746        local_var_req_builder = match "multi" {
6747            "multi" => local_var_req_builder.query(
6748                &local_var_str
6749                    .into_iter()
6750                    .map(|p| ("vpn_profile__n".to_owned(), p.to_string()))
6751                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6752            ),
6753            _ => local_var_req_builder.query(&[(
6754                "vpn_profile__n",
6755                &local_var_str
6756                    .into_iter()
6757                    .map(|p| p.to_string())
6758                    .collect::<Vec<String>>()
6759                    .join(",")
6760                    .to_string(),
6761            )]),
6762        };
6763    }
6764    if let Some(ref local_var_str) = weight {
6765        local_var_req_builder = match "multi" {
6766            "multi" => local_var_req_builder.query(
6767                &local_var_str
6768                    .into_iter()
6769                    .map(|p| ("weight".to_owned(), p.to_string()))
6770                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6771            ),
6772            _ => local_var_req_builder.query(&[(
6773                "weight",
6774                &local_var_str
6775                    .into_iter()
6776                    .map(|p| p.to_string())
6777                    .collect::<Vec<String>>()
6778                    .join(",")
6779                    .to_string(),
6780            )]),
6781        };
6782    }
6783    if let Some(ref local_var_str) = weight__gt {
6784        local_var_req_builder = match "multi" {
6785            "multi" => local_var_req_builder.query(
6786                &local_var_str
6787                    .into_iter()
6788                    .map(|p| ("weight__gt".to_owned(), p.to_string()))
6789                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6790            ),
6791            _ => local_var_req_builder.query(&[(
6792                "weight__gt",
6793                &local_var_str
6794                    .into_iter()
6795                    .map(|p| p.to_string())
6796                    .collect::<Vec<String>>()
6797                    .join(",")
6798                    .to_string(),
6799            )]),
6800        };
6801    }
6802    if let Some(ref local_var_str) = weight__gte {
6803        local_var_req_builder = match "multi" {
6804            "multi" => local_var_req_builder.query(
6805                &local_var_str
6806                    .into_iter()
6807                    .map(|p| ("weight__gte".to_owned(), p.to_string()))
6808                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6809            ),
6810            _ => local_var_req_builder.query(&[(
6811                "weight__gte",
6812                &local_var_str
6813                    .into_iter()
6814                    .map(|p| p.to_string())
6815                    .collect::<Vec<String>>()
6816                    .join(",")
6817                    .to_string(),
6818            )]),
6819        };
6820    }
6821    if let Some(ref local_var_str) = weight__lt {
6822        local_var_req_builder = match "multi" {
6823            "multi" => local_var_req_builder.query(
6824                &local_var_str
6825                    .into_iter()
6826                    .map(|p| ("weight__lt".to_owned(), p.to_string()))
6827                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6828            ),
6829            _ => local_var_req_builder.query(&[(
6830                "weight__lt",
6831                &local_var_str
6832                    .into_iter()
6833                    .map(|p| p.to_string())
6834                    .collect::<Vec<String>>()
6835                    .join(",")
6836                    .to_string(),
6837            )]),
6838        };
6839    }
6840    if let Some(ref local_var_str) = weight__lte {
6841        local_var_req_builder = match "multi" {
6842            "multi" => local_var_req_builder.query(
6843                &local_var_str
6844                    .into_iter()
6845                    .map(|p| ("weight__lte".to_owned(), p.to_string()))
6846                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6847            ),
6848            _ => local_var_req_builder.query(&[(
6849                "weight__lte",
6850                &local_var_str
6851                    .into_iter()
6852                    .map(|p| p.to_string())
6853                    .collect::<Vec<String>>()
6854                    .join(",")
6855                    .to_string(),
6856            )]),
6857        };
6858    }
6859    if let Some(ref local_var_str) = weight__n {
6860        local_var_req_builder = match "multi" {
6861            "multi" => local_var_req_builder.query(
6862                &local_var_str
6863                    .into_iter()
6864                    .map(|p| ("weight__n".to_owned(), p.to_string()))
6865                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6866            ),
6867            _ => local_var_req_builder.query(&[(
6868                "weight__n",
6869                &local_var_str
6870                    .into_iter()
6871                    .map(|p| p.to_string())
6872                    .collect::<Vec<String>>()
6873                    .join(",")
6874                    .to_string(),
6875            )]),
6876        };
6877    }
6878    if let Some(ref local_var_str) = depth {
6879        local_var_req_builder =
6880            local_var_req_builder.query(&[("depth", &local_var_str.to_string())]);
6881    }
6882    if let Some(ref local_var_str) = exclude_m2m {
6883        local_var_req_builder =
6884            local_var_req_builder.query(&[("exclude_m2m", &local_var_str.to_string())]);
6885    }
6886    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
6887        local_var_req_builder =
6888            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
6889    }
6890    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
6891        let local_var_key = local_var_apikey.key.clone();
6892        let local_var_value = match local_var_apikey.prefix {
6893            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
6894            None => local_var_key,
6895        };
6896        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
6897    };
6898
6899    let local_var_req = local_var_req_builder.build()?;
6900    let local_var_resp = local_var_client.execute(local_var_req).await?;
6901
6902    let local_var_status = local_var_resp.status();
6903    let local_var_content = local_var_resp.text().await?;
6904
6905    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
6906        serde_json::from_str(&local_var_content).map_err(Error::from)
6907    } else {
6908        let local_var_entity: Option<VpnVpnProfilePhase2PolicyAssignmentsListError> =
6909            serde_json::from_str(&local_var_content).ok();
6910        let local_var_error = ResponseContent {
6911            status: local_var_status,
6912            content: local_var_content,
6913            entity: local_var_entity,
6914        };
6915        Err(Error::ResponseError(local_var_error))
6916    }
6917}
6918
6919/// VPNProfilePhase2PolicyAssignment viewset.
6920pub async fn vpn_vpn_profile_phase2_policy_assignments_partial_update(
6921    configuration: &configuration::Configuration,
6922    id: &str,
6923    format: Option<&str>,
6924    patched_vpn_profile_phase2_policy_assignment_request: Option<
6925        crate::models::PatchedVpnProfilePhase2PolicyAssignmentRequest,
6926    >,
6927) -> Result<
6928    crate::models::VpnProfilePhase2PolicyAssignment,
6929    Error<VpnVpnProfilePhase2PolicyAssignmentsPartialUpdateError>,
6930> {
6931    let local_var_configuration = configuration;
6932
6933    let local_var_client = &local_var_configuration.client;
6934
6935    let local_var_uri_str = format!(
6936        "{}/vpn/vpn-profile-phase-2-policy-assignments/{id}/",
6937        local_var_configuration.base_path,
6938        id = crate::apis::urlencode(id)
6939    );
6940    let mut local_var_req_builder =
6941        local_var_client.request(reqwest::Method::PATCH, local_var_uri_str.as_str());
6942
6943    if let Some(ref local_var_str) = format {
6944        local_var_req_builder =
6945            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
6946    }
6947    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
6948        local_var_req_builder =
6949            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
6950    }
6951    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
6952        let local_var_key = local_var_apikey.key.clone();
6953        let local_var_value = match local_var_apikey.prefix {
6954            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
6955            None => local_var_key,
6956        };
6957        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
6958    };
6959    local_var_req_builder =
6960        local_var_req_builder.json(&patched_vpn_profile_phase2_policy_assignment_request);
6961
6962    let local_var_req = local_var_req_builder.build()?;
6963    let local_var_resp = local_var_client.execute(local_var_req).await?;
6964
6965    let local_var_status = local_var_resp.status();
6966    let local_var_content = local_var_resp.text().await?;
6967
6968    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
6969        serde_json::from_str(&local_var_content).map_err(Error::from)
6970    } else {
6971        let local_var_entity: Option<VpnVpnProfilePhase2PolicyAssignmentsPartialUpdateError> =
6972            serde_json::from_str(&local_var_content).ok();
6973        let local_var_error = ResponseContent {
6974            status: local_var_status,
6975            content: local_var_content,
6976            entity: local_var_entity,
6977        };
6978        Err(Error::ResponseError(local_var_error))
6979    }
6980}
6981
6982/// VPNProfilePhase2PolicyAssignment viewset.
6983pub async fn vpn_vpn_profile_phase2_policy_assignments_retrieve(
6984    configuration: &configuration::Configuration,
6985    id: &str,
6986    format: Option<&str>,
6987    depth: Option<i32>,
6988    exclude_m2m: Option<bool>,
6989) -> Result<
6990    crate::models::VpnProfilePhase2PolicyAssignment,
6991    Error<VpnVpnProfilePhase2PolicyAssignmentsRetrieveError>,
6992> {
6993    let local_var_configuration = configuration;
6994
6995    let local_var_client = &local_var_configuration.client;
6996
6997    let local_var_uri_str = format!(
6998        "{}/vpn/vpn-profile-phase-2-policy-assignments/{id}/",
6999        local_var_configuration.base_path,
7000        id = crate::apis::urlencode(id)
7001    );
7002    let mut local_var_req_builder =
7003        local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
7004
7005    if let Some(ref local_var_str) = format {
7006        local_var_req_builder =
7007            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
7008    }
7009    if let Some(ref local_var_str) = depth {
7010        local_var_req_builder =
7011            local_var_req_builder.query(&[("depth", &local_var_str.to_string())]);
7012    }
7013    if let Some(ref local_var_str) = exclude_m2m {
7014        local_var_req_builder =
7015            local_var_req_builder.query(&[("exclude_m2m", &local_var_str.to_string())]);
7016    }
7017    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
7018        local_var_req_builder =
7019            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
7020    }
7021    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
7022        let local_var_key = local_var_apikey.key.clone();
7023        let local_var_value = match local_var_apikey.prefix {
7024            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
7025            None => local_var_key,
7026        };
7027        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
7028    };
7029
7030    let local_var_req = local_var_req_builder.build()?;
7031    let local_var_resp = local_var_client.execute(local_var_req).await?;
7032
7033    let local_var_status = local_var_resp.status();
7034    let local_var_content = local_var_resp.text().await?;
7035
7036    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
7037        serde_json::from_str(&local_var_content).map_err(Error::from)
7038    } else {
7039        let local_var_entity: Option<VpnVpnProfilePhase2PolicyAssignmentsRetrieveError> =
7040            serde_json::from_str(&local_var_content).ok();
7041        let local_var_error = ResponseContent {
7042            status: local_var_status,
7043            content: local_var_content,
7044            entity: local_var_entity,
7045        };
7046        Err(Error::ResponseError(local_var_error))
7047    }
7048}
7049
7050/// VPNProfilePhase2PolicyAssignment viewset.
7051pub async fn vpn_vpn_profile_phase2_policy_assignments_update(
7052    configuration: &configuration::Configuration,
7053    id: &str,
7054    vpn_profile_phase2_policy_assignment_request: crate::models::VpnProfilePhase2PolicyAssignmentRequest,
7055    format: Option<&str>,
7056) -> Result<
7057    crate::models::VpnProfilePhase2PolicyAssignment,
7058    Error<VpnVpnProfilePhase2PolicyAssignmentsUpdateError>,
7059> {
7060    let local_var_configuration = configuration;
7061
7062    let local_var_client = &local_var_configuration.client;
7063
7064    let local_var_uri_str = format!(
7065        "{}/vpn/vpn-profile-phase-2-policy-assignments/{id}/",
7066        local_var_configuration.base_path,
7067        id = crate::apis::urlencode(id)
7068    );
7069    let mut local_var_req_builder =
7070        local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());
7071
7072    if let Some(ref local_var_str) = format {
7073        local_var_req_builder =
7074            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
7075    }
7076    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
7077        local_var_req_builder =
7078            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
7079    }
7080    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
7081        let local_var_key = local_var_apikey.key.clone();
7082        let local_var_value = match local_var_apikey.prefix {
7083            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
7084            None => local_var_key,
7085        };
7086        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
7087    };
7088    local_var_req_builder =
7089        local_var_req_builder.json(&vpn_profile_phase2_policy_assignment_request);
7090
7091    let local_var_req = local_var_req_builder.build()?;
7092    let local_var_resp = local_var_client.execute(local_var_req).await?;
7093
7094    let local_var_status = local_var_resp.status();
7095    let local_var_content = local_var_resp.text().await?;
7096
7097    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
7098        serde_json::from_str(&local_var_content).map_err(Error::from)
7099    } else {
7100        let local_var_entity: Option<VpnVpnProfilePhase2PolicyAssignmentsUpdateError> =
7101            serde_json::from_str(&local_var_content).ok();
7102        let local_var_error = ResponseContent {
7103            status: local_var_status,
7104            content: local_var_content,
7105            entity: local_var_entity,
7106        };
7107        Err(Error::ResponseError(local_var_error))
7108    }
7109}
7110
7111/// VPNProfile viewset.
7112pub async fn vpn_vpn_profiles_bulk_destroy(
7113    configuration: &configuration::Configuration,
7114    bulk_operation_request: Vec<crate::models::BulkOperationRequest>,
7115    format: Option<&str>,
7116) -> Result<(), Error<VpnVpnProfilesBulkDestroyError>> {
7117    let local_var_configuration = configuration;
7118
7119    let local_var_client = &local_var_configuration.client;
7120
7121    let local_var_uri_str = format!("{}/vpn/vpn-profiles/", local_var_configuration.base_path);
7122    let mut local_var_req_builder =
7123        local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());
7124
7125    if let Some(ref local_var_str) = format {
7126        local_var_req_builder =
7127            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
7128    }
7129    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
7130        local_var_req_builder =
7131            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
7132    }
7133    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
7134        let local_var_key = local_var_apikey.key.clone();
7135        let local_var_value = match local_var_apikey.prefix {
7136            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
7137            None => local_var_key,
7138        };
7139        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
7140    };
7141    local_var_req_builder = local_var_req_builder.json(&bulk_operation_request);
7142
7143    let local_var_req = local_var_req_builder.build()?;
7144    let local_var_resp = local_var_client.execute(local_var_req).await?;
7145
7146    let local_var_status = local_var_resp.status();
7147    let local_var_content = local_var_resp.text().await?;
7148
7149    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
7150        Ok(())
7151    } else {
7152        let local_var_entity: Option<VpnVpnProfilesBulkDestroyError> =
7153            serde_json::from_str(&local_var_content).ok();
7154        let local_var_error = ResponseContent {
7155            status: local_var_status,
7156            content: local_var_content,
7157            entity: local_var_entity,
7158        };
7159        Err(Error::ResponseError(local_var_error))
7160    }
7161}
7162
7163/// VPNProfile viewset.
7164pub async fn vpn_vpn_profiles_bulk_partial_update(
7165    configuration: &configuration::Configuration,
7166    patched_bulk_writable_vpn_profile_request: Vec<
7167        crate::models::PatchedBulkWritableVpnProfileRequest,
7168    >,
7169    format: Option<&str>,
7170) -> Result<Vec<crate::models::VpnProfile>, Error<VpnVpnProfilesBulkPartialUpdateError>> {
7171    let local_var_configuration = configuration;
7172
7173    let local_var_client = &local_var_configuration.client;
7174
7175    let local_var_uri_str = format!("{}/vpn/vpn-profiles/", local_var_configuration.base_path);
7176    let mut local_var_req_builder =
7177        local_var_client.request(reqwest::Method::PATCH, local_var_uri_str.as_str());
7178
7179    if let Some(ref local_var_str) = format {
7180        local_var_req_builder =
7181            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
7182    }
7183    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
7184        local_var_req_builder =
7185            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
7186    }
7187    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
7188        let local_var_key = local_var_apikey.key.clone();
7189        let local_var_value = match local_var_apikey.prefix {
7190            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
7191            None => local_var_key,
7192        };
7193        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
7194    };
7195    local_var_req_builder = local_var_req_builder.json(&patched_bulk_writable_vpn_profile_request);
7196
7197    let local_var_req = local_var_req_builder.build()?;
7198    let local_var_resp = local_var_client.execute(local_var_req).await?;
7199
7200    let local_var_status = local_var_resp.status();
7201    let local_var_content = local_var_resp.text().await?;
7202
7203    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
7204        serde_json::from_str(&local_var_content).map_err(Error::from)
7205    } else {
7206        let local_var_entity: Option<VpnVpnProfilesBulkPartialUpdateError> =
7207            serde_json::from_str(&local_var_content).ok();
7208        let local_var_error = ResponseContent {
7209            status: local_var_status,
7210            content: local_var_content,
7211            entity: local_var_entity,
7212        };
7213        Err(Error::ResponseError(local_var_error))
7214    }
7215}
7216
7217/// VPNProfile viewset.
7218pub async fn vpn_vpn_profiles_bulk_update(
7219    configuration: &configuration::Configuration,
7220    bulk_writable_vpn_profile_request: Vec<crate::models::BulkWritableVpnProfileRequest>,
7221    format: Option<&str>,
7222) -> Result<Vec<crate::models::VpnProfile>, Error<VpnVpnProfilesBulkUpdateError>> {
7223    let local_var_configuration = configuration;
7224
7225    let local_var_client = &local_var_configuration.client;
7226
7227    let local_var_uri_str = format!("{}/vpn/vpn-profiles/", local_var_configuration.base_path);
7228    let mut local_var_req_builder =
7229        local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());
7230
7231    if let Some(ref local_var_str) = format {
7232        local_var_req_builder =
7233            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
7234    }
7235    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
7236        local_var_req_builder =
7237            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
7238    }
7239    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
7240        let local_var_key = local_var_apikey.key.clone();
7241        let local_var_value = match local_var_apikey.prefix {
7242            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
7243            None => local_var_key,
7244        };
7245        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
7246    };
7247    local_var_req_builder = local_var_req_builder.json(&bulk_writable_vpn_profile_request);
7248
7249    let local_var_req = local_var_req_builder.build()?;
7250    let local_var_resp = local_var_client.execute(local_var_req).await?;
7251
7252    let local_var_status = local_var_resp.status();
7253    let local_var_content = local_var_resp.text().await?;
7254
7255    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
7256        serde_json::from_str(&local_var_content).map_err(Error::from)
7257    } else {
7258        let local_var_entity: Option<VpnVpnProfilesBulkUpdateError> =
7259            serde_json::from_str(&local_var_content).ok();
7260        let local_var_error = ResponseContent {
7261            status: local_var_status,
7262            content: local_var_content,
7263            entity: local_var_entity,
7264        };
7265        Err(Error::ResponseError(local_var_error))
7266    }
7267}
7268
7269/// VPNProfile viewset.
7270pub async fn vpn_vpn_profiles_create(
7271    configuration: &configuration::Configuration,
7272    vpn_profile_request: crate::models::VpnProfileRequest,
7273    format: Option<&str>,
7274) -> Result<crate::models::VpnProfile, Error<VpnVpnProfilesCreateError>> {
7275    let local_var_configuration = configuration;
7276
7277    let local_var_client = &local_var_configuration.client;
7278
7279    let local_var_uri_str = format!("{}/vpn/vpn-profiles/", local_var_configuration.base_path);
7280    let mut local_var_req_builder =
7281        local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
7282
7283    if let Some(ref local_var_str) = format {
7284        local_var_req_builder =
7285            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
7286    }
7287    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
7288        local_var_req_builder =
7289            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
7290    }
7291    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
7292        let local_var_key = local_var_apikey.key.clone();
7293        let local_var_value = match local_var_apikey.prefix {
7294            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
7295            None => local_var_key,
7296        };
7297        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
7298    };
7299    local_var_req_builder = local_var_req_builder.json(&vpn_profile_request);
7300
7301    let local_var_req = local_var_req_builder.build()?;
7302    let local_var_resp = local_var_client.execute(local_var_req).await?;
7303
7304    let local_var_status = local_var_resp.status();
7305    let local_var_content = local_var_resp.text().await?;
7306
7307    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
7308        serde_json::from_str(&local_var_content).map_err(Error::from)
7309    } else {
7310        let local_var_entity: Option<VpnVpnProfilesCreateError> =
7311            serde_json::from_str(&local_var_content).ok();
7312        let local_var_error = ResponseContent {
7313            status: local_var_status,
7314            content: local_var_content,
7315            entity: local_var_entity,
7316        };
7317        Err(Error::ResponseError(local_var_error))
7318    }
7319}
7320
7321/// VPNProfile viewset.
7322pub async fn vpn_vpn_profiles_destroy(
7323    configuration: &configuration::Configuration,
7324    id: &str,
7325    format: Option<&str>,
7326) -> Result<(), Error<VpnVpnProfilesDestroyError>> {
7327    let local_var_configuration = configuration;
7328
7329    let local_var_client = &local_var_configuration.client;
7330
7331    let local_var_uri_str = format!(
7332        "{}/vpn/vpn-profiles/{id}/",
7333        local_var_configuration.base_path,
7334        id = crate::apis::urlencode(id)
7335    );
7336    let mut local_var_req_builder =
7337        local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());
7338
7339    if let Some(ref local_var_str) = format {
7340        local_var_req_builder =
7341            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
7342    }
7343    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
7344        local_var_req_builder =
7345            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
7346    }
7347    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
7348        let local_var_key = local_var_apikey.key.clone();
7349        let local_var_value = match local_var_apikey.prefix {
7350            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
7351            None => local_var_key,
7352        };
7353        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
7354    };
7355
7356    let local_var_req = local_var_req_builder.build()?;
7357    let local_var_resp = local_var_client.execute(local_var_req).await?;
7358
7359    let local_var_status = local_var_resp.status();
7360    let local_var_content = local_var_resp.text().await?;
7361
7362    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
7363        Ok(())
7364    } else {
7365        let local_var_entity: Option<VpnVpnProfilesDestroyError> =
7366            serde_json::from_str(&local_var_content).ok();
7367        let local_var_error = ResponseContent {
7368            status: local_var_status,
7369            content: local_var_content,
7370            entity: local_var_entity,
7371        };
7372        Err(Error::ResponseError(local_var_error))
7373    }
7374}
7375
7376/// VPNProfile viewset.
7377pub async fn vpn_vpn_profiles_list(
7378    configuration: &configuration::Configuration,
7379    contacts: Option<Vec<String>>,
7380    contacts__isnull: Option<bool>,
7381    contacts__n: Option<Vec<String>>,
7382    created: Option<Vec<String>>,
7383    created__gt: Option<Vec<String>>,
7384    created__gte: Option<Vec<String>>,
7385    created__isnull: Option<bool>,
7386    created__lt: Option<Vec<String>>,
7387    created__lte: Option<Vec<String>>,
7388    created__n: Option<Vec<String>>,
7389    description: Option<Vec<String>>,
7390    description__ic: Option<Vec<String>>,
7391    description__ie: Option<Vec<String>>,
7392    description__iew: Option<Vec<String>>,
7393    description__ire: Option<Vec<String>>,
7394    description__isw: Option<Vec<String>>,
7395    description__n: Option<Vec<String>>,
7396    description__nic: Option<Vec<String>>,
7397    description__nie: Option<Vec<String>>,
7398    description__niew: Option<Vec<String>>,
7399    description__nire: Option<Vec<String>>,
7400    description__nisw: Option<Vec<String>>,
7401    description__nre: Option<Vec<String>>,
7402    description__re: Option<Vec<String>>,
7403    dynamic_groups: Option<Vec<String>>,
7404    dynamic_groups__n: Option<Vec<String>>,
7405    extra_options: Option<Vec<String>>,
7406    format: Option<&str>,
7407    id: Option<Vec<uuid::Uuid>>,
7408    id__n: Option<Vec<uuid::Uuid>>,
7409    keepalive_enabled: Option<bool>,
7410    keepalive_interval: Option<Vec<i32>>,
7411    keepalive_interval__gt: Option<Vec<i32>>,
7412    keepalive_interval__gte: Option<Vec<i32>>,
7413    keepalive_interval__isnull: Option<bool>,
7414    keepalive_interval__lt: Option<Vec<i32>>,
7415    keepalive_interval__lte: Option<Vec<i32>>,
7416    keepalive_interval__n: Option<Vec<i32>>,
7417    keepalive_retries: Option<Vec<i32>>,
7418    keepalive_retries__gt: Option<Vec<i32>>,
7419    keepalive_retries__gte: Option<Vec<i32>>,
7420    keepalive_retries__isnull: Option<bool>,
7421    keepalive_retries__lt: Option<Vec<i32>>,
7422    keepalive_retries__lte: Option<Vec<i32>>,
7423    keepalive_retries__n: Option<Vec<i32>>,
7424    last_updated: Option<Vec<String>>,
7425    last_updated__gt: Option<Vec<String>>,
7426    last_updated__gte: Option<Vec<String>>,
7427    last_updated__isnull: Option<bool>,
7428    last_updated__lt: Option<Vec<String>>,
7429    last_updated__lte: Option<Vec<String>>,
7430    last_updated__n: Option<Vec<String>>,
7431    limit: Option<i32>,
7432    name: Option<Vec<String>>,
7433    name__ic: Option<Vec<String>>,
7434    name__ie: Option<Vec<String>>,
7435    name__iew: Option<Vec<String>>,
7436    name__ire: Option<Vec<String>>,
7437    name__isw: Option<Vec<String>>,
7438    name__n: Option<Vec<String>>,
7439    name__nic: Option<Vec<String>>,
7440    name__nie: Option<Vec<String>>,
7441    name__niew: Option<Vec<String>>,
7442    name__nire: Option<Vec<String>>,
7443    name__nisw: Option<Vec<String>>,
7444    name__nre: Option<Vec<String>>,
7445    name__re: Option<Vec<String>>,
7446    nat_traversal: Option<bool>,
7447    offset: Option<i32>,
7448    q: Option<&str>,
7449    role: Option<Vec<String>>,
7450    role__isnull: Option<bool>,
7451    role__n: Option<Vec<uuid::Uuid>>,
7452    secrets_group: Option<Vec<uuid::Uuid>>,
7453    secrets_group__isnull: Option<bool>,
7454    secrets_group__n: Option<Vec<uuid::Uuid>>,
7455    sort: Option<&str>,
7456    tags: Option<Vec<String>>,
7457    tags__isnull: Option<bool>,
7458    tags__n: Option<Vec<String>>,
7459    teams: Option<Vec<String>>,
7460    teams__isnull: Option<bool>,
7461    teams__n: Option<Vec<String>>,
7462    tenant: Option<Vec<String>>,
7463    tenant__isnull: Option<bool>,
7464    tenant__n: Option<Vec<String>>,
7465    tenant_group: Option<Vec<String>>,
7466    tenant_group__isnull: Option<bool>,
7467    tenant_group__n: Option<Vec<String>>,
7468    tenant_id: Option<Vec<uuid::Uuid>>,
7469    tenant_id__isnull: Option<bool>,
7470    tenant_id__n: Option<Vec<uuid::Uuid>>,
7471    vpn_phase1_policies: Option<Vec<String>>,
7472    vpn_phase1_policies__n: Option<Vec<String>>,
7473    vpn_phase2_policies: Option<Vec<String>>,
7474    vpn_phase2_policies__n: Option<Vec<String>>,
7475    depth: Option<i32>,
7476    exclude_m2m: Option<bool>,
7477) -> Result<crate::models::PaginatedVpnProfileList, Error<VpnVpnProfilesListError>> {
7478    let local_var_configuration = configuration;
7479
7480    let local_var_client = &local_var_configuration.client;
7481
7482    let local_var_uri_str = format!("{}/vpn/vpn-profiles/", local_var_configuration.base_path);
7483    let mut local_var_req_builder =
7484        local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
7485
7486    if let Some(ref local_var_str) = contacts {
7487        local_var_req_builder = match "multi" {
7488            "multi" => local_var_req_builder.query(
7489                &local_var_str
7490                    .into_iter()
7491                    .map(|p| ("contacts".to_owned(), p.to_string()))
7492                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7493            ),
7494            _ => local_var_req_builder.query(&[(
7495                "contacts",
7496                &local_var_str
7497                    .into_iter()
7498                    .map(|p| p.to_string())
7499                    .collect::<Vec<String>>()
7500                    .join(",")
7501                    .to_string(),
7502            )]),
7503        };
7504    }
7505    if let Some(ref local_var_str) = contacts__isnull {
7506        local_var_req_builder =
7507            local_var_req_builder.query(&[("contacts__isnull", &local_var_str.to_string())]);
7508    }
7509    if let Some(ref local_var_str) = contacts__n {
7510        local_var_req_builder = match "multi" {
7511            "multi" => local_var_req_builder.query(
7512                &local_var_str
7513                    .into_iter()
7514                    .map(|p| ("contacts__n".to_owned(), p.to_string()))
7515                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7516            ),
7517            _ => local_var_req_builder.query(&[(
7518                "contacts__n",
7519                &local_var_str
7520                    .into_iter()
7521                    .map(|p| p.to_string())
7522                    .collect::<Vec<String>>()
7523                    .join(",")
7524                    .to_string(),
7525            )]),
7526        };
7527    }
7528    if let Some(ref local_var_str) = created {
7529        local_var_req_builder = match "multi" {
7530            "multi" => local_var_req_builder.query(
7531                &local_var_str
7532                    .into_iter()
7533                    .map(|p| ("created".to_owned(), p.to_string()))
7534                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7535            ),
7536            _ => local_var_req_builder.query(&[(
7537                "created",
7538                &local_var_str
7539                    .into_iter()
7540                    .map(|p| p.to_string())
7541                    .collect::<Vec<String>>()
7542                    .join(",")
7543                    .to_string(),
7544            )]),
7545        };
7546    }
7547    if let Some(ref local_var_str) = created__gt {
7548        local_var_req_builder = match "multi" {
7549            "multi" => local_var_req_builder.query(
7550                &local_var_str
7551                    .into_iter()
7552                    .map(|p| ("created__gt".to_owned(), p.to_string()))
7553                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7554            ),
7555            _ => local_var_req_builder.query(&[(
7556                "created__gt",
7557                &local_var_str
7558                    .into_iter()
7559                    .map(|p| p.to_string())
7560                    .collect::<Vec<String>>()
7561                    .join(",")
7562                    .to_string(),
7563            )]),
7564        };
7565    }
7566    if let Some(ref local_var_str) = created__gte {
7567        local_var_req_builder = match "multi" {
7568            "multi" => local_var_req_builder.query(
7569                &local_var_str
7570                    .into_iter()
7571                    .map(|p| ("created__gte".to_owned(), p.to_string()))
7572                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7573            ),
7574            _ => local_var_req_builder.query(&[(
7575                "created__gte",
7576                &local_var_str
7577                    .into_iter()
7578                    .map(|p| p.to_string())
7579                    .collect::<Vec<String>>()
7580                    .join(",")
7581                    .to_string(),
7582            )]),
7583        };
7584    }
7585    if let Some(ref local_var_str) = created__isnull {
7586        local_var_req_builder =
7587            local_var_req_builder.query(&[("created__isnull", &local_var_str.to_string())]);
7588    }
7589    if let Some(ref local_var_str) = created__lt {
7590        local_var_req_builder = match "multi" {
7591            "multi" => local_var_req_builder.query(
7592                &local_var_str
7593                    .into_iter()
7594                    .map(|p| ("created__lt".to_owned(), p.to_string()))
7595                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7596            ),
7597            _ => local_var_req_builder.query(&[(
7598                "created__lt",
7599                &local_var_str
7600                    .into_iter()
7601                    .map(|p| p.to_string())
7602                    .collect::<Vec<String>>()
7603                    .join(",")
7604                    .to_string(),
7605            )]),
7606        };
7607    }
7608    if let Some(ref local_var_str) = created__lte {
7609        local_var_req_builder = match "multi" {
7610            "multi" => local_var_req_builder.query(
7611                &local_var_str
7612                    .into_iter()
7613                    .map(|p| ("created__lte".to_owned(), p.to_string()))
7614                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7615            ),
7616            _ => local_var_req_builder.query(&[(
7617                "created__lte",
7618                &local_var_str
7619                    .into_iter()
7620                    .map(|p| p.to_string())
7621                    .collect::<Vec<String>>()
7622                    .join(",")
7623                    .to_string(),
7624            )]),
7625        };
7626    }
7627    if let Some(ref local_var_str) = created__n {
7628        local_var_req_builder = match "multi" {
7629            "multi" => local_var_req_builder.query(
7630                &local_var_str
7631                    .into_iter()
7632                    .map(|p| ("created__n".to_owned(), p.to_string()))
7633                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7634            ),
7635            _ => local_var_req_builder.query(&[(
7636                "created__n",
7637                &local_var_str
7638                    .into_iter()
7639                    .map(|p| p.to_string())
7640                    .collect::<Vec<String>>()
7641                    .join(",")
7642                    .to_string(),
7643            )]),
7644        };
7645    }
7646    if let Some(ref local_var_str) = description {
7647        local_var_req_builder = match "multi" {
7648            "multi" => local_var_req_builder.query(
7649                &local_var_str
7650                    .into_iter()
7651                    .map(|p| ("description".to_owned(), p.to_string()))
7652                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7653            ),
7654            _ => local_var_req_builder.query(&[(
7655                "description",
7656                &local_var_str
7657                    .into_iter()
7658                    .map(|p| p.to_string())
7659                    .collect::<Vec<String>>()
7660                    .join(",")
7661                    .to_string(),
7662            )]),
7663        };
7664    }
7665    if let Some(ref local_var_str) = description__ic {
7666        local_var_req_builder = match "multi" {
7667            "multi" => local_var_req_builder.query(
7668                &local_var_str
7669                    .into_iter()
7670                    .map(|p| ("description__ic".to_owned(), p.to_string()))
7671                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7672            ),
7673            _ => local_var_req_builder.query(&[(
7674                "description__ic",
7675                &local_var_str
7676                    .into_iter()
7677                    .map(|p| p.to_string())
7678                    .collect::<Vec<String>>()
7679                    .join(",")
7680                    .to_string(),
7681            )]),
7682        };
7683    }
7684    if let Some(ref local_var_str) = description__ie {
7685        local_var_req_builder = match "multi" {
7686            "multi" => local_var_req_builder.query(
7687                &local_var_str
7688                    .into_iter()
7689                    .map(|p| ("description__ie".to_owned(), p.to_string()))
7690                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7691            ),
7692            _ => local_var_req_builder.query(&[(
7693                "description__ie",
7694                &local_var_str
7695                    .into_iter()
7696                    .map(|p| p.to_string())
7697                    .collect::<Vec<String>>()
7698                    .join(",")
7699                    .to_string(),
7700            )]),
7701        };
7702    }
7703    if let Some(ref local_var_str) = description__iew {
7704        local_var_req_builder = match "multi" {
7705            "multi" => local_var_req_builder.query(
7706                &local_var_str
7707                    .into_iter()
7708                    .map(|p| ("description__iew".to_owned(), p.to_string()))
7709                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7710            ),
7711            _ => local_var_req_builder.query(&[(
7712                "description__iew",
7713                &local_var_str
7714                    .into_iter()
7715                    .map(|p| p.to_string())
7716                    .collect::<Vec<String>>()
7717                    .join(",")
7718                    .to_string(),
7719            )]),
7720        };
7721    }
7722    if let Some(ref local_var_str) = description__ire {
7723        local_var_req_builder = match "multi" {
7724            "multi" => local_var_req_builder.query(
7725                &local_var_str
7726                    .into_iter()
7727                    .map(|p| ("description__ire".to_owned(), p.to_string()))
7728                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7729            ),
7730            _ => local_var_req_builder.query(&[(
7731                "description__ire",
7732                &local_var_str
7733                    .into_iter()
7734                    .map(|p| p.to_string())
7735                    .collect::<Vec<String>>()
7736                    .join(",")
7737                    .to_string(),
7738            )]),
7739        };
7740    }
7741    if let Some(ref local_var_str) = description__isw {
7742        local_var_req_builder = match "multi" {
7743            "multi" => local_var_req_builder.query(
7744                &local_var_str
7745                    .into_iter()
7746                    .map(|p| ("description__isw".to_owned(), p.to_string()))
7747                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7748            ),
7749            _ => local_var_req_builder.query(&[(
7750                "description__isw",
7751                &local_var_str
7752                    .into_iter()
7753                    .map(|p| p.to_string())
7754                    .collect::<Vec<String>>()
7755                    .join(",")
7756                    .to_string(),
7757            )]),
7758        };
7759    }
7760    if let Some(ref local_var_str) = description__n {
7761        local_var_req_builder = match "multi" {
7762            "multi" => local_var_req_builder.query(
7763                &local_var_str
7764                    .into_iter()
7765                    .map(|p| ("description__n".to_owned(), p.to_string()))
7766                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7767            ),
7768            _ => local_var_req_builder.query(&[(
7769                "description__n",
7770                &local_var_str
7771                    .into_iter()
7772                    .map(|p| p.to_string())
7773                    .collect::<Vec<String>>()
7774                    .join(",")
7775                    .to_string(),
7776            )]),
7777        };
7778    }
7779    if let Some(ref local_var_str) = description__nic {
7780        local_var_req_builder = match "multi" {
7781            "multi" => local_var_req_builder.query(
7782                &local_var_str
7783                    .into_iter()
7784                    .map(|p| ("description__nic".to_owned(), p.to_string()))
7785                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7786            ),
7787            _ => local_var_req_builder.query(&[(
7788                "description__nic",
7789                &local_var_str
7790                    .into_iter()
7791                    .map(|p| p.to_string())
7792                    .collect::<Vec<String>>()
7793                    .join(",")
7794                    .to_string(),
7795            )]),
7796        };
7797    }
7798    if let Some(ref local_var_str) = description__nie {
7799        local_var_req_builder = match "multi" {
7800            "multi" => local_var_req_builder.query(
7801                &local_var_str
7802                    .into_iter()
7803                    .map(|p| ("description__nie".to_owned(), p.to_string()))
7804                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7805            ),
7806            _ => local_var_req_builder.query(&[(
7807                "description__nie",
7808                &local_var_str
7809                    .into_iter()
7810                    .map(|p| p.to_string())
7811                    .collect::<Vec<String>>()
7812                    .join(",")
7813                    .to_string(),
7814            )]),
7815        };
7816    }
7817    if let Some(ref local_var_str) = description__niew {
7818        local_var_req_builder = match "multi" {
7819            "multi" => local_var_req_builder.query(
7820                &local_var_str
7821                    .into_iter()
7822                    .map(|p| ("description__niew".to_owned(), p.to_string()))
7823                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7824            ),
7825            _ => local_var_req_builder.query(&[(
7826                "description__niew",
7827                &local_var_str
7828                    .into_iter()
7829                    .map(|p| p.to_string())
7830                    .collect::<Vec<String>>()
7831                    .join(",")
7832                    .to_string(),
7833            )]),
7834        };
7835    }
7836    if let Some(ref local_var_str) = description__nire {
7837        local_var_req_builder = match "multi" {
7838            "multi" => local_var_req_builder.query(
7839                &local_var_str
7840                    .into_iter()
7841                    .map(|p| ("description__nire".to_owned(), p.to_string()))
7842                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7843            ),
7844            _ => local_var_req_builder.query(&[(
7845                "description__nire",
7846                &local_var_str
7847                    .into_iter()
7848                    .map(|p| p.to_string())
7849                    .collect::<Vec<String>>()
7850                    .join(",")
7851                    .to_string(),
7852            )]),
7853        };
7854    }
7855    if let Some(ref local_var_str) = description__nisw {
7856        local_var_req_builder = match "multi" {
7857            "multi" => local_var_req_builder.query(
7858                &local_var_str
7859                    .into_iter()
7860                    .map(|p| ("description__nisw".to_owned(), p.to_string()))
7861                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7862            ),
7863            _ => local_var_req_builder.query(&[(
7864                "description__nisw",
7865                &local_var_str
7866                    .into_iter()
7867                    .map(|p| p.to_string())
7868                    .collect::<Vec<String>>()
7869                    .join(",")
7870                    .to_string(),
7871            )]),
7872        };
7873    }
7874    if let Some(ref local_var_str) = description__nre {
7875        local_var_req_builder = match "multi" {
7876            "multi" => local_var_req_builder.query(
7877                &local_var_str
7878                    .into_iter()
7879                    .map(|p| ("description__nre".to_owned(), p.to_string()))
7880                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7881            ),
7882            _ => local_var_req_builder.query(&[(
7883                "description__nre",
7884                &local_var_str
7885                    .into_iter()
7886                    .map(|p| p.to_string())
7887                    .collect::<Vec<String>>()
7888                    .join(",")
7889                    .to_string(),
7890            )]),
7891        };
7892    }
7893    if let Some(ref local_var_str) = description__re {
7894        local_var_req_builder = match "multi" {
7895            "multi" => local_var_req_builder.query(
7896                &local_var_str
7897                    .into_iter()
7898                    .map(|p| ("description__re".to_owned(), p.to_string()))
7899                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7900            ),
7901            _ => local_var_req_builder.query(&[(
7902                "description__re",
7903                &local_var_str
7904                    .into_iter()
7905                    .map(|p| p.to_string())
7906                    .collect::<Vec<String>>()
7907                    .join(",")
7908                    .to_string(),
7909            )]),
7910        };
7911    }
7912    if let Some(ref local_var_str) = dynamic_groups {
7913        local_var_req_builder = match "multi" {
7914            "multi" => local_var_req_builder.query(
7915                &local_var_str
7916                    .into_iter()
7917                    .map(|p| ("dynamic_groups".to_owned(), p.to_string()))
7918                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7919            ),
7920            _ => local_var_req_builder.query(&[(
7921                "dynamic_groups",
7922                &local_var_str
7923                    .into_iter()
7924                    .map(|p| p.to_string())
7925                    .collect::<Vec<String>>()
7926                    .join(",")
7927                    .to_string(),
7928            )]),
7929        };
7930    }
7931    if let Some(ref local_var_str) = dynamic_groups__n {
7932        local_var_req_builder = match "multi" {
7933            "multi" => local_var_req_builder.query(
7934                &local_var_str
7935                    .into_iter()
7936                    .map(|p| ("dynamic_groups__n".to_owned(), p.to_string()))
7937                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7938            ),
7939            _ => local_var_req_builder.query(&[(
7940                "dynamic_groups__n",
7941                &local_var_str
7942                    .into_iter()
7943                    .map(|p| p.to_string())
7944                    .collect::<Vec<String>>()
7945                    .join(",")
7946                    .to_string(),
7947            )]),
7948        };
7949    }
7950    if let Some(ref local_var_str) = extra_options {
7951        local_var_req_builder = match "multi" {
7952            "multi" => local_var_req_builder.query(
7953                &local_var_str
7954                    .into_iter()
7955                    .map(|p| ("extra_options".to_owned(), p.to_string()))
7956                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7957            ),
7958            _ => local_var_req_builder.query(&[(
7959                "extra_options",
7960                &local_var_str
7961                    .into_iter()
7962                    .map(|p| p.to_string())
7963                    .collect::<Vec<String>>()
7964                    .join(",")
7965                    .to_string(),
7966            )]),
7967        };
7968    }
7969    if let Some(ref local_var_str) = format {
7970        local_var_req_builder =
7971            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
7972    }
7973    if let Some(ref local_var_str) = id {
7974        local_var_req_builder = match "multi" {
7975            "multi" => local_var_req_builder.query(
7976                &local_var_str
7977                    .into_iter()
7978                    .map(|p| ("id".to_owned(), p.to_string()))
7979                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7980            ),
7981            _ => local_var_req_builder.query(&[(
7982                "id",
7983                &local_var_str
7984                    .into_iter()
7985                    .map(|p| p.to_string())
7986                    .collect::<Vec<String>>()
7987                    .join(",")
7988                    .to_string(),
7989            )]),
7990        };
7991    }
7992    if let Some(ref local_var_str) = id__n {
7993        local_var_req_builder = match "multi" {
7994            "multi" => local_var_req_builder.query(
7995                &local_var_str
7996                    .into_iter()
7997                    .map(|p| ("id__n".to_owned(), p.to_string()))
7998                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7999            ),
8000            _ => local_var_req_builder.query(&[(
8001                "id__n",
8002                &local_var_str
8003                    .into_iter()
8004                    .map(|p| p.to_string())
8005                    .collect::<Vec<String>>()
8006                    .join(",")
8007                    .to_string(),
8008            )]),
8009        };
8010    }
8011    if let Some(ref local_var_str) = keepalive_enabled {
8012        local_var_req_builder =
8013            local_var_req_builder.query(&[("keepalive_enabled", &local_var_str.to_string())]);
8014    }
8015    if let Some(ref local_var_str) = keepalive_interval {
8016        local_var_req_builder = match "multi" {
8017            "multi" => local_var_req_builder.query(
8018                &local_var_str
8019                    .into_iter()
8020                    .map(|p| ("keepalive_interval".to_owned(), p.to_string()))
8021                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8022            ),
8023            _ => local_var_req_builder.query(&[(
8024                "keepalive_interval",
8025                &local_var_str
8026                    .into_iter()
8027                    .map(|p| p.to_string())
8028                    .collect::<Vec<String>>()
8029                    .join(",")
8030                    .to_string(),
8031            )]),
8032        };
8033    }
8034    if let Some(ref local_var_str) = keepalive_interval__gt {
8035        local_var_req_builder = match "multi" {
8036            "multi" => local_var_req_builder.query(
8037                &local_var_str
8038                    .into_iter()
8039                    .map(|p| ("keepalive_interval__gt".to_owned(), p.to_string()))
8040                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8041            ),
8042            _ => local_var_req_builder.query(&[(
8043                "keepalive_interval__gt",
8044                &local_var_str
8045                    .into_iter()
8046                    .map(|p| p.to_string())
8047                    .collect::<Vec<String>>()
8048                    .join(",")
8049                    .to_string(),
8050            )]),
8051        };
8052    }
8053    if let Some(ref local_var_str) = keepalive_interval__gte {
8054        local_var_req_builder = match "multi" {
8055            "multi" => local_var_req_builder.query(
8056                &local_var_str
8057                    .into_iter()
8058                    .map(|p| ("keepalive_interval__gte".to_owned(), p.to_string()))
8059                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8060            ),
8061            _ => local_var_req_builder.query(&[(
8062                "keepalive_interval__gte",
8063                &local_var_str
8064                    .into_iter()
8065                    .map(|p| p.to_string())
8066                    .collect::<Vec<String>>()
8067                    .join(",")
8068                    .to_string(),
8069            )]),
8070        };
8071    }
8072    if let Some(ref local_var_str) = keepalive_interval__isnull {
8073        local_var_req_builder = local_var_req_builder
8074            .query(&[("keepalive_interval__isnull", &local_var_str.to_string())]);
8075    }
8076    if let Some(ref local_var_str) = keepalive_interval__lt {
8077        local_var_req_builder = match "multi" {
8078            "multi" => local_var_req_builder.query(
8079                &local_var_str
8080                    .into_iter()
8081                    .map(|p| ("keepalive_interval__lt".to_owned(), p.to_string()))
8082                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8083            ),
8084            _ => local_var_req_builder.query(&[(
8085                "keepalive_interval__lt",
8086                &local_var_str
8087                    .into_iter()
8088                    .map(|p| p.to_string())
8089                    .collect::<Vec<String>>()
8090                    .join(",")
8091                    .to_string(),
8092            )]),
8093        };
8094    }
8095    if let Some(ref local_var_str) = keepalive_interval__lte {
8096        local_var_req_builder = match "multi" {
8097            "multi" => local_var_req_builder.query(
8098                &local_var_str
8099                    .into_iter()
8100                    .map(|p| ("keepalive_interval__lte".to_owned(), p.to_string()))
8101                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8102            ),
8103            _ => local_var_req_builder.query(&[(
8104                "keepalive_interval__lte",
8105                &local_var_str
8106                    .into_iter()
8107                    .map(|p| p.to_string())
8108                    .collect::<Vec<String>>()
8109                    .join(",")
8110                    .to_string(),
8111            )]),
8112        };
8113    }
8114    if let Some(ref local_var_str) = keepalive_interval__n {
8115        local_var_req_builder = match "multi" {
8116            "multi" => local_var_req_builder.query(
8117                &local_var_str
8118                    .into_iter()
8119                    .map(|p| ("keepalive_interval__n".to_owned(), p.to_string()))
8120                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8121            ),
8122            _ => local_var_req_builder.query(&[(
8123                "keepalive_interval__n",
8124                &local_var_str
8125                    .into_iter()
8126                    .map(|p| p.to_string())
8127                    .collect::<Vec<String>>()
8128                    .join(",")
8129                    .to_string(),
8130            )]),
8131        };
8132    }
8133    if let Some(ref local_var_str) = keepalive_retries {
8134        local_var_req_builder = match "multi" {
8135            "multi" => local_var_req_builder.query(
8136                &local_var_str
8137                    .into_iter()
8138                    .map(|p| ("keepalive_retries".to_owned(), p.to_string()))
8139                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8140            ),
8141            _ => local_var_req_builder.query(&[(
8142                "keepalive_retries",
8143                &local_var_str
8144                    .into_iter()
8145                    .map(|p| p.to_string())
8146                    .collect::<Vec<String>>()
8147                    .join(",")
8148                    .to_string(),
8149            )]),
8150        };
8151    }
8152    if let Some(ref local_var_str) = keepalive_retries__gt {
8153        local_var_req_builder = match "multi" {
8154            "multi" => local_var_req_builder.query(
8155                &local_var_str
8156                    .into_iter()
8157                    .map(|p| ("keepalive_retries__gt".to_owned(), p.to_string()))
8158                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8159            ),
8160            _ => local_var_req_builder.query(&[(
8161                "keepalive_retries__gt",
8162                &local_var_str
8163                    .into_iter()
8164                    .map(|p| p.to_string())
8165                    .collect::<Vec<String>>()
8166                    .join(",")
8167                    .to_string(),
8168            )]),
8169        };
8170    }
8171    if let Some(ref local_var_str) = keepalive_retries__gte {
8172        local_var_req_builder = match "multi" {
8173            "multi" => local_var_req_builder.query(
8174                &local_var_str
8175                    .into_iter()
8176                    .map(|p| ("keepalive_retries__gte".to_owned(), p.to_string()))
8177                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8178            ),
8179            _ => local_var_req_builder.query(&[(
8180                "keepalive_retries__gte",
8181                &local_var_str
8182                    .into_iter()
8183                    .map(|p| p.to_string())
8184                    .collect::<Vec<String>>()
8185                    .join(",")
8186                    .to_string(),
8187            )]),
8188        };
8189    }
8190    if let Some(ref local_var_str) = keepalive_retries__isnull {
8191        local_var_req_builder = local_var_req_builder
8192            .query(&[("keepalive_retries__isnull", &local_var_str.to_string())]);
8193    }
8194    if let Some(ref local_var_str) = keepalive_retries__lt {
8195        local_var_req_builder = match "multi" {
8196            "multi" => local_var_req_builder.query(
8197                &local_var_str
8198                    .into_iter()
8199                    .map(|p| ("keepalive_retries__lt".to_owned(), p.to_string()))
8200                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8201            ),
8202            _ => local_var_req_builder.query(&[(
8203                "keepalive_retries__lt",
8204                &local_var_str
8205                    .into_iter()
8206                    .map(|p| p.to_string())
8207                    .collect::<Vec<String>>()
8208                    .join(",")
8209                    .to_string(),
8210            )]),
8211        };
8212    }
8213    if let Some(ref local_var_str) = keepalive_retries__lte {
8214        local_var_req_builder = match "multi" {
8215            "multi" => local_var_req_builder.query(
8216                &local_var_str
8217                    .into_iter()
8218                    .map(|p| ("keepalive_retries__lte".to_owned(), p.to_string()))
8219                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8220            ),
8221            _ => local_var_req_builder.query(&[(
8222                "keepalive_retries__lte",
8223                &local_var_str
8224                    .into_iter()
8225                    .map(|p| p.to_string())
8226                    .collect::<Vec<String>>()
8227                    .join(",")
8228                    .to_string(),
8229            )]),
8230        };
8231    }
8232    if let Some(ref local_var_str) = keepalive_retries__n {
8233        local_var_req_builder = match "multi" {
8234            "multi" => local_var_req_builder.query(
8235                &local_var_str
8236                    .into_iter()
8237                    .map(|p| ("keepalive_retries__n".to_owned(), p.to_string()))
8238                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8239            ),
8240            _ => local_var_req_builder.query(&[(
8241                "keepalive_retries__n",
8242                &local_var_str
8243                    .into_iter()
8244                    .map(|p| p.to_string())
8245                    .collect::<Vec<String>>()
8246                    .join(",")
8247                    .to_string(),
8248            )]),
8249        };
8250    }
8251    if let Some(ref local_var_str) = last_updated {
8252        local_var_req_builder = match "multi" {
8253            "multi" => local_var_req_builder.query(
8254                &local_var_str
8255                    .into_iter()
8256                    .map(|p| ("last_updated".to_owned(), p.to_string()))
8257                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8258            ),
8259            _ => local_var_req_builder.query(&[(
8260                "last_updated",
8261                &local_var_str
8262                    .into_iter()
8263                    .map(|p| p.to_string())
8264                    .collect::<Vec<String>>()
8265                    .join(",")
8266                    .to_string(),
8267            )]),
8268        };
8269    }
8270    if let Some(ref local_var_str) = last_updated__gt {
8271        local_var_req_builder = match "multi" {
8272            "multi" => local_var_req_builder.query(
8273                &local_var_str
8274                    .into_iter()
8275                    .map(|p| ("last_updated__gt".to_owned(), p.to_string()))
8276                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8277            ),
8278            _ => local_var_req_builder.query(&[(
8279                "last_updated__gt",
8280                &local_var_str
8281                    .into_iter()
8282                    .map(|p| p.to_string())
8283                    .collect::<Vec<String>>()
8284                    .join(",")
8285                    .to_string(),
8286            )]),
8287        };
8288    }
8289    if let Some(ref local_var_str) = last_updated__gte {
8290        local_var_req_builder = match "multi" {
8291            "multi" => local_var_req_builder.query(
8292                &local_var_str
8293                    .into_iter()
8294                    .map(|p| ("last_updated__gte".to_owned(), p.to_string()))
8295                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8296            ),
8297            _ => local_var_req_builder.query(&[(
8298                "last_updated__gte",
8299                &local_var_str
8300                    .into_iter()
8301                    .map(|p| p.to_string())
8302                    .collect::<Vec<String>>()
8303                    .join(",")
8304                    .to_string(),
8305            )]),
8306        };
8307    }
8308    if let Some(ref local_var_str) = last_updated__isnull {
8309        local_var_req_builder =
8310            local_var_req_builder.query(&[("last_updated__isnull", &local_var_str.to_string())]);
8311    }
8312    if let Some(ref local_var_str) = last_updated__lt {
8313        local_var_req_builder = match "multi" {
8314            "multi" => local_var_req_builder.query(
8315                &local_var_str
8316                    .into_iter()
8317                    .map(|p| ("last_updated__lt".to_owned(), p.to_string()))
8318                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8319            ),
8320            _ => local_var_req_builder.query(&[(
8321                "last_updated__lt",
8322                &local_var_str
8323                    .into_iter()
8324                    .map(|p| p.to_string())
8325                    .collect::<Vec<String>>()
8326                    .join(",")
8327                    .to_string(),
8328            )]),
8329        };
8330    }
8331    if let Some(ref local_var_str) = last_updated__lte {
8332        local_var_req_builder = match "multi" {
8333            "multi" => local_var_req_builder.query(
8334                &local_var_str
8335                    .into_iter()
8336                    .map(|p| ("last_updated__lte".to_owned(), p.to_string()))
8337                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8338            ),
8339            _ => local_var_req_builder.query(&[(
8340                "last_updated__lte",
8341                &local_var_str
8342                    .into_iter()
8343                    .map(|p| p.to_string())
8344                    .collect::<Vec<String>>()
8345                    .join(",")
8346                    .to_string(),
8347            )]),
8348        };
8349    }
8350    if let Some(ref local_var_str) = last_updated__n {
8351        local_var_req_builder = match "multi" {
8352            "multi" => local_var_req_builder.query(
8353                &local_var_str
8354                    .into_iter()
8355                    .map(|p| ("last_updated__n".to_owned(), p.to_string()))
8356                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8357            ),
8358            _ => local_var_req_builder.query(&[(
8359                "last_updated__n",
8360                &local_var_str
8361                    .into_iter()
8362                    .map(|p| p.to_string())
8363                    .collect::<Vec<String>>()
8364                    .join(",")
8365                    .to_string(),
8366            )]),
8367        };
8368    }
8369    if let Some(ref local_var_str) = limit {
8370        local_var_req_builder =
8371            local_var_req_builder.query(&[("limit", &local_var_str.to_string())]);
8372    }
8373    if let Some(ref local_var_str) = name {
8374        local_var_req_builder = match "multi" {
8375            "multi" => local_var_req_builder.query(
8376                &local_var_str
8377                    .into_iter()
8378                    .map(|p| ("name".to_owned(), p.to_string()))
8379                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8380            ),
8381            _ => local_var_req_builder.query(&[(
8382                "name",
8383                &local_var_str
8384                    .into_iter()
8385                    .map(|p| p.to_string())
8386                    .collect::<Vec<String>>()
8387                    .join(",")
8388                    .to_string(),
8389            )]),
8390        };
8391    }
8392    if let Some(ref local_var_str) = name__ic {
8393        local_var_req_builder = match "multi" {
8394            "multi" => local_var_req_builder.query(
8395                &local_var_str
8396                    .into_iter()
8397                    .map(|p| ("name__ic".to_owned(), p.to_string()))
8398                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8399            ),
8400            _ => local_var_req_builder.query(&[(
8401                "name__ic",
8402                &local_var_str
8403                    .into_iter()
8404                    .map(|p| p.to_string())
8405                    .collect::<Vec<String>>()
8406                    .join(",")
8407                    .to_string(),
8408            )]),
8409        };
8410    }
8411    if let Some(ref local_var_str) = name__ie {
8412        local_var_req_builder = match "multi" {
8413            "multi" => local_var_req_builder.query(
8414                &local_var_str
8415                    .into_iter()
8416                    .map(|p| ("name__ie".to_owned(), p.to_string()))
8417                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8418            ),
8419            _ => local_var_req_builder.query(&[(
8420                "name__ie",
8421                &local_var_str
8422                    .into_iter()
8423                    .map(|p| p.to_string())
8424                    .collect::<Vec<String>>()
8425                    .join(",")
8426                    .to_string(),
8427            )]),
8428        };
8429    }
8430    if let Some(ref local_var_str) = name__iew {
8431        local_var_req_builder = match "multi" {
8432            "multi" => local_var_req_builder.query(
8433                &local_var_str
8434                    .into_iter()
8435                    .map(|p| ("name__iew".to_owned(), p.to_string()))
8436                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8437            ),
8438            _ => local_var_req_builder.query(&[(
8439                "name__iew",
8440                &local_var_str
8441                    .into_iter()
8442                    .map(|p| p.to_string())
8443                    .collect::<Vec<String>>()
8444                    .join(",")
8445                    .to_string(),
8446            )]),
8447        };
8448    }
8449    if let Some(ref local_var_str) = name__ire {
8450        local_var_req_builder = match "multi" {
8451            "multi" => local_var_req_builder.query(
8452                &local_var_str
8453                    .into_iter()
8454                    .map(|p| ("name__ire".to_owned(), p.to_string()))
8455                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8456            ),
8457            _ => local_var_req_builder.query(&[(
8458                "name__ire",
8459                &local_var_str
8460                    .into_iter()
8461                    .map(|p| p.to_string())
8462                    .collect::<Vec<String>>()
8463                    .join(",")
8464                    .to_string(),
8465            )]),
8466        };
8467    }
8468    if let Some(ref local_var_str) = name__isw {
8469        local_var_req_builder = match "multi" {
8470            "multi" => local_var_req_builder.query(
8471                &local_var_str
8472                    .into_iter()
8473                    .map(|p| ("name__isw".to_owned(), p.to_string()))
8474                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8475            ),
8476            _ => local_var_req_builder.query(&[(
8477                "name__isw",
8478                &local_var_str
8479                    .into_iter()
8480                    .map(|p| p.to_string())
8481                    .collect::<Vec<String>>()
8482                    .join(",")
8483                    .to_string(),
8484            )]),
8485        };
8486    }
8487    if let Some(ref local_var_str) = name__n {
8488        local_var_req_builder = match "multi" {
8489            "multi" => local_var_req_builder.query(
8490                &local_var_str
8491                    .into_iter()
8492                    .map(|p| ("name__n".to_owned(), p.to_string()))
8493                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8494            ),
8495            _ => local_var_req_builder.query(&[(
8496                "name__n",
8497                &local_var_str
8498                    .into_iter()
8499                    .map(|p| p.to_string())
8500                    .collect::<Vec<String>>()
8501                    .join(",")
8502                    .to_string(),
8503            )]),
8504        };
8505    }
8506    if let Some(ref local_var_str) = name__nic {
8507        local_var_req_builder = match "multi" {
8508            "multi" => local_var_req_builder.query(
8509                &local_var_str
8510                    .into_iter()
8511                    .map(|p| ("name__nic".to_owned(), p.to_string()))
8512                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8513            ),
8514            _ => local_var_req_builder.query(&[(
8515                "name__nic",
8516                &local_var_str
8517                    .into_iter()
8518                    .map(|p| p.to_string())
8519                    .collect::<Vec<String>>()
8520                    .join(",")
8521                    .to_string(),
8522            )]),
8523        };
8524    }
8525    if let Some(ref local_var_str) = name__nie {
8526        local_var_req_builder = match "multi" {
8527            "multi" => local_var_req_builder.query(
8528                &local_var_str
8529                    .into_iter()
8530                    .map(|p| ("name__nie".to_owned(), p.to_string()))
8531                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8532            ),
8533            _ => local_var_req_builder.query(&[(
8534                "name__nie",
8535                &local_var_str
8536                    .into_iter()
8537                    .map(|p| p.to_string())
8538                    .collect::<Vec<String>>()
8539                    .join(",")
8540                    .to_string(),
8541            )]),
8542        };
8543    }
8544    if let Some(ref local_var_str) = name__niew {
8545        local_var_req_builder = match "multi" {
8546            "multi" => local_var_req_builder.query(
8547                &local_var_str
8548                    .into_iter()
8549                    .map(|p| ("name__niew".to_owned(), p.to_string()))
8550                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8551            ),
8552            _ => local_var_req_builder.query(&[(
8553                "name__niew",
8554                &local_var_str
8555                    .into_iter()
8556                    .map(|p| p.to_string())
8557                    .collect::<Vec<String>>()
8558                    .join(",")
8559                    .to_string(),
8560            )]),
8561        };
8562    }
8563    if let Some(ref local_var_str) = name__nire {
8564        local_var_req_builder = match "multi" {
8565            "multi" => local_var_req_builder.query(
8566                &local_var_str
8567                    .into_iter()
8568                    .map(|p| ("name__nire".to_owned(), p.to_string()))
8569                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8570            ),
8571            _ => local_var_req_builder.query(&[(
8572                "name__nire",
8573                &local_var_str
8574                    .into_iter()
8575                    .map(|p| p.to_string())
8576                    .collect::<Vec<String>>()
8577                    .join(",")
8578                    .to_string(),
8579            )]),
8580        };
8581    }
8582    if let Some(ref local_var_str) = name__nisw {
8583        local_var_req_builder = match "multi" {
8584            "multi" => local_var_req_builder.query(
8585                &local_var_str
8586                    .into_iter()
8587                    .map(|p| ("name__nisw".to_owned(), p.to_string()))
8588                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8589            ),
8590            _ => local_var_req_builder.query(&[(
8591                "name__nisw",
8592                &local_var_str
8593                    .into_iter()
8594                    .map(|p| p.to_string())
8595                    .collect::<Vec<String>>()
8596                    .join(",")
8597                    .to_string(),
8598            )]),
8599        };
8600    }
8601    if let Some(ref local_var_str) = name__nre {
8602        local_var_req_builder = match "multi" {
8603            "multi" => local_var_req_builder.query(
8604                &local_var_str
8605                    .into_iter()
8606                    .map(|p| ("name__nre".to_owned(), p.to_string()))
8607                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8608            ),
8609            _ => local_var_req_builder.query(&[(
8610                "name__nre",
8611                &local_var_str
8612                    .into_iter()
8613                    .map(|p| p.to_string())
8614                    .collect::<Vec<String>>()
8615                    .join(",")
8616                    .to_string(),
8617            )]),
8618        };
8619    }
8620    if let Some(ref local_var_str) = name__re {
8621        local_var_req_builder = match "multi" {
8622            "multi" => local_var_req_builder.query(
8623                &local_var_str
8624                    .into_iter()
8625                    .map(|p| ("name__re".to_owned(), p.to_string()))
8626                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8627            ),
8628            _ => local_var_req_builder.query(&[(
8629                "name__re",
8630                &local_var_str
8631                    .into_iter()
8632                    .map(|p| p.to_string())
8633                    .collect::<Vec<String>>()
8634                    .join(",")
8635                    .to_string(),
8636            )]),
8637        };
8638    }
8639    if let Some(ref local_var_str) = nat_traversal {
8640        local_var_req_builder =
8641            local_var_req_builder.query(&[("nat_traversal", &local_var_str.to_string())]);
8642    }
8643    if let Some(ref local_var_str) = offset {
8644        local_var_req_builder =
8645            local_var_req_builder.query(&[("offset", &local_var_str.to_string())]);
8646    }
8647    if let Some(ref local_var_str) = q {
8648        local_var_req_builder = local_var_req_builder.query(&[("q", &local_var_str.to_string())]);
8649    }
8650    if let Some(ref local_var_str) = role {
8651        local_var_req_builder = match "multi" {
8652            "multi" => local_var_req_builder.query(
8653                &local_var_str
8654                    .into_iter()
8655                    .map(|p| ("role".to_owned(), p.to_string()))
8656                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8657            ),
8658            _ => local_var_req_builder.query(&[(
8659                "role",
8660                &local_var_str
8661                    .into_iter()
8662                    .map(|p| p.to_string())
8663                    .collect::<Vec<String>>()
8664                    .join(",")
8665                    .to_string(),
8666            )]),
8667        };
8668    }
8669    if let Some(ref local_var_str) = role__isnull {
8670        local_var_req_builder =
8671            local_var_req_builder.query(&[("role__isnull", &local_var_str.to_string())]);
8672    }
8673    if let Some(ref local_var_str) = role__n {
8674        local_var_req_builder = match "multi" {
8675            "multi" => local_var_req_builder.query(
8676                &local_var_str
8677                    .into_iter()
8678                    .map(|p| ("role__n".to_owned(), p.to_string()))
8679                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8680            ),
8681            _ => local_var_req_builder.query(&[(
8682                "role__n",
8683                &local_var_str
8684                    .into_iter()
8685                    .map(|p| p.to_string())
8686                    .collect::<Vec<String>>()
8687                    .join(",")
8688                    .to_string(),
8689            )]),
8690        };
8691    }
8692    if let Some(ref local_var_str) = secrets_group {
8693        local_var_req_builder = match "multi" {
8694            "multi" => local_var_req_builder.query(
8695                &local_var_str
8696                    .into_iter()
8697                    .map(|p| ("secrets_group".to_owned(), p.to_string()))
8698                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8699            ),
8700            _ => local_var_req_builder.query(&[(
8701                "secrets_group",
8702                &local_var_str
8703                    .into_iter()
8704                    .map(|p| p.to_string())
8705                    .collect::<Vec<String>>()
8706                    .join(",")
8707                    .to_string(),
8708            )]),
8709        };
8710    }
8711    if let Some(ref local_var_str) = secrets_group__isnull {
8712        local_var_req_builder =
8713            local_var_req_builder.query(&[("secrets_group__isnull", &local_var_str.to_string())]);
8714    }
8715    if let Some(ref local_var_str) = secrets_group__n {
8716        local_var_req_builder = match "multi" {
8717            "multi" => local_var_req_builder.query(
8718                &local_var_str
8719                    .into_iter()
8720                    .map(|p| ("secrets_group__n".to_owned(), p.to_string()))
8721                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8722            ),
8723            _ => local_var_req_builder.query(&[(
8724                "secrets_group__n",
8725                &local_var_str
8726                    .into_iter()
8727                    .map(|p| p.to_string())
8728                    .collect::<Vec<String>>()
8729                    .join(",")
8730                    .to_string(),
8731            )]),
8732        };
8733    }
8734    if let Some(ref local_var_str) = sort {
8735        local_var_req_builder =
8736            local_var_req_builder.query(&[("sort", &local_var_str.to_string())]);
8737    }
8738    if let Some(ref local_var_str) = tags {
8739        local_var_req_builder = match "multi" {
8740            "multi" => local_var_req_builder.query(
8741                &local_var_str
8742                    .into_iter()
8743                    .map(|p| ("tags".to_owned(), p.to_string()))
8744                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8745            ),
8746            _ => local_var_req_builder.query(&[(
8747                "tags",
8748                &local_var_str
8749                    .into_iter()
8750                    .map(|p| p.to_string())
8751                    .collect::<Vec<String>>()
8752                    .join(",")
8753                    .to_string(),
8754            )]),
8755        };
8756    }
8757    if let Some(ref local_var_str) = tags__isnull {
8758        local_var_req_builder =
8759            local_var_req_builder.query(&[("tags__isnull", &local_var_str.to_string())]);
8760    }
8761    if let Some(ref local_var_str) = tags__n {
8762        local_var_req_builder = match "multi" {
8763            "multi" => local_var_req_builder.query(
8764                &local_var_str
8765                    .into_iter()
8766                    .map(|p| ("tags__n".to_owned(), p.to_string()))
8767                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8768            ),
8769            _ => local_var_req_builder.query(&[(
8770                "tags__n",
8771                &local_var_str
8772                    .into_iter()
8773                    .map(|p| p.to_string())
8774                    .collect::<Vec<String>>()
8775                    .join(",")
8776                    .to_string(),
8777            )]),
8778        };
8779    }
8780    if let Some(ref local_var_str) = teams {
8781        local_var_req_builder = match "multi" {
8782            "multi" => local_var_req_builder.query(
8783                &local_var_str
8784                    .into_iter()
8785                    .map(|p| ("teams".to_owned(), p.to_string()))
8786                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8787            ),
8788            _ => local_var_req_builder.query(&[(
8789                "teams",
8790                &local_var_str
8791                    .into_iter()
8792                    .map(|p| p.to_string())
8793                    .collect::<Vec<String>>()
8794                    .join(",")
8795                    .to_string(),
8796            )]),
8797        };
8798    }
8799    if let Some(ref local_var_str) = teams__isnull {
8800        local_var_req_builder =
8801            local_var_req_builder.query(&[("teams__isnull", &local_var_str.to_string())]);
8802    }
8803    if let Some(ref local_var_str) = teams__n {
8804        local_var_req_builder = match "multi" {
8805            "multi" => local_var_req_builder.query(
8806                &local_var_str
8807                    .into_iter()
8808                    .map(|p| ("teams__n".to_owned(), p.to_string()))
8809                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8810            ),
8811            _ => local_var_req_builder.query(&[(
8812                "teams__n",
8813                &local_var_str
8814                    .into_iter()
8815                    .map(|p| p.to_string())
8816                    .collect::<Vec<String>>()
8817                    .join(",")
8818                    .to_string(),
8819            )]),
8820        };
8821    }
8822    if let Some(ref local_var_str) = tenant {
8823        local_var_req_builder = match "multi" {
8824            "multi" => local_var_req_builder.query(
8825                &local_var_str
8826                    .into_iter()
8827                    .map(|p| ("tenant".to_owned(), p.to_string()))
8828                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8829            ),
8830            _ => local_var_req_builder.query(&[(
8831                "tenant",
8832                &local_var_str
8833                    .into_iter()
8834                    .map(|p| p.to_string())
8835                    .collect::<Vec<String>>()
8836                    .join(",")
8837                    .to_string(),
8838            )]),
8839        };
8840    }
8841    if let Some(ref local_var_str) = tenant__isnull {
8842        local_var_req_builder =
8843            local_var_req_builder.query(&[("tenant__isnull", &local_var_str.to_string())]);
8844    }
8845    if let Some(ref local_var_str) = tenant__n {
8846        local_var_req_builder = match "multi" {
8847            "multi" => local_var_req_builder.query(
8848                &local_var_str
8849                    .into_iter()
8850                    .map(|p| ("tenant__n".to_owned(), p.to_string()))
8851                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8852            ),
8853            _ => local_var_req_builder.query(&[(
8854                "tenant__n",
8855                &local_var_str
8856                    .into_iter()
8857                    .map(|p| p.to_string())
8858                    .collect::<Vec<String>>()
8859                    .join(",")
8860                    .to_string(),
8861            )]),
8862        };
8863    }
8864    if let Some(ref local_var_str) = tenant_group {
8865        local_var_req_builder = match "multi" {
8866            "multi" => local_var_req_builder.query(
8867                &local_var_str
8868                    .into_iter()
8869                    .map(|p| ("tenant_group".to_owned(), p.to_string()))
8870                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8871            ),
8872            _ => local_var_req_builder.query(&[(
8873                "tenant_group",
8874                &local_var_str
8875                    .into_iter()
8876                    .map(|p| p.to_string())
8877                    .collect::<Vec<String>>()
8878                    .join(",")
8879                    .to_string(),
8880            )]),
8881        };
8882    }
8883    if let Some(ref local_var_str) = tenant_group__isnull {
8884        local_var_req_builder =
8885            local_var_req_builder.query(&[("tenant_group__isnull", &local_var_str.to_string())]);
8886    }
8887    if let Some(ref local_var_str) = tenant_group__n {
8888        local_var_req_builder = match "multi" {
8889            "multi" => local_var_req_builder.query(
8890                &local_var_str
8891                    .into_iter()
8892                    .map(|p| ("tenant_group__n".to_owned(), p.to_string()))
8893                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8894            ),
8895            _ => local_var_req_builder.query(&[(
8896                "tenant_group__n",
8897                &local_var_str
8898                    .into_iter()
8899                    .map(|p| p.to_string())
8900                    .collect::<Vec<String>>()
8901                    .join(",")
8902                    .to_string(),
8903            )]),
8904        };
8905    }
8906    if let Some(ref local_var_str) = tenant_id {
8907        local_var_req_builder = match "multi" {
8908            "multi" => local_var_req_builder.query(
8909                &local_var_str
8910                    .into_iter()
8911                    .map(|p| ("tenant_id".to_owned(), p.to_string()))
8912                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8913            ),
8914            _ => local_var_req_builder.query(&[(
8915                "tenant_id",
8916                &local_var_str
8917                    .into_iter()
8918                    .map(|p| p.to_string())
8919                    .collect::<Vec<String>>()
8920                    .join(",")
8921                    .to_string(),
8922            )]),
8923        };
8924    }
8925    if let Some(ref local_var_str) = tenant_id__isnull {
8926        local_var_req_builder =
8927            local_var_req_builder.query(&[("tenant_id__isnull", &local_var_str.to_string())]);
8928    }
8929    if let Some(ref local_var_str) = tenant_id__n {
8930        local_var_req_builder = match "multi" {
8931            "multi" => local_var_req_builder.query(
8932                &local_var_str
8933                    .into_iter()
8934                    .map(|p| ("tenant_id__n".to_owned(), p.to_string()))
8935                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8936            ),
8937            _ => local_var_req_builder.query(&[(
8938                "tenant_id__n",
8939                &local_var_str
8940                    .into_iter()
8941                    .map(|p| p.to_string())
8942                    .collect::<Vec<String>>()
8943                    .join(",")
8944                    .to_string(),
8945            )]),
8946        };
8947    }
8948    if let Some(ref local_var_str) = vpn_phase1_policies {
8949        local_var_req_builder = match "multi" {
8950            "multi" => local_var_req_builder.query(
8951                &local_var_str
8952                    .into_iter()
8953                    .map(|p| ("vpn_phase1_policies".to_owned(), p.to_string()))
8954                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8955            ),
8956            _ => local_var_req_builder.query(&[(
8957                "vpn_phase1_policies",
8958                &local_var_str
8959                    .into_iter()
8960                    .map(|p| p.to_string())
8961                    .collect::<Vec<String>>()
8962                    .join(",")
8963                    .to_string(),
8964            )]),
8965        };
8966    }
8967    if let Some(ref local_var_str) = vpn_phase1_policies__n {
8968        local_var_req_builder = match "multi" {
8969            "multi" => local_var_req_builder.query(
8970                &local_var_str
8971                    .into_iter()
8972                    .map(|p| ("vpn_phase1_policies__n".to_owned(), p.to_string()))
8973                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8974            ),
8975            _ => local_var_req_builder.query(&[(
8976                "vpn_phase1_policies__n",
8977                &local_var_str
8978                    .into_iter()
8979                    .map(|p| p.to_string())
8980                    .collect::<Vec<String>>()
8981                    .join(",")
8982                    .to_string(),
8983            )]),
8984        };
8985    }
8986    if let Some(ref local_var_str) = vpn_phase2_policies {
8987        local_var_req_builder = match "multi" {
8988            "multi" => local_var_req_builder.query(
8989                &local_var_str
8990                    .into_iter()
8991                    .map(|p| ("vpn_phase2_policies".to_owned(), p.to_string()))
8992                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8993            ),
8994            _ => local_var_req_builder.query(&[(
8995                "vpn_phase2_policies",
8996                &local_var_str
8997                    .into_iter()
8998                    .map(|p| p.to_string())
8999                    .collect::<Vec<String>>()
9000                    .join(",")
9001                    .to_string(),
9002            )]),
9003        };
9004    }
9005    if let Some(ref local_var_str) = vpn_phase2_policies__n {
9006        local_var_req_builder = match "multi" {
9007            "multi" => local_var_req_builder.query(
9008                &local_var_str
9009                    .into_iter()
9010                    .map(|p| ("vpn_phase2_policies__n".to_owned(), p.to_string()))
9011                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9012            ),
9013            _ => local_var_req_builder.query(&[(
9014                "vpn_phase2_policies__n",
9015                &local_var_str
9016                    .into_iter()
9017                    .map(|p| p.to_string())
9018                    .collect::<Vec<String>>()
9019                    .join(",")
9020                    .to_string(),
9021            )]),
9022        };
9023    }
9024    if let Some(ref local_var_str) = depth {
9025        local_var_req_builder =
9026            local_var_req_builder.query(&[("depth", &local_var_str.to_string())]);
9027    }
9028    if let Some(ref local_var_str) = exclude_m2m {
9029        local_var_req_builder =
9030            local_var_req_builder.query(&[("exclude_m2m", &local_var_str.to_string())]);
9031    }
9032    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
9033        local_var_req_builder =
9034            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
9035    }
9036    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
9037        let local_var_key = local_var_apikey.key.clone();
9038        let local_var_value = match local_var_apikey.prefix {
9039            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
9040            None => local_var_key,
9041        };
9042        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
9043    };
9044
9045    let local_var_req = local_var_req_builder.build()?;
9046    let local_var_resp = local_var_client.execute(local_var_req).await?;
9047
9048    let local_var_status = local_var_resp.status();
9049    let local_var_content = local_var_resp.text().await?;
9050
9051    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
9052        serde_json::from_str(&local_var_content).map_err(Error::from)
9053    } else {
9054        let local_var_entity: Option<VpnVpnProfilesListError> =
9055            serde_json::from_str(&local_var_content).ok();
9056        let local_var_error = ResponseContent {
9057            status: local_var_status,
9058            content: local_var_content,
9059            entity: local_var_entity,
9060        };
9061        Err(Error::ResponseError(local_var_error))
9062    }
9063}
9064
9065/// API methods for returning or creating notes on an object.
9066pub async fn vpn_vpn_profiles_notes_create(
9067    configuration: &configuration::Configuration,
9068    id: &str,
9069    note_input_request: crate::models::NoteInputRequest,
9070    format: Option<&str>,
9071) -> Result<crate::models::Note, Error<VpnVpnProfilesNotesCreateError>> {
9072    let local_var_configuration = configuration;
9073
9074    let local_var_client = &local_var_configuration.client;
9075
9076    let local_var_uri_str = format!(
9077        "{}/vpn/vpn-profiles/{id}/notes/",
9078        local_var_configuration.base_path,
9079        id = crate::apis::urlencode(id)
9080    );
9081    let mut local_var_req_builder =
9082        local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
9083
9084    if let Some(ref local_var_str) = format {
9085        local_var_req_builder =
9086            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
9087    }
9088    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
9089        local_var_req_builder =
9090            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
9091    }
9092    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
9093        let local_var_key = local_var_apikey.key.clone();
9094        let local_var_value = match local_var_apikey.prefix {
9095            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
9096            None => local_var_key,
9097        };
9098        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
9099    };
9100    local_var_req_builder = local_var_req_builder.json(&note_input_request);
9101
9102    let local_var_req = local_var_req_builder.build()?;
9103    let local_var_resp = local_var_client.execute(local_var_req).await?;
9104
9105    let local_var_status = local_var_resp.status();
9106    let local_var_content = local_var_resp.text().await?;
9107
9108    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
9109        serde_json::from_str(&local_var_content).map_err(Error::from)
9110    } else {
9111        let local_var_entity: Option<VpnVpnProfilesNotesCreateError> =
9112            serde_json::from_str(&local_var_content).ok();
9113        let local_var_error = ResponseContent {
9114            status: local_var_status,
9115            content: local_var_content,
9116            entity: local_var_entity,
9117        };
9118        Err(Error::ResponseError(local_var_error))
9119    }
9120}
9121
9122/// API methods for returning or creating notes on an object.
9123pub async fn vpn_vpn_profiles_notes_list(
9124    configuration: &configuration::Configuration,
9125    id: &str,
9126    format: Option<&str>,
9127    limit: Option<i32>,
9128    offset: Option<i32>,
9129    depth: Option<i32>,
9130    exclude_m2m: Option<bool>,
9131) -> Result<crate::models::PaginatedNoteList, Error<VpnVpnProfilesNotesListError>> {
9132    let local_var_configuration = configuration;
9133
9134    let local_var_client = &local_var_configuration.client;
9135
9136    let local_var_uri_str = format!(
9137        "{}/vpn/vpn-profiles/{id}/notes/",
9138        local_var_configuration.base_path,
9139        id = crate::apis::urlencode(id)
9140    );
9141    let mut local_var_req_builder =
9142        local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
9143
9144    if let Some(ref local_var_str) = format {
9145        local_var_req_builder =
9146            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
9147    }
9148    if let Some(ref local_var_str) = limit {
9149        local_var_req_builder =
9150            local_var_req_builder.query(&[("limit", &local_var_str.to_string())]);
9151    }
9152    if let Some(ref local_var_str) = offset {
9153        local_var_req_builder =
9154            local_var_req_builder.query(&[("offset", &local_var_str.to_string())]);
9155    }
9156    if let Some(ref local_var_str) = depth {
9157        local_var_req_builder =
9158            local_var_req_builder.query(&[("depth", &local_var_str.to_string())]);
9159    }
9160    if let Some(ref local_var_str) = exclude_m2m {
9161        local_var_req_builder =
9162            local_var_req_builder.query(&[("exclude_m2m", &local_var_str.to_string())]);
9163    }
9164    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
9165        local_var_req_builder =
9166            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
9167    }
9168    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
9169        let local_var_key = local_var_apikey.key.clone();
9170        let local_var_value = match local_var_apikey.prefix {
9171            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
9172            None => local_var_key,
9173        };
9174        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
9175    };
9176
9177    let local_var_req = local_var_req_builder.build()?;
9178    let local_var_resp = local_var_client.execute(local_var_req).await?;
9179
9180    let local_var_status = local_var_resp.status();
9181    let local_var_content = local_var_resp.text().await?;
9182
9183    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
9184        serde_json::from_str(&local_var_content).map_err(Error::from)
9185    } else {
9186        let local_var_entity: Option<VpnVpnProfilesNotesListError> =
9187            serde_json::from_str(&local_var_content).ok();
9188        let local_var_error = ResponseContent {
9189            status: local_var_status,
9190            content: local_var_content,
9191            entity: local_var_entity,
9192        };
9193        Err(Error::ResponseError(local_var_error))
9194    }
9195}
9196
9197/// VPNProfile viewset.
9198pub async fn vpn_vpn_profiles_partial_update(
9199    configuration: &configuration::Configuration,
9200    id: &str,
9201    format: Option<&str>,
9202    patched_vpn_profile_request: Option<crate::models::PatchedVpnProfileRequest>,
9203) -> Result<crate::models::VpnProfile, Error<VpnVpnProfilesPartialUpdateError>> {
9204    let local_var_configuration = configuration;
9205
9206    let local_var_client = &local_var_configuration.client;
9207
9208    let local_var_uri_str = format!(
9209        "{}/vpn/vpn-profiles/{id}/",
9210        local_var_configuration.base_path,
9211        id = crate::apis::urlencode(id)
9212    );
9213    let mut local_var_req_builder =
9214        local_var_client.request(reqwest::Method::PATCH, local_var_uri_str.as_str());
9215
9216    if let Some(ref local_var_str) = format {
9217        local_var_req_builder =
9218            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
9219    }
9220    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
9221        local_var_req_builder =
9222            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
9223    }
9224    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
9225        let local_var_key = local_var_apikey.key.clone();
9226        let local_var_value = match local_var_apikey.prefix {
9227            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
9228            None => local_var_key,
9229        };
9230        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
9231    };
9232    local_var_req_builder = local_var_req_builder.json(&patched_vpn_profile_request);
9233
9234    let local_var_req = local_var_req_builder.build()?;
9235    let local_var_resp = local_var_client.execute(local_var_req).await?;
9236
9237    let local_var_status = local_var_resp.status();
9238    let local_var_content = local_var_resp.text().await?;
9239
9240    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
9241        serde_json::from_str(&local_var_content).map_err(Error::from)
9242    } else {
9243        let local_var_entity: Option<VpnVpnProfilesPartialUpdateError> =
9244            serde_json::from_str(&local_var_content).ok();
9245        let local_var_error = ResponseContent {
9246            status: local_var_status,
9247            content: local_var_content,
9248            entity: local_var_entity,
9249        };
9250        Err(Error::ResponseError(local_var_error))
9251    }
9252}
9253
9254/// VPNProfile viewset.
9255pub async fn vpn_vpn_profiles_retrieve(
9256    configuration: &configuration::Configuration,
9257    id: &str,
9258    format: Option<&str>,
9259    depth: Option<i32>,
9260    exclude_m2m: Option<bool>,
9261) -> Result<crate::models::VpnProfile, Error<VpnVpnProfilesRetrieveError>> {
9262    let local_var_configuration = configuration;
9263
9264    let local_var_client = &local_var_configuration.client;
9265
9266    let local_var_uri_str = format!(
9267        "{}/vpn/vpn-profiles/{id}/",
9268        local_var_configuration.base_path,
9269        id = crate::apis::urlencode(id)
9270    );
9271    let mut local_var_req_builder =
9272        local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
9273
9274    if let Some(ref local_var_str) = format {
9275        local_var_req_builder =
9276            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
9277    }
9278    if let Some(ref local_var_str) = depth {
9279        local_var_req_builder =
9280            local_var_req_builder.query(&[("depth", &local_var_str.to_string())]);
9281    }
9282    if let Some(ref local_var_str) = exclude_m2m {
9283        local_var_req_builder =
9284            local_var_req_builder.query(&[("exclude_m2m", &local_var_str.to_string())]);
9285    }
9286    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
9287        local_var_req_builder =
9288            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
9289    }
9290    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
9291        let local_var_key = local_var_apikey.key.clone();
9292        let local_var_value = match local_var_apikey.prefix {
9293            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
9294            None => local_var_key,
9295        };
9296        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
9297    };
9298
9299    let local_var_req = local_var_req_builder.build()?;
9300    let local_var_resp = local_var_client.execute(local_var_req).await?;
9301
9302    let local_var_status = local_var_resp.status();
9303    let local_var_content = local_var_resp.text().await?;
9304
9305    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
9306        serde_json::from_str(&local_var_content).map_err(Error::from)
9307    } else {
9308        let local_var_entity: Option<VpnVpnProfilesRetrieveError> =
9309            serde_json::from_str(&local_var_content).ok();
9310        let local_var_error = ResponseContent {
9311            status: local_var_status,
9312            content: local_var_content,
9313            entity: local_var_entity,
9314        };
9315        Err(Error::ResponseError(local_var_error))
9316    }
9317}
9318
9319/// VPNProfile viewset.
9320pub async fn vpn_vpn_profiles_update(
9321    configuration: &configuration::Configuration,
9322    id: &str,
9323    vpn_profile_request: crate::models::VpnProfileRequest,
9324    format: Option<&str>,
9325) -> Result<crate::models::VpnProfile, Error<VpnVpnProfilesUpdateError>> {
9326    let local_var_configuration = configuration;
9327
9328    let local_var_client = &local_var_configuration.client;
9329
9330    let local_var_uri_str = format!(
9331        "{}/vpn/vpn-profiles/{id}/",
9332        local_var_configuration.base_path,
9333        id = crate::apis::urlencode(id)
9334    );
9335    let mut local_var_req_builder =
9336        local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());
9337
9338    if let Some(ref local_var_str) = format {
9339        local_var_req_builder =
9340            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
9341    }
9342    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
9343        local_var_req_builder =
9344            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
9345    }
9346    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
9347        let local_var_key = local_var_apikey.key.clone();
9348        let local_var_value = match local_var_apikey.prefix {
9349            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
9350            None => local_var_key,
9351        };
9352        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
9353    };
9354    local_var_req_builder = local_var_req_builder.json(&vpn_profile_request);
9355
9356    let local_var_req = local_var_req_builder.build()?;
9357    let local_var_resp = local_var_client.execute(local_var_req).await?;
9358
9359    let local_var_status = local_var_resp.status();
9360    let local_var_content = local_var_resp.text().await?;
9361
9362    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
9363        serde_json::from_str(&local_var_content).map_err(Error::from)
9364    } else {
9365        let local_var_entity: Option<VpnVpnProfilesUpdateError> =
9366            serde_json::from_str(&local_var_content).ok();
9367        let local_var_error = ResponseContent {
9368            status: local_var_status,
9369            content: local_var_content,
9370            entity: local_var_entity,
9371        };
9372        Err(Error::ResponseError(local_var_error))
9373    }
9374}
9375
9376/// VPNTermination viewset.
9377pub async fn vpn_vpn_terminations_bulk_destroy(
9378    configuration: &configuration::Configuration,
9379    bulk_operation_request: Vec<crate::models::BulkOperationRequest>,
9380    format: Option<&str>,
9381) -> Result<(), Error<VpnVpnTerminationsBulkDestroyError>> {
9382    let local_var_configuration = configuration;
9383
9384    let local_var_client = &local_var_configuration.client;
9385
9386    let local_var_uri_str = format!(
9387        "{}/vpn/vpn-terminations/",
9388        local_var_configuration.base_path
9389    );
9390    let mut local_var_req_builder =
9391        local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());
9392
9393    if let Some(ref local_var_str) = format {
9394        local_var_req_builder =
9395            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
9396    }
9397    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
9398        local_var_req_builder =
9399            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
9400    }
9401    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
9402        let local_var_key = local_var_apikey.key.clone();
9403        let local_var_value = match local_var_apikey.prefix {
9404            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
9405            None => local_var_key,
9406        };
9407        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
9408    };
9409    local_var_req_builder = local_var_req_builder.json(&bulk_operation_request);
9410
9411    let local_var_req = local_var_req_builder.build()?;
9412    let local_var_resp = local_var_client.execute(local_var_req).await?;
9413
9414    let local_var_status = local_var_resp.status();
9415    let local_var_content = local_var_resp.text().await?;
9416
9417    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
9418        Ok(())
9419    } else {
9420        let local_var_entity: Option<VpnVpnTerminationsBulkDestroyError> =
9421            serde_json::from_str(&local_var_content).ok();
9422        let local_var_error = ResponseContent {
9423            status: local_var_status,
9424            content: local_var_content,
9425            entity: local_var_entity,
9426        };
9427        Err(Error::ResponseError(local_var_error))
9428    }
9429}
9430
9431/// VPNTermination viewset.
9432pub async fn vpn_vpn_terminations_bulk_partial_update(
9433    configuration: &configuration::Configuration,
9434    patched_bulk_writable_vpn_termination_request: Vec<
9435        crate::models::PatchedBulkWritableVpnTerminationRequest,
9436    >,
9437    format: Option<&str>,
9438) -> Result<Vec<crate::models::VpnTermination>, Error<VpnVpnTerminationsBulkPartialUpdateError>> {
9439    let local_var_configuration = configuration;
9440
9441    let local_var_client = &local_var_configuration.client;
9442
9443    let local_var_uri_str = format!(
9444        "{}/vpn/vpn-terminations/",
9445        local_var_configuration.base_path
9446    );
9447    let mut local_var_req_builder =
9448        local_var_client.request(reqwest::Method::PATCH, local_var_uri_str.as_str());
9449
9450    if let Some(ref local_var_str) = format {
9451        local_var_req_builder =
9452            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
9453    }
9454    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
9455        local_var_req_builder =
9456            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
9457    }
9458    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
9459        let local_var_key = local_var_apikey.key.clone();
9460        let local_var_value = match local_var_apikey.prefix {
9461            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
9462            None => local_var_key,
9463        };
9464        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
9465    };
9466    local_var_req_builder =
9467        local_var_req_builder.json(&patched_bulk_writable_vpn_termination_request);
9468
9469    let local_var_req = local_var_req_builder.build()?;
9470    let local_var_resp = local_var_client.execute(local_var_req).await?;
9471
9472    let local_var_status = local_var_resp.status();
9473    let local_var_content = local_var_resp.text().await?;
9474
9475    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
9476        serde_json::from_str(&local_var_content).map_err(Error::from)
9477    } else {
9478        let local_var_entity: Option<VpnVpnTerminationsBulkPartialUpdateError> =
9479            serde_json::from_str(&local_var_content).ok();
9480        let local_var_error = ResponseContent {
9481            status: local_var_status,
9482            content: local_var_content,
9483            entity: local_var_entity,
9484        };
9485        Err(Error::ResponseError(local_var_error))
9486    }
9487}
9488
9489/// VPNTermination viewset.
9490pub async fn vpn_vpn_terminations_bulk_update(
9491    configuration: &configuration::Configuration,
9492    bulk_writable_vpn_termination_request: Vec<crate::models::BulkWritableVpnTerminationRequest>,
9493    format: Option<&str>,
9494) -> Result<Vec<crate::models::VpnTermination>, Error<VpnVpnTerminationsBulkUpdateError>> {
9495    let local_var_configuration = configuration;
9496
9497    let local_var_client = &local_var_configuration.client;
9498
9499    let local_var_uri_str = format!(
9500        "{}/vpn/vpn-terminations/",
9501        local_var_configuration.base_path
9502    );
9503    let mut local_var_req_builder =
9504        local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());
9505
9506    if let Some(ref local_var_str) = format {
9507        local_var_req_builder =
9508            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
9509    }
9510    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
9511        local_var_req_builder =
9512            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
9513    }
9514    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
9515        let local_var_key = local_var_apikey.key.clone();
9516        let local_var_value = match local_var_apikey.prefix {
9517            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
9518            None => local_var_key,
9519        };
9520        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
9521    };
9522    local_var_req_builder = local_var_req_builder.json(&bulk_writable_vpn_termination_request);
9523
9524    let local_var_req = local_var_req_builder.build()?;
9525    let local_var_resp = local_var_client.execute(local_var_req).await?;
9526
9527    let local_var_status = local_var_resp.status();
9528    let local_var_content = local_var_resp.text().await?;
9529
9530    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
9531        serde_json::from_str(&local_var_content).map_err(Error::from)
9532    } else {
9533        let local_var_entity: Option<VpnVpnTerminationsBulkUpdateError> =
9534            serde_json::from_str(&local_var_content).ok();
9535        let local_var_error = ResponseContent {
9536            status: local_var_status,
9537            content: local_var_content,
9538            entity: local_var_entity,
9539        };
9540        Err(Error::ResponseError(local_var_error))
9541    }
9542}
9543
9544/// VPNTermination viewset.
9545pub async fn vpn_vpn_terminations_create(
9546    configuration: &configuration::Configuration,
9547    vpn_termination_request: crate::models::VpnTerminationRequest,
9548    format: Option<&str>,
9549) -> Result<crate::models::VpnTermination, Error<VpnVpnTerminationsCreateError>> {
9550    let local_var_configuration = configuration;
9551
9552    let local_var_client = &local_var_configuration.client;
9553
9554    let local_var_uri_str = format!(
9555        "{}/vpn/vpn-terminations/",
9556        local_var_configuration.base_path
9557    );
9558    let mut local_var_req_builder =
9559        local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
9560
9561    if let Some(ref local_var_str) = format {
9562        local_var_req_builder =
9563            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
9564    }
9565    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
9566        local_var_req_builder =
9567            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
9568    }
9569    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
9570        let local_var_key = local_var_apikey.key.clone();
9571        let local_var_value = match local_var_apikey.prefix {
9572            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
9573            None => local_var_key,
9574        };
9575        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
9576    };
9577    local_var_req_builder = local_var_req_builder.json(&vpn_termination_request);
9578
9579    let local_var_req = local_var_req_builder.build()?;
9580    let local_var_resp = local_var_client.execute(local_var_req).await?;
9581
9582    let local_var_status = local_var_resp.status();
9583    let local_var_content = local_var_resp.text().await?;
9584
9585    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
9586        serde_json::from_str(&local_var_content).map_err(Error::from)
9587    } else {
9588        let local_var_entity: Option<VpnVpnTerminationsCreateError> =
9589            serde_json::from_str(&local_var_content).ok();
9590        let local_var_error = ResponseContent {
9591            status: local_var_status,
9592            content: local_var_content,
9593            entity: local_var_entity,
9594        };
9595        Err(Error::ResponseError(local_var_error))
9596    }
9597}
9598
9599/// VPNTermination viewset.
9600pub async fn vpn_vpn_terminations_destroy(
9601    configuration: &configuration::Configuration,
9602    id: &str,
9603    format: Option<&str>,
9604) -> Result<(), Error<VpnVpnTerminationsDestroyError>> {
9605    let local_var_configuration = configuration;
9606
9607    let local_var_client = &local_var_configuration.client;
9608
9609    let local_var_uri_str = format!(
9610        "{}/vpn/vpn-terminations/{id}/",
9611        local_var_configuration.base_path,
9612        id = crate::apis::urlencode(id)
9613    );
9614    let mut local_var_req_builder =
9615        local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());
9616
9617    if let Some(ref local_var_str) = format {
9618        local_var_req_builder =
9619            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
9620    }
9621    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
9622        local_var_req_builder =
9623            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
9624    }
9625    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
9626        let local_var_key = local_var_apikey.key.clone();
9627        let local_var_value = match local_var_apikey.prefix {
9628            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
9629            None => local_var_key,
9630        };
9631        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
9632    };
9633
9634    let local_var_req = local_var_req_builder.build()?;
9635    let local_var_resp = local_var_client.execute(local_var_req).await?;
9636
9637    let local_var_status = local_var_resp.status();
9638    let local_var_content = local_var_resp.text().await?;
9639
9640    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
9641        Ok(())
9642    } else {
9643        let local_var_entity: Option<VpnVpnTerminationsDestroyError> =
9644            serde_json::from_str(&local_var_content).ok();
9645        let local_var_error = ResponseContent {
9646            status: local_var_status,
9647            content: local_var_content,
9648            entity: local_var_entity,
9649        };
9650        Err(Error::ResponseError(local_var_error))
9651    }
9652}
9653
9654/// VPNTermination viewset.
9655pub async fn vpn_vpn_terminations_list(
9656    configuration: &configuration::Configuration,
9657    contacts: Option<Vec<String>>,
9658    contacts__isnull: Option<bool>,
9659    contacts__n: Option<Vec<String>>,
9660    created: Option<Vec<String>>,
9661    created__gt: Option<Vec<String>>,
9662    created__gte: Option<Vec<String>>,
9663    created__isnull: Option<bool>,
9664    created__lt: Option<Vec<String>>,
9665    created__lte: Option<Vec<String>>,
9666    created__n: Option<Vec<String>>,
9667    dynamic_groups: Option<Vec<String>>,
9668    dynamic_groups__n: Option<Vec<String>>,
9669    format: Option<&str>,
9670    id: Option<Vec<uuid::Uuid>>,
9671    id__n: Option<Vec<uuid::Uuid>>,
9672    interface: Option<Vec<String>>,
9673    interface__isnull: Option<bool>,
9674    interface__n: Option<Vec<String>>,
9675    last_updated: Option<Vec<String>>,
9676    last_updated__gt: Option<Vec<String>>,
9677    last_updated__gte: Option<Vec<String>>,
9678    last_updated__isnull: Option<bool>,
9679    last_updated__lt: Option<Vec<String>>,
9680    last_updated__lte: Option<Vec<String>>,
9681    last_updated__n: Option<Vec<String>>,
9682    limit: Option<i32>,
9683    offset: Option<i32>,
9684    q: Option<&str>,
9685    sort: Option<&str>,
9686    tags: Option<Vec<String>>,
9687    tags__isnull: Option<bool>,
9688    tags__n: Option<Vec<String>>,
9689    teams: Option<Vec<String>>,
9690    teams__isnull: Option<bool>,
9691    teams__n: Option<Vec<String>>,
9692    vlan: Option<Vec<String>>,
9693    vlan__isnull: Option<bool>,
9694    vlan__n: Option<Vec<String>>,
9695    vm_interface: Option<Vec<String>>,
9696    vm_interface__isnull: Option<bool>,
9697    vm_interface__n: Option<Vec<String>>,
9698    vpn: Option<Vec<String>>,
9699    vpn__n: Option<Vec<String>>,
9700    depth: Option<i32>,
9701    exclude_m2m: Option<bool>,
9702) -> Result<crate::models::PaginatedVpnTerminationList, Error<VpnVpnTerminationsListError>> {
9703    let local_var_configuration = configuration;
9704
9705    let local_var_client = &local_var_configuration.client;
9706
9707    let local_var_uri_str = format!(
9708        "{}/vpn/vpn-terminations/",
9709        local_var_configuration.base_path
9710    );
9711    let mut local_var_req_builder =
9712        local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
9713
9714    if let Some(ref local_var_str) = contacts {
9715        local_var_req_builder = match "multi" {
9716            "multi" => local_var_req_builder.query(
9717                &local_var_str
9718                    .into_iter()
9719                    .map(|p| ("contacts".to_owned(), p.to_string()))
9720                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9721            ),
9722            _ => local_var_req_builder.query(&[(
9723                "contacts",
9724                &local_var_str
9725                    .into_iter()
9726                    .map(|p| p.to_string())
9727                    .collect::<Vec<String>>()
9728                    .join(",")
9729                    .to_string(),
9730            )]),
9731        };
9732    }
9733    if let Some(ref local_var_str) = contacts__isnull {
9734        local_var_req_builder =
9735            local_var_req_builder.query(&[("contacts__isnull", &local_var_str.to_string())]);
9736    }
9737    if let Some(ref local_var_str) = contacts__n {
9738        local_var_req_builder = match "multi" {
9739            "multi" => local_var_req_builder.query(
9740                &local_var_str
9741                    .into_iter()
9742                    .map(|p| ("contacts__n".to_owned(), p.to_string()))
9743                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9744            ),
9745            _ => local_var_req_builder.query(&[(
9746                "contacts__n",
9747                &local_var_str
9748                    .into_iter()
9749                    .map(|p| p.to_string())
9750                    .collect::<Vec<String>>()
9751                    .join(",")
9752                    .to_string(),
9753            )]),
9754        };
9755    }
9756    if let Some(ref local_var_str) = created {
9757        local_var_req_builder = match "multi" {
9758            "multi" => local_var_req_builder.query(
9759                &local_var_str
9760                    .into_iter()
9761                    .map(|p| ("created".to_owned(), p.to_string()))
9762                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9763            ),
9764            _ => local_var_req_builder.query(&[(
9765                "created",
9766                &local_var_str
9767                    .into_iter()
9768                    .map(|p| p.to_string())
9769                    .collect::<Vec<String>>()
9770                    .join(",")
9771                    .to_string(),
9772            )]),
9773        };
9774    }
9775    if let Some(ref local_var_str) = created__gt {
9776        local_var_req_builder = match "multi" {
9777            "multi" => local_var_req_builder.query(
9778                &local_var_str
9779                    .into_iter()
9780                    .map(|p| ("created__gt".to_owned(), p.to_string()))
9781                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9782            ),
9783            _ => local_var_req_builder.query(&[(
9784                "created__gt",
9785                &local_var_str
9786                    .into_iter()
9787                    .map(|p| p.to_string())
9788                    .collect::<Vec<String>>()
9789                    .join(",")
9790                    .to_string(),
9791            )]),
9792        };
9793    }
9794    if let Some(ref local_var_str) = created__gte {
9795        local_var_req_builder = match "multi" {
9796            "multi" => local_var_req_builder.query(
9797                &local_var_str
9798                    .into_iter()
9799                    .map(|p| ("created__gte".to_owned(), p.to_string()))
9800                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9801            ),
9802            _ => local_var_req_builder.query(&[(
9803                "created__gte",
9804                &local_var_str
9805                    .into_iter()
9806                    .map(|p| p.to_string())
9807                    .collect::<Vec<String>>()
9808                    .join(",")
9809                    .to_string(),
9810            )]),
9811        };
9812    }
9813    if let Some(ref local_var_str) = created__isnull {
9814        local_var_req_builder =
9815            local_var_req_builder.query(&[("created__isnull", &local_var_str.to_string())]);
9816    }
9817    if let Some(ref local_var_str) = created__lt {
9818        local_var_req_builder = match "multi" {
9819            "multi" => local_var_req_builder.query(
9820                &local_var_str
9821                    .into_iter()
9822                    .map(|p| ("created__lt".to_owned(), p.to_string()))
9823                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9824            ),
9825            _ => local_var_req_builder.query(&[(
9826                "created__lt",
9827                &local_var_str
9828                    .into_iter()
9829                    .map(|p| p.to_string())
9830                    .collect::<Vec<String>>()
9831                    .join(",")
9832                    .to_string(),
9833            )]),
9834        };
9835    }
9836    if let Some(ref local_var_str) = created__lte {
9837        local_var_req_builder = match "multi" {
9838            "multi" => local_var_req_builder.query(
9839                &local_var_str
9840                    .into_iter()
9841                    .map(|p| ("created__lte".to_owned(), p.to_string()))
9842                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9843            ),
9844            _ => local_var_req_builder.query(&[(
9845                "created__lte",
9846                &local_var_str
9847                    .into_iter()
9848                    .map(|p| p.to_string())
9849                    .collect::<Vec<String>>()
9850                    .join(",")
9851                    .to_string(),
9852            )]),
9853        };
9854    }
9855    if let Some(ref local_var_str) = created__n {
9856        local_var_req_builder = match "multi" {
9857            "multi" => local_var_req_builder.query(
9858                &local_var_str
9859                    .into_iter()
9860                    .map(|p| ("created__n".to_owned(), p.to_string()))
9861                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9862            ),
9863            _ => local_var_req_builder.query(&[(
9864                "created__n",
9865                &local_var_str
9866                    .into_iter()
9867                    .map(|p| p.to_string())
9868                    .collect::<Vec<String>>()
9869                    .join(",")
9870                    .to_string(),
9871            )]),
9872        };
9873    }
9874    if let Some(ref local_var_str) = dynamic_groups {
9875        local_var_req_builder = match "multi" {
9876            "multi" => local_var_req_builder.query(
9877                &local_var_str
9878                    .into_iter()
9879                    .map(|p| ("dynamic_groups".to_owned(), p.to_string()))
9880                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9881            ),
9882            _ => local_var_req_builder.query(&[(
9883                "dynamic_groups",
9884                &local_var_str
9885                    .into_iter()
9886                    .map(|p| p.to_string())
9887                    .collect::<Vec<String>>()
9888                    .join(",")
9889                    .to_string(),
9890            )]),
9891        };
9892    }
9893    if let Some(ref local_var_str) = dynamic_groups__n {
9894        local_var_req_builder = match "multi" {
9895            "multi" => local_var_req_builder.query(
9896                &local_var_str
9897                    .into_iter()
9898                    .map(|p| ("dynamic_groups__n".to_owned(), p.to_string()))
9899                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9900            ),
9901            _ => local_var_req_builder.query(&[(
9902                "dynamic_groups__n",
9903                &local_var_str
9904                    .into_iter()
9905                    .map(|p| p.to_string())
9906                    .collect::<Vec<String>>()
9907                    .join(",")
9908                    .to_string(),
9909            )]),
9910        };
9911    }
9912    if let Some(ref local_var_str) = format {
9913        local_var_req_builder =
9914            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
9915    }
9916    if let Some(ref local_var_str) = id {
9917        local_var_req_builder = match "multi" {
9918            "multi" => local_var_req_builder.query(
9919                &local_var_str
9920                    .into_iter()
9921                    .map(|p| ("id".to_owned(), p.to_string()))
9922                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9923            ),
9924            _ => local_var_req_builder.query(&[(
9925                "id",
9926                &local_var_str
9927                    .into_iter()
9928                    .map(|p| p.to_string())
9929                    .collect::<Vec<String>>()
9930                    .join(",")
9931                    .to_string(),
9932            )]),
9933        };
9934    }
9935    if let Some(ref local_var_str) = id__n {
9936        local_var_req_builder = match "multi" {
9937            "multi" => local_var_req_builder.query(
9938                &local_var_str
9939                    .into_iter()
9940                    .map(|p| ("id__n".to_owned(), p.to_string()))
9941                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9942            ),
9943            _ => local_var_req_builder.query(&[(
9944                "id__n",
9945                &local_var_str
9946                    .into_iter()
9947                    .map(|p| p.to_string())
9948                    .collect::<Vec<String>>()
9949                    .join(",")
9950                    .to_string(),
9951            )]),
9952        };
9953    }
9954    if let Some(ref local_var_str) = interface {
9955        local_var_req_builder = match "multi" {
9956            "multi" => local_var_req_builder.query(
9957                &local_var_str
9958                    .into_iter()
9959                    .map(|p| ("interface".to_owned(), p.to_string()))
9960                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9961            ),
9962            _ => local_var_req_builder.query(&[(
9963                "interface",
9964                &local_var_str
9965                    .into_iter()
9966                    .map(|p| p.to_string())
9967                    .collect::<Vec<String>>()
9968                    .join(",")
9969                    .to_string(),
9970            )]),
9971        };
9972    }
9973    if let Some(ref local_var_str) = interface__isnull {
9974        local_var_req_builder =
9975            local_var_req_builder.query(&[("interface__isnull", &local_var_str.to_string())]);
9976    }
9977    if let Some(ref local_var_str) = interface__n {
9978        local_var_req_builder = match "multi" {
9979            "multi" => local_var_req_builder.query(
9980                &local_var_str
9981                    .into_iter()
9982                    .map(|p| ("interface__n".to_owned(), p.to_string()))
9983                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9984            ),
9985            _ => local_var_req_builder.query(&[(
9986                "interface__n",
9987                &local_var_str
9988                    .into_iter()
9989                    .map(|p| p.to_string())
9990                    .collect::<Vec<String>>()
9991                    .join(",")
9992                    .to_string(),
9993            )]),
9994        };
9995    }
9996    if let Some(ref local_var_str) = last_updated {
9997        local_var_req_builder = match "multi" {
9998            "multi" => local_var_req_builder.query(
9999                &local_var_str
10000                    .into_iter()
10001                    .map(|p| ("last_updated".to_owned(), p.to_string()))
10002                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10003            ),
10004            _ => local_var_req_builder.query(&[(
10005                "last_updated",
10006                &local_var_str
10007                    .into_iter()
10008                    .map(|p| p.to_string())
10009                    .collect::<Vec<String>>()
10010                    .join(",")
10011                    .to_string(),
10012            )]),
10013        };
10014    }
10015    if let Some(ref local_var_str) = last_updated__gt {
10016        local_var_req_builder = match "multi" {
10017            "multi" => local_var_req_builder.query(
10018                &local_var_str
10019                    .into_iter()
10020                    .map(|p| ("last_updated__gt".to_owned(), p.to_string()))
10021                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10022            ),
10023            _ => local_var_req_builder.query(&[(
10024                "last_updated__gt",
10025                &local_var_str
10026                    .into_iter()
10027                    .map(|p| p.to_string())
10028                    .collect::<Vec<String>>()
10029                    .join(",")
10030                    .to_string(),
10031            )]),
10032        };
10033    }
10034    if let Some(ref local_var_str) = last_updated__gte {
10035        local_var_req_builder = match "multi" {
10036            "multi" => local_var_req_builder.query(
10037                &local_var_str
10038                    .into_iter()
10039                    .map(|p| ("last_updated__gte".to_owned(), p.to_string()))
10040                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10041            ),
10042            _ => local_var_req_builder.query(&[(
10043                "last_updated__gte",
10044                &local_var_str
10045                    .into_iter()
10046                    .map(|p| p.to_string())
10047                    .collect::<Vec<String>>()
10048                    .join(",")
10049                    .to_string(),
10050            )]),
10051        };
10052    }
10053    if let Some(ref local_var_str) = last_updated__isnull {
10054        local_var_req_builder =
10055            local_var_req_builder.query(&[("last_updated__isnull", &local_var_str.to_string())]);
10056    }
10057    if let Some(ref local_var_str) = last_updated__lt {
10058        local_var_req_builder = match "multi" {
10059            "multi" => local_var_req_builder.query(
10060                &local_var_str
10061                    .into_iter()
10062                    .map(|p| ("last_updated__lt".to_owned(), p.to_string()))
10063                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10064            ),
10065            _ => local_var_req_builder.query(&[(
10066                "last_updated__lt",
10067                &local_var_str
10068                    .into_iter()
10069                    .map(|p| p.to_string())
10070                    .collect::<Vec<String>>()
10071                    .join(",")
10072                    .to_string(),
10073            )]),
10074        };
10075    }
10076    if let Some(ref local_var_str) = last_updated__lte {
10077        local_var_req_builder = match "multi" {
10078            "multi" => local_var_req_builder.query(
10079                &local_var_str
10080                    .into_iter()
10081                    .map(|p| ("last_updated__lte".to_owned(), p.to_string()))
10082                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10083            ),
10084            _ => local_var_req_builder.query(&[(
10085                "last_updated__lte",
10086                &local_var_str
10087                    .into_iter()
10088                    .map(|p| p.to_string())
10089                    .collect::<Vec<String>>()
10090                    .join(",")
10091                    .to_string(),
10092            )]),
10093        };
10094    }
10095    if let Some(ref local_var_str) = last_updated__n {
10096        local_var_req_builder = match "multi" {
10097            "multi" => local_var_req_builder.query(
10098                &local_var_str
10099                    .into_iter()
10100                    .map(|p| ("last_updated__n".to_owned(), p.to_string()))
10101                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10102            ),
10103            _ => local_var_req_builder.query(&[(
10104                "last_updated__n",
10105                &local_var_str
10106                    .into_iter()
10107                    .map(|p| p.to_string())
10108                    .collect::<Vec<String>>()
10109                    .join(",")
10110                    .to_string(),
10111            )]),
10112        };
10113    }
10114    if let Some(ref local_var_str) = limit {
10115        local_var_req_builder =
10116            local_var_req_builder.query(&[("limit", &local_var_str.to_string())]);
10117    }
10118    if let Some(ref local_var_str) = offset {
10119        local_var_req_builder =
10120            local_var_req_builder.query(&[("offset", &local_var_str.to_string())]);
10121    }
10122    if let Some(ref local_var_str) = q {
10123        local_var_req_builder = local_var_req_builder.query(&[("q", &local_var_str.to_string())]);
10124    }
10125    if let Some(ref local_var_str) = sort {
10126        local_var_req_builder =
10127            local_var_req_builder.query(&[("sort", &local_var_str.to_string())]);
10128    }
10129    if let Some(ref local_var_str) = tags {
10130        local_var_req_builder = match "multi" {
10131            "multi" => local_var_req_builder.query(
10132                &local_var_str
10133                    .into_iter()
10134                    .map(|p| ("tags".to_owned(), p.to_string()))
10135                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10136            ),
10137            _ => local_var_req_builder.query(&[(
10138                "tags",
10139                &local_var_str
10140                    .into_iter()
10141                    .map(|p| p.to_string())
10142                    .collect::<Vec<String>>()
10143                    .join(",")
10144                    .to_string(),
10145            )]),
10146        };
10147    }
10148    if let Some(ref local_var_str) = tags__isnull {
10149        local_var_req_builder =
10150            local_var_req_builder.query(&[("tags__isnull", &local_var_str.to_string())]);
10151    }
10152    if let Some(ref local_var_str) = tags__n {
10153        local_var_req_builder = match "multi" {
10154            "multi" => local_var_req_builder.query(
10155                &local_var_str
10156                    .into_iter()
10157                    .map(|p| ("tags__n".to_owned(), p.to_string()))
10158                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10159            ),
10160            _ => local_var_req_builder.query(&[(
10161                "tags__n",
10162                &local_var_str
10163                    .into_iter()
10164                    .map(|p| p.to_string())
10165                    .collect::<Vec<String>>()
10166                    .join(",")
10167                    .to_string(),
10168            )]),
10169        };
10170    }
10171    if let Some(ref local_var_str) = teams {
10172        local_var_req_builder = match "multi" {
10173            "multi" => local_var_req_builder.query(
10174                &local_var_str
10175                    .into_iter()
10176                    .map(|p| ("teams".to_owned(), p.to_string()))
10177                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10178            ),
10179            _ => local_var_req_builder.query(&[(
10180                "teams",
10181                &local_var_str
10182                    .into_iter()
10183                    .map(|p| p.to_string())
10184                    .collect::<Vec<String>>()
10185                    .join(",")
10186                    .to_string(),
10187            )]),
10188        };
10189    }
10190    if let Some(ref local_var_str) = teams__isnull {
10191        local_var_req_builder =
10192            local_var_req_builder.query(&[("teams__isnull", &local_var_str.to_string())]);
10193    }
10194    if let Some(ref local_var_str) = teams__n {
10195        local_var_req_builder = match "multi" {
10196            "multi" => local_var_req_builder.query(
10197                &local_var_str
10198                    .into_iter()
10199                    .map(|p| ("teams__n".to_owned(), p.to_string()))
10200                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10201            ),
10202            _ => local_var_req_builder.query(&[(
10203                "teams__n",
10204                &local_var_str
10205                    .into_iter()
10206                    .map(|p| p.to_string())
10207                    .collect::<Vec<String>>()
10208                    .join(",")
10209                    .to_string(),
10210            )]),
10211        };
10212    }
10213    if let Some(ref local_var_str) = vlan {
10214        local_var_req_builder = match "multi" {
10215            "multi" => local_var_req_builder.query(
10216                &local_var_str
10217                    .into_iter()
10218                    .map(|p| ("vlan".to_owned(), p.to_string()))
10219                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10220            ),
10221            _ => local_var_req_builder.query(&[(
10222                "vlan",
10223                &local_var_str
10224                    .into_iter()
10225                    .map(|p| p.to_string())
10226                    .collect::<Vec<String>>()
10227                    .join(",")
10228                    .to_string(),
10229            )]),
10230        };
10231    }
10232    if let Some(ref local_var_str) = vlan__isnull {
10233        local_var_req_builder =
10234            local_var_req_builder.query(&[("vlan__isnull", &local_var_str.to_string())]);
10235    }
10236    if let Some(ref local_var_str) = vlan__n {
10237        local_var_req_builder = match "multi" {
10238            "multi" => local_var_req_builder.query(
10239                &local_var_str
10240                    .into_iter()
10241                    .map(|p| ("vlan__n".to_owned(), p.to_string()))
10242                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10243            ),
10244            _ => local_var_req_builder.query(&[(
10245                "vlan__n",
10246                &local_var_str
10247                    .into_iter()
10248                    .map(|p| p.to_string())
10249                    .collect::<Vec<String>>()
10250                    .join(",")
10251                    .to_string(),
10252            )]),
10253        };
10254    }
10255    if let Some(ref local_var_str) = vm_interface {
10256        local_var_req_builder = match "multi" {
10257            "multi" => local_var_req_builder.query(
10258                &local_var_str
10259                    .into_iter()
10260                    .map(|p| ("vm_interface".to_owned(), p.to_string()))
10261                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10262            ),
10263            _ => local_var_req_builder.query(&[(
10264                "vm_interface",
10265                &local_var_str
10266                    .into_iter()
10267                    .map(|p| p.to_string())
10268                    .collect::<Vec<String>>()
10269                    .join(",")
10270                    .to_string(),
10271            )]),
10272        };
10273    }
10274    if let Some(ref local_var_str) = vm_interface__isnull {
10275        local_var_req_builder =
10276            local_var_req_builder.query(&[("vm_interface__isnull", &local_var_str.to_string())]);
10277    }
10278    if let Some(ref local_var_str) = vm_interface__n {
10279        local_var_req_builder = match "multi" {
10280            "multi" => local_var_req_builder.query(
10281                &local_var_str
10282                    .into_iter()
10283                    .map(|p| ("vm_interface__n".to_owned(), p.to_string()))
10284                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10285            ),
10286            _ => local_var_req_builder.query(&[(
10287                "vm_interface__n",
10288                &local_var_str
10289                    .into_iter()
10290                    .map(|p| p.to_string())
10291                    .collect::<Vec<String>>()
10292                    .join(",")
10293                    .to_string(),
10294            )]),
10295        };
10296    }
10297    if let Some(ref local_var_str) = vpn {
10298        local_var_req_builder = match "multi" {
10299            "multi" => local_var_req_builder.query(
10300                &local_var_str
10301                    .into_iter()
10302                    .map(|p| ("vpn".to_owned(), p.to_string()))
10303                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10304            ),
10305            _ => local_var_req_builder.query(&[(
10306                "vpn",
10307                &local_var_str
10308                    .into_iter()
10309                    .map(|p| p.to_string())
10310                    .collect::<Vec<String>>()
10311                    .join(",")
10312                    .to_string(),
10313            )]),
10314        };
10315    }
10316    if let Some(ref local_var_str) = vpn__n {
10317        local_var_req_builder = match "multi" {
10318            "multi" => local_var_req_builder.query(
10319                &local_var_str
10320                    .into_iter()
10321                    .map(|p| ("vpn__n".to_owned(), p.to_string()))
10322                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10323            ),
10324            _ => local_var_req_builder.query(&[(
10325                "vpn__n",
10326                &local_var_str
10327                    .into_iter()
10328                    .map(|p| p.to_string())
10329                    .collect::<Vec<String>>()
10330                    .join(",")
10331                    .to_string(),
10332            )]),
10333        };
10334    }
10335    if let Some(ref local_var_str) = depth {
10336        local_var_req_builder =
10337            local_var_req_builder.query(&[("depth", &local_var_str.to_string())]);
10338    }
10339    if let Some(ref local_var_str) = exclude_m2m {
10340        local_var_req_builder =
10341            local_var_req_builder.query(&[("exclude_m2m", &local_var_str.to_string())]);
10342    }
10343    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
10344        local_var_req_builder =
10345            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
10346    }
10347    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
10348        let local_var_key = local_var_apikey.key.clone();
10349        let local_var_value = match local_var_apikey.prefix {
10350            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
10351            None => local_var_key,
10352        };
10353        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
10354    };
10355
10356    let local_var_req = local_var_req_builder.build()?;
10357    let local_var_resp = local_var_client.execute(local_var_req).await?;
10358
10359    let local_var_status = local_var_resp.status();
10360    let local_var_content = local_var_resp.text().await?;
10361
10362    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
10363        serde_json::from_str(&local_var_content).map_err(Error::from)
10364    } else {
10365        let local_var_entity: Option<VpnVpnTerminationsListError> =
10366            serde_json::from_str(&local_var_content).ok();
10367        let local_var_error = ResponseContent {
10368            status: local_var_status,
10369            content: local_var_content,
10370            entity: local_var_entity,
10371        };
10372        Err(Error::ResponseError(local_var_error))
10373    }
10374}
10375
10376/// API methods for returning or creating notes on an object.
10377pub async fn vpn_vpn_terminations_notes_create(
10378    configuration: &configuration::Configuration,
10379    id: &str,
10380    note_input_request: crate::models::NoteInputRequest,
10381    format: Option<&str>,
10382) -> Result<crate::models::Note, Error<VpnVpnTerminationsNotesCreateError>> {
10383    let local_var_configuration = configuration;
10384
10385    let local_var_client = &local_var_configuration.client;
10386
10387    let local_var_uri_str = format!(
10388        "{}/vpn/vpn-terminations/{id}/notes/",
10389        local_var_configuration.base_path,
10390        id = crate::apis::urlencode(id)
10391    );
10392    let mut local_var_req_builder =
10393        local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
10394
10395    if let Some(ref local_var_str) = format {
10396        local_var_req_builder =
10397            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
10398    }
10399    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
10400        local_var_req_builder =
10401            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
10402    }
10403    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
10404        let local_var_key = local_var_apikey.key.clone();
10405        let local_var_value = match local_var_apikey.prefix {
10406            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
10407            None => local_var_key,
10408        };
10409        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
10410    };
10411    local_var_req_builder = local_var_req_builder.json(&note_input_request);
10412
10413    let local_var_req = local_var_req_builder.build()?;
10414    let local_var_resp = local_var_client.execute(local_var_req).await?;
10415
10416    let local_var_status = local_var_resp.status();
10417    let local_var_content = local_var_resp.text().await?;
10418
10419    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
10420        serde_json::from_str(&local_var_content).map_err(Error::from)
10421    } else {
10422        let local_var_entity: Option<VpnVpnTerminationsNotesCreateError> =
10423            serde_json::from_str(&local_var_content).ok();
10424        let local_var_error = ResponseContent {
10425            status: local_var_status,
10426            content: local_var_content,
10427            entity: local_var_entity,
10428        };
10429        Err(Error::ResponseError(local_var_error))
10430    }
10431}
10432
10433/// API methods for returning or creating notes on an object.
10434pub async fn vpn_vpn_terminations_notes_list(
10435    configuration: &configuration::Configuration,
10436    id: &str,
10437    format: Option<&str>,
10438    limit: Option<i32>,
10439    offset: Option<i32>,
10440    depth: Option<i32>,
10441    exclude_m2m: Option<bool>,
10442) -> Result<crate::models::PaginatedNoteList, Error<VpnVpnTerminationsNotesListError>> {
10443    let local_var_configuration = configuration;
10444
10445    let local_var_client = &local_var_configuration.client;
10446
10447    let local_var_uri_str = format!(
10448        "{}/vpn/vpn-terminations/{id}/notes/",
10449        local_var_configuration.base_path,
10450        id = crate::apis::urlencode(id)
10451    );
10452    let mut local_var_req_builder =
10453        local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
10454
10455    if let Some(ref local_var_str) = format {
10456        local_var_req_builder =
10457            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
10458    }
10459    if let Some(ref local_var_str) = limit {
10460        local_var_req_builder =
10461            local_var_req_builder.query(&[("limit", &local_var_str.to_string())]);
10462    }
10463    if let Some(ref local_var_str) = offset {
10464        local_var_req_builder =
10465            local_var_req_builder.query(&[("offset", &local_var_str.to_string())]);
10466    }
10467    if let Some(ref local_var_str) = depth {
10468        local_var_req_builder =
10469            local_var_req_builder.query(&[("depth", &local_var_str.to_string())]);
10470    }
10471    if let Some(ref local_var_str) = exclude_m2m {
10472        local_var_req_builder =
10473            local_var_req_builder.query(&[("exclude_m2m", &local_var_str.to_string())]);
10474    }
10475    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
10476        local_var_req_builder =
10477            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
10478    }
10479    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
10480        let local_var_key = local_var_apikey.key.clone();
10481        let local_var_value = match local_var_apikey.prefix {
10482            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
10483            None => local_var_key,
10484        };
10485        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
10486    };
10487
10488    let local_var_req = local_var_req_builder.build()?;
10489    let local_var_resp = local_var_client.execute(local_var_req).await?;
10490
10491    let local_var_status = local_var_resp.status();
10492    let local_var_content = local_var_resp.text().await?;
10493
10494    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
10495        serde_json::from_str(&local_var_content).map_err(Error::from)
10496    } else {
10497        let local_var_entity: Option<VpnVpnTerminationsNotesListError> =
10498            serde_json::from_str(&local_var_content).ok();
10499        let local_var_error = ResponseContent {
10500            status: local_var_status,
10501            content: local_var_content,
10502            entity: local_var_entity,
10503        };
10504        Err(Error::ResponseError(local_var_error))
10505    }
10506}
10507
10508/// VPNTermination viewset.
10509pub async fn vpn_vpn_terminations_partial_update(
10510    configuration: &configuration::Configuration,
10511    id: &str,
10512    format: Option<&str>,
10513    patched_vpn_termination_request: Option<crate::models::PatchedVpnTerminationRequest>,
10514) -> Result<crate::models::VpnTermination, Error<VpnVpnTerminationsPartialUpdateError>> {
10515    let local_var_configuration = configuration;
10516
10517    let local_var_client = &local_var_configuration.client;
10518
10519    let local_var_uri_str = format!(
10520        "{}/vpn/vpn-terminations/{id}/",
10521        local_var_configuration.base_path,
10522        id = crate::apis::urlencode(id)
10523    );
10524    let mut local_var_req_builder =
10525        local_var_client.request(reqwest::Method::PATCH, local_var_uri_str.as_str());
10526
10527    if let Some(ref local_var_str) = format {
10528        local_var_req_builder =
10529            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
10530    }
10531    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
10532        local_var_req_builder =
10533            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
10534    }
10535    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
10536        let local_var_key = local_var_apikey.key.clone();
10537        let local_var_value = match local_var_apikey.prefix {
10538            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
10539            None => local_var_key,
10540        };
10541        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
10542    };
10543    local_var_req_builder = local_var_req_builder.json(&patched_vpn_termination_request);
10544
10545    let local_var_req = local_var_req_builder.build()?;
10546    let local_var_resp = local_var_client.execute(local_var_req).await?;
10547
10548    let local_var_status = local_var_resp.status();
10549    let local_var_content = local_var_resp.text().await?;
10550
10551    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
10552        serde_json::from_str(&local_var_content).map_err(Error::from)
10553    } else {
10554        let local_var_entity: Option<VpnVpnTerminationsPartialUpdateError> =
10555            serde_json::from_str(&local_var_content).ok();
10556        let local_var_error = ResponseContent {
10557            status: local_var_status,
10558            content: local_var_content,
10559            entity: local_var_entity,
10560        };
10561        Err(Error::ResponseError(local_var_error))
10562    }
10563}
10564
10565/// VPNTermination viewset.
10566pub async fn vpn_vpn_terminations_retrieve(
10567    configuration: &configuration::Configuration,
10568    id: &str,
10569    format: Option<&str>,
10570    depth: Option<i32>,
10571    exclude_m2m: Option<bool>,
10572) -> Result<crate::models::VpnTermination, Error<VpnVpnTerminationsRetrieveError>> {
10573    let local_var_configuration = configuration;
10574
10575    let local_var_client = &local_var_configuration.client;
10576
10577    let local_var_uri_str = format!(
10578        "{}/vpn/vpn-terminations/{id}/",
10579        local_var_configuration.base_path,
10580        id = crate::apis::urlencode(id)
10581    );
10582    let mut local_var_req_builder =
10583        local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
10584
10585    if let Some(ref local_var_str) = format {
10586        local_var_req_builder =
10587            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
10588    }
10589    if let Some(ref local_var_str) = depth {
10590        local_var_req_builder =
10591            local_var_req_builder.query(&[("depth", &local_var_str.to_string())]);
10592    }
10593    if let Some(ref local_var_str) = exclude_m2m {
10594        local_var_req_builder =
10595            local_var_req_builder.query(&[("exclude_m2m", &local_var_str.to_string())]);
10596    }
10597    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
10598        local_var_req_builder =
10599            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
10600    }
10601    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
10602        let local_var_key = local_var_apikey.key.clone();
10603        let local_var_value = match local_var_apikey.prefix {
10604            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
10605            None => local_var_key,
10606        };
10607        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
10608    };
10609
10610    let local_var_req = local_var_req_builder.build()?;
10611    let local_var_resp = local_var_client.execute(local_var_req).await?;
10612
10613    let local_var_status = local_var_resp.status();
10614    let local_var_content = local_var_resp.text().await?;
10615
10616    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
10617        serde_json::from_str(&local_var_content).map_err(Error::from)
10618    } else {
10619        let local_var_entity: Option<VpnVpnTerminationsRetrieveError> =
10620            serde_json::from_str(&local_var_content).ok();
10621        let local_var_error = ResponseContent {
10622            status: local_var_status,
10623            content: local_var_content,
10624            entity: local_var_entity,
10625        };
10626        Err(Error::ResponseError(local_var_error))
10627    }
10628}
10629
10630/// VPNTermination viewset.
10631pub async fn vpn_vpn_terminations_update(
10632    configuration: &configuration::Configuration,
10633    id: &str,
10634    vpn_termination_request: crate::models::VpnTerminationRequest,
10635    format: Option<&str>,
10636) -> Result<crate::models::VpnTermination, Error<VpnVpnTerminationsUpdateError>> {
10637    let local_var_configuration = configuration;
10638
10639    let local_var_client = &local_var_configuration.client;
10640
10641    let local_var_uri_str = format!(
10642        "{}/vpn/vpn-terminations/{id}/",
10643        local_var_configuration.base_path,
10644        id = crate::apis::urlencode(id)
10645    );
10646    let mut local_var_req_builder =
10647        local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());
10648
10649    if let Some(ref local_var_str) = format {
10650        local_var_req_builder =
10651            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
10652    }
10653    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
10654        local_var_req_builder =
10655            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
10656    }
10657    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
10658        let local_var_key = local_var_apikey.key.clone();
10659        let local_var_value = match local_var_apikey.prefix {
10660            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
10661            None => local_var_key,
10662        };
10663        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
10664    };
10665    local_var_req_builder = local_var_req_builder.json(&vpn_termination_request);
10666
10667    let local_var_req = local_var_req_builder.build()?;
10668    let local_var_resp = local_var_client.execute(local_var_req).await?;
10669
10670    let local_var_status = local_var_resp.status();
10671    let local_var_content = local_var_resp.text().await?;
10672
10673    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
10674        serde_json::from_str(&local_var_content).map_err(Error::from)
10675    } else {
10676        let local_var_entity: Option<VpnVpnTerminationsUpdateError> =
10677            serde_json::from_str(&local_var_content).ok();
10678        let local_var_error = ResponseContent {
10679            status: local_var_status,
10680            content: local_var_content,
10681            entity: local_var_entity,
10682        };
10683        Err(Error::ResponseError(local_var_error))
10684    }
10685}
10686
10687/// VPNTunnelEndpoint viewset.
10688pub async fn vpn_vpn_tunnel_endpoints_bulk_destroy(
10689    configuration: &configuration::Configuration,
10690    bulk_operation_request: Vec<crate::models::BulkOperationRequest>,
10691    format: Option<&str>,
10692) -> Result<(), Error<VpnVpnTunnelEndpointsBulkDestroyError>> {
10693    let local_var_configuration = configuration;
10694
10695    let local_var_client = &local_var_configuration.client;
10696
10697    let local_var_uri_str = format!(
10698        "{}/vpn/vpn-tunnel-endpoints/",
10699        local_var_configuration.base_path
10700    );
10701    let mut local_var_req_builder =
10702        local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());
10703
10704    if let Some(ref local_var_str) = format {
10705        local_var_req_builder =
10706            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
10707    }
10708    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
10709        local_var_req_builder =
10710            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
10711    }
10712    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
10713        let local_var_key = local_var_apikey.key.clone();
10714        let local_var_value = match local_var_apikey.prefix {
10715            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
10716            None => local_var_key,
10717        };
10718        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
10719    };
10720    local_var_req_builder = local_var_req_builder.json(&bulk_operation_request);
10721
10722    let local_var_req = local_var_req_builder.build()?;
10723    let local_var_resp = local_var_client.execute(local_var_req).await?;
10724
10725    let local_var_status = local_var_resp.status();
10726    let local_var_content = local_var_resp.text().await?;
10727
10728    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
10729        Ok(())
10730    } else {
10731        let local_var_entity: Option<VpnVpnTunnelEndpointsBulkDestroyError> =
10732            serde_json::from_str(&local_var_content).ok();
10733        let local_var_error = ResponseContent {
10734            status: local_var_status,
10735            content: local_var_content,
10736            entity: local_var_entity,
10737        };
10738        Err(Error::ResponseError(local_var_error))
10739    }
10740}
10741
10742/// VPNTunnelEndpoint viewset.
10743pub async fn vpn_vpn_tunnel_endpoints_bulk_partial_update(
10744    configuration: &configuration::Configuration,
10745    patched_bulk_writable_vpn_tunnel_endpoint_request: Vec<
10746        crate::models::PatchedBulkWritableVpnTunnelEndpointRequest,
10747    >,
10748    format: Option<&str>,
10749) -> Result<Vec<crate::models::VpnTunnelEndpoint>, Error<VpnVpnTunnelEndpointsBulkPartialUpdateError>>
10750{
10751    let local_var_configuration = configuration;
10752
10753    let local_var_client = &local_var_configuration.client;
10754
10755    let local_var_uri_str = format!(
10756        "{}/vpn/vpn-tunnel-endpoints/",
10757        local_var_configuration.base_path
10758    );
10759    let mut local_var_req_builder =
10760        local_var_client.request(reqwest::Method::PATCH, local_var_uri_str.as_str());
10761
10762    if let Some(ref local_var_str) = format {
10763        local_var_req_builder =
10764            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
10765    }
10766    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
10767        local_var_req_builder =
10768            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
10769    }
10770    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
10771        let local_var_key = local_var_apikey.key.clone();
10772        let local_var_value = match local_var_apikey.prefix {
10773            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
10774            None => local_var_key,
10775        };
10776        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
10777    };
10778    local_var_req_builder =
10779        local_var_req_builder.json(&patched_bulk_writable_vpn_tunnel_endpoint_request);
10780
10781    let local_var_req = local_var_req_builder.build()?;
10782    let local_var_resp = local_var_client.execute(local_var_req).await?;
10783
10784    let local_var_status = local_var_resp.status();
10785    let local_var_content = local_var_resp.text().await?;
10786
10787    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
10788        serde_json::from_str(&local_var_content).map_err(Error::from)
10789    } else {
10790        let local_var_entity: Option<VpnVpnTunnelEndpointsBulkPartialUpdateError> =
10791            serde_json::from_str(&local_var_content).ok();
10792        let local_var_error = ResponseContent {
10793            status: local_var_status,
10794            content: local_var_content,
10795            entity: local_var_entity,
10796        };
10797        Err(Error::ResponseError(local_var_error))
10798    }
10799}
10800
10801/// VPNTunnelEndpoint viewset.
10802pub async fn vpn_vpn_tunnel_endpoints_bulk_update(
10803    configuration: &configuration::Configuration,
10804    bulk_writable_vpn_tunnel_endpoint_request: Vec<
10805        crate::models::BulkWritableVpnTunnelEndpointRequest,
10806    >,
10807    format: Option<&str>,
10808) -> Result<Vec<crate::models::VpnTunnelEndpoint>, Error<VpnVpnTunnelEndpointsBulkUpdateError>> {
10809    let local_var_configuration = configuration;
10810
10811    let local_var_client = &local_var_configuration.client;
10812
10813    let local_var_uri_str = format!(
10814        "{}/vpn/vpn-tunnel-endpoints/",
10815        local_var_configuration.base_path
10816    );
10817    let mut local_var_req_builder =
10818        local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());
10819
10820    if let Some(ref local_var_str) = format {
10821        local_var_req_builder =
10822            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
10823    }
10824    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
10825        local_var_req_builder =
10826            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
10827    }
10828    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
10829        let local_var_key = local_var_apikey.key.clone();
10830        let local_var_value = match local_var_apikey.prefix {
10831            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
10832            None => local_var_key,
10833        };
10834        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
10835    };
10836    local_var_req_builder = local_var_req_builder.json(&bulk_writable_vpn_tunnel_endpoint_request);
10837
10838    let local_var_req = local_var_req_builder.build()?;
10839    let local_var_resp = local_var_client.execute(local_var_req).await?;
10840
10841    let local_var_status = local_var_resp.status();
10842    let local_var_content = local_var_resp.text().await?;
10843
10844    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
10845        serde_json::from_str(&local_var_content).map_err(Error::from)
10846    } else {
10847        let local_var_entity: Option<VpnVpnTunnelEndpointsBulkUpdateError> =
10848            serde_json::from_str(&local_var_content).ok();
10849        let local_var_error = ResponseContent {
10850            status: local_var_status,
10851            content: local_var_content,
10852            entity: local_var_entity,
10853        };
10854        Err(Error::ResponseError(local_var_error))
10855    }
10856}
10857
10858/// VPNTunnelEndpoint viewset.
10859pub async fn vpn_vpn_tunnel_endpoints_create(
10860    configuration: &configuration::Configuration,
10861    format: Option<&str>,
10862    vpn_tunnel_endpoint_request: Option<crate::models::VpnTunnelEndpointRequest>,
10863) -> Result<crate::models::VpnTunnelEndpoint, Error<VpnVpnTunnelEndpointsCreateError>> {
10864    let local_var_configuration = configuration;
10865
10866    let local_var_client = &local_var_configuration.client;
10867
10868    let local_var_uri_str = format!(
10869        "{}/vpn/vpn-tunnel-endpoints/",
10870        local_var_configuration.base_path
10871    );
10872    let mut local_var_req_builder =
10873        local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
10874
10875    if let Some(ref local_var_str) = format {
10876        local_var_req_builder =
10877            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
10878    }
10879    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
10880        local_var_req_builder =
10881            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
10882    }
10883    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
10884        let local_var_key = local_var_apikey.key.clone();
10885        let local_var_value = match local_var_apikey.prefix {
10886            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
10887            None => local_var_key,
10888        };
10889        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
10890    };
10891    local_var_req_builder = local_var_req_builder.json(&vpn_tunnel_endpoint_request);
10892
10893    let local_var_req = local_var_req_builder.build()?;
10894    let local_var_resp = local_var_client.execute(local_var_req).await?;
10895
10896    let local_var_status = local_var_resp.status();
10897    let local_var_content = local_var_resp.text().await?;
10898
10899    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
10900        serde_json::from_str(&local_var_content).map_err(Error::from)
10901    } else {
10902        let local_var_entity: Option<VpnVpnTunnelEndpointsCreateError> =
10903            serde_json::from_str(&local_var_content).ok();
10904        let local_var_error = ResponseContent {
10905            status: local_var_status,
10906            content: local_var_content,
10907            entity: local_var_entity,
10908        };
10909        Err(Error::ResponseError(local_var_error))
10910    }
10911}
10912
10913/// VPNTunnelEndpoint viewset.
10914pub async fn vpn_vpn_tunnel_endpoints_destroy(
10915    configuration: &configuration::Configuration,
10916    id: &str,
10917    format: Option<&str>,
10918) -> Result<(), Error<VpnVpnTunnelEndpointsDestroyError>> {
10919    let local_var_configuration = configuration;
10920
10921    let local_var_client = &local_var_configuration.client;
10922
10923    let local_var_uri_str = format!(
10924        "{}/vpn/vpn-tunnel-endpoints/{id}/",
10925        local_var_configuration.base_path,
10926        id = crate::apis::urlencode(id)
10927    );
10928    let mut local_var_req_builder =
10929        local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());
10930
10931    if let Some(ref local_var_str) = format {
10932        local_var_req_builder =
10933            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
10934    }
10935    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
10936        local_var_req_builder =
10937            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
10938    }
10939    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
10940        let local_var_key = local_var_apikey.key.clone();
10941        let local_var_value = match local_var_apikey.prefix {
10942            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
10943            None => local_var_key,
10944        };
10945        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
10946    };
10947
10948    let local_var_req = local_var_req_builder.build()?;
10949    let local_var_resp = local_var_client.execute(local_var_req).await?;
10950
10951    let local_var_status = local_var_resp.status();
10952    let local_var_content = local_var_resp.text().await?;
10953
10954    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
10955        Ok(())
10956    } else {
10957        let local_var_entity: Option<VpnVpnTunnelEndpointsDestroyError> =
10958            serde_json::from_str(&local_var_content).ok();
10959        let local_var_error = ResponseContent {
10960            status: local_var_status,
10961            content: local_var_content,
10962            entity: local_var_entity,
10963        };
10964        Err(Error::ResponseError(local_var_error))
10965    }
10966}
10967
10968/// VPNTunnelEndpoint viewset.
10969pub async fn vpn_vpn_tunnel_endpoints_list(
10970    configuration: &configuration::Configuration,
10971    contacts: Option<Vec<String>>,
10972    contacts__isnull: Option<bool>,
10973    contacts__n: Option<Vec<String>>,
10974    created: Option<Vec<String>>,
10975    created__gt: Option<Vec<String>>,
10976    created__gte: Option<Vec<String>>,
10977    created__isnull: Option<bool>,
10978    created__lt: Option<Vec<String>>,
10979    created__lte: Option<Vec<String>>,
10980    created__n: Option<Vec<String>>,
10981    device: Option<Vec<String>>,
10982    device__isnull: Option<bool>,
10983    device__n: Option<Vec<String>>,
10984    dynamic_groups: Option<Vec<String>>,
10985    dynamic_groups__n: Option<Vec<String>>,
10986    endpoint_a_vpn_tunnels: Option<Vec<String>>,
10987    endpoint_a_vpn_tunnels__isnull: Option<bool>,
10988    endpoint_a_vpn_tunnels__n: Option<Vec<String>>,
10989    endpoint_z_vpn_tunnels: Option<Vec<String>>,
10990    endpoint_z_vpn_tunnels__isnull: Option<bool>,
10991    endpoint_z_vpn_tunnels__n: Option<Vec<String>>,
10992    format: Option<&str>,
10993    id: Option<Vec<uuid::Uuid>>,
10994    id__n: Option<Vec<uuid::Uuid>>,
10995    last_updated: Option<Vec<String>>,
10996    last_updated__gt: Option<Vec<String>>,
10997    last_updated__gte: Option<Vec<String>>,
10998    last_updated__isnull: Option<bool>,
10999    last_updated__lt: Option<Vec<String>>,
11000    last_updated__lte: Option<Vec<String>>,
11001    last_updated__n: Option<Vec<String>>,
11002    limit: Option<i32>,
11003    name: Option<Vec<String>>,
11004    name__ic: Option<Vec<String>>,
11005    name__ie: Option<Vec<String>>,
11006    name__iew: Option<Vec<String>>,
11007    name__ire: Option<Vec<String>>,
11008    name__isw: Option<Vec<String>>,
11009    name__n: Option<Vec<String>>,
11010    name__nic: Option<Vec<String>>,
11011    name__nie: Option<Vec<String>>,
11012    name__niew: Option<Vec<String>>,
11013    name__nire: Option<Vec<String>>,
11014    name__nisw: Option<Vec<String>>,
11015    name__nre: Option<Vec<String>>,
11016    name__re: Option<Vec<String>>,
11017    offset: Option<i32>,
11018    protected_prefixes: Option<Vec<uuid::Uuid>>,
11019    protected_prefixes__n: Option<Vec<uuid::Uuid>>,
11020    protected_prefixes_dg: Option<Vec<uuid::Uuid>>,
11021    protected_prefixes_dg__n: Option<Vec<uuid::Uuid>>,
11022    q: Option<&str>,
11023    role: Option<Vec<String>>,
11024    role__isnull: Option<bool>,
11025    role__n: Option<Vec<uuid::Uuid>>,
11026    sort: Option<&str>,
11027    source_fqdn: Option<Vec<String>>,
11028    source_fqdn__ic: Option<Vec<String>>,
11029    source_fqdn__ie: Option<Vec<String>>,
11030    source_fqdn__iew: Option<Vec<String>>,
11031    source_fqdn__ire: Option<Vec<String>>,
11032    source_fqdn__isw: Option<Vec<String>>,
11033    source_fqdn__n: Option<Vec<String>>,
11034    source_fqdn__nic: Option<Vec<String>>,
11035    source_fqdn__nie: Option<Vec<String>>,
11036    source_fqdn__niew: Option<Vec<String>>,
11037    source_fqdn__nire: Option<Vec<String>>,
11038    source_fqdn__nisw: Option<Vec<String>>,
11039    source_fqdn__nre: Option<Vec<String>>,
11040    source_fqdn__re: Option<Vec<String>>,
11041    source_interface: Option<Vec<String>>,
11042    source_interface__isnull: Option<bool>,
11043    source_interface__n: Option<Vec<String>>,
11044    source_ipaddress: Option<Vec<String>>,
11045    source_ipaddress__isnull: Option<bool>,
11046    source_ipaddress__n: Option<Vec<String>>,
11047    tags: Option<Vec<String>>,
11048    tags__isnull: Option<bool>,
11049    tags__n: Option<Vec<String>>,
11050    teams: Option<Vec<String>>,
11051    teams__isnull: Option<bool>,
11052    teams__n: Option<Vec<String>>,
11053    tenant: Option<Vec<String>>,
11054    tenant__isnull: Option<bool>,
11055    tenant__n: Option<Vec<String>>,
11056    tenant_group: Option<Vec<String>>,
11057    tenant_group__isnull: Option<bool>,
11058    tenant_group__n: Option<Vec<String>>,
11059    tenant_id: Option<Vec<uuid::Uuid>>,
11060    tenant_id__isnull: Option<bool>,
11061    tenant_id__n: Option<Vec<uuid::Uuid>>,
11062    tunnel_interface: Option<Vec<String>>,
11063    tunnel_interface__isnull: Option<bool>,
11064    tunnel_interface__n: Option<Vec<String>>,
11065    vpn_profile: Option<Vec<uuid::Uuid>>,
11066    vpn_profile__isnull: Option<bool>,
11067    vpn_profile__n: Option<Vec<uuid::Uuid>>,
11068    depth: Option<i32>,
11069    exclude_m2m: Option<bool>,
11070) -> Result<crate::models::PaginatedVpnTunnelEndpointList, Error<VpnVpnTunnelEndpointsListError>> {
11071    let local_var_configuration = configuration;
11072
11073    let local_var_client = &local_var_configuration.client;
11074
11075    let local_var_uri_str = format!(
11076        "{}/vpn/vpn-tunnel-endpoints/",
11077        local_var_configuration.base_path
11078    );
11079    let mut local_var_req_builder =
11080        local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
11081
11082    if let Some(ref local_var_str) = contacts {
11083        local_var_req_builder = match "multi" {
11084            "multi" => local_var_req_builder.query(
11085                &local_var_str
11086                    .into_iter()
11087                    .map(|p| ("contacts".to_owned(), p.to_string()))
11088                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11089            ),
11090            _ => local_var_req_builder.query(&[(
11091                "contacts",
11092                &local_var_str
11093                    .into_iter()
11094                    .map(|p| p.to_string())
11095                    .collect::<Vec<String>>()
11096                    .join(",")
11097                    .to_string(),
11098            )]),
11099        };
11100    }
11101    if let Some(ref local_var_str) = contacts__isnull {
11102        local_var_req_builder =
11103            local_var_req_builder.query(&[("contacts__isnull", &local_var_str.to_string())]);
11104    }
11105    if let Some(ref local_var_str) = contacts__n {
11106        local_var_req_builder = match "multi" {
11107            "multi" => local_var_req_builder.query(
11108                &local_var_str
11109                    .into_iter()
11110                    .map(|p| ("contacts__n".to_owned(), p.to_string()))
11111                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11112            ),
11113            _ => local_var_req_builder.query(&[(
11114                "contacts__n",
11115                &local_var_str
11116                    .into_iter()
11117                    .map(|p| p.to_string())
11118                    .collect::<Vec<String>>()
11119                    .join(",")
11120                    .to_string(),
11121            )]),
11122        };
11123    }
11124    if let Some(ref local_var_str) = created {
11125        local_var_req_builder = match "multi" {
11126            "multi" => local_var_req_builder.query(
11127                &local_var_str
11128                    .into_iter()
11129                    .map(|p| ("created".to_owned(), p.to_string()))
11130                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11131            ),
11132            _ => local_var_req_builder.query(&[(
11133                "created",
11134                &local_var_str
11135                    .into_iter()
11136                    .map(|p| p.to_string())
11137                    .collect::<Vec<String>>()
11138                    .join(",")
11139                    .to_string(),
11140            )]),
11141        };
11142    }
11143    if let Some(ref local_var_str) = created__gt {
11144        local_var_req_builder = match "multi" {
11145            "multi" => local_var_req_builder.query(
11146                &local_var_str
11147                    .into_iter()
11148                    .map(|p| ("created__gt".to_owned(), p.to_string()))
11149                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11150            ),
11151            _ => local_var_req_builder.query(&[(
11152                "created__gt",
11153                &local_var_str
11154                    .into_iter()
11155                    .map(|p| p.to_string())
11156                    .collect::<Vec<String>>()
11157                    .join(",")
11158                    .to_string(),
11159            )]),
11160        };
11161    }
11162    if let Some(ref local_var_str) = created__gte {
11163        local_var_req_builder = match "multi" {
11164            "multi" => local_var_req_builder.query(
11165                &local_var_str
11166                    .into_iter()
11167                    .map(|p| ("created__gte".to_owned(), p.to_string()))
11168                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11169            ),
11170            _ => local_var_req_builder.query(&[(
11171                "created__gte",
11172                &local_var_str
11173                    .into_iter()
11174                    .map(|p| p.to_string())
11175                    .collect::<Vec<String>>()
11176                    .join(",")
11177                    .to_string(),
11178            )]),
11179        };
11180    }
11181    if let Some(ref local_var_str) = created__isnull {
11182        local_var_req_builder =
11183            local_var_req_builder.query(&[("created__isnull", &local_var_str.to_string())]);
11184    }
11185    if let Some(ref local_var_str) = created__lt {
11186        local_var_req_builder = match "multi" {
11187            "multi" => local_var_req_builder.query(
11188                &local_var_str
11189                    .into_iter()
11190                    .map(|p| ("created__lt".to_owned(), p.to_string()))
11191                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11192            ),
11193            _ => local_var_req_builder.query(&[(
11194                "created__lt",
11195                &local_var_str
11196                    .into_iter()
11197                    .map(|p| p.to_string())
11198                    .collect::<Vec<String>>()
11199                    .join(",")
11200                    .to_string(),
11201            )]),
11202        };
11203    }
11204    if let Some(ref local_var_str) = created__lte {
11205        local_var_req_builder = match "multi" {
11206            "multi" => local_var_req_builder.query(
11207                &local_var_str
11208                    .into_iter()
11209                    .map(|p| ("created__lte".to_owned(), p.to_string()))
11210                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11211            ),
11212            _ => local_var_req_builder.query(&[(
11213                "created__lte",
11214                &local_var_str
11215                    .into_iter()
11216                    .map(|p| p.to_string())
11217                    .collect::<Vec<String>>()
11218                    .join(",")
11219                    .to_string(),
11220            )]),
11221        };
11222    }
11223    if let Some(ref local_var_str) = created__n {
11224        local_var_req_builder = match "multi" {
11225            "multi" => local_var_req_builder.query(
11226                &local_var_str
11227                    .into_iter()
11228                    .map(|p| ("created__n".to_owned(), p.to_string()))
11229                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11230            ),
11231            _ => local_var_req_builder.query(&[(
11232                "created__n",
11233                &local_var_str
11234                    .into_iter()
11235                    .map(|p| p.to_string())
11236                    .collect::<Vec<String>>()
11237                    .join(",")
11238                    .to_string(),
11239            )]),
11240        };
11241    }
11242    if let Some(ref local_var_str) = device {
11243        local_var_req_builder = match "multi" {
11244            "multi" => local_var_req_builder.query(
11245                &local_var_str
11246                    .into_iter()
11247                    .map(|p| ("device".to_owned(), p.to_string()))
11248                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11249            ),
11250            _ => local_var_req_builder.query(&[(
11251                "device",
11252                &local_var_str
11253                    .into_iter()
11254                    .map(|p| p.to_string())
11255                    .collect::<Vec<String>>()
11256                    .join(",")
11257                    .to_string(),
11258            )]),
11259        };
11260    }
11261    if let Some(ref local_var_str) = device__isnull {
11262        local_var_req_builder =
11263            local_var_req_builder.query(&[("device__isnull", &local_var_str.to_string())]);
11264    }
11265    if let Some(ref local_var_str) = device__n {
11266        local_var_req_builder = match "multi" {
11267            "multi" => local_var_req_builder.query(
11268                &local_var_str
11269                    .into_iter()
11270                    .map(|p| ("device__n".to_owned(), p.to_string()))
11271                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11272            ),
11273            _ => local_var_req_builder.query(&[(
11274                "device__n",
11275                &local_var_str
11276                    .into_iter()
11277                    .map(|p| p.to_string())
11278                    .collect::<Vec<String>>()
11279                    .join(",")
11280                    .to_string(),
11281            )]),
11282        };
11283    }
11284    if let Some(ref local_var_str) = dynamic_groups {
11285        local_var_req_builder = match "multi" {
11286            "multi" => local_var_req_builder.query(
11287                &local_var_str
11288                    .into_iter()
11289                    .map(|p| ("dynamic_groups".to_owned(), p.to_string()))
11290                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11291            ),
11292            _ => local_var_req_builder.query(&[(
11293                "dynamic_groups",
11294                &local_var_str
11295                    .into_iter()
11296                    .map(|p| p.to_string())
11297                    .collect::<Vec<String>>()
11298                    .join(",")
11299                    .to_string(),
11300            )]),
11301        };
11302    }
11303    if let Some(ref local_var_str) = dynamic_groups__n {
11304        local_var_req_builder = match "multi" {
11305            "multi" => local_var_req_builder.query(
11306                &local_var_str
11307                    .into_iter()
11308                    .map(|p| ("dynamic_groups__n".to_owned(), p.to_string()))
11309                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11310            ),
11311            _ => local_var_req_builder.query(&[(
11312                "dynamic_groups__n",
11313                &local_var_str
11314                    .into_iter()
11315                    .map(|p| p.to_string())
11316                    .collect::<Vec<String>>()
11317                    .join(",")
11318                    .to_string(),
11319            )]),
11320        };
11321    }
11322    if let Some(ref local_var_str) = endpoint_a_vpn_tunnels {
11323        local_var_req_builder = match "multi" {
11324            "multi" => local_var_req_builder.query(
11325                &local_var_str
11326                    .into_iter()
11327                    .map(|p| ("endpoint_a_vpn_tunnels".to_owned(), p.to_string()))
11328                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11329            ),
11330            _ => local_var_req_builder.query(&[(
11331                "endpoint_a_vpn_tunnels",
11332                &local_var_str
11333                    .into_iter()
11334                    .map(|p| p.to_string())
11335                    .collect::<Vec<String>>()
11336                    .join(",")
11337                    .to_string(),
11338            )]),
11339        };
11340    }
11341    if let Some(ref local_var_str) = endpoint_a_vpn_tunnels__isnull {
11342        local_var_req_builder = local_var_req_builder
11343            .query(&[("endpoint_a_vpn_tunnels__isnull", &local_var_str.to_string())]);
11344    }
11345    if let Some(ref local_var_str) = endpoint_a_vpn_tunnels__n {
11346        local_var_req_builder = match "multi" {
11347            "multi" => local_var_req_builder.query(
11348                &local_var_str
11349                    .into_iter()
11350                    .map(|p| ("endpoint_a_vpn_tunnels__n".to_owned(), p.to_string()))
11351                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11352            ),
11353            _ => local_var_req_builder.query(&[(
11354                "endpoint_a_vpn_tunnels__n",
11355                &local_var_str
11356                    .into_iter()
11357                    .map(|p| p.to_string())
11358                    .collect::<Vec<String>>()
11359                    .join(",")
11360                    .to_string(),
11361            )]),
11362        };
11363    }
11364    if let Some(ref local_var_str) = endpoint_z_vpn_tunnels {
11365        local_var_req_builder = match "multi" {
11366            "multi" => local_var_req_builder.query(
11367                &local_var_str
11368                    .into_iter()
11369                    .map(|p| ("endpoint_z_vpn_tunnels".to_owned(), p.to_string()))
11370                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11371            ),
11372            _ => local_var_req_builder.query(&[(
11373                "endpoint_z_vpn_tunnels",
11374                &local_var_str
11375                    .into_iter()
11376                    .map(|p| p.to_string())
11377                    .collect::<Vec<String>>()
11378                    .join(",")
11379                    .to_string(),
11380            )]),
11381        };
11382    }
11383    if let Some(ref local_var_str) = endpoint_z_vpn_tunnels__isnull {
11384        local_var_req_builder = local_var_req_builder
11385            .query(&[("endpoint_z_vpn_tunnels__isnull", &local_var_str.to_string())]);
11386    }
11387    if let Some(ref local_var_str) = endpoint_z_vpn_tunnels__n {
11388        local_var_req_builder = match "multi" {
11389            "multi" => local_var_req_builder.query(
11390                &local_var_str
11391                    .into_iter()
11392                    .map(|p| ("endpoint_z_vpn_tunnels__n".to_owned(), p.to_string()))
11393                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11394            ),
11395            _ => local_var_req_builder.query(&[(
11396                "endpoint_z_vpn_tunnels__n",
11397                &local_var_str
11398                    .into_iter()
11399                    .map(|p| p.to_string())
11400                    .collect::<Vec<String>>()
11401                    .join(",")
11402                    .to_string(),
11403            )]),
11404        };
11405    }
11406    if let Some(ref local_var_str) = format {
11407        local_var_req_builder =
11408            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
11409    }
11410    if let Some(ref local_var_str) = id {
11411        local_var_req_builder = match "multi" {
11412            "multi" => local_var_req_builder.query(
11413                &local_var_str
11414                    .into_iter()
11415                    .map(|p| ("id".to_owned(), p.to_string()))
11416                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11417            ),
11418            _ => local_var_req_builder.query(&[(
11419                "id",
11420                &local_var_str
11421                    .into_iter()
11422                    .map(|p| p.to_string())
11423                    .collect::<Vec<String>>()
11424                    .join(",")
11425                    .to_string(),
11426            )]),
11427        };
11428    }
11429    if let Some(ref local_var_str) = id__n {
11430        local_var_req_builder = match "multi" {
11431            "multi" => local_var_req_builder.query(
11432                &local_var_str
11433                    .into_iter()
11434                    .map(|p| ("id__n".to_owned(), p.to_string()))
11435                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11436            ),
11437            _ => local_var_req_builder.query(&[(
11438                "id__n",
11439                &local_var_str
11440                    .into_iter()
11441                    .map(|p| p.to_string())
11442                    .collect::<Vec<String>>()
11443                    .join(",")
11444                    .to_string(),
11445            )]),
11446        };
11447    }
11448    if let Some(ref local_var_str) = last_updated {
11449        local_var_req_builder = match "multi" {
11450            "multi" => local_var_req_builder.query(
11451                &local_var_str
11452                    .into_iter()
11453                    .map(|p| ("last_updated".to_owned(), p.to_string()))
11454                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11455            ),
11456            _ => local_var_req_builder.query(&[(
11457                "last_updated",
11458                &local_var_str
11459                    .into_iter()
11460                    .map(|p| p.to_string())
11461                    .collect::<Vec<String>>()
11462                    .join(",")
11463                    .to_string(),
11464            )]),
11465        };
11466    }
11467    if let Some(ref local_var_str) = last_updated__gt {
11468        local_var_req_builder = match "multi" {
11469            "multi" => local_var_req_builder.query(
11470                &local_var_str
11471                    .into_iter()
11472                    .map(|p| ("last_updated__gt".to_owned(), p.to_string()))
11473                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11474            ),
11475            _ => local_var_req_builder.query(&[(
11476                "last_updated__gt",
11477                &local_var_str
11478                    .into_iter()
11479                    .map(|p| p.to_string())
11480                    .collect::<Vec<String>>()
11481                    .join(",")
11482                    .to_string(),
11483            )]),
11484        };
11485    }
11486    if let Some(ref local_var_str) = last_updated__gte {
11487        local_var_req_builder = match "multi" {
11488            "multi" => local_var_req_builder.query(
11489                &local_var_str
11490                    .into_iter()
11491                    .map(|p| ("last_updated__gte".to_owned(), p.to_string()))
11492                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11493            ),
11494            _ => local_var_req_builder.query(&[(
11495                "last_updated__gte",
11496                &local_var_str
11497                    .into_iter()
11498                    .map(|p| p.to_string())
11499                    .collect::<Vec<String>>()
11500                    .join(",")
11501                    .to_string(),
11502            )]),
11503        };
11504    }
11505    if let Some(ref local_var_str) = last_updated__isnull {
11506        local_var_req_builder =
11507            local_var_req_builder.query(&[("last_updated__isnull", &local_var_str.to_string())]);
11508    }
11509    if let Some(ref local_var_str) = last_updated__lt {
11510        local_var_req_builder = match "multi" {
11511            "multi" => local_var_req_builder.query(
11512                &local_var_str
11513                    .into_iter()
11514                    .map(|p| ("last_updated__lt".to_owned(), p.to_string()))
11515                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11516            ),
11517            _ => local_var_req_builder.query(&[(
11518                "last_updated__lt",
11519                &local_var_str
11520                    .into_iter()
11521                    .map(|p| p.to_string())
11522                    .collect::<Vec<String>>()
11523                    .join(",")
11524                    .to_string(),
11525            )]),
11526        };
11527    }
11528    if let Some(ref local_var_str) = last_updated__lte {
11529        local_var_req_builder = match "multi" {
11530            "multi" => local_var_req_builder.query(
11531                &local_var_str
11532                    .into_iter()
11533                    .map(|p| ("last_updated__lte".to_owned(), p.to_string()))
11534                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11535            ),
11536            _ => local_var_req_builder.query(&[(
11537                "last_updated__lte",
11538                &local_var_str
11539                    .into_iter()
11540                    .map(|p| p.to_string())
11541                    .collect::<Vec<String>>()
11542                    .join(",")
11543                    .to_string(),
11544            )]),
11545        };
11546    }
11547    if let Some(ref local_var_str) = last_updated__n {
11548        local_var_req_builder = match "multi" {
11549            "multi" => local_var_req_builder.query(
11550                &local_var_str
11551                    .into_iter()
11552                    .map(|p| ("last_updated__n".to_owned(), p.to_string()))
11553                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11554            ),
11555            _ => local_var_req_builder.query(&[(
11556                "last_updated__n",
11557                &local_var_str
11558                    .into_iter()
11559                    .map(|p| p.to_string())
11560                    .collect::<Vec<String>>()
11561                    .join(",")
11562                    .to_string(),
11563            )]),
11564        };
11565    }
11566    if let Some(ref local_var_str) = limit {
11567        local_var_req_builder =
11568            local_var_req_builder.query(&[("limit", &local_var_str.to_string())]);
11569    }
11570    if let Some(ref local_var_str) = name {
11571        local_var_req_builder = match "multi" {
11572            "multi" => local_var_req_builder.query(
11573                &local_var_str
11574                    .into_iter()
11575                    .map(|p| ("name".to_owned(), p.to_string()))
11576                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11577            ),
11578            _ => local_var_req_builder.query(&[(
11579                "name",
11580                &local_var_str
11581                    .into_iter()
11582                    .map(|p| p.to_string())
11583                    .collect::<Vec<String>>()
11584                    .join(",")
11585                    .to_string(),
11586            )]),
11587        };
11588    }
11589    if let Some(ref local_var_str) = name__ic {
11590        local_var_req_builder = match "multi" {
11591            "multi" => local_var_req_builder.query(
11592                &local_var_str
11593                    .into_iter()
11594                    .map(|p| ("name__ic".to_owned(), p.to_string()))
11595                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11596            ),
11597            _ => local_var_req_builder.query(&[(
11598                "name__ic",
11599                &local_var_str
11600                    .into_iter()
11601                    .map(|p| p.to_string())
11602                    .collect::<Vec<String>>()
11603                    .join(",")
11604                    .to_string(),
11605            )]),
11606        };
11607    }
11608    if let Some(ref local_var_str) = name__ie {
11609        local_var_req_builder = match "multi" {
11610            "multi" => local_var_req_builder.query(
11611                &local_var_str
11612                    .into_iter()
11613                    .map(|p| ("name__ie".to_owned(), p.to_string()))
11614                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11615            ),
11616            _ => local_var_req_builder.query(&[(
11617                "name__ie",
11618                &local_var_str
11619                    .into_iter()
11620                    .map(|p| p.to_string())
11621                    .collect::<Vec<String>>()
11622                    .join(",")
11623                    .to_string(),
11624            )]),
11625        };
11626    }
11627    if let Some(ref local_var_str) = name__iew {
11628        local_var_req_builder = match "multi" {
11629            "multi" => local_var_req_builder.query(
11630                &local_var_str
11631                    .into_iter()
11632                    .map(|p| ("name__iew".to_owned(), p.to_string()))
11633                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11634            ),
11635            _ => local_var_req_builder.query(&[(
11636                "name__iew",
11637                &local_var_str
11638                    .into_iter()
11639                    .map(|p| p.to_string())
11640                    .collect::<Vec<String>>()
11641                    .join(",")
11642                    .to_string(),
11643            )]),
11644        };
11645    }
11646    if let Some(ref local_var_str) = name__ire {
11647        local_var_req_builder = match "multi" {
11648            "multi" => local_var_req_builder.query(
11649                &local_var_str
11650                    .into_iter()
11651                    .map(|p| ("name__ire".to_owned(), p.to_string()))
11652                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11653            ),
11654            _ => local_var_req_builder.query(&[(
11655                "name__ire",
11656                &local_var_str
11657                    .into_iter()
11658                    .map(|p| p.to_string())
11659                    .collect::<Vec<String>>()
11660                    .join(",")
11661                    .to_string(),
11662            )]),
11663        };
11664    }
11665    if let Some(ref local_var_str) = name__isw {
11666        local_var_req_builder = match "multi" {
11667            "multi" => local_var_req_builder.query(
11668                &local_var_str
11669                    .into_iter()
11670                    .map(|p| ("name__isw".to_owned(), p.to_string()))
11671                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11672            ),
11673            _ => local_var_req_builder.query(&[(
11674                "name__isw",
11675                &local_var_str
11676                    .into_iter()
11677                    .map(|p| p.to_string())
11678                    .collect::<Vec<String>>()
11679                    .join(",")
11680                    .to_string(),
11681            )]),
11682        };
11683    }
11684    if let Some(ref local_var_str) = name__n {
11685        local_var_req_builder = match "multi" {
11686            "multi" => local_var_req_builder.query(
11687                &local_var_str
11688                    .into_iter()
11689                    .map(|p| ("name__n".to_owned(), p.to_string()))
11690                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11691            ),
11692            _ => local_var_req_builder.query(&[(
11693                "name__n",
11694                &local_var_str
11695                    .into_iter()
11696                    .map(|p| p.to_string())
11697                    .collect::<Vec<String>>()
11698                    .join(",")
11699                    .to_string(),
11700            )]),
11701        };
11702    }
11703    if let Some(ref local_var_str) = name__nic {
11704        local_var_req_builder = match "multi" {
11705            "multi" => local_var_req_builder.query(
11706                &local_var_str
11707                    .into_iter()
11708                    .map(|p| ("name__nic".to_owned(), p.to_string()))
11709                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11710            ),
11711            _ => local_var_req_builder.query(&[(
11712                "name__nic",
11713                &local_var_str
11714                    .into_iter()
11715                    .map(|p| p.to_string())
11716                    .collect::<Vec<String>>()
11717                    .join(",")
11718                    .to_string(),
11719            )]),
11720        };
11721    }
11722    if let Some(ref local_var_str) = name__nie {
11723        local_var_req_builder = match "multi" {
11724            "multi" => local_var_req_builder.query(
11725                &local_var_str
11726                    .into_iter()
11727                    .map(|p| ("name__nie".to_owned(), p.to_string()))
11728                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11729            ),
11730            _ => local_var_req_builder.query(&[(
11731                "name__nie",
11732                &local_var_str
11733                    .into_iter()
11734                    .map(|p| p.to_string())
11735                    .collect::<Vec<String>>()
11736                    .join(",")
11737                    .to_string(),
11738            )]),
11739        };
11740    }
11741    if let Some(ref local_var_str) = name__niew {
11742        local_var_req_builder = match "multi" {
11743            "multi" => local_var_req_builder.query(
11744                &local_var_str
11745                    .into_iter()
11746                    .map(|p| ("name__niew".to_owned(), p.to_string()))
11747                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11748            ),
11749            _ => local_var_req_builder.query(&[(
11750                "name__niew",
11751                &local_var_str
11752                    .into_iter()
11753                    .map(|p| p.to_string())
11754                    .collect::<Vec<String>>()
11755                    .join(",")
11756                    .to_string(),
11757            )]),
11758        };
11759    }
11760    if let Some(ref local_var_str) = name__nire {
11761        local_var_req_builder = match "multi" {
11762            "multi" => local_var_req_builder.query(
11763                &local_var_str
11764                    .into_iter()
11765                    .map(|p| ("name__nire".to_owned(), p.to_string()))
11766                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11767            ),
11768            _ => local_var_req_builder.query(&[(
11769                "name__nire",
11770                &local_var_str
11771                    .into_iter()
11772                    .map(|p| p.to_string())
11773                    .collect::<Vec<String>>()
11774                    .join(",")
11775                    .to_string(),
11776            )]),
11777        };
11778    }
11779    if let Some(ref local_var_str) = name__nisw {
11780        local_var_req_builder = match "multi" {
11781            "multi" => local_var_req_builder.query(
11782                &local_var_str
11783                    .into_iter()
11784                    .map(|p| ("name__nisw".to_owned(), p.to_string()))
11785                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11786            ),
11787            _ => local_var_req_builder.query(&[(
11788                "name__nisw",
11789                &local_var_str
11790                    .into_iter()
11791                    .map(|p| p.to_string())
11792                    .collect::<Vec<String>>()
11793                    .join(",")
11794                    .to_string(),
11795            )]),
11796        };
11797    }
11798    if let Some(ref local_var_str) = name__nre {
11799        local_var_req_builder = match "multi" {
11800            "multi" => local_var_req_builder.query(
11801                &local_var_str
11802                    .into_iter()
11803                    .map(|p| ("name__nre".to_owned(), p.to_string()))
11804                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11805            ),
11806            _ => local_var_req_builder.query(&[(
11807                "name__nre",
11808                &local_var_str
11809                    .into_iter()
11810                    .map(|p| p.to_string())
11811                    .collect::<Vec<String>>()
11812                    .join(",")
11813                    .to_string(),
11814            )]),
11815        };
11816    }
11817    if let Some(ref local_var_str) = name__re {
11818        local_var_req_builder = match "multi" {
11819            "multi" => local_var_req_builder.query(
11820                &local_var_str
11821                    .into_iter()
11822                    .map(|p| ("name__re".to_owned(), p.to_string()))
11823                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11824            ),
11825            _ => local_var_req_builder.query(&[(
11826                "name__re",
11827                &local_var_str
11828                    .into_iter()
11829                    .map(|p| p.to_string())
11830                    .collect::<Vec<String>>()
11831                    .join(",")
11832                    .to_string(),
11833            )]),
11834        };
11835    }
11836    if let Some(ref local_var_str) = offset {
11837        local_var_req_builder =
11838            local_var_req_builder.query(&[("offset", &local_var_str.to_string())]);
11839    }
11840    if let Some(ref local_var_str) = protected_prefixes {
11841        local_var_req_builder = match "multi" {
11842            "multi" => local_var_req_builder.query(
11843                &local_var_str
11844                    .into_iter()
11845                    .map(|p| ("protected_prefixes".to_owned(), p.to_string()))
11846                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11847            ),
11848            _ => local_var_req_builder.query(&[(
11849                "protected_prefixes",
11850                &local_var_str
11851                    .into_iter()
11852                    .map(|p| p.to_string())
11853                    .collect::<Vec<String>>()
11854                    .join(",")
11855                    .to_string(),
11856            )]),
11857        };
11858    }
11859    if let Some(ref local_var_str) = protected_prefixes__n {
11860        local_var_req_builder = match "multi" {
11861            "multi" => local_var_req_builder.query(
11862                &local_var_str
11863                    .into_iter()
11864                    .map(|p| ("protected_prefixes__n".to_owned(), p.to_string()))
11865                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11866            ),
11867            _ => local_var_req_builder.query(&[(
11868                "protected_prefixes__n",
11869                &local_var_str
11870                    .into_iter()
11871                    .map(|p| p.to_string())
11872                    .collect::<Vec<String>>()
11873                    .join(",")
11874                    .to_string(),
11875            )]),
11876        };
11877    }
11878    if let Some(ref local_var_str) = protected_prefixes_dg {
11879        local_var_req_builder = match "multi" {
11880            "multi" => local_var_req_builder.query(
11881                &local_var_str
11882                    .into_iter()
11883                    .map(|p| ("protected_prefixes_dg".to_owned(), p.to_string()))
11884                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11885            ),
11886            _ => local_var_req_builder.query(&[(
11887                "protected_prefixes_dg",
11888                &local_var_str
11889                    .into_iter()
11890                    .map(|p| p.to_string())
11891                    .collect::<Vec<String>>()
11892                    .join(",")
11893                    .to_string(),
11894            )]),
11895        };
11896    }
11897    if let Some(ref local_var_str) = protected_prefixes_dg__n {
11898        local_var_req_builder = match "multi" {
11899            "multi" => local_var_req_builder.query(
11900                &local_var_str
11901                    .into_iter()
11902                    .map(|p| ("protected_prefixes_dg__n".to_owned(), p.to_string()))
11903                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11904            ),
11905            _ => local_var_req_builder.query(&[(
11906                "protected_prefixes_dg__n",
11907                &local_var_str
11908                    .into_iter()
11909                    .map(|p| p.to_string())
11910                    .collect::<Vec<String>>()
11911                    .join(",")
11912                    .to_string(),
11913            )]),
11914        };
11915    }
11916    if let Some(ref local_var_str) = q {
11917        local_var_req_builder = local_var_req_builder.query(&[("q", &local_var_str.to_string())]);
11918    }
11919    if let Some(ref local_var_str) = role {
11920        local_var_req_builder = match "multi" {
11921            "multi" => local_var_req_builder.query(
11922                &local_var_str
11923                    .into_iter()
11924                    .map(|p| ("role".to_owned(), p.to_string()))
11925                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11926            ),
11927            _ => local_var_req_builder.query(&[(
11928                "role",
11929                &local_var_str
11930                    .into_iter()
11931                    .map(|p| p.to_string())
11932                    .collect::<Vec<String>>()
11933                    .join(",")
11934                    .to_string(),
11935            )]),
11936        };
11937    }
11938    if let Some(ref local_var_str) = role__isnull {
11939        local_var_req_builder =
11940            local_var_req_builder.query(&[("role__isnull", &local_var_str.to_string())]);
11941    }
11942    if let Some(ref local_var_str) = role__n {
11943        local_var_req_builder = match "multi" {
11944            "multi" => local_var_req_builder.query(
11945                &local_var_str
11946                    .into_iter()
11947                    .map(|p| ("role__n".to_owned(), p.to_string()))
11948                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11949            ),
11950            _ => local_var_req_builder.query(&[(
11951                "role__n",
11952                &local_var_str
11953                    .into_iter()
11954                    .map(|p| p.to_string())
11955                    .collect::<Vec<String>>()
11956                    .join(",")
11957                    .to_string(),
11958            )]),
11959        };
11960    }
11961    if let Some(ref local_var_str) = sort {
11962        local_var_req_builder =
11963            local_var_req_builder.query(&[("sort", &local_var_str.to_string())]);
11964    }
11965    if let Some(ref local_var_str) = source_fqdn {
11966        local_var_req_builder = match "multi" {
11967            "multi" => local_var_req_builder.query(
11968                &local_var_str
11969                    .into_iter()
11970                    .map(|p| ("source_fqdn".to_owned(), p.to_string()))
11971                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11972            ),
11973            _ => local_var_req_builder.query(&[(
11974                "source_fqdn",
11975                &local_var_str
11976                    .into_iter()
11977                    .map(|p| p.to_string())
11978                    .collect::<Vec<String>>()
11979                    .join(",")
11980                    .to_string(),
11981            )]),
11982        };
11983    }
11984    if let Some(ref local_var_str) = source_fqdn__ic {
11985        local_var_req_builder = match "multi" {
11986            "multi" => local_var_req_builder.query(
11987                &local_var_str
11988                    .into_iter()
11989                    .map(|p| ("source_fqdn__ic".to_owned(), p.to_string()))
11990                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11991            ),
11992            _ => local_var_req_builder.query(&[(
11993                "source_fqdn__ic",
11994                &local_var_str
11995                    .into_iter()
11996                    .map(|p| p.to_string())
11997                    .collect::<Vec<String>>()
11998                    .join(",")
11999                    .to_string(),
12000            )]),
12001        };
12002    }
12003    if let Some(ref local_var_str) = source_fqdn__ie {
12004        local_var_req_builder = match "multi" {
12005            "multi" => local_var_req_builder.query(
12006                &local_var_str
12007                    .into_iter()
12008                    .map(|p| ("source_fqdn__ie".to_owned(), p.to_string()))
12009                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12010            ),
12011            _ => local_var_req_builder.query(&[(
12012                "source_fqdn__ie",
12013                &local_var_str
12014                    .into_iter()
12015                    .map(|p| p.to_string())
12016                    .collect::<Vec<String>>()
12017                    .join(",")
12018                    .to_string(),
12019            )]),
12020        };
12021    }
12022    if let Some(ref local_var_str) = source_fqdn__iew {
12023        local_var_req_builder = match "multi" {
12024            "multi" => local_var_req_builder.query(
12025                &local_var_str
12026                    .into_iter()
12027                    .map(|p| ("source_fqdn__iew".to_owned(), p.to_string()))
12028                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12029            ),
12030            _ => local_var_req_builder.query(&[(
12031                "source_fqdn__iew",
12032                &local_var_str
12033                    .into_iter()
12034                    .map(|p| p.to_string())
12035                    .collect::<Vec<String>>()
12036                    .join(",")
12037                    .to_string(),
12038            )]),
12039        };
12040    }
12041    if let Some(ref local_var_str) = source_fqdn__ire {
12042        local_var_req_builder = match "multi" {
12043            "multi" => local_var_req_builder.query(
12044                &local_var_str
12045                    .into_iter()
12046                    .map(|p| ("source_fqdn__ire".to_owned(), p.to_string()))
12047                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12048            ),
12049            _ => local_var_req_builder.query(&[(
12050                "source_fqdn__ire",
12051                &local_var_str
12052                    .into_iter()
12053                    .map(|p| p.to_string())
12054                    .collect::<Vec<String>>()
12055                    .join(",")
12056                    .to_string(),
12057            )]),
12058        };
12059    }
12060    if let Some(ref local_var_str) = source_fqdn__isw {
12061        local_var_req_builder = match "multi" {
12062            "multi" => local_var_req_builder.query(
12063                &local_var_str
12064                    .into_iter()
12065                    .map(|p| ("source_fqdn__isw".to_owned(), p.to_string()))
12066                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12067            ),
12068            _ => local_var_req_builder.query(&[(
12069                "source_fqdn__isw",
12070                &local_var_str
12071                    .into_iter()
12072                    .map(|p| p.to_string())
12073                    .collect::<Vec<String>>()
12074                    .join(",")
12075                    .to_string(),
12076            )]),
12077        };
12078    }
12079    if let Some(ref local_var_str) = source_fqdn__n {
12080        local_var_req_builder = match "multi" {
12081            "multi" => local_var_req_builder.query(
12082                &local_var_str
12083                    .into_iter()
12084                    .map(|p| ("source_fqdn__n".to_owned(), p.to_string()))
12085                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12086            ),
12087            _ => local_var_req_builder.query(&[(
12088                "source_fqdn__n",
12089                &local_var_str
12090                    .into_iter()
12091                    .map(|p| p.to_string())
12092                    .collect::<Vec<String>>()
12093                    .join(",")
12094                    .to_string(),
12095            )]),
12096        };
12097    }
12098    if let Some(ref local_var_str) = source_fqdn__nic {
12099        local_var_req_builder = match "multi" {
12100            "multi" => local_var_req_builder.query(
12101                &local_var_str
12102                    .into_iter()
12103                    .map(|p| ("source_fqdn__nic".to_owned(), p.to_string()))
12104                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12105            ),
12106            _ => local_var_req_builder.query(&[(
12107                "source_fqdn__nic",
12108                &local_var_str
12109                    .into_iter()
12110                    .map(|p| p.to_string())
12111                    .collect::<Vec<String>>()
12112                    .join(",")
12113                    .to_string(),
12114            )]),
12115        };
12116    }
12117    if let Some(ref local_var_str) = source_fqdn__nie {
12118        local_var_req_builder = match "multi" {
12119            "multi" => local_var_req_builder.query(
12120                &local_var_str
12121                    .into_iter()
12122                    .map(|p| ("source_fqdn__nie".to_owned(), p.to_string()))
12123                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12124            ),
12125            _ => local_var_req_builder.query(&[(
12126                "source_fqdn__nie",
12127                &local_var_str
12128                    .into_iter()
12129                    .map(|p| p.to_string())
12130                    .collect::<Vec<String>>()
12131                    .join(",")
12132                    .to_string(),
12133            )]),
12134        };
12135    }
12136    if let Some(ref local_var_str) = source_fqdn__niew {
12137        local_var_req_builder = match "multi" {
12138            "multi" => local_var_req_builder.query(
12139                &local_var_str
12140                    .into_iter()
12141                    .map(|p| ("source_fqdn__niew".to_owned(), p.to_string()))
12142                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12143            ),
12144            _ => local_var_req_builder.query(&[(
12145                "source_fqdn__niew",
12146                &local_var_str
12147                    .into_iter()
12148                    .map(|p| p.to_string())
12149                    .collect::<Vec<String>>()
12150                    .join(",")
12151                    .to_string(),
12152            )]),
12153        };
12154    }
12155    if let Some(ref local_var_str) = source_fqdn__nire {
12156        local_var_req_builder = match "multi" {
12157            "multi" => local_var_req_builder.query(
12158                &local_var_str
12159                    .into_iter()
12160                    .map(|p| ("source_fqdn__nire".to_owned(), p.to_string()))
12161                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12162            ),
12163            _ => local_var_req_builder.query(&[(
12164                "source_fqdn__nire",
12165                &local_var_str
12166                    .into_iter()
12167                    .map(|p| p.to_string())
12168                    .collect::<Vec<String>>()
12169                    .join(",")
12170                    .to_string(),
12171            )]),
12172        };
12173    }
12174    if let Some(ref local_var_str) = source_fqdn__nisw {
12175        local_var_req_builder = match "multi" {
12176            "multi" => local_var_req_builder.query(
12177                &local_var_str
12178                    .into_iter()
12179                    .map(|p| ("source_fqdn__nisw".to_owned(), p.to_string()))
12180                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12181            ),
12182            _ => local_var_req_builder.query(&[(
12183                "source_fqdn__nisw",
12184                &local_var_str
12185                    .into_iter()
12186                    .map(|p| p.to_string())
12187                    .collect::<Vec<String>>()
12188                    .join(",")
12189                    .to_string(),
12190            )]),
12191        };
12192    }
12193    if let Some(ref local_var_str) = source_fqdn__nre {
12194        local_var_req_builder = match "multi" {
12195            "multi" => local_var_req_builder.query(
12196                &local_var_str
12197                    .into_iter()
12198                    .map(|p| ("source_fqdn__nre".to_owned(), p.to_string()))
12199                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12200            ),
12201            _ => local_var_req_builder.query(&[(
12202                "source_fqdn__nre",
12203                &local_var_str
12204                    .into_iter()
12205                    .map(|p| p.to_string())
12206                    .collect::<Vec<String>>()
12207                    .join(",")
12208                    .to_string(),
12209            )]),
12210        };
12211    }
12212    if let Some(ref local_var_str) = source_fqdn__re {
12213        local_var_req_builder = match "multi" {
12214            "multi" => local_var_req_builder.query(
12215                &local_var_str
12216                    .into_iter()
12217                    .map(|p| ("source_fqdn__re".to_owned(), p.to_string()))
12218                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12219            ),
12220            _ => local_var_req_builder.query(&[(
12221                "source_fqdn__re",
12222                &local_var_str
12223                    .into_iter()
12224                    .map(|p| p.to_string())
12225                    .collect::<Vec<String>>()
12226                    .join(",")
12227                    .to_string(),
12228            )]),
12229        };
12230    }
12231    if let Some(ref local_var_str) = source_interface {
12232        local_var_req_builder = match "multi" {
12233            "multi" => local_var_req_builder.query(
12234                &local_var_str
12235                    .into_iter()
12236                    .map(|p| ("source_interface".to_owned(), p.to_string()))
12237                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12238            ),
12239            _ => local_var_req_builder.query(&[(
12240                "source_interface",
12241                &local_var_str
12242                    .into_iter()
12243                    .map(|p| p.to_string())
12244                    .collect::<Vec<String>>()
12245                    .join(",")
12246                    .to_string(),
12247            )]),
12248        };
12249    }
12250    if let Some(ref local_var_str) = source_interface__isnull {
12251        local_var_req_builder = local_var_req_builder
12252            .query(&[("source_interface__isnull", &local_var_str.to_string())]);
12253    }
12254    if let Some(ref local_var_str) = source_interface__n {
12255        local_var_req_builder = match "multi" {
12256            "multi" => local_var_req_builder.query(
12257                &local_var_str
12258                    .into_iter()
12259                    .map(|p| ("source_interface__n".to_owned(), p.to_string()))
12260                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12261            ),
12262            _ => local_var_req_builder.query(&[(
12263                "source_interface__n",
12264                &local_var_str
12265                    .into_iter()
12266                    .map(|p| p.to_string())
12267                    .collect::<Vec<String>>()
12268                    .join(",")
12269                    .to_string(),
12270            )]),
12271        };
12272    }
12273    if let Some(ref local_var_str) = source_ipaddress {
12274        local_var_req_builder = match "multi" {
12275            "multi" => local_var_req_builder.query(
12276                &local_var_str
12277                    .into_iter()
12278                    .map(|p| ("source_ipaddress".to_owned(), p.to_string()))
12279                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12280            ),
12281            _ => local_var_req_builder.query(&[(
12282                "source_ipaddress",
12283                &local_var_str
12284                    .into_iter()
12285                    .map(|p| p.to_string())
12286                    .collect::<Vec<String>>()
12287                    .join(",")
12288                    .to_string(),
12289            )]),
12290        };
12291    }
12292    if let Some(ref local_var_str) = source_ipaddress__isnull {
12293        local_var_req_builder = local_var_req_builder
12294            .query(&[("source_ipaddress__isnull", &local_var_str.to_string())]);
12295    }
12296    if let Some(ref local_var_str) = source_ipaddress__n {
12297        local_var_req_builder = match "multi" {
12298            "multi" => local_var_req_builder.query(
12299                &local_var_str
12300                    .into_iter()
12301                    .map(|p| ("source_ipaddress__n".to_owned(), p.to_string()))
12302                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12303            ),
12304            _ => local_var_req_builder.query(&[(
12305                "source_ipaddress__n",
12306                &local_var_str
12307                    .into_iter()
12308                    .map(|p| p.to_string())
12309                    .collect::<Vec<String>>()
12310                    .join(",")
12311                    .to_string(),
12312            )]),
12313        };
12314    }
12315    if let Some(ref local_var_str) = tags {
12316        local_var_req_builder = match "multi" {
12317            "multi" => local_var_req_builder.query(
12318                &local_var_str
12319                    .into_iter()
12320                    .map(|p| ("tags".to_owned(), p.to_string()))
12321                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12322            ),
12323            _ => local_var_req_builder.query(&[(
12324                "tags",
12325                &local_var_str
12326                    .into_iter()
12327                    .map(|p| p.to_string())
12328                    .collect::<Vec<String>>()
12329                    .join(",")
12330                    .to_string(),
12331            )]),
12332        };
12333    }
12334    if let Some(ref local_var_str) = tags__isnull {
12335        local_var_req_builder =
12336            local_var_req_builder.query(&[("tags__isnull", &local_var_str.to_string())]);
12337    }
12338    if let Some(ref local_var_str) = tags__n {
12339        local_var_req_builder = match "multi" {
12340            "multi" => local_var_req_builder.query(
12341                &local_var_str
12342                    .into_iter()
12343                    .map(|p| ("tags__n".to_owned(), p.to_string()))
12344                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12345            ),
12346            _ => local_var_req_builder.query(&[(
12347                "tags__n",
12348                &local_var_str
12349                    .into_iter()
12350                    .map(|p| p.to_string())
12351                    .collect::<Vec<String>>()
12352                    .join(",")
12353                    .to_string(),
12354            )]),
12355        };
12356    }
12357    if let Some(ref local_var_str) = teams {
12358        local_var_req_builder = match "multi" {
12359            "multi" => local_var_req_builder.query(
12360                &local_var_str
12361                    .into_iter()
12362                    .map(|p| ("teams".to_owned(), p.to_string()))
12363                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12364            ),
12365            _ => local_var_req_builder.query(&[(
12366                "teams",
12367                &local_var_str
12368                    .into_iter()
12369                    .map(|p| p.to_string())
12370                    .collect::<Vec<String>>()
12371                    .join(",")
12372                    .to_string(),
12373            )]),
12374        };
12375    }
12376    if let Some(ref local_var_str) = teams__isnull {
12377        local_var_req_builder =
12378            local_var_req_builder.query(&[("teams__isnull", &local_var_str.to_string())]);
12379    }
12380    if let Some(ref local_var_str) = teams__n {
12381        local_var_req_builder = match "multi" {
12382            "multi" => local_var_req_builder.query(
12383                &local_var_str
12384                    .into_iter()
12385                    .map(|p| ("teams__n".to_owned(), p.to_string()))
12386                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12387            ),
12388            _ => local_var_req_builder.query(&[(
12389                "teams__n",
12390                &local_var_str
12391                    .into_iter()
12392                    .map(|p| p.to_string())
12393                    .collect::<Vec<String>>()
12394                    .join(",")
12395                    .to_string(),
12396            )]),
12397        };
12398    }
12399    if let Some(ref local_var_str) = tenant {
12400        local_var_req_builder = match "multi" {
12401            "multi" => local_var_req_builder.query(
12402                &local_var_str
12403                    .into_iter()
12404                    .map(|p| ("tenant".to_owned(), p.to_string()))
12405                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12406            ),
12407            _ => local_var_req_builder.query(&[(
12408                "tenant",
12409                &local_var_str
12410                    .into_iter()
12411                    .map(|p| p.to_string())
12412                    .collect::<Vec<String>>()
12413                    .join(",")
12414                    .to_string(),
12415            )]),
12416        };
12417    }
12418    if let Some(ref local_var_str) = tenant__isnull {
12419        local_var_req_builder =
12420            local_var_req_builder.query(&[("tenant__isnull", &local_var_str.to_string())]);
12421    }
12422    if let Some(ref local_var_str) = tenant__n {
12423        local_var_req_builder = match "multi" {
12424            "multi" => local_var_req_builder.query(
12425                &local_var_str
12426                    .into_iter()
12427                    .map(|p| ("tenant__n".to_owned(), p.to_string()))
12428                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12429            ),
12430            _ => local_var_req_builder.query(&[(
12431                "tenant__n",
12432                &local_var_str
12433                    .into_iter()
12434                    .map(|p| p.to_string())
12435                    .collect::<Vec<String>>()
12436                    .join(",")
12437                    .to_string(),
12438            )]),
12439        };
12440    }
12441    if let Some(ref local_var_str) = tenant_group {
12442        local_var_req_builder = match "multi" {
12443            "multi" => local_var_req_builder.query(
12444                &local_var_str
12445                    .into_iter()
12446                    .map(|p| ("tenant_group".to_owned(), p.to_string()))
12447                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12448            ),
12449            _ => local_var_req_builder.query(&[(
12450                "tenant_group",
12451                &local_var_str
12452                    .into_iter()
12453                    .map(|p| p.to_string())
12454                    .collect::<Vec<String>>()
12455                    .join(",")
12456                    .to_string(),
12457            )]),
12458        };
12459    }
12460    if let Some(ref local_var_str) = tenant_group__isnull {
12461        local_var_req_builder =
12462            local_var_req_builder.query(&[("tenant_group__isnull", &local_var_str.to_string())]);
12463    }
12464    if let Some(ref local_var_str) = tenant_group__n {
12465        local_var_req_builder = match "multi" {
12466            "multi" => local_var_req_builder.query(
12467                &local_var_str
12468                    .into_iter()
12469                    .map(|p| ("tenant_group__n".to_owned(), p.to_string()))
12470                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12471            ),
12472            _ => local_var_req_builder.query(&[(
12473                "tenant_group__n",
12474                &local_var_str
12475                    .into_iter()
12476                    .map(|p| p.to_string())
12477                    .collect::<Vec<String>>()
12478                    .join(",")
12479                    .to_string(),
12480            )]),
12481        };
12482    }
12483    if let Some(ref local_var_str) = tenant_id {
12484        local_var_req_builder = match "multi" {
12485            "multi" => local_var_req_builder.query(
12486                &local_var_str
12487                    .into_iter()
12488                    .map(|p| ("tenant_id".to_owned(), p.to_string()))
12489                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12490            ),
12491            _ => local_var_req_builder.query(&[(
12492                "tenant_id",
12493                &local_var_str
12494                    .into_iter()
12495                    .map(|p| p.to_string())
12496                    .collect::<Vec<String>>()
12497                    .join(",")
12498                    .to_string(),
12499            )]),
12500        };
12501    }
12502    if let Some(ref local_var_str) = tenant_id__isnull {
12503        local_var_req_builder =
12504            local_var_req_builder.query(&[("tenant_id__isnull", &local_var_str.to_string())]);
12505    }
12506    if let Some(ref local_var_str) = tenant_id__n {
12507        local_var_req_builder = match "multi" {
12508            "multi" => local_var_req_builder.query(
12509                &local_var_str
12510                    .into_iter()
12511                    .map(|p| ("tenant_id__n".to_owned(), p.to_string()))
12512                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12513            ),
12514            _ => local_var_req_builder.query(&[(
12515                "tenant_id__n",
12516                &local_var_str
12517                    .into_iter()
12518                    .map(|p| p.to_string())
12519                    .collect::<Vec<String>>()
12520                    .join(",")
12521                    .to_string(),
12522            )]),
12523        };
12524    }
12525    if let Some(ref local_var_str) = tunnel_interface {
12526        local_var_req_builder = match "multi" {
12527            "multi" => local_var_req_builder.query(
12528                &local_var_str
12529                    .into_iter()
12530                    .map(|p| ("tunnel_interface".to_owned(), p.to_string()))
12531                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12532            ),
12533            _ => local_var_req_builder.query(&[(
12534                "tunnel_interface",
12535                &local_var_str
12536                    .into_iter()
12537                    .map(|p| p.to_string())
12538                    .collect::<Vec<String>>()
12539                    .join(",")
12540                    .to_string(),
12541            )]),
12542        };
12543    }
12544    if let Some(ref local_var_str) = tunnel_interface__isnull {
12545        local_var_req_builder = local_var_req_builder
12546            .query(&[("tunnel_interface__isnull", &local_var_str.to_string())]);
12547    }
12548    if let Some(ref local_var_str) = tunnel_interface__n {
12549        local_var_req_builder = match "multi" {
12550            "multi" => local_var_req_builder.query(
12551                &local_var_str
12552                    .into_iter()
12553                    .map(|p| ("tunnel_interface__n".to_owned(), p.to_string()))
12554                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12555            ),
12556            _ => local_var_req_builder.query(&[(
12557                "tunnel_interface__n",
12558                &local_var_str
12559                    .into_iter()
12560                    .map(|p| p.to_string())
12561                    .collect::<Vec<String>>()
12562                    .join(",")
12563                    .to_string(),
12564            )]),
12565        };
12566    }
12567    if let Some(ref local_var_str) = vpn_profile {
12568        local_var_req_builder = match "multi" {
12569            "multi" => local_var_req_builder.query(
12570                &local_var_str
12571                    .into_iter()
12572                    .map(|p| ("vpn_profile".to_owned(), p.to_string()))
12573                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12574            ),
12575            _ => local_var_req_builder.query(&[(
12576                "vpn_profile",
12577                &local_var_str
12578                    .into_iter()
12579                    .map(|p| p.to_string())
12580                    .collect::<Vec<String>>()
12581                    .join(",")
12582                    .to_string(),
12583            )]),
12584        };
12585    }
12586    if let Some(ref local_var_str) = vpn_profile__isnull {
12587        local_var_req_builder =
12588            local_var_req_builder.query(&[("vpn_profile__isnull", &local_var_str.to_string())]);
12589    }
12590    if let Some(ref local_var_str) = vpn_profile__n {
12591        local_var_req_builder = match "multi" {
12592            "multi" => local_var_req_builder.query(
12593                &local_var_str
12594                    .into_iter()
12595                    .map(|p| ("vpn_profile__n".to_owned(), p.to_string()))
12596                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12597            ),
12598            _ => local_var_req_builder.query(&[(
12599                "vpn_profile__n",
12600                &local_var_str
12601                    .into_iter()
12602                    .map(|p| p.to_string())
12603                    .collect::<Vec<String>>()
12604                    .join(",")
12605                    .to_string(),
12606            )]),
12607        };
12608    }
12609    if let Some(ref local_var_str) = depth {
12610        local_var_req_builder =
12611            local_var_req_builder.query(&[("depth", &local_var_str.to_string())]);
12612    }
12613    if let Some(ref local_var_str) = exclude_m2m {
12614        local_var_req_builder =
12615            local_var_req_builder.query(&[("exclude_m2m", &local_var_str.to_string())]);
12616    }
12617    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
12618        local_var_req_builder =
12619            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
12620    }
12621    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
12622        let local_var_key = local_var_apikey.key.clone();
12623        let local_var_value = match local_var_apikey.prefix {
12624            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
12625            None => local_var_key,
12626        };
12627        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
12628    };
12629
12630    let local_var_req = local_var_req_builder.build()?;
12631    let local_var_resp = local_var_client.execute(local_var_req).await?;
12632
12633    let local_var_status = local_var_resp.status();
12634    let local_var_content = local_var_resp.text().await?;
12635
12636    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
12637        serde_json::from_str(&local_var_content).map_err(Error::from)
12638    } else {
12639        let local_var_entity: Option<VpnVpnTunnelEndpointsListError> =
12640            serde_json::from_str(&local_var_content).ok();
12641        let local_var_error = ResponseContent {
12642            status: local_var_status,
12643            content: local_var_content,
12644            entity: local_var_entity,
12645        };
12646        Err(Error::ResponseError(local_var_error))
12647    }
12648}
12649
12650/// API methods for returning or creating notes on an object.
12651pub async fn vpn_vpn_tunnel_endpoints_notes_create(
12652    configuration: &configuration::Configuration,
12653    id: &str,
12654    note_input_request: crate::models::NoteInputRequest,
12655    format: Option<&str>,
12656) -> Result<crate::models::Note, Error<VpnVpnTunnelEndpointsNotesCreateError>> {
12657    let local_var_configuration = configuration;
12658
12659    let local_var_client = &local_var_configuration.client;
12660
12661    let local_var_uri_str = format!(
12662        "{}/vpn/vpn-tunnel-endpoints/{id}/notes/",
12663        local_var_configuration.base_path,
12664        id = crate::apis::urlencode(id)
12665    );
12666    let mut local_var_req_builder =
12667        local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
12668
12669    if let Some(ref local_var_str) = format {
12670        local_var_req_builder =
12671            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
12672    }
12673    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
12674        local_var_req_builder =
12675            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
12676    }
12677    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
12678        let local_var_key = local_var_apikey.key.clone();
12679        let local_var_value = match local_var_apikey.prefix {
12680            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
12681            None => local_var_key,
12682        };
12683        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
12684    };
12685    local_var_req_builder = local_var_req_builder.json(&note_input_request);
12686
12687    let local_var_req = local_var_req_builder.build()?;
12688    let local_var_resp = local_var_client.execute(local_var_req).await?;
12689
12690    let local_var_status = local_var_resp.status();
12691    let local_var_content = local_var_resp.text().await?;
12692
12693    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
12694        serde_json::from_str(&local_var_content).map_err(Error::from)
12695    } else {
12696        let local_var_entity: Option<VpnVpnTunnelEndpointsNotesCreateError> =
12697            serde_json::from_str(&local_var_content).ok();
12698        let local_var_error = ResponseContent {
12699            status: local_var_status,
12700            content: local_var_content,
12701            entity: local_var_entity,
12702        };
12703        Err(Error::ResponseError(local_var_error))
12704    }
12705}
12706
12707/// API methods for returning or creating notes on an object.
12708pub async fn vpn_vpn_tunnel_endpoints_notes_list(
12709    configuration: &configuration::Configuration,
12710    id: &str,
12711    format: Option<&str>,
12712    limit: Option<i32>,
12713    offset: Option<i32>,
12714    depth: Option<i32>,
12715    exclude_m2m: Option<bool>,
12716) -> Result<crate::models::PaginatedNoteList, Error<VpnVpnTunnelEndpointsNotesListError>> {
12717    let local_var_configuration = configuration;
12718
12719    let local_var_client = &local_var_configuration.client;
12720
12721    let local_var_uri_str = format!(
12722        "{}/vpn/vpn-tunnel-endpoints/{id}/notes/",
12723        local_var_configuration.base_path,
12724        id = crate::apis::urlencode(id)
12725    );
12726    let mut local_var_req_builder =
12727        local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
12728
12729    if let Some(ref local_var_str) = format {
12730        local_var_req_builder =
12731            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
12732    }
12733    if let Some(ref local_var_str) = limit {
12734        local_var_req_builder =
12735            local_var_req_builder.query(&[("limit", &local_var_str.to_string())]);
12736    }
12737    if let Some(ref local_var_str) = offset {
12738        local_var_req_builder =
12739            local_var_req_builder.query(&[("offset", &local_var_str.to_string())]);
12740    }
12741    if let Some(ref local_var_str) = depth {
12742        local_var_req_builder =
12743            local_var_req_builder.query(&[("depth", &local_var_str.to_string())]);
12744    }
12745    if let Some(ref local_var_str) = exclude_m2m {
12746        local_var_req_builder =
12747            local_var_req_builder.query(&[("exclude_m2m", &local_var_str.to_string())]);
12748    }
12749    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
12750        local_var_req_builder =
12751            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
12752    }
12753    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
12754        let local_var_key = local_var_apikey.key.clone();
12755        let local_var_value = match local_var_apikey.prefix {
12756            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
12757            None => local_var_key,
12758        };
12759        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
12760    };
12761
12762    let local_var_req = local_var_req_builder.build()?;
12763    let local_var_resp = local_var_client.execute(local_var_req).await?;
12764
12765    let local_var_status = local_var_resp.status();
12766    let local_var_content = local_var_resp.text().await?;
12767
12768    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
12769        serde_json::from_str(&local_var_content).map_err(Error::from)
12770    } else {
12771        let local_var_entity: Option<VpnVpnTunnelEndpointsNotesListError> =
12772            serde_json::from_str(&local_var_content).ok();
12773        let local_var_error = ResponseContent {
12774            status: local_var_status,
12775            content: local_var_content,
12776            entity: local_var_entity,
12777        };
12778        Err(Error::ResponseError(local_var_error))
12779    }
12780}
12781
12782/// VPNTunnelEndpoint viewset.
12783pub async fn vpn_vpn_tunnel_endpoints_partial_update(
12784    configuration: &configuration::Configuration,
12785    id: &str,
12786    format: Option<&str>,
12787    patched_vpn_tunnel_endpoint_request: Option<crate::models::PatchedVpnTunnelEndpointRequest>,
12788) -> Result<crate::models::VpnTunnelEndpoint, Error<VpnVpnTunnelEndpointsPartialUpdateError>> {
12789    let local_var_configuration = configuration;
12790
12791    let local_var_client = &local_var_configuration.client;
12792
12793    let local_var_uri_str = format!(
12794        "{}/vpn/vpn-tunnel-endpoints/{id}/",
12795        local_var_configuration.base_path,
12796        id = crate::apis::urlencode(id)
12797    );
12798    let mut local_var_req_builder =
12799        local_var_client.request(reqwest::Method::PATCH, local_var_uri_str.as_str());
12800
12801    if let Some(ref local_var_str) = format {
12802        local_var_req_builder =
12803            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
12804    }
12805    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
12806        local_var_req_builder =
12807            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
12808    }
12809    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
12810        let local_var_key = local_var_apikey.key.clone();
12811        let local_var_value = match local_var_apikey.prefix {
12812            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
12813            None => local_var_key,
12814        };
12815        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
12816    };
12817    local_var_req_builder = local_var_req_builder.json(&patched_vpn_tunnel_endpoint_request);
12818
12819    let local_var_req = local_var_req_builder.build()?;
12820    let local_var_resp = local_var_client.execute(local_var_req).await?;
12821
12822    let local_var_status = local_var_resp.status();
12823    let local_var_content = local_var_resp.text().await?;
12824
12825    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
12826        serde_json::from_str(&local_var_content).map_err(Error::from)
12827    } else {
12828        let local_var_entity: Option<VpnVpnTunnelEndpointsPartialUpdateError> =
12829            serde_json::from_str(&local_var_content).ok();
12830        let local_var_error = ResponseContent {
12831            status: local_var_status,
12832            content: local_var_content,
12833            entity: local_var_entity,
12834        };
12835        Err(Error::ResponseError(local_var_error))
12836    }
12837}
12838
12839/// VPNTunnelEndpoint viewset.
12840pub async fn vpn_vpn_tunnel_endpoints_retrieve(
12841    configuration: &configuration::Configuration,
12842    id: &str,
12843    format: Option<&str>,
12844    depth: Option<i32>,
12845    exclude_m2m: Option<bool>,
12846) -> Result<crate::models::VpnTunnelEndpoint, Error<VpnVpnTunnelEndpointsRetrieveError>> {
12847    let local_var_configuration = configuration;
12848
12849    let local_var_client = &local_var_configuration.client;
12850
12851    let local_var_uri_str = format!(
12852        "{}/vpn/vpn-tunnel-endpoints/{id}/",
12853        local_var_configuration.base_path,
12854        id = crate::apis::urlencode(id)
12855    );
12856    let mut local_var_req_builder =
12857        local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
12858
12859    if let Some(ref local_var_str) = format {
12860        local_var_req_builder =
12861            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
12862    }
12863    if let Some(ref local_var_str) = depth {
12864        local_var_req_builder =
12865            local_var_req_builder.query(&[("depth", &local_var_str.to_string())]);
12866    }
12867    if let Some(ref local_var_str) = exclude_m2m {
12868        local_var_req_builder =
12869            local_var_req_builder.query(&[("exclude_m2m", &local_var_str.to_string())]);
12870    }
12871    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
12872        local_var_req_builder =
12873            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
12874    }
12875    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
12876        let local_var_key = local_var_apikey.key.clone();
12877        let local_var_value = match local_var_apikey.prefix {
12878            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
12879            None => local_var_key,
12880        };
12881        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
12882    };
12883
12884    let local_var_req = local_var_req_builder.build()?;
12885    let local_var_resp = local_var_client.execute(local_var_req).await?;
12886
12887    let local_var_status = local_var_resp.status();
12888    let local_var_content = local_var_resp.text().await?;
12889
12890    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
12891        serde_json::from_str(&local_var_content).map_err(Error::from)
12892    } else {
12893        let local_var_entity: Option<VpnVpnTunnelEndpointsRetrieveError> =
12894            serde_json::from_str(&local_var_content).ok();
12895        let local_var_error = ResponseContent {
12896            status: local_var_status,
12897            content: local_var_content,
12898            entity: local_var_entity,
12899        };
12900        Err(Error::ResponseError(local_var_error))
12901    }
12902}
12903
12904/// VPNTunnelEndpoint viewset.
12905pub async fn vpn_vpn_tunnel_endpoints_update(
12906    configuration: &configuration::Configuration,
12907    id: &str,
12908    format: Option<&str>,
12909    vpn_tunnel_endpoint_request: Option<crate::models::VpnTunnelEndpointRequest>,
12910) -> Result<crate::models::VpnTunnelEndpoint, Error<VpnVpnTunnelEndpointsUpdateError>> {
12911    let local_var_configuration = configuration;
12912
12913    let local_var_client = &local_var_configuration.client;
12914
12915    let local_var_uri_str = format!(
12916        "{}/vpn/vpn-tunnel-endpoints/{id}/",
12917        local_var_configuration.base_path,
12918        id = crate::apis::urlencode(id)
12919    );
12920    let mut local_var_req_builder =
12921        local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());
12922
12923    if let Some(ref local_var_str) = format {
12924        local_var_req_builder =
12925            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
12926    }
12927    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
12928        local_var_req_builder =
12929            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
12930    }
12931    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
12932        let local_var_key = local_var_apikey.key.clone();
12933        let local_var_value = match local_var_apikey.prefix {
12934            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
12935            None => local_var_key,
12936        };
12937        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
12938    };
12939    local_var_req_builder = local_var_req_builder.json(&vpn_tunnel_endpoint_request);
12940
12941    let local_var_req = local_var_req_builder.build()?;
12942    let local_var_resp = local_var_client.execute(local_var_req).await?;
12943
12944    let local_var_status = local_var_resp.status();
12945    let local_var_content = local_var_resp.text().await?;
12946
12947    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
12948        serde_json::from_str(&local_var_content).map_err(Error::from)
12949    } else {
12950        let local_var_entity: Option<VpnVpnTunnelEndpointsUpdateError> =
12951            serde_json::from_str(&local_var_content).ok();
12952        let local_var_error = ResponseContent {
12953            status: local_var_status,
12954            content: local_var_content,
12955            entity: local_var_entity,
12956        };
12957        Err(Error::ResponseError(local_var_error))
12958    }
12959}
12960
12961/// VPNTunnel viewset.
12962pub async fn vpn_vpn_tunnels_bulk_destroy(
12963    configuration: &configuration::Configuration,
12964    bulk_operation_request: Vec<crate::models::BulkOperationRequest>,
12965    format: Option<&str>,
12966) -> Result<(), Error<VpnVpnTunnelsBulkDestroyError>> {
12967    let local_var_configuration = configuration;
12968
12969    let local_var_client = &local_var_configuration.client;
12970
12971    let local_var_uri_str = format!("{}/vpn/vpn-tunnels/", local_var_configuration.base_path);
12972    let mut local_var_req_builder =
12973        local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());
12974
12975    if let Some(ref local_var_str) = format {
12976        local_var_req_builder =
12977            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
12978    }
12979    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
12980        local_var_req_builder =
12981            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
12982    }
12983    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
12984        let local_var_key = local_var_apikey.key.clone();
12985        let local_var_value = match local_var_apikey.prefix {
12986            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
12987            None => local_var_key,
12988        };
12989        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
12990    };
12991    local_var_req_builder = local_var_req_builder.json(&bulk_operation_request);
12992
12993    let local_var_req = local_var_req_builder.build()?;
12994    let local_var_resp = local_var_client.execute(local_var_req).await?;
12995
12996    let local_var_status = local_var_resp.status();
12997    let local_var_content = local_var_resp.text().await?;
12998
12999    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
13000        Ok(())
13001    } else {
13002        let local_var_entity: Option<VpnVpnTunnelsBulkDestroyError> =
13003            serde_json::from_str(&local_var_content).ok();
13004        let local_var_error = ResponseContent {
13005            status: local_var_status,
13006            content: local_var_content,
13007            entity: local_var_entity,
13008        };
13009        Err(Error::ResponseError(local_var_error))
13010    }
13011}
13012
13013/// VPNTunnel viewset.
13014pub async fn vpn_vpn_tunnels_bulk_partial_update(
13015    configuration: &configuration::Configuration,
13016    patched_bulk_writable_vpn_tunnel_request: Vec<
13017        crate::models::PatchedBulkWritableVpnTunnelRequest,
13018    >,
13019    format: Option<&str>,
13020) -> Result<Vec<crate::models::VpnTunnel>, Error<VpnVpnTunnelsBulkPartialUpdateError>> {
13021    let local_var_configuration = configuration;
13022
13023    let local_var_client = &local_var_configuration.client;
13024
13025    let local_var_uri_str = format!("{}/vpn/vpn-tunnels/", local_var_configuration.base_path);
13026    let mut local_var_req_builder =
13027        local_var_client.request(reqwest::Method::PATCH, local_var_uri_str.as_str());
13028
13029    if let Some(ref local_var_str) = format {
13030        local_var_req_builder =
13031            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
13032    }
13033    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
13034        local_var_req_builder =
13035            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
13036    }
13037    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
13038        let local_var_key = local_var_apikey.key.clone();
13039        let local_var_value = match local_var_apikey.prefix {
13040            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
13041            None => local_var_key,
13042        };
13043        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
13044    };
13045    local_var_req_builder = local_var_req_builder.json(&patched_bulk_writable_vpn_tunnel_request);
13046
13047    let local_var_req = local_var_req_builder.build()?;
13048    let local_var_resp = local_var_client.execute(local_var_req).await?;
13049
13050    let local_var_status = local_var_resp.status();
13051    let local_var_content = local_var_resp.text().await?;
13052
13053    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
13054        serde_json::from_str(&local_var_content).map_err(Error::from)
13055    } else {
13056        let local_var_entity: Option<VpnVpnTunnelsBulkPartialUpdateError> =
13057            serde_json::from_str(&local_var_content).ok();
13058        let local_var_error = ResponseContent {
13059            status: local_var_status,
13060            content: local_var_content,
13061            entity: local_var_entity,
13062        };
13063        Err(Error::ResponseError(local_var_error))
13064    }
13065}
13066
13067/// VPNTunnel viewset.
13068pub async fn vpn_vpn_tunnels_bulk_update(
13069    configuration: &configuration::Configuration,
13070    bulk_writable_vpn_tunnel_request: Vec<crate::models::BulkWritableVpnTunnelRequest>,
13071    format: Option<&str>,
13072) -> Result<Vec<crate::models::VpnTunnel>, Error<VpnVpnTunnelsBulkUpdateError>> {
13073    let local_var_configuration = configuration;
13074
13075    let local_var_client = &local_var_configuration.client;
13076
13077    let local_var_uri_str = format!("{}/vpn/vpn-tunnels/", local_var_configuration.base_path);
13078    let mut local_var_req_builder =
13079        local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());
13080
13081    if let Some(ref local_var_str) = format {
13082        local_var_req_builder =
13083            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
13084    }
13085    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
13086        local_var_req_builder =
13087            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
13088    }
13089    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
13090        let local_var_key = local_var_apikey.key.clone();
13091        let local_var_value = match local_var_apikey.prefix {
13092            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
13093            None => local_var_key,
13094        };
13095        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
13096    };
13097    local_var_req_builder = local_var_req_builder.json(&bulk_writable_vpn_tunnel_request);
13098
13099    let local_var_req = local_var_req_builder.build()?;
13100    let local_var_resp = local_var_client.execute(local_var_req).await?;
13101
13102    let local_var_status = local_var_resp.status();
13103    let local_var_content = local_var_resp.text().await?;
13104
13105    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
13106        serde_json::from_str(&local_var_content).map_err(Error::from)
13107    } else {
13108        let local_var_entity: Option<VpnVpnTunnelsBulkUpdateError> =
13109            serde_json::from_str(&local_var_content).ok();
13110        let local_var_error = ResponseContent {
13111            status: local_var_status,
13112            content: local_var_content,
13113            entity: local_var_entity,
13114        };
13115        Err(Error::ResponseError(local_var_error))
13116    }
13117}
13118
13119/// VPNTunnel viewset.
13120pub async fn vpn_vpn_tunnels_create(
13121    configuration: &configuration::Configuration,
13122    vpn_tunnel_request: crate::models::VpnTunnelRequest,
13123    format: Option<&str>,
13124) -> Result<crate::models::VpnTunnel, Error<VpnVpnTunnelsCreateError>> {
13125    let local_var_configuration = configuration;
13126
13127    let local_var_client = &local_var_configuration.client;
13128
13129    let local_var_uri_str = format!("{}/vpn/vpn-tunnels/", local_var_configuration.base_path);
13130    let mut local_var_req_builder =
13131        local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
13132
13133    if let Some(ref local_var_str) = format {
13134        local_var_req_builder =
13135            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
13136    }
13137    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
13138        local_var_req_builder =
13139            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
13140    }
13141    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
13142        let local_var_key = local_var_apikey.key.clone();
13143        let local_var_value = match local_var_apikey.prefix {
13144            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
13145            None => local_var_key,
13146        };
13147        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
13148    };
13149    local_var_req_builder = local_var_req_builder.json(&vpn_tunnel_request);
13150
13151    let local_var_req = local_var_req_builder.build()?;
13152    let local_var_resp = local_var_client.execute(local_var_req).await?;
13153
13154    let local_var_status = local_var_resp.status();
13155    let local_var_content = local_var_resp.text().await?;
13156
13157    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
13158        serde_json::from_str(&local_var_content).map_err(Error::from)
13159    } else {
13160        let local_var_entity: Option<VpnVpnTunnelsCreateError> =
13161            serde_json::from_str(&local_var_content).ok();
13162        let local_var_error = ResponseContent {
13163            status: local_var_status,
13164            content: local_var_content,
13165            entity: local_var_entity,
13166        };
13167        Err(Error::ResponseError(local_var_error))
13168    }
13169}
13170
13171/// VPNTunnel viewset.
13172pub async fn vpn_vpn_tunnels_destroy(
13173    configuration: &configuration::Configuration,
13174    id: &str,
13175    format: Option<&str>,
13176) -> Result<(), Error<VpnVpnTunnelsDestroyError>> {
13177    let local_var_configuration = configuration;
13178
13179    let local_var_client = &local_var_configuration.client;
13180
13181    let local_var_uri_str = format!(
13182        "{}/vpn/vpn-tunnels/{id}/",
13183        local_var_configuration.base_path,
13184        id = crate::apis::urlencode(id)
13185    );
13186    let mut local_var_req_builder =
13187        local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());
13188
13189    if let Some(ref local_var_str) = format {
13190        local_var_req_builder =
13191            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
13192    }
13193    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
13194        local_var_req_builder =
13195            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
13196    }
13197    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
13198        let local_var_key = local_var_apikey.key.clone();
13199        let local_var_value = match local_var_apikey.prefix {
13200            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
13201            None => local_var_key,
13202        };
13203        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
13204    };
13205
13206    let local_var_req = local_var_req_builder.build()?;
13207    let local_var_resp = local_var_client.execute(local_var_req).await?;
13208
13209    let local_var_status = local_var_resp.status();
13210    let local_var_content = local_var_resp.text().await?;
13211
13212    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
13213        Ok(())
13214    } else {
13215        let local_var_entity: Option<VpnVpnTunnelsDestroyError> =
13216            serde_json::from_str(&local_var_content).ok();
13217        let local_var_error = ResponseContent {
13218            status: local_var_status,
13219            content: local_var_content,
13220            entity: local_var_entity,
13221        };
13222        Err(Error::ResponseError(local_var_error))
13223    }
13224}
13225
13226/// VPNTunnel viewset.
13227pub async fn vpn_vpn_tunnels_list(
13228    configuration: &configuration::Configuration,
13229    contacts: Option<Vec<String>>,
13230    contacts__isnull: Option<bool>,
13231    contacts__n: Option<Vec<String>>,
13232    created: Option<Vec<String>>,
13233    created__gt: Option<Vec<String>>,
13234    created__gte: Option<Vec<String>>,
13235    created__isnull: Option<bool>,
13236    created__lt: Option<Vec<String>>,
13237    created__lte: Option<Vec<String>>,
13238    created__n: Option<Vec<String>>,
13239    description: Option<Vec<String>>,
13240    description__ic: Option<Vec<String>>,
13241    description__ie: Option<Vec<String>>,
13242    description__iew: Option<Vec<String>>,
13243    description__ire: Option<Vec<String>>,
13244    description__isw: Option<Vec<String>>,
13245    description__n: Option<Vec<String>>,
13246    description__nic: Option<Vec<String>>,
13247    description__nie: Option<Vec<String>>,
13248    description__niew: Option<Vec<String>>,
13249    description__nire: Option<Vec<String>>,
13250    description__nisw: Option<Vec<String>>,
13251    description__nre: Option<Vec<String>>,
13252    description__re: Option<Vec<String>>,
13253    dynamic_groups: Option<Vec<String>>,
13254    dynamic_groups__n: Option<Vec<String>>,
13255    encapsulation: Option<Vec<String>>,
13256    encapsulation__ic: Option<Vec<String>>,
13257    encapsulation__ie: Option<Vec<String>>,
13258    encapsulation__iew: Option<Vec<String>>,
13259    encapsulation__ire: Option<Vec<String>>,
13260    encapsulation__isw: Option<Vec<String>>,
13261    encapsulation__n: Option<Vec<String>>,
13262    encapsulation__nic: Option<Vec<String>>,
13263    encapsulation__nie: Option<Vec<String>>,
13264    encapsulation__niew: Option<Vec<String>>,
13265    encapsulation__nire: Option<Vec<String>>,
13266    encapsulation__nisw: Option<Vec<String>>,
13267    encapsulation__nre: Option<Vec<String>>,
13268    encapsulation__re: Option<Vec<String>>,
13269    endpoint_a: Option<Vec<uuid::Uuid>>,
13270    endpoint_a__isnull: Option<bool>,
13271    endpoint_a__n: Option<Vec<uuid::Uuid>>,
13272    endpoint_z: Option<Vec<uuid::Uuid>>,
13273    endpoint_z__isnull: Option<bool>,
13274    endpoint_z__n: Option<Vec<uuid::Uuid>>,
13275    format: Option<&str>,
13276    id: Option<Vec<uuid::Uuid>>,
13277    id__n: Option<Vec<uuid::Uuid>>,
13278    last_updated: Option<Vec<String>>,
13279    last_updated__gt: Option<Vec<String>>,
13280    last_updated__gte: Option<Vec<String>>,
13281    last_updated__isnull: Option<bool>,
13282    last_updated__lt: Option<Vec<String>>,
13283    last_updated__lte: Option<Vec<String>>,
13284    last_updated__n: Option<Vec<String>>,
13285    limit: Option<i32>,
13286    name: Option<Vec<String>>,
13287    name__ic: Option<Vec<String>>,
13288    name__ie: Option<Vec<String>>,
13289    name__iew: Option<Vec<String>>,
13290    name__ire: Option<Vec<String>>,
13291    name__isw: Option<Vec<String>>,
13292    name__n: Option<Vec<String>>,
13293    name__nic: Option<Vec<String>>,
13294    name__nie: Option<Vec<String>>,
13295    name__niew: Option<Vec<String>>,
13296    name__nire: Option<Vec<String>>,
13297    name__nisw: Option<Vec<String>>,
13298    name__nre: Option<Vec<String>>,
13299    name__re: Option<Vec<String>>,
13300    offset: Option<i32>,
13301    q: Option<&str>,
13302    role: Option<Vec<String>>,
13303    role__isnull: Option<bool>,
13304    role__n: Option<Vec<uuid::Uuid>>,
13305    secrets_group: Option<Vec<uuid::Uuid>>,
13306    secrets_group__isnull: Option<bool>,
13307    secrets_group__n: Option<Vec<uuid::Uuid>>,
13308    sort: Option<&str>,
13309    status: Option<Vec<String>>,
13310    status__n: Option<Vec<uuid::Uuid>>,
13311    tags: Option<Vec<String>>,
13312    tags__isnull: Option<bool>,
13313    tags__n: Option<Vec<String>>,
13314    teams: Option<Vec<String>>,
13315    teams__isnull: Option<bool>,
13316    teams__n: Option<Vec<String>>,
13317    tenant: Option<Vec<String>>,
13318    tenant__isnull: Option<bool>,
13319    tenant__n: Option<Vec<String>>,
13320    tenant_group: Option<Vec<String>>,
13321    tenant_group__isnull: Option<bool>,
13322    tenant_group__n: Option<Vec<String>>,
13323    tenant_id: Option<Vec<uuid::Uuid>>,
13324    tenant_id__isnull: Option<bool>,
13325    tenant_id__n: Option<Vec<uuid::Uuid>>,
13326    tunnel_id: Option<Vec<String>>,
13327    tunnel_id__ic: Option<Vec<String>>,
13328    tunnel_id__ie: Option<Vec<String>>,
13329    tunnel_id__iew: Option<Vec<String>>,
13330    tunnel_id__ire: Option<Vec<String>>,
13331    tunnel_id__isw: Option<Vec<String>>,
13332    tunnel_id__n: Option<Vec<String>>,
13333    tunnel_id__nic: Option<Vec<String>>,
13334    tunnel_id__nie: Option<Vec<String>>,
13335    tunnel_id__niew: Option<Vec<String>>,
13336    tunnel_id__nire: Option<Vec<String>>,
13337    tunnel_id__nisw: Option<Vec<String>>,
13338    tunnel_id__nre: Option<Vec<String>>,
13339    tunnel_id__re: Option<Vec<String>>,
13340    vpn: Option<Vec<String>>,
13341    vpn__isnull: Option<bool>,
13342    vpn__n: Option<Vec<String>>,
13343    vpn_profile: Option<Vec<String>>,
13344    vpn_profile__isnull: Option<bool>,
13345    vpn_profile__n: Option<Vec<String>>,
13346    depth: Option<i32>,
13347    exclude_m2m: Option<bool>,
13348) -> Result<crate::models::PaginatedVpnTunnelList, Error<VpnVpnTunnelsListError>> {
13349    let local_var_configuration = configuration;
13350
13351    let local_var_client = &local_var_configuration.client;
13352
13353    let local_var_uri_str = format!("{}/vpn/vpn-tunnels/", local_var_configuration.base_path);
13354    let mut local_var_req_builder =
13355        local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
13356
13357    if let Some(ref local_var_str) = contacts {
13358        local_var_req_builder = match "multi" {
13359            "multi" => local_var_req_builder.query(
13360                &local_var_str
13361                    .into_iter()
13362                    .map(|p| ("contacts".to_owned(), p.to_string()))
13363                    .collect::<Vec<(std::string::String, std::string::String)>>(),
13364            ),
13365            _ => local_var_req_builder.query(&[(
13366                "contacts",
13367                &local_var_str
13368                    .into_iter()
13369                    .map(|p| p.to_string())
13370                    .collect::<Vec<String>>()
13371                    .join(",")
13372                    .to_string(),
13373            )]),
13374        };
13375    }
13376    if let Some(ref local_var_str) = contacts__isnull {
13377        local_var_req_builder =
13378            local_var_req_builder.query(&[("contacts__isnull", &local_var_str.to_string())]);
13379    }
13380    if let Some(ref local_var_str) = contacts__n {
13381        local_var_req_builder = match "multi" {
13382            "multi" => local_var_req_builder.query(
13383                &local_var_str
13384                    .into_iter()
13385                    .map(|p| ("contacts__n".to_owned(), p.to_string()))
13386                    .collect::<Vec<(std::string::String, std::string::String)>>(),
13387            ),
13388            _ => local_var_req_builder.query(&[(
13389                "contacts__n",
13390                &local_var_str
13391                    .into_iter()
13392                    .map(|p| p.to_string())
13393                    .collect::<Vec<String>>()
13394                    .join(",")
13395                    .to_string(),
13396            )]),
13397        };
13398    }
13399    if let Some(ref local_var_str) = created {
13400        local_var_req_builder = match "multi" {
13401            "multi" => local_var_req_builder.query(
13402                &local_var_str
13403                    .into_iter()
13404                    .map(|p| ("created".to_owned(), p.to_string()))
13405                    .collect::<Vec<(std::string::String, std::string::String)>>(),
13406            ),
13407            _ => local_var_req_builder.query(&[(
13408                "created",
13409                &local_var_str
13410                    .into_iter()
13411                    .map(|p| p.to_string())
13412                    .collect::<Vec<String>>()
13413                    .join(",")
13414                    .to_string(),
13415            )]),
13416        };
13417    }
13418    if let Some(ref local_var_str) = created__gt {
13419        local_var_req_builder = match "multi" {
13420            "multi" => local_var_req_builder.query(
13421                &local_var_str
13422                    .into_iter()
13423                    .map(|p| ("created__gt".to_owned(), p.to_string()))
13424                    .collect::<Vec<(std::string::String, std::string::String)>>(),
13425            ),
13426            _ => local_var_req_builder.query(&[(
13427                "created__gt",
13428                &local_var_str
13429                    .into_iter()
13430                    .map(|p| p.to_string())
13431                    .collect::<Vec<String>>()
13432                    .join(",")
13433                    .to_string(),
13434            )]),
13435        };
13436    }
13437    if let Some(ref local_var_str) = created__gte {
13438        local_var_req_builder = match "multi" {
13439            "multi" => local_var_req_builder.query(
13440                &local_var_str
13441                    .into_iter()
13442                    .map(|p| ("created__gte".to_owned(), p.to_string()))
13443                    .collect::<Vec<(std::string::String, std::string::String)>>(),
13444            ),
13445            _ => local_var_req_builder.query(&[(
13446                "created__gte",
13447                &local_var_str
13448                    .into_iter()
13449                    .map(|p| p.to_string())
13450                    .collect::<Vec<String>>()
13451                    .join(",")
13452                    .to_string(),
13453            )]),
13454        };
13455    }
13456    if let Some(ref local_var_str) = created__isnull {
13457        local_var_req_builder =
13458            local_var_req_builder.query(&[("created__isnull", &local_var_str.to_string())]);
13459    }
13460    if let Some(ref local_var_str) = created__lt {
13461        local_var_req_builder = match "multi" {
13462            "multi" => local_var_req_builder.query(
13463                &local_var_str
13464                    .into_iter()
13465                    .map(|p| ("created__lt".to_owned(), p.to_string()))
13466                    .collect::<Vec<(std::string::String, std::string::String)>>(),
13467            ),
13468            _ => local_var_req_builder.query(&[(
13469                "created__lt",
13470                &local_var_str
13471                    .into_iter()
13472                    .map(|p| p.to_string())
13473                    .collect::<Vec<String>>()
13474                    .join(",")
13475                    .to_string(),
13476            )]),
13477        };
13478    }
13479    if let Some(ref local_var_str) = created__lte {
13480        local_var_req_builder = match "multi" {
13481            "multi" => local_var_req_builder.query(
13482                &local_var_str
13483                    .into_iter()
13484                    .map(|p| ("created__lte".to_owned(), p.to_string()))
13485                    .collect::<Vec<(std::string::String, std::string::String)>>(),
13486            ),
13487            _ => local_var_req_builder.query(&[(
13488                "created__lte",
13489                &local_var_str
13490                    .into_iter()
13491                    .map(|p| p.to_string())
13492                    .collect::<Vec<String>>()
13493                    .join(",")
13494                    .to_string(),
13495            )]),
13496        };
13497    }
13498    if let Some(ref local_var_str) = created__n {
13499        local_var_req_builder = match "multi" {
13500            "multi" => local_var_req_builder.query(
13501                &local_var_str
13502                    .into_iter()
13503                    .map(|p| ("created__n".to_owned(), p.to_string()))
13504                    .collect::<Vec<(std::string::String, std::string::String)>>(),
13505            ),
13506            _ => local_var_req_builder.query(&[(
13507                "created__n",
13508                &local_var_str
13509                    .into_iter()
13510                    .map(|p| p.to_string())
13511                    .collect::<Vec<String>>()
13512                    .join(",")
13513                    .to_string(),
13514            )]),
13515        };
13516    }
13517    if let Some(ref local_var_str) = description {
13518        local_var_req_builder = match "multi" {
13519            "multi" => local_var_req_builder.query(
13520                &local_var_str
13521                    .into_iter()
13522                    .map(|p| ("description".to_owned(), p.to_string()))
13523                    .collect::<Vec<(std::string::String, std::string::String)>>(),
13524            ),
13525            _ => local_var_req_builder.query(&[(
13526                "description",
13527                &local_var_str
13528                    .into_iter()
13529                    .map(|p| p.to_string())
13530                    .collect::<Vec<String>>()
13531                    .join(",")
13532                    .to_string(),
13533            )]),
13534        };
13535    }
13536    if let Some(ref local_var_str) = description__ic {
13537        local_var_req_builder = match "multi" {
13538            "multi" => local_var_req_builder.query(
13539                &local_var_str
13540                    .into_iter()
13541                    .map(|p| ("description__ic".to_owned(), p.to_string()))
13542                    .collect::<Vec<(std::string::String, std::string::String)>>(),
13543            ),
13544            _ => local_var_req_builder.query(&[(
13545                "description__ic",
13546                &local_var_str
13547                    .into_iter()
13548                    .map(|p| p.to_string())
13549                    .collect::<Vec<String>>()
13550                    .join(",")
13551                    .to_string(),
13552            )]),
13553        };
13554    }
13555    if let Some(ref local_var_str) = description__ie {
13556        local_var_req_builder = match "multi" {
13557            "multi" => local_var_req_builder.query(
13558                &local_var_str
13559                    .into_iter()
13560                    .map(|p| ("description__ie".to_owned(), p.to_string()))
13561                    .collect::<Vec<(std::string::String, std::string::String)>>(),
13562            ),
13563            _ => local_var_req_builder.query(&[(
13564                "description__ie",
13565                &local_var_str
13566                    .into_iter()
13567                    .map(|p| p.to_string())
13568                    .collect::<Vec<String>>()
13569                    .join(",")
13570                    .to_string(),
13571            )]),
13572        };
13573    }
13574    if let Some(ref local_var_str) = description__iew {
13575        local_var_req_builder = match "multi" {
13576            "multi" => local_var_req_builder.query(
13577                &local_var_str
13578                    .into_iter()
13579                    .map(|p| ("description__iew".to_owned(), p.to_string()))
13580                    .collect::<Vec<(std::string::String, std::string::String)>>(),
13581            ),
13582            _ => local_var_req_builder.query(&[(
13583                "description__iew",
13584                &local_var_str
13585                    .into_iter()
13586                    .map(|p| p.to_string())
13587                    .collect::<Vec<String>>()
13588                    .join(",")
13589                    .to_string(),
13590            )]),
13591        };
13592    }
13593    if let Some(ref local_var_str) = description__ire {
13594        local_var_req_builder = match "multi" {
13595            "multi" => local_var_req_builder.query(
13596                &local_var_str
13597                    .into_iter()
13598                    .map(|p| ("description__ire".to_owned(), p.to_string()))
13599                    .collect::<Vec<(std::string::String, std::string::String)>>(),
13600            ),
13601            _ => local_var_req_builder.query(&[(
13602                "description__ire",
13603                &local_var_str
13604                    .into_iter()
13605                    .map(|p| p.to_string())
13606                    .collect::<Vec<String>>()
13607                    .join(",")
13608                    .to_string(),
13609            )]),
13610        };
13611    }
13612    if let Some(ref local_var_str) = description__isw {
13613        local_var_req_builder = match "multi" {
13614            "multi" => local_var_req_builder.query(
13615                &local_var_str
13616                    .into_iter()
13617                    .map(|p| ("description__isw".to_owned(), p.to_string()))
13618                    .collect::<Vec<(std::string::String, std::string::String)>>(),
13619            ),
13620            _ => local_var_req_builder.query(&[(
13621                "description__isw",
13622                &local_var_str
13623                    .into_iter()
13624                    .map(|p| p.to_string())
13625                    .collect::<Vec<String>>()
13626                    .join(",")
13627                    .to_string(),
13628            )]),
13629        };
13630    }
13631    if let Some(ref local_var_str) = description__n {
13632        local_var_req_builder = match "multi" {
13633            "multi" => local_var_req_builder.query(
13634                &local_var_str
13635                    .into_iter()
13636                    .map(|p| ("description__n".to_owned(), p.to_string()))
13637                    .collect::<Vec<(std::string::String, std::string::String)>>(),
13638            ),
13639            _ => local_var_req_builder.query(&[(
13640                "description__n",
13641                &local_var_str
13642                    .into_iter()
13643                    .map(|p| p.to_string())
13644                    .collect::<Vec<String>>()
13645                    .join(",")
13646                    .to_string(),
13647            )]),
13648        };
13649    }
13650    if let Some(ref local_var_str) = description__nic {
13651        local_var_req_builder = match "multi" {
13652            "multi" => local_var_req_builder.query(
13653                &local_var_str
13654                    .into_iter()
13655                    .map(|p| ("description__nic".to_owned(), p.to_string()))
13656                    .collect::<Vec<(std::string::String, std::string::String)>>(),
13657            ),
13658            _ => local_var_req_builder.query(&[(
13659                "description__nic",
13660                &local_var_str
13661                    .into_iter()
13662                    .map(|p| p.to_string())
13663                    .collect::<Vec<String>>()
13664                    .join(",")
13665                    .to_string(),
13666            )]),
13667        };
13668    }
13669    if let Some(ref local_var_str) = description__nie {
13670        local_var_req_builder = match "multi" {
13671            "multi" => local_var_req_builder.query(
13672                &local_var_str
13673                    .into_iter()
13674                    .map(|p| ("description__nie".to_owned(), p.to_string()))
13675                    .collect::<Vec<(std::string::String, std::string::String)>>(),
13676            ),
13677            _ => local_var_req_builder.query(&[(
13678                "description__nie",
13679                &local_var_str
13680                    .into_iter()
13681                    .map(|p| p.to_string())
13682                    .collect::<Vec<String>>()
13683                    .join(",")
13684                    .to_string(),
13685            )]),
13686        };
13687    }
13688    if let Some(ref local_var_str) = description__niew {
13689        local_var_req_builder = match "multi" {
13690            "multi" => local_var_req_builder.query(
13691                &local_var_str
13692                    .into_iter()
13693                    .map(|p| ("description__niew".to_owned(), p.to_string()))
13694                    .collect::<Vec<(std::string::String, std::string::String)>>(),
13695            ),
13696            _ => local_var_req_builder.query(&[(
13697                "description__niew",
13698                &local_var_str
13699                    .into_iter()
13700                    .map(|p| p.to_string())
13701                    .collect::<Vec<String>>()
13702                    .join(",")
13703                    .to_string(),
13704            )]),
13705        };
13706    }
13707    if let Some(ref local_var_str) = description__nire {
13708        local_var_req_builder = match "multi" {
13709            "multi" => local_var_req_builder.query(
13710                &local_var_str
13711                    .into_iter()
13712                    .map(|p| ("description__nire".to_owned(), p.to_string()))
13713                    .collect::<Vec<(std::string::String, std::string::String)>>(),
13714            ),
13715            _ => local_var_req_builder.query(&[(
13716                "description__nire",
13717                &local_var_str
13718                    .into_iter()
13719                    .map(|p| p.to_string())
13720                    .collect::<Vec<String>>()
13721                    .join(",")
13722                    .to_string(),
13723            )]),
13724        };
13725    }
13726    if let Some(ref local_var_str) = description__nisw {
13727        local_var_req_builder = match "multi" {
13728            "multi" => local_var_req_builder.query(
13729                &local_var_str
13730                    .into_iter()
13731                    .map(|p| ("description__nisw".to_owned(), p.to_string()))
13732                    .collect::<Vec<(std::string::String, std::string::String)>>(),
13733            ),
13734            _ => local_var_req_builder.query(&[(
13735                "description__nisw",
13736                &local_var_str
13737                    .into_iter()
13738                    .map(|p| p.to_string())
13739                    .collect::<Vec<String>>()
13740                    .join(",")
13741                    .to_string(),
13742            )]),
13743        };
13744    }
13745    if let Some(ref local_var_str) = description__nre {
13746        local_var_req_builder = match "multi" {
13747            "multi" => local_var_req_builder.query(
13748                &local_var_str
13749                    .into_iter()
13750                    .map(|p| ("description__nre".to_owned(), p.to_string()))
13751                    .collect::<Vec<(std::string::String, std::string::String)>>(),
13752            ),
13753            _ => local_var_req_builder.query(&[(
13754                "description__nre",
13755                &local_var_str
13756                    .into_iter()
13757                    .map(|p| p.to_string())
13758                    .collect::<Vec<String>>()
13759                    .join(",")
13760                    .to_string(),
13761            )]),
13762        };
13763    }
13764    if let Some(ref local_var_str) = description__re {
13765        local_var_req_builder = match "multi" {
13766            "multi" => local_var_req_builder.query(
13767                &local_var_str
13768                    .into_iter()
13769                    .map(|p| ("description__re".to_owned(), p.to_string()))
13770                    .collect::<Vec<(std::string::String, std::string::String)>>(),
13771            ),
13772            _ => local_var_req_builder.query(&[(
13773                "description__re",
13774                &local_var_str
13775                    .into_iter()
13776                    .map(|p| p.to_string())
13777                    .collect::<Vec<String>>()
13778                    .join(",")
13779                    .to_string(),
13780            )]),
13781        };
13782    }
13783    if let Some(ref local_var_str) = dynamic_groups {
13784        local_var_req_builder = match "multi" {
13785            "multi" => local_var_req_builder.query(
13786                &local_var_str
13787                    .into_iter()
13788                    .map(|p| ("dynamic_groups".to_owned(), p.to_string()))
13789                    .collect::<Vec<(std::string::String, std::string::String)>>(),
13790            ),
13791            _ => local_var_req_builder.query(&[(
13792                "dynamic_groups",
13793                &local_var_str
13794                    .into_iter()
13795                    .map(|p| p.to_string())
13796                    .collect::<Vec<String>>()
13797                    .join(",")
13798                    .to_string(),
13799            )]),
13800        };
13801    }
13802    if let Some(ref local_var_str) = dynamic_groups__n {
13803        local_var_req_builder = match "multi" {
13804            "multi" => local_var_req_builder.query(
13805                &local_var_str
13806                    .into_iter()
13807                    .map(|p| ("dynamic_groups__n".to_owned(), p.to_string()))
13808                    .collect::<Vec<(std::string::String, std::string::String)>>(),
13809            ),
13810            _ => local_var_req_builder.query(&[(
13811                "dynamic_groups__n",
13812                &local_var_str
13813                    .into_iter()
13814                    .map(|p| p.to_string())
13815                    .collect::<Vec<String>>()
13816                    .join(",")
13817                    .to_string(),
13818            )]),
13819        };
13820    }
13821    if let Some(ref local_var_str) = encapsulation {
13822        local_var_req_builder = match "multi" {
13823            "multi" => local_var_req_builder.query(
13824                &local_var_str
13825                    .into_iter()
13826                    .map(|p| ("encapsulation".to_owned(), p.to_string()))
13827                    .collect::<Vec<(std::string::String, std::string::String)>>(),
13828            ),
13829            _ => local_var_req_builder.query(&[(
13830                "encapsulation",
13831                &local_var_str
13832                    .into_iter()
13833                    .map(|p| p.to_string())
13834                    .collect::<Vec<String>>()
13835                    .join(",")
13836                    .to_string(),
13837            )]),
13838        };
13839    }
13840    if let Some(ref local_var_str) = encapsulation__ic {
13841        local_var_req_builder = match "multi" {
13842            "multi" => local_var_req_builder.query(
13843                &local_var_str
13844                    .into_iter()
13845                    .map(|p| ("encapsulation__ic".to_owned(), p.to_string()))
13846                    .collect::<Vec<(std::string::String, std::string::String)>>(),
13847            ),
13848            _ => local_var_req_builder.query(&[(
13849                "encapsulation__ic",
13850                &local_var_str
13851                    .into_iter()
13852                    .map(|p| p.to_string())
13853                    .collect::<Vec<String>>()
13854                    .join(",")
13855                    .to_string(),
13856            )]),
13857        };
13858    }
13859    if let Some(ref local_var_str) = encapsulation__ie {
13860        local_var_req_builder = match "multi" {
13861            "multi" => local_var_req_builder.query(
13862                &local_var_str
13863                    .into_iter()
13864                    .map(|p| ("encapsulation__ie".to_owned(), p.to_string()))
13865                    .collect::<Vec<(std::string::String, std::string::String)>>(),
13866            ),
13867            _ => local_var_req_builder.query(&[(
13868                "encapsulation__ie",
13869                &local_var_str
13870                    .into_iter()
13871                    .map(|p| p.to_string())
13872                    .collect::<Vec<String>>()
13873                    .join(",")
13874                    .to_string(),
13875            )]),
13876        };
13877    }
13878    if let Some(ref local_var_str) = encapsulation__iew {
13879        local_var_req_builder = match "multi" {
13880            "multi" => local_var_req_builder.query(
13881                &local_var_str
13882                    .into_iter()
13883                    .map(|p| ("encapsulation__iew".to_owned(), p.to_string()))
13884                    .collect::<Vec<(std::string::String, std::string::String)>>(),
13885            ),
13886            _ => local_var_req_builder.query(&[(
13887                "encapsulation__iew",
13888                &local_var_str
13889                    .into_iter()
13890                    .map(|p| p.to_string())
13891                    .collect::<Vec<String>>()
13892                    .join(",")
13893                    .to_string(),
13894            )]),
13895        };
13896    }
13897    if let Some(ref local_var_str) = encapsulation__ire {
13898        local_var_req_builder = match "multi" {
13899            "multi" => local_var_req_builder.query(
13900                &local_var_str
13901                    .into_iter()
13902                    .map(|p| ("encapsulation__ire".to_owned(), p.to_string()))
13903                    .collect::<Vec<(std::string::String, std::string::String)>>(),
13904            ),
13905            _ => local_var_req_builder.query(&[(
13906                "encapsulation__ire",
13907                &local_var_str
13908                    .into_iter()
13909                    .map(|p| p.to_string())
13910                    .collect::<Vec<String>>()
13911                    .join(",")
13912                    .to_string(),
13913            )]),
13914        };
13915    }
13916    if let Some(ref local_var_str) = encapsulation__isw {
13917        local_var_req_builder = match "multi" {
13918            "multi" => local_var_req_builder.query(
13919                &local_var_str
13920                    .into_iter()
13921                    .map(|p| ("encapsulation__isw".to_owned(), p.to_string()))
13922                    .collect::<Vec<(std::string::String, std::string::String)>>(),
13923            ),
13924            _ => local_var_req_builder.query(&[(
13925                "encapsulation__isw",
13926                &local_var_str
13927                    .into_iter()
13928                    .map(|p| p.to_string())
13929                    .collect::<Vec<String>>()
13930                    .join(",")
13931                    .to_string(),
13932            )]),
13933        };
13934    }
13935    if let Some(ref local_var_str) = encapsulation__n {
13936        local_var_req_builder = match "multi" {
13937            "multi" => local_var_req_builder.query(
13938                &local_var_str
13939                    .into_iter()
13940                    .map(|p| ("encapsulation__n".to_owned(), p.to_string()))
13941                    .collect::<Vec<(std::string::String, std::string::String)>>(),
13942            ),
13943            _ => local_var_req_builder.query(&[(
13944                "encapsulation__n",
13945                &local_var_str
13946                    .into_iter()
13947                    .map(|p| p.to_string())
13948                    .collect::<Vec<String>>()
13949                    .join(",")
13950                    .to_string(),
13951            )]),
13952        };
13953    }
13954    if let Some(ref local_var_str) = encapsulation__nic {
13955        local_var_req_builder = match "multi" {
13956            "multi" => local_var_req_builder.query(
13957                &local_var_str
13958                    .into_iter()
13959                    .map(|p| ("encapsulation__nic".to_owned(), p.to_string()))
13960                    .collect::<Vec<(std::string::String, std::string::String)>>(),
13961            ),
13962            _ => local_var_req_builder.query(&[(
13963                "encapsulation__nic",
13964                &local_var_str
13965                    .into_iter()
13966                    .map(|p| p.to_string())
13967                    .collect::<Vec<String>>()
13968                    .join(",")
13969                    .to_string(),
13970            )]),
13971        };
13972    }
13973    if let Some(ref local_var_str) = encapsulation__nie {
13974        local_var_req_builder = match "multi" {
13975            "multi" => local_var_req_builder.query(
13976                &local_var_str
13977                    .into_iter()
13978                    .map(|p| ("encapsulation__nie".to_owned(), p.to_string()))
13979                    .collect::<Vec<(std::string::String, std::string::String)>>(),
13980            ),
13981            _ => local_var_req_builder.query(&[(
13982                "encapsulation__nie",
13983                &local_var_str
13984                    .into_iter()
13985                    .map(|p| p.to_string())
13986                    .collect::<Vec<String>>()
13987                    .join(",")
13988                    .to_string(),
13989            )]),
13990        };
13991    }
13992    if let Some(ref local_var_str) = encapsulation__niew {
13993        local_var_req_builder = match "multi" {
13994            "multi" => local_var_req_builder.query(
13995                &local_var_str
13996                    .into_iter()
13997                    .map(|p| ("encapsulation__niew".to_owned(), p.to_string()))
13998                    .collect::<Vec<(std::string::String, std::string::String)>>(),
13999            ),
14000            _ => local_var_req_builder.query(&[(
14001                "encapsulation__niew",
14002                &local_var_str
14003                    .into_iter()
14004                    .map(|p| p.to_string())
14005                    .collect::<Vec<String>>()
14006                    .join(",")
14007                    .to_string(),
14008            )]),
14009        };
14010    }
14011    if let Some(ref local_var_str) = encapsulation__nire {
14012        local_var_req_builder = match "multi" {
14013            "multi" => local_var_req_builder.query(
14014                &local_var_str
14015                    .into_iter()
14016                    .map(|p| ("encapsulation__nire".to_owned(), p.to_string()))
14017                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14018            ),
14019            _ => local_var_req_builder.query(&[(
14020                "encapsulation__nire",
14021                &local_var_str
14022                    .into_iter()
14023                    .map(|p| p.to_string())
14024                    .collect::<Vec<String>>()
14025                    .join(",")
14026                    .to_string(),
14027            )]),
14028        };
14029    }
14030    if let Some(ref local_var_str) = encapsulation__nisw {
14031        local_var_req_builder = match "multi" {
14032            "multi" => local_var_req_builder.query(
14033                &local_var_str
14034                    .into_iter()
14035                    .map(|p| ("encapsulation__nisw".to_owned(), p.to_string()))
14036                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14037            ),
14038            _ => local_var_req_builder.query(&[(
14039                "encapsulation__nisw",
14040                &local_var_str
14041                    .into_iter()
14042                    .map(|p| p.to_string())
14043                    .collect::<Vec<String>>()
14044                    .join(",")
14045                    .to_string(),
14046            )]),
14047        };
14048    }
14049    if let Some(ref local_var_str) = encapsulation__nre {
14050        local_var_req_builder = match "multi" {
14051            "multi" => local_var_req_builder.query(
14052                &local_var_str
14053                    .into_iter()
14054                    .map(|p| ("encapsulation__nre".to_owned(), p.to_string()))
14055                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14056            ),
14057            _ => local_var_req_builder.query(&[(
14058                "encapsulation__nre",
14059                &local_var_str
14060                    .into_iter()
14061                    .map(|p| p.to_string())
14062                    .collect::<Vec<String>>()
14063                    .join(",")
14064                    .to_string(),
14065            )]),
14066        };
14067    }
14068    if let Some(ref local_var_str) = encapsulation__re {
14069        local_var_req_builder = match "multi" {
14070            "multi" => local_var_req_builder.query(
14071                &local_var_str
14072                    .into_iter()
14073                    .map(|p| ("encapsulation__re".to_owned(), p.to_string()))
14074                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14075            ),
14076            _ => local_var_req_builder.query(&[(
14077                "encapsulation__re",
14078                &local_var_str
14079                    .into_iter()
14080                    .map(|p| p.to_string())
14081                    .collect::<Vec<String>>()
14082                    .join(",")
14083                    .to_string(),
14084            )]),
14085        };
14086    }
14087    if let Some(ref local_var_str) = endpoint_a {
14088        local_var_req_builder = match "multi" {
14089            "multi" => local_var_req_builder.query(
14090                &local_var_str
14091                    .into_iter()
14092                    .map(|p| ("endpoint_a".to_owned(), p.to_string()))
14093                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14094            ),
14095            _ => local_var_req_builder.query(&[(
14096                "endpoint_a",
14097                &local_var_str
14098                    .into_iter()
14099                    .map(|p| p.to_string())
14100                    .collect::<Vec<String>>()
14101                    .join(",")
14102                    .to_string(),
14103            )]),
14104        };
14105    }
14106    if let Some(ref local_var_str) = endpoint_a__isnull {
14107        local_var_req_builder =
14108            local_var_req_builder.query(&[("endpoint_a__isnull", &local_var_str.to_string())]);
14109    }
14110    if let Some(ref local_var_str) = endpoint_a__n {
14111        local_var_req_builder = match "multi" {
14112            "multi" => local_var_req_builder.query(
14113                &local_var_str
14114                    .into_iter()
14115                    .map(|p| ("endpoint_a__n".to_owned(), p.to_string()))
14116                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14117            ),
14118            _ => local_var_req_builder.query(&[(
14119                "endpoint_a__n",
14120                &local_var_str
14121                    .into_iter()
14122                    .map(|p| p.to_string())
14123                    .collect::<Vec<String>>()
14124                    .join(",")
14125                    .to_string(),
14126            )]),
14127        };
14128    }
14129    if let Some(ref local_var_str) = endpoint_z {
14130        local_var_req_builder = match "multi" {
14131            "multi" => local_var_req_builder.query(
14132                &local_var_str
14133                    .into_iter()
14134                    .map(|p| ("endpoint_z".to_owned(), p.to_string()))
14135                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14136            ),
14137            _ => local_var_req_builder.query(&[(
14138                "endpoint_z",
14139                &local_var_str
14140                    .into_iter()
14141                    .map(|p| p.to_string())
14142                    .collect::<Vec<String>>()
14143                    .join(",")
14144                    .to_string(),
14145            )]),
14146        };
14147    }
14148    if let Some(ref local_var_str) = endpoint_z__isnull {
14149        local_var_req_builder =
14150            local_var_req_builder.query(&[("endpoint_z__isnull", &local_var_str.to_string())]);
14151    }
14152    if let Some(ref local_var_str) = endpoint_z__n {
14153        local_var_req_builder = match "multi" {
14154            "multi" => local_var_req_builder.query(
14155                &local_var_str
14156                    .into_iter()
14157                    .map(|p| ("endpoint_z__n".to_owned(), p.to_string()))
14158                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14159            ),
14160            _ => local_var_req_builder.query(&[(
14161                "endpoint_z__n",
14162                &local_var_str
14163                    .into_iter()
14164                    .map(|p| p.to_string())
14165                    .collect::<Vec<String>>()
14166                    .join(",")
14167                    .to_string(),
14168            )]),
14169        };
14170    }
14171    if let Some(ref local_var_str) = format {
14172        local_var_req_builder =
14173            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
14174    }
14175    if let Some(ref local_var_str) = id {
14176        local_var_req_builder = match "multi" {
14177            "multi" => local_var_req_builder.query(
14178                &local_var_str
14179                    .into_iter()
14180                    .map(|p| ("id".to_owned(), p.to_string()))
14181                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14182            ),
14183            _ => local_var_req_builder.query(&[(
14184                "id",
14185                &local_var_str
14186                    .into_iter()
14187                    .map(|p| p.to_string())
14188                    .collect::<Vec<String>>()
14189                    .join(",")
14190                    .to_string(),
14191            )]),
14192        };
14193    }
14194    if let Some(ref local_var_str) = id__n {
14195        local_var_req_builder = match "multi" {
14196            "multi" => local_var_req_builder.query(
14197                &local_var_str
14198                    .into_iter()
14199                    .map(|p| ("id__n".to_owned(), p.to_string()))
14200                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14201            ),
14202            _ => local_var_req_builder.query(&[(
14203                "id__n",
14204                &local_var_str
14205                    .into_iter()
14206                    .map(|p| p.to_string())
14207                    .collect::<Vec<String>>()
14208                    .join(",")
14209                    .to_string(),
14210            )]),
14211        };
14212    }
14213    if let Some(ref local_var_str) = last_updated {
14214        local_var_req_builder = match "multi" {
14215            "multi" => local_var_req_builder.query(
14216                &local_var_str
14217                    .into_iter()
14218                    .map(|p| ("last_updated".to_owned(), p.to_string()))
14219                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14220            ),
14221            _ => local_var_req_builder.query(&[(
14222                "last_updated",
14223                &local_var_str
14224                    .into_iter()
14225                    .map(|p| p.to_string())
14226                    .collect::<Vec<String>>()
14227                    .join(",")
14228                    .to_string(),
14229            )]),
14230        };
14231    }
14232    if let Some(ref local_var_str) = last_updated__gt {
14233        local_var_req_builder = match "multi" {
14234            "multi" => local_var_req_builder.query(
14235                &local_var_str
14236                    .into_iter()
14237                    .map(|p| ("last_updated__gt".to_owned(), p.to_string()))
14238                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14239            ),
14240            _ => local_var_req_builder.query(&[(
14241                "last_updated__gt",
14242                &local_var_str
14243                    .into_iter()
14244                    .map(|p| p.to_string())
14245                    .collect::<Vec<String>>()
14246                    .join(",")
14247                    .to_string(),
14248            )]),
14249        };
14250    }
14251    if let Some(ref local_var_str) = last_updated__gte {
14252        local_var_req_builder = match "multi" {
14253            "multi" => local_var_req_builder.query(
14254                &local_var_str
14255                    .into_iter()
14256                    .map(|p| ("last_updated__gte".to_owned(), p.to_string()))
14257                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14258            ),
14259            _ => local_var_req_builder.query(&[(
14260                "last_updated__gte",
14261                &local_var_str
14262                    .into_iter()
14263                    .map(|p| p.to_string())
14264                    .collect::<Vec<String>>()
14265                    .join(",")
14266                    .to_string(),
14267            )]),
14268        };
14269    }
14270    if let Some(ref local_var_str) = last_updated__isnull {
14271        local_var_req_builder =
14272            local_var_req_builder.query(&[("last_updated__isnull", &local_var_str.to_string())]);
14273    }
14274    if let Some(ref local_var_str) = last_updated__lt {
14275        local_var_req_builder = match "multi" {
14276            "multi" => local_var_req_builder.query(
14277                &local_var_str
14278                    .into_iter()
14279                    .map(|p| ("last_updated__lt".to_owned(), p.to_string()))
14280                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14281            ),
14282            _ => local_var_req_builder.query(&[(
14283                "last_updated__lt",
14284                &local_var_str
14285                    .into_iter()
14286                    .map(|p| p.to_string())
14287                    .collect::<Vec<String>>()
14288                    .join(",")
14289                    .to_string(),
14290            )]),
14291        };
14292    }
14293    if let Some(ref local_var_str) = last_updated__lte {
14294        local_var_req_builder = match "multi" {
14295            "multi" => local_var_req_builder.query(
14296                &local_var_str
14297                    .into_iter()
14298                    .map(|p| ("last_updated__lte".to_owned(), p.to_string()))
14299                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14300            ),
14301            _ => local_var_req_builder.query(&[(
14302                "last_updated__lte",
14303                &local_var_str
14304                    .into_iter()
14305                    .map(|p| p.to_string())
14306                    .collect::<Vec<String>>()
14307                    .join(",")
14308                    .to_string(),
14309            )]),
14310        };
14311    }
14312    if let Some(ref local_var_str) = last_updated__n {
14313        local_var_req_builder = match "multi" {
14314            "multi" => local_var_req_builder.query(
14315                &local_var_str
14316                    .into_iter()
14317                    .map(|p| ("last_updated__n".to_owned(), p.to_string()))
14318                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14319            ),
14320            _ => local_var_req_builder.query(&[(
14321                "last_updated__n",
14322                &local_var_str
14323                    .into_iter()
14324                    .map(|p| p.to_string())
14325                    .collect::<Vec<String>>()
14326                    .join(",")
14327                    .to_string(),
14328            )]),
14329        };
14330    }
14331    if let Some(ref local_var_str) = limit {
14332        local_var_req_builder =
14333            local_var_req_builder.query(&[("limit", &local_var_str.to_string())]);
14334    }
14335    if let Some(ref local_var_str) = name {
14336        local_var_req_builder = match "multi" {
14337            "multi" => local_var_req_builder.query(
14338                &local_var_str
14339                    .into_iter()
14340                    .map(|p| ("name".to_owned(), p.to_string()))
14341                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14342            ),
14343            _ => local_var_req_builder.query(&[(
14344                "name",
14345                &local_var_str
14346                    .into_iter()
14347                    .map(|p| p.to_string())
14348                    .collect::<Vec<String>>()
14349                    .join(",")
14350                    .to_string(),
14351            )]),
14352        };
14353    }
14354    if let Some(ref local_var_str) = name__ic {
14355        local_var_req_builder = match "multi" {
14356            "multi" => local_var_req_builder.query(
14357                &local_var_str
14358                    .into_iter()
14359                    .map(|p| ("name__ic".to_owned(), p.to_string()))
14360                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14361            ),
14362            _ => local_var_req_builder.query(&[(
14363                "name__ic",
14364                &local_var_str
14365                    .into_iter()
14366                    .map(|p| p.to_string())
14367                    .collect::<Vec<String>>()
14368                    .join(",")
14369                    .to_string(),
14370            )]),
14371        };
14372    }
14373    if let Some(ref local_var_str) = name__ie {
14374        local_var_req_builder = match "multi" {
14375            "multi" => local_var_req_builder.query(
14376                &local_var_str
14377                    .into_iter()
14378                    .map(|p| ("name__ie".to_owned(), p.to_string()))
14379                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14380            ),
14381            _ => local_var_req_builder.query(&[(
14382                "name__ie",
14383                &local_var_str
14384                    .into_iter()
14385                    .map(|p| p.to_string())
14386                    .collect::<Vec<String>>()
14387                    .join(",")
14388                    .to_string(),
14389            )]),
14390        };
14391    }
14392    if let Some(ref local_var_str) = name__iew {
14393        local_var_req_builder = match "multi" {
14394            "multi" => local_var_req_builder.query(
14395                &local_var_str
14396                    .into_iter()
14397                    .map(|p| ("name__iew".to_owned(), p.to_string()))
14398                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14399            ),
14400            _ => local_var_req_builder.query(&[(
14401                "name__iew",
14402                &local_var_str
14403                    .into_iter()
14404                    .map(|p| p.to_string())
14405                    .collect::<Vec<String>>()
14406                    .join(",")
14407                    .to_string(),
14408            )]),
14409        };
14410    }
14411    if let Some(ref local_var_str) = name__ire {
14412        local_var_req_builder = match "multi" {
14413            "multi" => local_var_req_builder.query(
14414                &local_var_str
14415                    .into_iter()
14416                    .map(|p| ("name__ire".to_owned(), p.to_string()))
14417                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14418            ),
14419            _ => local_var_req_builder.query(&[(
14420                "name__ire",
14421                &local_var_str
14422                    .into_iter()
14423                    .map(|p| p.to_string())
14424                    .collect::<Vec<String>>()
14425                    .join(",")
14426                    .to_string(),
14427            )]),
14428        };
14429    }
14430    if let Some(ref local_var_str) = name__isw {
14431        local_var_req_builder = match "multi" {
14432            "multi" => local_var_req_builder.query(
14433                &local_var_str
14434                    .into_iter()
14435                    .map(|p| ("name__isw".to_owned(), p.to_string()))
14436                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14437            ),
14438            _ => local_var_req_builder.query(&[(
14439                "name__isw",
14440                &local_var_str
14441                    .into_iter()
14442                    .map(|p| p.to_string())
14443                    .collect::<Vec<String>>()
14444                    .join(",")
14445                    .to_string(),
14446            )]),
14447        };
14448    }
14449    if let Some(ref local_var_str) = name__n {
14450        local_var_req_builder = match "multi" {
14451            "multi" => local_var_req_builder.query(
14452                &local_var_str
14453                    .into_iter()
14454                    .map(|p| ("name__n".to_owned(), p.to_string()))
14455                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14456            ),
14457            _ => local_var_req_builder.query(&[(
14458                "name__n",
14459                &local_var_str
14460                    .into_iter()
14461                    .map(|p| p.to_string())
14462                    .collect::<Vec<String>>()
14463                    .join(",")
14464                    .to_string(),
14465            )]),
14466        };
14467    }
14468    if let Some(ref local_var_str) = name__nic {
14469        local_var_req_builder = match "multi" {
14470            "multi" => local_var_req_builder.query(
14471                &local_var_str
14472                    .into_iter()
14473                    .map(|p| ("name__nic".to_owned(), p.to_string()))
14474                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14475            ),
14476            _ => local_var_req_builder.query(&[(
14477                "name__nic",
14478                &local_var_str
14479                    .into_iter()
14480                    .map(|p| p.to_string())
14481                    .collect::<Vec<String>>()
14482                    .join(",")
14483                    .to_string(),
14484            )]),
14485        };
14486    }
14487    if let Some(ref local_var_str) = name__nie {
14488        local_var_req_builder = match "multi" {
14489            "multi" => local_var_req_builder.query(
14490                &local_var_str
14491                    .into_iter()
14492                    .map(|p| ("name__nie".to_owned(), p.to_string()))
14493                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14494            ),
14495            _ => local_var_req_builder.query(&[(
14496                "name__nie",
14497                &local_var_str
14498                    .into_iter()
14499                    .map(|p| p.to_string())
14500                    .collect::<Vec<String>>()
14501                    .join(",")
14502                    .to_string(),
14503            )]),
14504        };
14505    }
14506    if let Some(ref local_var_str) = name__niew {
14507        local_var_req_builder = match "multi" {
14508            "multi" => local_var_req_builder.query(
14509                &local_var_str
14510                    .into_iter()
14511                    .map(|p| ("name__niew".to_owned(), p.to_string()))
14512                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14513            ),
14514            _ => local_var_req_builder.query(&[(
14515                "name__niew",
14516                &local_var_str
14517                    .into_iter()
14518                    .map(|p| p.to_string())
14519                    .collect::<Vec<String>>()
14520                    .join(",")
14521                    .to_string(),
14522            )]),
14523        };
14524    }
14525    if let Some(ref local_var_str) = name__nire {
14526        local_var_req_builder = match "multi" {
14527            "multi" => local_var_req_builder.query(
14528                &local_var_str
14529                    .into_iter()
14530                    .map(|p| ("name__nire".to_owned(), p.to_string()))
14531                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14532            ),
14533            _ => local_var_req_builder.query(&[(
14534                "name__nire",
14535                &local_var_str
14536                    .into_iter()
14537                    .map(|p| p.to_string())
14538                    .collect::<Vec<String>>()
14539                    .join(",")
14540                    .to_string(),
14541            )]),
14542        };
14543    }
14544    if let Some(ref local_var_str) = name__nisw {
14545        local_var_req_builder = match "multi" {
14546            "multi" => local_var_req_builder.query(
14547                &local_var_str
14548                    .into_iter()
14549                    .map(|p| ("name__nisw".to_owned(), p.to_string()))
14550                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14551            ),
14552            _ => local_var_req_builder.query(&[(
14553                "name__nisw",
14554                &local_var_str
14555                    .into_iter()
14556                    .map(|p| p.to_string())
14557                    .collect::<Vec<String>>()
14558                    .join(",")
14559                    .to_string(),
14560            )]),
14561        };
14562    }
14563    if let Some(ref local_var_str) = name__nre {
14564        local_var_req_builder = match "multi" {
14565            "multi" => local_var_req_builder.query(
14566                &local_var_str
14567                    .into_iter()
14568                    .map(|p| ("name__nre".to_owned(), p.to_string()))
14569                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14570            ),
14571            _ => local_var_req_builder.query(&[(
14572                "name__nre",
14573                &local_var_str
14574                    .into_iter()
14575                    .map(|p| p.to_string())
14576                    .collect::<Vec<String>>()
14577                    .join(",")
14578                    .to_string(),
14579            )]),
14580        };
14581    }
14582    if let Some(ref local_var_str) = name__re {
14583        local_var_req_builder = match "multi" {
14584            "multi" => local_var_req_builder.query(
14585                &local_var_str
14586                    .into_iter()
14587                    .map(|p| ("name__re".to_owned(), p.to_string()))
14588                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14589            ),
14590            _ => local_var_req_builder.query(&[(
14591                "name__re",
14592                &local_var_str
14593                    .into_iter()
14594                    .map(|p| p.to_string())
14595                    .collect::<Vec<String>>()
14596                    .join(",")
14597                    .to_string(),
14598            )]),
14599        };
14600    }
14601    if let Some(ref local_var_str) = offset {
14602        local_var_req_builder =
14603            local_var_req_builder.query(&[("offset", &local_var_str.to_string())]);
14604    }
14605    if let Some(ref local_var_str) = q {
14606        local_var_req_builder = local_var_req_builder.query(&[("q", &local_var_str.to_string())]);
14607    }
14608    if let Some(ref local_var_str) = role {
14609        local_var_req_builder = match "multi" {
14610            "multi" => local_var_req_builder.query(
14611                &local_var_str
14612                    .into_iter()
14613                    .map(|p| ("role".to_owned(), p.to_string()))
14614                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14615            ),
14616            _ => local_var_req_builder.query(&[(
14617                "role",
14618                &local_var_str
14619                    .into_iter()
14620                    .map(|p| p.to_string())
14621                    .collect::<Vec<String>>()
14622                    .join(",")
14623                    .to_string(),
14624            )]),
14625        };
14626    }
14627    if let Some(ref local_var_str) = role__isnull {
14628        local_var_req_builder =
14629            local_var_req_builder.query(&[("role__isnull", &local_var_str.to_string())]);
14630    }
14631    if let Some(ref local_var_str) = role__n {
14632        local_var_req_builder = match "multi" {
14633            "multi" => local_var_req_builder.query(
14634                &local_var_str
14635                    .into_iter()
14636                    .map(|p| ("role__n".to_owned(), p.to_string()))
14637                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14638            ),
14639            _ => local_var_req_builder.query(&[(
14640                "role__n",
14641                &local_var_str
14642                    .into_iter()
14643                    .map(|p| p.to_string())
14644                    .collect::<Vec<String>>()
14645                    .join(",")
14646                    .to_string(),
14647            )]),
14648        };
14649    }
14650    if let Some(ref local_var_str) = secrets_group {
14651        local_var_req_builder = match "multi" {
14652            "multi" => local_var_req_builder.query(
14653                &local_var_str
14654                    .into_iter()
14655                    .map(|p| ("secrets_group".to_owned(), p.to_string()))
14656                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14657            ),
14658            _ => local_var_req_builder.query(&[(
14659                "secrets_group",
14660                &local_var_str
14661                    .into_iter()
14662                    .map(|p| p.to_string())
14663                    .collect::<Vec<String>>()
14664                    .join(",")
14665                    .to_string(),
14666            )]),
14667        };
14668    }
14669    if let Some(ref local_var_str) = secrets_group__isnull {
14670        local_var_req_builder =
14671            local_var_req_builder.query(&[("secrets_group__isnull", &local_var_str.to_string())]);
14672    }
14673    if let Some(ref local_var_str) = secrets_group__n {
14674        local_var_req_builder = match "multi" {
14675            "multi" => local_var_req_builder.query(
14676                &local_var_str
14677                    .into_iter()
14678                    .map(|p| ("secrets_group__n".to_owned(), p.to_string()))
14679                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14680            ),
14681            _ => local_var_req_builder.query(&[(
14682                "secrets_group__n",
14683                &local_var_str
14684                    .into_iter()
14685                    .map(|p| p.to_string())
14686                    .collect::<Vec<String>>()
14687                    .join(",")
14688                    .to_string(),
14689            )]),
14690        };
14691    }
14692    if let Some(ref local_var_str) = sort {
14693        local_var_req_builder =
14694            local_var_req_builder.query(&[("sort", &local_var_str.to_string())]);
14695    }
14696    if let Some(ref local_var_str) = status {
14697        local_var_req_builder = match "multi" {
14698            "multi" => local_var_req_builder.query(
14699                &local_var_str
14700                    .into_iter()
14701                    .map(|p| ("status".to_owned(), p.to_string()))
14702                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14703            ),
14704            _ => local_var_req_builder.query(&[(
14705                "status",
14706                &local_var_str
14707                    .into_iter()
14708                    .map(|p| p.to_string())
14709                    .collect::<Vec<String>>()
14710                    .join(",")
14711                    .to_string(),
14712            )]),
14713        };
14714    }
14715    if let Some(ref local_var_str) = status__n {
14716        local_var_req_builder = match "multi" {
14717            "multi" => local_var_req_builder.query(
14718                &local_var_str
14719                    .into_iter()
14720                    .map(|p| ("status__n".to_owned(), p.to_string()))
14721                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14722            ),
14723            _ => local_var_req_builder.query(&[(
14724                "status__n",
14725                &local_var_str
14726                    .into_iter()
14727                    .map(|p| p.to_string())
14728                    .collect::<Vec<String>>()
14729                    .join(",")
14730                    .to_string(),
14731            )]),
14732        };
14733    }
14734    if let Some(ref local_var_str) = tags {
14735        local_var_req_builder = match "multi" {
14736            "multi" => local_var_req_builder.query(
14737                &local_var_str
14738                    .into_iter()
14739                    .map(|p| ("tags".to_owned(), p.to_string()))
14740                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14741            ),
14742            _ => local_var_req_builder.query(&[(
14743                "tags",
14744                &local_var_str
14745                    .into_iter()
14746                    .map(|p| p.to_string())
14747                    .collect::<Vec<String>>()
14748                    .join(",")
14749                    .to_string(),
14750            )]),
14751        };
14752    }
14753    if let Some(ref local_var_str) = tags__isnull {
14754        local_var_req_builder =
14755            local_var_req_builder.query(&[("tags__isnull", &local_var_str.to_string())]);
14756    }
14757    if let Some(ref local_var_str) = tags__n {
14758        local_var_req_builder = match "multi" {
14759            "multi" => local_var_req_builder.query(
14760                &local_var_str
14761                    .into_iter()
14762                    .map(|p| ("tags__n".to_owned(), p.to_string()))
14763                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14764            ),
14765            _ => local_var_req_builder.query(&[(
14766                "tags__n",
14767                &local_var_str
14768                    .into_iter()
14769                    .map(|p| p.to_string())
14770                    .collect::<Vec<String>>()
14771                    .join(",")
14772                    .to_string(),
14773            )]),
14774        };
14775    }
14776    if let Some(ref local_var_str) = teams {
14777        local_var_req_builder = match "multi" {
14778            "multi" => local_var_req_builder.query(
14779                &local_var_str
14780                    .into_iter()
14781                    .map(|p| ("teams".to_owned(), p.to_string()))
14782                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14783            ),
14784            _ => local_var_req_builder.query(&[(
14785                "teams",
14786                &local_var_str
14787                    .into_iter()
14788                    .map(|p| p.to_string())
14789                    .collect::<Vec<String>>()
14790                    .join(",")
14791                    .to_string(),
14792            )]),
14793        };
14794    }
14795    if let Some(ref local_var_str) = teams__isnull {
14796        local_var_req_builder =
14797            local_var_req_builder.query(&[("teams__isnull", &local_var_str.to_string())]);
14798    }
14799    if let Some(ref local_var_str) = teams__n {
14800        local_var_req_builder = match "multi" {
14801            "multi" => local_var_req_builder.query(
14802                &local_var_str
14803                    .into_iter()
14804                    .map(|p| ("teams__n".to_owned(), p.to_string()))
14805                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14806            ),
14807            _ => local_var_req_builder.query(&[(
14808                "teams__n",
14809                &local_var_str
14810                    .into_iter()
14811                    .map(|p| p.to_string())
14812                    .collect::<Vec<String>>()
14813                    .join(",")
14814                    .to_string(),
14815            )]),
14816        };
14817    }
14818    if let Some(ref local_var_str) = tenant {
14819        local_var_req_builder = match "multi" {
14820            "multi" => local_var_req_builder.query(
14821                &local_var_str
14822                    .into_iter()
14823                    .map(|p| ("tenant".to_owned(), p.to_string()))
14824                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14825            ),
14826            _ => local_var_req_builder.query(&[(
14827                "tenant",
14828                &local_var_str
14829                    .into_iter()
14830                    .map(|p| p.to_string())
14831                    .collect::<Vec<String>>()
14832                    .join(",")
14833                    .to_string(),
14834            )]),
14835        };
14836    }
14837    if let Some(ref local_var_str) = tenant__isnull {
14838        local_var_req_builder =
14839            local_var_req_builder.query(&[("tenant__isnull", &local_var_str.to_string())]);
14840    }
14841    if let Some(ref local_var_str) = tenant__n {
14842        local_var_req_builder = match "multi" {
14843            "multi" => local_var_req_builder.query(
14844                &local_var_str
14845                    .into_iter()
14846                    .map(|p| ("tenant__n".to_owned(), p.to_string()))
14847                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14848            ),
14849            _ => local_var_req_builder.query(&[(
14850                "tenant__n",
14851                &local_var_str
14852                    .into_iter()
14853                    .map(|p| p.to_string())
14854                    .collect::<Vec<String>>()
14855                    .join(",")
14856                    .to_string(),
14857            )]),
14858        };
14859    }
14860    if let Some(ref local_var_str) = tenant_group {
14861        local_var_req_builder = match "multi" {
14862            "multi" => local_var_req_builder.query(
14863                &local_var_str
14864                    .into_iter()
14865                    .map(|p| ("tenant_group".to_owned(), p.to_string()))
14866                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14867            ),
14868            _ => local_var_req_builder.query(&[(
14869                "tenant_group",
14870                &local_var_str
14871                    .into_iter()
14872                    .map(|p| p.to_string())
14873                    .collect::<Vec<String>>()
14874                    .join(",")
14875                    .to_string(),
14876            )]),
14877        };
14878    }
14879    if let Some(ref local_var_str) = tenant_group__isnull {
14880        local_var_req_builder =
14881            local_var_req_builder.query(&[("tenant_group__isnull", &local_var_str.to_string())]);
14882    }
14883    if let Some(ref local_var_str) = tenant_group__n {
14884        local_var_req_builder = match "multi" {
14885            "multi" => local_var_req_builder.query(
14886                &local_var_str
14887                    .into_iter()
14888                    .map(|p| ("tenant_group__n".to_owned(), p.to_string()))
14889                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14890            ),
14891            _ => local_var_req_builder.query(&[(
14892                "tenant_group__n",
14893                &local_var_str
14894                    .into_iter()
14895                    .map(|p| p.to_string())
14896                    .collect::<Vec<String>>()
14897                    .join(",")
14898                    .to_string(),
14899            )]),
14900        };
14901    }
14902    if let Some(ref local_var_str) = tenant_id {
14903        local_var_req_builder = match "multi" {
14904            "multi" => local_var_req_builder.query(
14905                &local_var_str
14906                    .into_iter()
14907                    .map(|p| ("tenant_id".to_owned(), p.to_string()))
14908                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14909            ),
14910            _ => local_var_req_builder.query(&[(
14911                "tenant_id",
14912                &local_var_str
14913                    .into_iter()
14914                    .map(|p| p.to_string())
14915                    .collect::<Vec<String>>()
14916                    .join(",")
14917                    .to_string(),
14918            )]),
14919        };
14920    }
14921    if let Some(ref local_var_str) = tenant_id__isnull {
14922        local_var_req_builder =
14923            local_var_req_builder.query(&[("tenant_id__isnull", &local_var_str.to_string())]);
14924    }
14925    if let Some(ref local_var_str) = tenant_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| ("tenant_id__n".to_owned(), p.to_string()))
14931                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14932            ),
14933            _ => local_var_req_builder.query(&[(
14934                "tenant_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) = tunnel_id {
14945        local_var_req_builder = match "multi" {
14946            "multi" => local_var_req_builder.query(
14947                &local_var_str
14948                    .into_iter()
14949                    .map(|p| ("tunnel_id".to_owned(), p.to_string()))
14950                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14951            ),
14952            _ => local_var_req_builder.query(&[(
14953                "tunnel_id",
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) = tunnel_id__ic {
14964        local_var_req_builder = match "multi" {
14965            "multi" => local_var_req_builder.query(
14966                &local_var_str
14967                    .into_iter()
14968                    .map(|p| ("tunnel_id__ic".to_owned(), p.to_string()))
14969                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14970            ),
14971            _ => local_var_req_builder.query(&[(
14972                "tunnel_id__ic",
14973                &local_var_str
14974                    .into_iter()
14975                    .map(|p| p.to_string())
14976                    .collect::<Vec<String>>()
14977                    .join(",")
14978                    .to_string(),
14979            )]),
14980        };
14981    }
14982    if let Some(ref local_var_str) = tunnel_id__ie {
14983        local_var_req_builder = match "multi" {
14984            "multi" => local_var_req_builder.query(
14985                &local_var_str
14986                    .into_iter()
14987                    .map(|p| ("tunnel_id__ie".to_owned(), p.to_string()))
14988                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14989            ),
14990            _ => local_var_req_builder.query(&[(
14991                "tunnel_id__ie",
14992                &local_var_str
14993                    .into_iter()
14994                    .map(|p| p.to_string())
14995                    .collect::<Vec<String>>()
14996                    .join(",")
14997                    .to_string(),
14998            )]),
14999        };
15000    }
15001    if let Some(ref local_var_str) = tunnel_id__iew {
15002        local_var_req_builder = match "multi" {
15003            "multi" => local_var_req_builder.query(
15004                &local_var_str
15005                    .into_iter()
15006                    .map(|p| ("tunnel_id__iew".to_owned(), p.to_string()))
15007                    .collect::<Vec<(std::string::String, std::string::String)>>(),
15008            ),
15009            _ => local_var_req_builder.query(&[(
15010                "tunnel_id__iew",
15011                &local_var_str
15012                    .into_iter()
15013                    .map(|p| p.to_string())
15014                    .collect::<Vec<String>>()
15015                    .join(",")
15016                    .to_string(),
15017            )]),
15018        };
15019    }
15020    if let Some(ref local_var_str) = tunnel_id__ire {
15021        local_var_req_builder = match "multi" {
15022            "multi" => local_var_req_builder.query(
15023                &local_var_str
15024                    .into_iter()
15025                    .map(|p| ("tunnel_id__ire".to_owned(), p.to_string()))
15026                    .collect::<Vec<(std::string::String, std::string::String)>>(),
15027            ),
15028            _ => local_var_req_builder.query(&[(
15029                "tunnel_id__ire",
15030                &local_var_str
15031                    .into_iter()
15032                    .map(|p| p.to_string())
15033                    .collect::<Vec<String>>()
15034                    .join(",")
15035                    .to_string(),
15036            )]),
15037        };
15038    }
15039    if let Some(ref local_var_str) = tunnel_id__isw {
15040        local_var_req_builder = match "multi" {
15041            "multi" => local_var_req_builder.query(
15042                &local_var_str
15043                    .into_iter()
15044                    .map(|p| ("tunnel_id__isw".to_owned(), p.to_string()))
15045                    .collect::<Vec<(std::string::String, std::string::String)>>(),
15046            ),
15047            _ => local_var_req_builder.query(&[(
15048                "tunnel_id__isw",
15049                &local_var_str
15050                    .into_iter()
15051                    .map(|p| p.to_string())
15052                    .collect::<Vec<String>>()
15053                    .join(",")
15054                    .to_string(),
15055            )]),
15056        };
15057    }
15058    if let Some(ref local_var_str) = tunnel_id__n {
15059        local_var_req_builder = match "multi" {
15060            "multi" => local_var_req_builder.query(
15061                &local_var_str
15062                    .into_iter()
15063                    .map(|p| ("tunnel_id__n".to_owned(), p.to_string()))
15064                    .collect::<Vec<(std::string::String, std::string::String)>>(),
15065            ),
15066            _ => local_var_req_builder.query(&[(
15067                "tunnel_id__n",
15068                &local_var_str
15069                    .into_iter()
15070                    .map(|p| p.to_string())
15071                    .collect::<Vec<String>>()
15072                    .join(",")
15073                    .to_string(),
15074            )]),
15075        };
15076    }
15077    if let Some(ref local_var_str) = tunnel_id__nic {
15078        local_var_req_builder = match "multi" {
15079            "multi" => local_var_req_builder.query(
15080                &local_var_str
15081                    .into_iter()
15082                    .map(|p| ("tunnel_id__nic".to_owned(), p.to_string()))
15083                    .collect::<Vec<(std::string::String, std::string::String)>>(),
15084            ),
15085            _ => local_var_req_builder.query(&[(
15086                "tunnel_id__nic",
15087                &local_var_str
15088                    .into_iter()
15089                    .map(|p| p.to_string())
15090                    .collect::<Vec<String>>()
15091                    .join(",")
15092                    .to_string(),
15093            )]),
15094        };
15095    }
15096    if let Some(ref local_var_str) = tunnel_id__nie {
15097        local_var_req_builder = match "multi" {
15098            "multi" => local_var_req_builder.query(
15099                &local_var_str
15100                    .into_iter()
15101                    .map(|p| ("tunnel_id__nie".to_owned(), p.to_string()))
15102                    .collect::<Vec<(std::string::String, std::string::String)>>(),
15103            ),
15104            _ => local_var_req_builder.query(&[(
15105                "tunnel_id__nie",
15106                &local_var_str
15107                    .into_iter()
15108                    .map(|p| p.to_string())
15109                    .collect::<Vec<String>>()
15110                    .join(",")
15111                    .to_string(),
15112            )]),
15113        };
15114    }
15115    if let Some(ref local_var_str) = tunnel_id__niew {
15116        local_var_req_builder = match "multi" {
15117            "multi" => local_var_req_builder.query(
15118                &local_var_str
15119                    .into_iter()
15120                    .map(|p| ("tunnel_id__niew".to_owned(), p.to_string()))
15121                    .collect::<Vec<(std::string::String, std::string::String)>>(),
15122            ),
15123            _ => local_var_req_builder.query(&[(
15124                "tunnel_id__niew",
15125                &local_var_str
15126                    .into_iter()
15127                    .map(|p| p.to_string())
15128                    .collect::<Vec<String>>()
15129                    .join(",")
15130                    .to_string(),
15131            )]),
15132        };
15133    }
15134    if let Some(ref local_var_str) = tunnel_id__nire {
15135        local_var_req_builder = match "multi" {
15136            "multi" => local_var_req_builder.query(
15137                &local_var_str
15138                    .into_iter()
15139                    .map(|p| ("tunnel_id__nire".to_owned(), p.to_string()))
15140                    .collect::<Vec<(std::string::String, std::string::String)>>(),
15141            ),
15142            _ => local_var_req_builder.query(&[(
15143                "tunnel_id__nire",
15144                &local_var_str
15145                    .into_iter()
15146                    .map(|p| p.to_string())
15147                    .collect::<Vec<String>>()
15148                    .join(",")
15149                    .to_string(),
15150            )]),
15151        };
15152    }
15153    if let Some(ref local_var_str) = tunnel_id__nisw {
15154        local_var_req_builder = match "multi" {
15155            "multi" => local_var_req_builder.query(
15156                &local_var_str
15157                    .into_iter()
15158                    .map(|p| ("tunnel_id__nisw".to_owned(), p.to_string()))
15159                    .collect::<Vec<(std::string::String, std::string::String)>>(),
15160            ),
15161            _ => local_var_req_builder.query(&[(
15162                "tunnel_id__nisw",
15163                &local_var_str
15164                    .into_iter()
15165                    .map(|p| p.to_string())
15166                    .collect::<Vec<String>>()
15167                    .join(",")
15168                    .to_string(),
15169            )]),
15170        };
15171    }
15172    if let Some(ref local_var_str) = tunnel_id__nre {
15173        local_var_req_builder = match "multi" {
15174            "multi" => local_var_req_builder.query(
15175                &local_var_str
15176                    .into_iter()
15177                    .map(|p| ("tunnel_id__nre".to_owned(), p.to_string()))
15178                    .collect::<Vec<(std::string::String, std::string::String)>>(),
15179            ),
15180            _ => local_var_req_builder.query(&[(
15181                "tunnel_id__nre",
15182                &local_var_str
15183                    .into_iter()
15184                    .map(|p| p.to_string())
15185                    .collect::<Vec<String>>()
15186                    .join(",")
15187                    .to_string(),
15188            )]),
15189        };
15190    }
15191    if let Some(ref local_var_str) = tunnel_id__re {
15192        local_var_req_builder = match "multi" {
15193            "multi" => local_var_req_builder.query(
15194                &local_var_str
15195                    .into_iter()
15196                    .map(|p| ("tunnel_id__re".to_owned(), p.to_string()))
15197                    .collect::<Vec<(std::string::String, std::string::String)>>(),
15198            ),
15199            _ => local_var_req_builder.query(&[(
15200                "tunnel_id__re",
15201                &local_var_str
15202                    .into_iter()
15203                    .map(|p| p.to_string())
15204                    .collect::<Vec<String>>()
15205                    .join(",")
15206                    .to_string(),
15207            )]),
15208        };
15209    }
15210    if let Some(ref local_var_str) = vpn {
15211        local_var_req_builder = match "multi" {
15212            "multi" => local_var_req_builder.query(
15213                &local_var_str
15214                    .into_iter()
15215                    .map(|p| ("vpn".to_owned(), p.to_string()))
15216                    .collect::<Vec<(std::string::String, std::string::String)>>(),
15217            ),
15218            _ => local_var_req_builder.query(&[(
15219                "vpn",
15220                &local_var_str
15221                    .into_iter()
15222                    .map(|p| p.to_string())
15223                    .collect::<Vec<String>>()
15224                    .join(",")
15225                    .to_string(),
15226            )]),
15227        };
15228    }
15229    if let Some(ref local_var_str) = vpn__isnull {
15230        local_var_req_builder =
15231            local_var_req_builder.query(&[("vpn__isnull", &local_var_str.to_string())]);
15232    }
15233    if let Some(ref local_var_str) = vpn__n {
15234        local_var_req_builder = match "multi" {
15235            "multi" => local_var_req_builder.query(
15236                &local_var_str
15237                    .into_iter()
15238                    .map(|p| ("vpn__n".to_owned(), p.to_string()))
15239                    .collect::<Vec<(std::string::String, std::string::String)>>(),
15240            ),
15241            _ => local_var_req_builder.query(&[(
15242                "vpn__n",
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) = vpn_profile {
15253        local_var_req_builder = match "multi" {
15254            "multi" => local_var_req_builder.query(
15255                &local_var_str
15256                    .into_iter()
15257                    .map(|p| ("vpn_profile".to_owned(), p.to_string()))
15258                    .collect::<Vec<(std::string::String, std::string::String)>>(),
15259            ),
15260            _ => local_var_req_builder.query(&[(
15261                "vpn_profile",
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) = vpn_profile__isnull {
15272        local_var_req_builder =
15273            local_var_req_builder.query(&[("vpn_profile__isnull", &local_var_str.to_string())]);
15274    }
15275    if let Some(ref local_var_str) = vpn_profile__n {
15276        local_var_req_builder = match "multi" {
15277            "multi" => local_var_req_builder.query(
15278                &local_var_str
15279                    .into_iter()
15280                    .map(|p| ("vpn_profile__n".to_owned(), p.to_string()))
15281                    .collect::<Vec<(std::string::String, std::string::String)>>(),
15282            ),
15283            _ => local_var_req_builder.query(&[(
15284                "vpn_profile__n",
15285                &local_var_str
15286                    .into_iter()
15287                    .map(|p| p.to_string())
15288                    .collect::<Vec<String>>()
15289                    .join(",")
15290                    .to_string(),
15291            )]),
15292        };
15293    }
15294    if let Some(ref local_var_str) = depth {
15295        local_var_req_builder =
15296            local_var_req_builder.query(&[("depth", &local_var_str.to_string())]);
15297    }
15298    if let Some(ref local_var_str) = exclude_m2m {
15299        local_var_req_builder =
15300            local_var_req_builder.query(&[("exclude_m2m", &local_var_str.to_string())]);
15301    }
15302    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
15303        local_var_req_builder =
15304            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
15305    }
15306    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
15307        let local_var_key = local_var_apikey.key.clone();
15308        let local_var_value = match local_var_apikey.prefix {
15309            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
15310            None => local_var_key,
15311        };
15312        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
15313    };
15314
15315    let local_var_req = local_var_req_builder.build()?;
15316    let local_var_resp = local_var_client.execute(local_var_req).await?;
15317
15318    let local_var_status = local_var_resp.status();
15319    let local_var_content = local_var_resp.text().await?;
15320
15321    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
15322        serde_json::from_str(&local_var_content).map_err(Error::from)
15323    } else {
15324        let local_var_entity: Option<VpnVpnTunnelsListError> =
15325            serde_json::from_str(&local_var_content).ok();
15326        let local_var_error = ResponseContent {
15327            status: local_var_status,
15328            content: local_var_content,
15329            entity: local_var_entity,
15330        };
15331        Err(Error::ResponseError(local_var_error))
15332    }
15333}
15334
15335/// API methods for returning or creating notes on an object.
15336pub async fn vpn_vpn_tunnels_notes_create(
15337    configuration: &configuration::Configuration,
15338    id: &str,
15339    note_input_request: crate::models::NoteInputRequest,
15340    format: Option<&str>,
15341) -> Result<crate::models::Note, Error<VpnVpnTunnelsNotesCreateError>> {
15342    let local_var_configuration = configuration;
15343
15344    let local_var_client = &local_var_configuration.client;
15345
15346    let local_var_uri_str = format!(
15347        "{}/vpn/vpn-tunnels/{id}/notes/",
15348        local_var_configuration.base_path,
15349        id = crate::apis::urlencode(id)
15350    );
15351    let mut local_var_req_builder =
15352        local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
15353
15354    if let Some(ref local_var_str) = format {
15355        local_var_req_builder =
15356            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
15357    }
15358    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
15359        local_var_req_builder =
15360            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
15361    }
15362    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
15363        let local_var_key = local_var_apikey.key.clone();
15364        let local_var_value = match local_var_apikey.prefix {
15365            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
15366            None => local_var_key,
15367        };
15368        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
15369    };
15370    local_var_req_builder = local_var_req_builder.json(&note_input_request);
15371
15372    let local_var_req = local_var_req_builder.build()?;
15373    let local_var_resp = local_var_client.execute(local_var_req).await?;
15374
15375    let local_var_status = local_var_resp.status();
15376    let local_var_content = local_var_resp.text().await?;
15377
15378    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
15379        serde_json::from_str(&local_var_content).map_err(Error::from)
15380    } else {
15381        let local_var_entity: Option<VpnVpnTunnelsNotesCreateError> =
15382            serde_json::from_str(&local_var_content).ok();
15383        let local_var_error = ResponseContent {
15384            status: local_var_status,
15385            content: local_var_content,
15386            entity: local_var_entity,
15387        };
15388        Err(Error::ResponseError(local_var_error))
15389    }
15390}
15391
15392/// API methods for returning or creating notes on an object.
15393pub async fn vpn_vpn_tunnels_notes_list(
15394    configuration: &configuration::Configuration,
15395    id: &str,
15396    format: Option<&str>,
15397    limit: Option<i32>,
15398    offset: Option<i32>,
15399    depth: Option<i32>,
15400    exclude_m2m: Option<bool>,
15401) -> Result<crate::models::PaginatedNoteList, Error<VpnVpnTunnelsNotesListError>> {
15402    let local_var_configuration = configuration;
15403
15404    let local_var_client = &local_var_configuration.client;
15405
15406    let local_var_uri_str = format!(
15407        "{}/vpn/vpn-tunnels/{id}/notes/",
15408        local_var_configuration.base_path,
15409        id = crate::apis::urlencode(id)
15410    );
15411    let mut local_var_req_builder =
15412        local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
15413
15414    if let Some(ref local_var_str) = format {
15415        local_var_req_builder =
15416            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
15417    }
15418    if let Some(ref local_var_str) = limit {
15419        local_var_req_builder =
15420            local_var_req_builder.query(&[("limit", &local_var_str.to_string())]);
15421    }
15422    if let Some(ref local_var_str) = offset {
15423        local_var_req_builder =
15424            local_var_req_builder.query(&[("offset", &local_var_str.to_string())]);
15425    }
15426    if let Some(ref local_var_str) = depth {
15427        local_var_req_builder =
15428            local_var_req_builder.query(&[("depth", &local_var_str.to_string())]);
15429    }
15430    if let Some(ref local_var_str) = exclude_m2m {
15431        local_var_req_builder =
15432            local_var_req_builder.query(&[("exclude_m2m", &local_var_str.to_string())]);
15433    }
15434    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
15435        local_var_req_builder =
15436            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
15437    }
15438    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
15439        let local_var_key = local_var_apikey.key.clone();
15440        let local_var_value = match local_var_apikey.prefix {
15441            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
15442            None => local_var_key,
15443        };
15444        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
15445    };
15446
15447    let local_var_req = local_var_req_builder.build()?;
15448    let local_var_resp = local_var_client.execute(local_var_req).await?;
15449
15450    let local_var_status = local_var_resp.status();
15451    let local_var_content = local_var_resp.text().await?;
15452
15453    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
15454        serde_json::from_str(&local_var_content).map_err(Error::from)
15455    } else {
15456        let local_var_entity: Option<VpnVpnTunnelsNotesListError> =
15457            serde_json::from_str(&local_var_content).ok();
15458        let local_var_error = ResponseContent {
15459            status: local_var_status,
15460            content: local_var_content,
15461            entity: local_var_entity,
15462        };
15463        Err(Error::ResponseError(local_var_error))
15464    }
15465}
15466
15467/// VPNTunnel viewset.
15468pub async fn vpn_vpn_tunnels_partial_update(
15469    configuration: &configuration::Configuration,
15470    id: &str,
15471    format: Option<&str>,
15472    patched_vpn_tunnel_request: Option<crate::models::PatchedVpnTunnelRequest>,
15473) -> Result<crate::models::VpnTunnel, Error<VpnVpnTunnelsPartialUpdateError>> {
15474    let local_var_configuration = configuration;
15475
15476    let local_var_client = &local_var_configuration.client;
15477
15478    let local_var_uri_str = format!(
15479        "{}/vpn/vpn-tunnels/{id}/",
15480        local_var_configuration.base_path,
15481        id = crate::apis::urlencode(id)
15482    );
15483    let mut local_var_req_builder =
15484        local_var_client.request(reqwest::Method::PATCH, local_var_uri_str.as_str());
15485
15486    if let Some(ref local_var_str) = format {
15487        local_var_req_builder =
15488            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
15489    }
15490    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
15491        local_var_req_builder =
15492            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
15493    }
15494    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
15495        let local_var_key = local_var_apikey.key.clone();
15496        let local_var_value = match local_var_apikey.prefix {
15497            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
15498            None => local_var_key,
15499        };
15500        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
15501    };
15502    local_var_req_builder = local_var_req_builder.json(&patched_vpn_tunnel_request);
15503
15504    let local_var_req = local_var_req_builder.build()?;
15505    let local_var_resp = local_var_client.execute(local_var_req).await?;
15506
15507    let local_var_status = local_var_resp.status();
15508    let local_var_content = local_var_resp.text().await?;
15509
15510    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
15511        serde_json::from_str(&local_var_content).map_err(Error::from)
15512    } else {
15513        let local_var_entity: Option<VpnVpnTunnelsPartialUpdateError> =
15514            serde_json::from_str(&local_var_content).ok();
15515        let local_var_error = ResponseContent {
15516            status: local_var_status,
15517            content: local_var_content,
15518            entity: local_var_entity,
15519        };
15520        Err(Error::ResponseError(local_var_error))
15521    }
15522}
15523
15524/// VPNTunnel viewset.
15525pub async fn vpn_vpn_tunnels_retrieve(
15526    configuration: &configuration::Configuration,
15527    id: &str,
15528    format: Option<&str>,
15529    depth: Option<i32>,
15530    exclude_m2m: Option<bool>,
15531) -> Result<crate::models::VpnTunnel, Error<VpnVpnTunnelsRetrieveError>> {
15532    let local_var_configuration = configuration;
15533
15534    let local_var_client = &local_var_configuration.client;
15535
15536    let local_var_uri_str = format!(
15537        "{}/vpn/vpn-tunnels/{id}/",
15538        local_var_configuration.base_path,
15539        id = crate::apis::urlencode(id)
15540    );
15541    let mut local_var_req_builder =
15542        local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
15543
15544    if let Some(ref local_var_str) = format {
15545        local_var_req_builder =
15546            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
15547    }
15548    if let Some(ref local_var_str) = depth {
15549        local_var_req_builder =
15550            local_var_req_builder.query(&[("depth", &local_var_str.to_string())]);
15551    }
15552    if let Some(ref local_var_str) = exclude_m2m {
15553        local_var_req_builder =
15554            local_var_req_builder.query(&[("exclude_m2m", &local_var_str.to_string())]);
15555    }
15556    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
15557        local_var_req_builder =
15558            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
15559    }
15560    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
15561        let local_var_key = local_var_apikey.key.clone();
15562        let local_var_value = match local_var_apikey.prefix {
15563            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
15564            None => local_var_key,
15565        };
15566        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
15567    };
15568
15569    let local_var_req = local_var_req_builder.build()?;
15570    let local_var_resp = local_var_client.execute(local_var_req).await?;
15571
15572    let local_var_status = local_var_resp.status();
15573    let local_var_content = local_var_resp.text().await?;
15574
15575    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
15576        serde_json::from_str(&local_var_content).map_err(Error::from)
15577    } else {
15578        let local_var_entity: Option<VpnVpnTunnelsRetrieveError> =
15579            serde_json::from_str(&local_var_content).ok();
15580        let local_var_error = ResponseContent {
15581            status: local_var_status,
15582            content: local_var_content,
15583            entity: local_var_entity,
15584        };
15585        Err(Error::ResponseError(local_var_error))
15586    }
15587}
15588
15589/// VPNTunnel viewset.
15590pub async fn vpn_vpn_tunnels_update(
15591    configuration: &configuration::Configuration,
15592    id: &str,
15593    vpn_tunnel_request: crate::models::VpnTunnelRequest,
15594    format: Option<&str>,
15595) -> Result<crate::models::VpnTunnel, Error<VpnVpnTunnelsUpdateError>> {
15596    let local_var_configuration = configuration;
15597
15598    let local_var_client = &local_var_configuration.client;
15599
15600    let local_var_uri_str = format!(
15601        "{}/vpn/vpn-tunnels/{id}/",
15602        local_var_configuration.base_path,
15603        id = crate::apis::urlencode(id)
15604    );
15605    let mut local_var_req_builder =
15606        local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());
15607
15608    if let Some(ref local_var_str) = format {
15609        local_var_req_builder =
15610            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
15611    }
15612    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
15613        local_var_req_builder =
15614            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
15615    }
15616    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
15617        let local_var_key = local_var_apikey.key.clone();
15618        let local_var_value = match local_var_apikey.prefix {
15619            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
15620            None => local_var_key,
15621        };
15622        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
15623    };
15624    local_var_req_builder = local_var_req_builder.json(&vpn_tunnel_request);
15625
15626    let local_var_req = local_var_req_builder.build()?;
15627    let local_var_resp = local_var_client.execute(local_var_req).await?;
15628
15629    let local_var_status = local_var_resp.status();
15630    let local_var_content = local_var_resp.text().await?;
15631
15632    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
15633        serde_json::from_str(&local_var_content).map_err(Error::from)
15634    } else {
15635        let local_var_entity: Option<VpnVpnTunnelsUpdateError> =
15636            serde_json::from_str(&local_var_content).ok();
15637        let local_var_error = ResponseContent {
15638            status: local_var_status,
15639            content: local_var_content,
15640            entity: local_var_entity,
15641        };
15642        Err(Error::ResponseError(local_var_error))
15643    }
15644}
15645
15646/// VPN viewset.
15647pub async fn vpn_vpns_bulk_destroy(
15648    configuration: &configuration::Configuration,
15649    bulk_operation_request: Vec<crate::models::BulkOperationRequest>,
15650    format: Option<&str>,
15651) -> Result<(), Error<VpnVpnsBulkDestroyError>> {
15652    let local_var_configuration = configuration;
15653
15654    let local_var_client = &local_var_configuration.client;
15655
15656    let local_var_uri_str = format!("{}/vpn/vpns/", local_var_configuration.base_path);
15657    let mut local_var_req_builder =
15658        local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());
15659
15660    if let Some(ref local_var_str) = format {
15661        local_var_req_builder =
15662            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
15663    }
15664    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
15665        local_var_req_builder =
15666            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
15667    }
15668    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
15669        let local_var_key = local_var_apikey.key.clone();
15670        let local_var_value = match local_var_apikey.prefix {
15671            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
15672            None => local_var_key,
15673        };
15674        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
15675    };
15676    local_var_req_builder = local_var_req_builder.json(&bulk_operation_request);
15677
15678    let local_var_req = local_var_req_builder.build()?;
15679    let local_var_resp = local_var_client.execute(local_var_req).await?;
15680
15681    let local_var_status = local_var_resp.status();
15682    let local_var_content = local_var_resp.text().await?;
15683
15684    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
15685        Ok(())
15686    } else {
15687        let local_var_entity: Option<VpnVpnsBulkDestroyError> =
15688            serde_json::from_str(&local_var_content).ok();
15689        let local_var_error = ResponseContent {
15690            status: local_var_status,
15691            content: local_var_content,
15692            entity: local_var_entity,
15693        };
15694        Err(Error::ResponseError(local_var_error))
15695    }
15696}
15697
15698/// VPN viewset.
15699pub async fn vpn_vpns_bulk_partial_update(
15700    configuration: &configuration::Configuration,
15701    patched_bulk_writable_vpn_request: Vec<crate::models::PatchedBulkWritableVpnRequest>,
15702    format: Option<&str>,
15703) -> Result<Vec<crate::models::Vpn>, Error<VpnVpnsBulkPartialUpdateError>> {
15704    let local_var_configuration = configuration;
15705
15706    let local_var_client = &local_var_configuration.client;
15707
15708    let local_var_uri_str = format!("{}/vpn/vpns/", local_var_configuration.base_path);
15709    let mut local_var_req_builder =
15710        local_var_client.request(reqwest::Method::PATCH, local_var_uri_str.as_str());
15711
15712    if let Some(ref local_var_str) = format {
15713        local_var_req_builder =
15714            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
15715    }
15716    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
15717        local_var_req_builder =
15718            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
15719    }
15720    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
15721        let local_var_key = local_var_apikey.key.clone();
15722        let local_var_value = match local_var_apikey.prefix {
15723            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
15724            None => local_var_key,
15725        };
15726        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
15727    };
15728    local_var_req_builder = local_var_req_builder.json(&patched_bulk_writable_vpn_request);
15729
15730    let local_var_req = local_var_req_builder.build()?;
15731    let local_var_resp = local_var_client.execute(local_var_req).await?;
15732
15733    let local_var_status = local_var_resp.status();
15734    let local_var_content = local_var_resp.text().await?;
15735
15736    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
15737        serde_json::from_str(&local_var_content).map_err(Error::from)
15738    } else {
15739        let local_var_entity: Option<VpnVpnsBulkPartialUpdateError> =
15740            serde_json::from_str(&local_var_content).ok();
15741        let local_var_error = ResponseContent {
15742            status: local_var_status,
15743            content: local_var_content,
15744            entity: local_var_entity,
15745        };
15746        Err(Error::ResponseError(local_var_error))
15747    }
15748}
15749
15750/// VPN viewset.
15751pub async fn vpn_vpns_bulk_update(
15752    configuration: &configuration::Configuration,
15753    bulk_writable_vpn_request: Vec<crate::models::BulkWritableVpnRequest>,
15754    format: Option<&str>,
15755) -> Result<Vec<crate::models::Vpn>, Error<VpnVpnsBulkUpdateError>> {
15756    let local_var_configuration = configuration;
15757
15758    let local_var_client = &local_var_configuration.client;
15759
15760    let local_var_uri_str = format!("{}/vpn/vpns/", local_var_configuration.base_path);
15761    let mut local_var_req_builder =
15762        local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());
15763
15764    if let Some(ref local_var_str) = format {
15765        local_var_req_builder =
15766            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
15767    }
15768    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
15769        local_var_req_builder =
15770            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
15771    }
15772    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
15773        let local_var_key = local_var_apikey.key.clone();
15774        let local_var_value = match local_var_apikey.prefix {
15775            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
15776            None => local_var_key,
15777        };
15778        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
15779    };
15780    local_var_req_builder = local_var_req_builder.json(&bulk_writable_vpn_request);
15781
15782    let local_var_req = local_var_req_builder.build()?;
15783    let local_var_resp = local_var_client.execute(local_var_req).await?;
15784
15785    let local_var_status = local_var_resp.status();
15786    let local_var_content = local_var_resp.text().await?;
15787
15788    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
15789        serde_json::from_str(&local_var_content).map_err(Error::from)
15790    } else {
15791        let local_var_entity: Option<VpnVpnsBulkUpdateError> =
15792            serde_json::from_str(&local_var_content).ok();
15793        let local_var_error = ResponseContent {
15794            status: local_var_status,
15795            content: local_var_content,
15796            entity: local_var_entity,
15797        };
15798        Err(Error::ResponseError(local_var_error))
15799    }
15800}
15801
15802/// VPN viewset.
15803pub async fn vpn_vpns_create(
15804    configuration: &configuration::Configuration,
15805    vpn_request: crate::models::VpnRequest,
15806    format: Option<&str>,
15807) -> Result<crate::models::Vpn, Error<VpnVpnsCreateError>> {
15808    let local_var_configuration = configuration;
15809
15810    let local_var_client = &local_var_configuration.client;
15811
15812    let local_var_uri_str = format!("{}/vpn/vpns/", local_var_configuration.base_path);
15813    let mut local_var_req_builder =
15814        local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
15815
15816    if let Some(ref local_var_str) = format {
15817        local_var_req_builder =
15818            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
15819    }
15820    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
15821        local_var_req_builder =
15822            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
15823    }
15824    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
15825        let local_var_key = local_var_apikey.key.clone();
15826        let local_var_value = match local_var_apikey.prefix {
15827            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
15828            None => local_var_key,
15829        };
15830        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
15831    };
15832    local_var_req_builder = local_var_req_builder.json(&vpn_request);
15833
15834    let local_var_req = local_var_req_builder.build()?;
15835    let local_var_resp = local_var_client.execute(local_var_req).await?;
15836
15837    let local_var_status = local_var_resp.status();
15838    let local_var_content = local_var_resp.text().await?;
15839
15840    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
15841        serde_json::from_str(&local_var_content).map_err(Error::from)
15842    } else {
15843        let local_var_entity: Option<VpnVpnsCreateError> =
15844            serde_json::from_str(&local_var_content).ok();
15845        let local_var_error = ResponseContent {
15846            status: local_var_status,
15847            content: local_var_content,
15848            entity: local_var_entity,
15849        };
15850        Err(Error::ResponseError(local_var_error))
15851    }
15852}
15853
15854/// VPN viewset.
15855pub async fn vpn_vpns_destroy(
15856    configuration: &configuration::Configuration,
15857    id: &str,
15858    format: Option<&str>,
15859) -> Result<(), Error<VpnVpnsDestroyError>> {
15860    let local_var_configuration = configuration;
15861
15862    let local_var_client = &local_var_configuration.client;
15863
15864    let local_var_uri_str = format!(
15865        "{}/vpn/vpns/{id}/",
15866        local_var_configuration.base_path,
15867        id = crate::apis::urlencode(id)
15868    );
15869    let mut local_var_req_builder =
15870        local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());
15871
15872    if let Some(ref local_var_str) = format {
15873        local_var_req_builder =
15874            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
15875    }
15876    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
15877        local_var_req_builder =
15878            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
15879    }
15880    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
15881        let local_var_key = local_var_apikey.key.clone();
15882        let local_var_value = match local_var_apikey.prefix {
15883            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
15884            None => local_var_key,
15885        };
15886        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
15887    };
15888
15889    let local_var_req = local_var_req_builder.build()?;
15890    let local_var_resp = local_var_client.execute(local_var_req).await?;
15891
15892    let local_var_status = local_var_resp.status();
15893    let local_var_content = local_var_resp.text().await?;
15894
15895    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
15896        Ok(())
15897    } else {
15898        let local_var_entity: Option<VpnVpnsDestroyError> =
15899            serde_json::from_str(&local_var_content).ok();
15900        let local_var_error = ResponseContent {
15901            status: local_var_status,
15902            content: local_var_content,
15903            entity: local_var_entity,
15904        };
15905        Err(Error::ResponseError(local_var_error))
15906    }
15907}
15908
15909/// VPN viewset.
15910pub async fn vpn_vpns_list(
15911    configuration: &configuration::Configuration,
15912    contacts: Option<Vec<String>>,
15913    contacts__isnull: Option<bool>,
15914    contacts__n: Option<Vec<String>>,
15915    created: Option<Vec<String>>,
15916    created__gt: Option<Vec<String>>,
15917    created__gte: Option<Vec<String>>,
15918    created__isnull: Option<bool>,
15919    created__lt: Option<Vec<String>>,
15920    created__lte: Option<Vec<String>>,
15921    created__n: Option<Vec<String>>,
15922    description: Option<Vec<String>>,
15923    description__ic: Option<Vec<String>>,
15924    description__ie: Option<Vec<String>>,
15925    description__iew: Option<Vec<String>>,
15926    description__ire: Option<Vec<String>>,
15927    description__isw: Option<Vec<String>>,
15928    description__n: Option<Vec<String>>,
15929    description__nic: Option<Vec<String>>,
15930    description__nie: Option<Vec<String>>,
15931    description__niew: Option<Vec<String>>,
15932    description__nire: Option<Vec<String>>,
15933    description__nisw: Option<Vec<String>>,
15934    description__nre: Option<Vec<String>>,
15935    description__re: Option<Vec<String>>,
15936    dynamic_groups: Option<Vec<String>>,
15937    dynamic_groups__n: Option<Vec<String>>,
15938    extra_attributes: Option<Vec<String>>,
15939    format: Option<&str>,
15940    id: Option<Vec<uuid::Uuid>>,
15941    id__n: Option<Vec<uuid::Uuid>>,
15942    last_updated: Option<Vec<String>>,
15943    last_updated__gt: Option<Vec<String>>,
15944    last_updated__gte: Option<Vec<String>>,
15945    last_updated__isnull: Option<bool>,
15946    last_updated__lt: Option<Vec<String>>,
15947    last_updated__lte: Option<Vec<String>>,
15948    last_updated__n: Option<Vec<String>>,
15949    limit: Option<i32>,
15950    name: Option<Vec<String>>,
15951    name__ic: Option<Vec<String>>,
15952    name__ie: Option<Vec<String>>,
15953    name__iew: Option<Vec<String>>,
15954    name__ire: Option<Vec<String>>,
15955    name__isw: Option<Vec<String>>,
15956    name__n: Option<Vec<String>>,
15957    name__nic: Option<Vec<String>>,
15958    name__nie: Option<Vec<String>>,
15959    name__niew: Option<Vec<String>>,
15960    name__nire: Option<Vec<String>>,
15961    name__nisw: Option<Vec<String>>,
15962    name__nre: Option<Vec<String>>,
15963    name__re: Option<Vec<String>>,
15964    offset: Option<i32>,
15965    q: Option<&str>,
15966    role: Option<Vec<String>>,
15967    role__isnull: Option<bool>,
15968    role__n: Option<Vec<uuid::Uuid>>,
15969    service_type: Option<Vec<String>>,
15970    service_type__ic: Option<Vec<String>>,
15971    service_type__ie: Option<Vec<String>>,
15972    service_type__iew: Option<Vec<String>>,
15973    service_type__ire: Option<Vec<String>>,
15974    service_type__isw: Option<Vec<String>>,
15975    service_type__n: Option<Vec<String>>,
15976    service_type__nic: Option<Vec<String>>,
15977    service_type__nie: Option<Vec<String>>,
15978    service_type__niew: Option<Vec<String>>,
15979    service_type__nire: Option<Vec<String>>,
15980    service_type__nisw: Option<Vec<String>>,
15981    service_type__nre: Option<Vec<String>>,
15982    service_type__re: Option<Vec<String>>,
15983    sort: Option<&str>,
15984    status: Option<Vec<String>>,
15985    status__isnull: Option<bool>,
15986    status__n: Option<Vec<uuid::Uuid>>,
15987    tags: Option<Vec<String>>,
15988    tags__isnull: Option<bool>,
15989    tags__n: Option<Vec<String>>,
15990    teams: Option<Vec<String>>,
15991    teams__isnull: Option<bool>,
15992    teams__n: Option<Vec<String>>,
15993    tenant: Option<Vec<String>>,
15994    tenant__isnull: Option<bool>,
15995    tenant__n: Option<Vec<String>>,
15996    tenant_group: Option<Vec<String>>,
15997    tenant_group__isnull: Option<bool>,
15998    tenant_group__n: Option<Vec<String>>,
15999    tenant_id: Option<Vec<uuid::Uuid>>,
16000    tenant_id__isnull: Option<bool>,
16001    tenant_id__n: Option<Vec<uuid::Uuid>>,
16002    vpn_id: Option<Vec<String>>,
16003    vpn_id__ic: Option<Vec<String>>,
16004    vpn_id__ie: Option<Vec<String>>,
16005    vpn_id__iew: Option<Vec<String>>,
16006    vpn_id__ire: Option<Vec<String>>,
16007    vpn_id__isw: Option<Vec<String>>,
16008    vpn_id__n: Option<Vec<String>>,
16009    vpn_id__nic: Option<Vec<String>>,
16010    vpn_id__nie: Option<Vec<String>>,
16011    vpn_id__niew: Option<Vec<String>>,
16012    vpn_id__nire: Option<Vec<String>>,
16013    vpn_id__nisw: Option<Vec<String>>,
16014    vpn_id__nre: Option<Vec<String>>,
16015    vpn_id__re: Option<Vec<String>>,
16016    vpn_profile: Option<Vec<String>>,
16017    vpn_profile__isnull: Option<bool>,
16018    vpn_profile__n: Option<Vec<String>>,
16019    depth: Option<i32>,
16020    exclude_m2m: Option<bool>,
16021) -> Result<crate::models::PaginatedVpnList, Error<VpnVpnsListError>> {
16022    let local_var_configuration = configuration;
16023
16024    let local_var_client = &local_var_configuration.client;
16025
16026    let local_var_uri_str = format!("{}/vpn/vpns/", local_var_configuration.base_path);
16027    let mut local_var_req_builder =
16028        local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
16029
16030    if let Some(ref local_var_str) = contacts {
16031        local_var_req_builder = match "multi" {
16032            "multi" => local_var_req_builder.query(
16033                &local_var_str
16034                    .into_iter()
16035                    .map(|p| ("contacts".to_owned(), p.to_string()))
16036                    .collect::<Vec<(std::string::String, std::string::String)>>(),
16037            ),
16038            _ => local_var_req_builder.query(&[(
16039                "contacts",
16040                &local_var_str
16041                    .into_iter()
16042                    .map(|p| p.to_string())
16043                    .collect::<Vec<String>>()
16044                    .join(",")
16045                    .to_string(),
16046            )]),
16047        };
16048    }
16049    if let Some(ref local_var_str) = contacts__isnull {
16050        local_var_req_builder =
16051            local_var_req_builder.query(&[("contacts__isnull", &local_var_str.to_string())]);
16052    }
16053    if let Some(ref local_var_str) = contacts__n {
16054        local_var_req_builder = match "multi" {
16055            "multi" => local_var_req_builder.query(
16056                &local_var_str
16057                    .into_iter()
16058                    .map(|p| ("contacts__n".to_owned(), p.to_string()))
16059                    .collect::<Vec<(std::string::String, std::string::String)>>(),
16060            ),
16061            _ => local_var_req_builder.query(&[(
16062                "contacts__n",
16063                &local_var_str
16064                    .into_iter()
16065                    .map(|p| p.to_string())
16066                    .collect::<Vec<String>>()
16067                    .join(",")
16068                    .to_string(),
16069            )]),
16070        };
16071    }
16072    if let Some(ref local_var_str) = created {
16073        local_var_req_builder = match "multi" {
16074            "multi" => local_var_req_builder.query(
16075                &local_var_str
16076                    .into_iter()
16077                    .map(|p| ("created".to_owned(), p.to_string()))
16078                    .collect::<Vec<(std::string::String, std::string::String)>>(),
16079            ),
16080            _ => local_var_req_builder.query(&[(
16081                "created",
16082                &local_var_str
16083                    .into_iter()
16084                    .map(|p| p.to_string())
16085                    .collect::<Vec<String>>()
16086                    .join(",")
16087                    .to_string(),
16088            )]),
16089        };
16090    }
16091    if let Some(ref local_var_str) = created__gt {
16092        local_var_req_builder = match "multi" {
16093            "multi" => local_var_req_builder.query(
16094                &local_var_str
16095                    .into_iter()
16096                    .map(|p| ("created__gt".to_owned(), p.to_string()))
16097                    .collect::<Vec<(std::string::String, std::string::String)>>(),
16098            ),
16099            _ => local_var_req_builder.query(&[(
16100                "created__gt",
16101                &local_var_str
16102                    .into_iter()
16103                    .map(|p| p.to_string())
16104                    .collect::<Vec<String>>()
16105                    .join(",")
16106                    .to_string(),
16107            )]),
16108        };
16109    }
16110    if let Some(ref local_var_str) = created__gte {
16111        local_var_req_builder = match "multi" {
16112            "multi" => local_var_req_builder.query(
16113                &local_var_str
16114                    .into_iter()
16115                    .map(|p| ("created__gte".to_owned(), p.to_string()))
16116                    .collect::<Vec<(std::string::String, std::string::String)>>(),
16117            ),
16118            _ => local_var_req_builder.query(&[(
16119                "created__gte",
16120                &local_var_str
16121                    .into_iter()
16122                    .map(|p| p.to_string())
16123                    .collect::<Vec<String>>()
16124                    .join(",")
16125                    .to_string(),
16126            )]),
16127        };
16128    }
16129    if let Some(ref local_var_str) = created__isnull {
16130        local_var_req_builder =
16131            local_var_req_builder.query(&[("created__isnull", &local_var_str.to_string())]);
16132    }
16133    if let Some(ref local_var_str) = created__lt {
16134        local_var_req_builder = match "multi" {
16135            "multi" => local_var_req_builder.query(
16136                &local_var_str
16137                    .into_iter()
16138                    .map(|p| ("created__lt".to_owned(), p.to_string()))
16139                    .collect::<Vec<(std::string::String, std::string::String)>>(),
16140            ),
16141            _ => local_var_req_builder.query(&[(
16142                "created__lt",
16143                &local_var_str
16144                    .into_iter()
16145                    .map(|p| p.to_string())
16146                    .collect::<Vec<String>>()
16147                    .join(",")
16148                    .to_string(),
16149            )]),
16150        };
16151    }
16152    if let Some(ref local_var_str) = created__lte {
16153        local_var_req_builder = match "multi" {
16154            "multi" => local_var_req_builder.query(
16155                &local_var_str
16156                    .into_iter()
16157                    .map(|p| ("created__lte".to_owned(), p.to_string()))
16158                    .collect::<Vec<(std::string::String, std::string::String)>>(),
16159            ),
16160            _ => local_var_req_builder.query(&[(
16161                "created__lte",
16162                &local_var_str
16163                    .into_iter()
16164                    .map(|p| p.to_string())
16165                    .collect::<Vec<String>>()
16166                    .join(",")
16167                    .to_string(),
16168            )]),
16169        };
16170    }
16171    if let Some(ref local_var_str) = created__n {
16172        local_var_req_builder = match "multi" {
16173            "multi" => local_var_req_builder.query(
16174                &local_var_str
16175                    .into_iter()
16176                    .map(|p| ("created__n".to_owned(), p.to_string()))
16177                    .collect::<Vec<(std::string::String, std::string::String)>>(),
16178            ),
16179            _ => local_var_req_builder.query(&[(
16180                "created__n",
16181                &local_var_str
16182                    .into_iter()
16183                    .map(|p| p.to_string())
16184                    .collect::<Vec<String>>()
16185                    .join(",")
16186                    .to_string(),
16187            )]),
16188        };
16189    }
16190    if let Some(ref local_var_str) = description {
16191        local_var_req_builder = match "multi" {
16192            "multi" => local_var_req_builder.query(
16193                &local_var_str
16194                    .into_iter()
16195                    .map(|p| ("description".to_owned(), p.to_string()))
16196                    .collect::<Vec<(std::string::String, std::string::String)>>(),
16197            ),
16198            _ => local_var_req_builder.query(&[(
16199                "description",
16200                &local_var_str
16201                    .into_iter()
16202                    .map(|p| p.to_string())
16203                    .collect::<Vec<String>>()
16204                    .join(",")
16205                    .to_string(),
16206            )]),
16207        };
16208    }
16209    if let Some(ref local_var_str) = description__ic {
16210        local_var_req_builder = match "multi" {
16211            "multi" => local_var_req_builder.query(
16212                &local_var_str
16213                    .into_iter()
16214                    .map(|p| ("description__ic".to_owned(), p.to_string()))
16215                    .collect::<Vec<(std::string::String, std::string::String)>>(),
16216            ),
16217            _ => local_var_req_builder.query(&[(
16218                "description__ic",
16219                &local_var_str
16220                    .into_iter()
16221                    .map(|p| p.to_string())
16222                    .collect::<Vec<String>>()
16223                    .join(",")
16224                    .to_string(),
16225            )]),
16226        };
16227    }
16228    if let Some(ref local_var_str) = description__ie {
16229        local_var_req_builder = match "multi" {
16230            "multi" => local_var_req_builder.query(
16231                &local_var_str
16232                    .into_iter()
16233                    .map(|p| ("description__ie".to_owned(), p.to_string()))
16234                    .collect::<Vec<(std::string::String, std::string::String)>>(),
16235            ),
16236            _ => local_var_req_builder.query(&[(
16237                "description__ie",
16238                &local_var_str
16239                    .into_iter()
16240                    .map(|p| p.to_string())
16241                    .collect::<Vec<String>>()
16242                    .join(",")
16243                    .to_string(),
16244            )]),
16245        };
16246    }
16247    if let Some(ref local_var_str) = description__iew {
16248        local_var_req_builder = match "multi" {
16249            "multi" => local_var_req_builder.query(
16250                &local_var_str
16251                    .into_iter()
16252                    .map(|p| ("description__iew".to_owned(), p.to_string()))
16253                    .collect::<Vec<(std::string::String, std::string::String)>>(),
16254            ),
16255            _ => local_var_req_builder.query(&[(
16256                "description__iew",
16257                &local_var_str
16258                    .into_iter()
16259                    .map(|p| p.to_string())
16260                    .collect::<Vec<String>>()
16261                    .join(",")
16262                    .to_string(),
16263            )]),
16264        };
16265    }
16266    if let Some(ref local_var_str) = description__ire {
16267        local_var_req_builder = match "multi" {
16268            "multi" => local_var_req_builder.query(
16269                &local_var_str
16270                    .into_iter()
16271                    .map(|p| ("description__ire".to_owned(), p.to_string()))
16272                    .collect::<Vec<(std::string::String, std::string::String)>>(),
16273            ),
16274            _ => local_var_req_builder.query(&[(
16275                "description__ire",
16276                &local_var_str
16277                    .into_iter()
16278                    .map(|p| p.to_string())
16279                    .collect::<Vec<String>>()
16280                    .join(",")
16281                    .to_string(),
16282            )]),
16283        };
16284    }
16285    if let Some(ref local_var_str) = description__isw {
16286        local_var_req_builder = match "multi" {
16287            "multi" => local_var_req_builder.query(
16288                &local_var_str
16289                    .into_iter()
16290                    .map(|p| ("description__isw".to_owned(), p.to_string()))
16291                    .collect::<Vec<(std::string::String, std::string::String)>>(),
16292            ),
16293            _ => local_var_req_builder.query(&[(
16294                "description__isw",
16295                &local_var_str
16296                    .into_iter()
16297                    .map(|p| p.to_string())
16298                    .collect::<Vec<String>>()
16299                    .join(",")
16300                    .to_string(),
16301            )]),
16302        };
16303    }
16304    if let Some(ref local_var_str) = description__n {
16305        local_var_req_builder = match "multi" {
16306            "multi" => local_var_req_builder.query(
16307                &local_var_str
16308                    .into_iter()
16309                    .map(|p| ("description__n".to_owned(), p.to_string()))
16310                    .collect::<Vec<(std::string::String, std::string::String)>>(),
16311            ),
16312            _ => local_var_req_builder.query(&[(
16313                "description__n",
16314                &local_var_str
16315                    .into_iter()
16316                    .map(|p| p.to_string())
16317                    .collect::<Vec<String>>()
16318                    .join(",")
16319                    .to_string(),
16320            )]),
16321        };
16322    }
16323    if let Some(ref local_var_str) = description__nic {
16324        local_var_req_builder = match "multi" {
16325            "multi" => local_var_req_builder.query(
16326                &local_var_str
16327                    .into_iter()
16328                    .map(|p| ("description__nic".to_owned(), p.to_string()))
16329                    .collect::<Vec<(std::string::String, std::string::String)>>(),
16330            ),
16331            _ => local_var_req_builder.query(&[(
16332                "description__nic",
16333                &local_var_str
16334                    .into_iter()
16335                    .map(|p| p.to_string())
16336                    .collect::<Vec<String>>()
16337                    .join(",")
16338                    .to_string(),
16339            )]),
16340        };
16341    }
16342    if let Some(ref local_var_str) = description__nie {
16343        local_var_req_builder = match "multi" {
16344            "multi" => local_var_req_builder.query(
16345                &local_var_str
16346                    .into_iter()
16347                    .map(|p| ("description__nie".to_owned(), p.to_string()))
16348                    .collect::<Vec<(std::string::String, std::string::String)>>(),
16349            ),
16350            _ => local_var_req_builder.query(&[(
16351                "description__nie",
16352                &local_var_str
16353                    .into_iter()
16354                    .map(|p| p.to_string())
16355                    .collect::<Vec<String>>()
16356                    .join(",")
16357                    .to_string(),
16358            )]),
16359        };
16360    }
16361    if let Some(ref local_var_str) = description__niew {
16362        local_var_req_builder = match "multi" {
16363            "multi" => local_var_req_builder.query(
16364                &local_var_str
16365                    .into_iter()
16366                    .map(|p| ("description__niew".to_owned(), p.to_string()))
16367                    .collect::<Vec<(std::string::String, std::string::String)>>(),
16368            ),
16369            _ => local_var_req_builder.query(&[(
16370                "description__niew",
16371                &local_var_str
16372                    .into_iter()
16373                    .map(|p| p.to_string())
16374                    .collect::<Vec<String>>()
16375                    .join(",")
16376                    .to_string(),
16377            )]),
16378        };
16379    }
16380    if let Some(ref local_var_str) = description__nire {
16381        local_var_req_builder = match "multi" {
16382            "multi" => local_var_req_builder.query(
16383                &local_var_str
16384                    .into_iter()
16385                    .map(|p| ("description__nire".to_owned(), p.to_string()))
16386                    .collect::<Vec<(std::string::String, std::string::String)>>(),
16387            ),
16388            _ => local_var_req_builder.query(&[(
16389                "description__nire",
16390                &local_var_str
16391                    .into_iter()
16392                    .map(|p| p.to_string())
16393                    .collect::<Vec<String>>()
16394                    .join(",")
16395                    .to_string(),
16396            )]),
16397        };
16398    }
16399    if let Some(ref local_var_str) = description__nisw {
16400        local_var_req_builder = match "multi" {
16401            "multi" => local_var_req_builder.query(
16402                &local_var_str
16403                    .into_iter()
16404                    .map(|p| ("description__nisw".to_owned(), p.to_string()))
16405                    .collect::<Vec<(std::string::String, std::string::String)>>(),
16406            ),
16407            _ => local_var_req_builder.query(&[(
16408                "description__nisw",
16409                &local_var_str
16410                    .into_iter()
16411                    .map(|p| p.to_string())
16412                    .collect::<Vec<String>>()
16413                    .join(",")
16414                    .to_string(),
16415            )]),
16416        };
16417    }
16418    if let Some(ref local_var_str) = description__nre {
16419        local_var_req_builder = match "multi" {
16420            "multi" => local_var_req_builder.query(
16421                &local_var_str
16422                    .into_iter()
16423                    .map(|p| ("description__nre".to_owned(), p.to_string()))
16424                    .collect::<Vec<(std::string::String, std::string::String)>>(),
16425            ),
16426            _ => local_var_req_builder.query(&[(
16427                "description__nre",
16428                &local_var_str
16429                    .into_iter()
16430                    .map(|p| p.to_string())
16431                    .collect::<Vec<String>>()
16432                    .join(",")
16433                    .to_string(),
16434            )]),
16435        };
16436    }
16437    if let Some(ref local_var_str) = description__re {
16438        local_var_req_builder = match "multi" {
16439            "multi" => local_var_req_builder.query(
16440                &local_var_str
16441                    .into_iter()
16442                    .map(|p| ("description__re".to_owned(), p.to_string()))
16443                    .collect::<Vec<(std::string::String, std::string::String)>>(),
16444            ),
16445            _ => local_var_req_builder.query(&[(
16446                "description__re",
16447                &local_var_str
16448                    .into_iter()
16449                    .map(|p| p.to_string())
16450                    .collect::<Vec<String>>()
16451                    .join(",")
16452                    .to_string(),
16453            )]),
16454        };
16455    }
16456    if let Some(ref local_var_str) = dynamic_groups {
16457        local_var_req_builder = match "multi" {
16458            "multi" => local_var_req_builder.query(
16459                &local_var_str
16460                    .into_iter()
16461                    .map(|p| ("dynamic_groups".to_owned(), p.to_string()))
16462                    .collect::<Vec<(std::string::String, std::string::String)>>(),
16463            ),
16464            _ => local_var_req_builder.query(&[(
16465                "dynamic_groups",
16466                &local_var_str
16467                    .into_iter()
16468                    .map(|p| p.to_string())
16469                    .collect::<Vec<String>>()
16470                    .join(",")
16471                    .to_string(),
16472            )]),
16473        };
16474    }
16475    if let Some(ref local_var_str) = dynamic_groups__n {
16476        local_var_req_builder = match "multi" {
16477            "multi" => local_var_req_builder.query(
16478                &local_var_str
16479                    .into_iter()
16480                    .map(|p| ("dynamic_groups__n".to_owned(), p.to_string()))
16481                    .collect::<Vec<(std::string::String, std::string::String)>>(),
16482            ),
16483            _ => local_var_req_builder.query(&[(
16484                "dynamic_groups__n",
16485                &local_var_str
16486                    .into_iter()
16487                    .map(|p| p.to_string())
16488                    .collect::<Vec<String>>()
16489                    .join(",")
16490                    .to_string(),
16491            )]),
16492        };
16493    }
16494    if let Some(ref local_var_str) = extra_attributes {
16495        local_var_req_builder = match "multi" {
16496            "multi" => local_var_req_builder.query(
16497                &local_var_str
16498                    .into_iter()
16499                    .map(|p| ("extra_attributes".to_owned(), p.to_string()))
16500                    .collect::<Vec<(std::string::String, std::string::String)>>(),
16501            ),
16502            _ => local_var_req_builder.query(&[(
16503                "extra_attributes",
16504                &local_var_str
16505                    .into_iter()
16506                    .map(|p| p.to_string())
16507                    .collect::<Vec<String>>()
16508                    .join(",")
16509                    .to_string(),
16510            )]),
16511        };
16512    }
16513    if let Some(ref local_var_str) = format {
16514        local_var_req_builder =
16515            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
16516    }
16517    if let Some(ref local_var_str) = id {
16518        local_var_req_builder = match "multi" {
16519            "multi" => local_var_req_builder.query(
16520                &local_var_str
16521                    .into_iter()
16522                    .map(|p| ("id".to_owned(), p.to_string()))
16523                    .collect::<Vec<(std::string::String, std::string::String)>>(),
16524            ),
16525            _ => local_var_req_builder.query(&[(
16526                "id",
16527                &local_var_str
16528                    .into_iter()
16529                    .map(|p| p.to_string())
16530                    .collect::<Vec<String>>()
16531                    .join(",")
16532                    .to_string(),
16533            )]),
16534        };
16535    }
16536    if let Some(ref local_var_str) = id__n {
16537        local_var_req_builder = match "multi" {
16538            "multi" => local_var_req_builder.query(
16539                &local_var_str
16540                    .into_iter()
16541                    .map(|p| ("id__n".to_owned(), p.to_string()))
16542                    .collect::<Vec<(std::string::String, std::string::String)>>(),
16543            ),
16544            _ => local_var_req_builder.query(&[(
16545                "id__n",
16546                &local_var_str
16547                    .into_iter()
16548                    .map(|p| p.to_string())
16549                    .collect::<Vec<String>>()
16550                    .join(",")
16551                    .to_string(),
16552            )]),
16553        };
16554    }
16555    if let Some(ref local_var_str) = last_updated {
16556        local_var_req_builder = match "multi" {
16557            "multi" => local_var_req_builder.query(
16558                &local_var_str
16559                    .into_iter()
16560                    .map(|p| ("last_updated".to_owned(), p.to_string()))
16561                    .collect::<Vec<(std::string::String, std::string::String)>>(),
16562            ),
16563            _ => local_var_req_builder.query(&[(
16564                "last_updated",
16565                &local_var_str
16566                    .into_iter()
16567                    .map(|p| p.to_string())
16568                    .collect::<Vec<String>>()
16569                    .join(",")
16570                    .to_string(),
16571            )]),
16572        };
16573    }
16574    if let Some(ref local_var_str) = last_updated__gt {
16575        local_var_req_builder = match "multi" {
16576            "multi" => local_var_req_builder.query(
16577                &local_var_str
16578                    .into_iter()
16579                    .map(|p| ("last_updated__gt".to_owned(), p.to_string()))
16580                    .collect::<Vec<(std::string::String, std::string::String)>>(),
16581            ),
16582            _ => local_var_req_builder.query(&[(
16583                "last_updated__gt",
16584                &local_var_str
16585                    .into_iter()
16586                    .map(|p| p.to_string())
16587                    .collect::<Vec<String>>()
16588                    .join(",")
16589                    .to_string(),
16590            )]),
16591        };
16592    }
16593    if let Some(ref local_var_str) = last_updated__gte {
16594        local_var_req_builder = match "multi" {
16595            "multi" => local_var_req_builder.query(
16596                &local_var_str
16597                    .into_iter()
16598                    .map(|p| ("last_updated__gte".to_owned(), p.to_string()))
16599                    .collect::<Vec<(std::string::String, std::string::String)>>(),
16600            ),
16601            _ => local_var_req_builder.query(&[(
16602                "last_updated__gte",
16603                &local_var_str
16604                    .into_iter()
16605                    .map(|p| p.to_string())
16606                    .collect::<Vec<String>>()
16607                    .join(",")
16608                    .to_string(),
16609            )]),
16610        };
16611    }
16612    if let Some(ref local_var_str) = last_updated__isnull {
16613        local_var_req_builder =
16614            local_var_req_builder.query(&[("last_updated__isnull", &local_var_str.to_string())]);
16615    }
16616    if let Some(ref local_var_str) = last_updated__lt {
16617        local_var_req_builder = match "multi" {
16618            "multi" => local_var_req_builder.query(
16619                &local_var_str
16620                    .into_iter()
16621                    .map(|p| ("last_updated__lt".to_owned(), p.to_string()))
16622                    .collect::<Vec<(std::string::String, std::string::String)>>(),
16623            ),
16624            _ => local_var_req_builder.query(&[(
16625                "last_updated__lt",
16626                &local_var_str
16627                    .into_iter()
16628                    .map(|p| p.to_string())
16629                    .collect::<Vec<String>>()
16630                    .join(",")
16631                    .to_string(),
16632            )]),
16633        };
16634    }
16635    if let Some(ref local_var_str) = last_updated__lte {
16636        local_var_req_builder = match "multi" {
16637            "multi" => local_var_req_builder.query(
16638                &local_var_str
16639                    .into_iter()
16640                    .map(|p| ("last_updated__lte".to_owned(), p.to_string()))
16641                    .collect::<Vec<(std::string::String, std::string::String)>>(),
16642            ),
16643            _ => local_var_req_builder.query(&[(
16644                "last_updated__lte",
16645                &local_var_str
16646                    .into_iter()
16647                    .map(|p| p.to_string())
16648                    .collect::<Vec<String>>()
16649                    .join(",")
16650                    .to_string(),
16651            )]),
16652        };
16653    }
16654    if let Some(ref local_var_str) = last_updated__n {
16655        local_var_req_builder = match "multi" {
16656            "multi" => local_var_req_builder.query(
16657                &local_var_str
16658                    .into_iter()
16659                    .map(|p| ("last_updated__n".to_owned(), p.to_string()))
16660                    .collect::<Vec<(std::string::String, std::string::String)>>(),
16661            ),
16662            _ => local_var_req_builder.query(&[(
16663                "last_updated__n",
16664                &local_var_str
16665                    .into_iter()
16666                    .map(|p| p.to_string())
16667                    .collect::<Vec<String>>()
16668                    .join(",")
16669                    .to_string(),
16670            )]),
16671        };
16672    }
16673    if let Some(ref local_var_str) = limit {
16674        local_var_req_builder =
16675            local_var_req_builder.query(&[("limit", &local_var_str.to_string())]);
16676    }
16677    if let Some(ref local_var_str) = name {
16678        local_var_req_builder = match "multi" {
16679            "multi" => local_var_req_builder.query(
16680                &local_var_str
16681                    .into_iter()
16682                    .map(|p| ("name".to_owned(), p.to_string()))
16683                    .collect::<Vec<(std::string::String, std::string::String)>>(),
16684            ),
16685            _ => local_var_req_builder.query(&[(
16686                "name",
16687                &local_var_str
16688                    .into_iter()
16689                    .map(|p| p.to_string())
16690                    .collect::<Vec<String>>()
16691                    .join(",")
16692                    .to_string(),
16693            )]),
16694        };
16695    }
16696    if let Some(ref local_var_str) = name__ic {
16697        local_var_req_builder = match "multi" {
16698            "multi" => local_var_req_builder.query(
16699                &local_var_str
16700                    .into_iter()
16701                    .map(|p| ("name__ic".to_owned(), p.to_string()))
16702                    .collect::<Vec<(std::string::String, std::string::String)>>(),
16703            ),
16704            _ => local_var_req_builder.query(&[(
16705                "name__ic",
16706                &local_var_str
16707                    .into_iter()
16708                    .map(|p| p.to_string())
16709                    .collect::<Vec<String>>()
16710                    .join(",")
16711                    .to_string(),
16712            )]),
16713        };
16714    }
16715    if let Some(ref local_var_str) = name__ie {
16716        local_var_req_builder = match "multi" {
16717            "multi" => local_var_req_builder.query(
16718                &local_var_str
16719                    .into_iter()
16720                    .map(|p| ("name__ie".to_owned(), p.to_string()))
16721                    .collect::<Vec<(std::string::String, std::string::String)>>(),
16722            ),
16723            _ => local_var_req_builder.query(&[(
16724                "name__ie",
16725                &local_var_str
16726                    .into_iter()
16727                    .map(|p| p.to_string())
16728                    .collect::<Vec<String>>()
16729                    .join(",")
16730                    .to_string(),
16731            )]),
16732        };
16733    }
16734    if let Some(ref local_var_str) = name__iew {
16735        local_var_req_builder = match "multi" {
16736            "multi" => local_var_req_builder.query(
16737                &local_var_str
16738                    .into_iter()
16739                    .map(|p| ("name__iew".to_owned(), p.to_string()))
16740                    .collect::<Vec<(std::string::String, std::string::String)>>(),
16741            ),
16742            _ => local_var_req_builder.query(&[(
16743                "name__iew",
16744                &local_var_str
16745                    .into_iter()
16746                    .map(|p| p.to_string())
16747                    .collect::<Vec<String>>()
16748                    .join(",")
16749                    .to_string(),
16750            )]),
16751        };
16752    }
16753    if let Some(ref local_var_str) = name__ire {
16754        local_var_req_builder = match "multi" {
16755            "multi" => local_var_req_builder.query(
16756                &local_var_str
16757                    .into_iter()
16758                    .map(|p| ("name__ire".to_owned(), p.to_string()))
16759                    .collect::<Vec<(std::string::String, std::string::String)>>(),
16760            ),
16761            _ => local_var_req_builder.query(&[(
16762                "name__ire",
16763                &local_var_str
16764                    .into_iter()
16765                    .map(|p| p.to_string())
16766                    .collect::<Vec<String>>()
16767                    .join(",")
16768                    .to_string(),
16769            )]),
16770        };
16771    }
16772    if let Some(ref local_var_str) = name__isw {
16773        local_var_req_builder = match "multi" {
16774            "multi" => local_var_req_builder.query(
16775                &local_var_str
16776                    .into_iter()
16777                    .map(|p| ("name__isw".to_owned(), p.to_string()))
16778                    .collect::<Vec<(std::string::String, std::string::String)>>(),
16779            ),
16780            _ => local_var_req_builder.query(&[(
16781                "name__isw",
16782                &local_var_str
16783                    .into_iter()
16784                    .map(|p| p.to_string())
16785                    .collect::<Vec<String>>()
16786                    .join(",")
16787                    .to_string(),
16788            )]),
16789        };
16790    }
16791    if let Some(ref local_var_str) = name__n {
16792        local_var_req_builder = match "multi" {
16793            "multi" => local_var_req_builder.query(
16794                &local_var_str
16795                    .into_iter()
16796                    .map(|p| ("name__n".to_owned(), p.to_string()))
16797                    .collect::<Vec<(std::string::String, std::string::String)>>(),
16798            ),
16799            _ => local_var_req_builder.query(&[(
16800                "name__n",
16801                &local_var_str
16802                    .into_iter()
16803                    .map(|p| p.to_string())
16804                    .collect::<Vec<String>>()
16805                    .join(",")
16806                    .to_string(),
16807            )]),
16808        };
16809    }
16810    if let Some(ref local_var_str) = name__nic {
16811        local_var_req_builder = match "multi" {
16812            "multi" => local_var_req_builder.query(
16813                &local_var_str
16814                    .into_iter()
16815                    .map(|p| ("name__nic".to_owned(), p.to_string()))
16816                    .collect::<Vec<(std::string::String, std::string::String)>>(),
16817            ),
16818            _ => local_var_req_builder.query(&[(
16819                "name__nic",
16820                &local_var_str
16821                    .into_iter()
16822                    .map(|p| p.to_string())
16823                    .collect::<Vec<String>>()
16824                    .join(",")
16825                    .to_string(),
16826            )]),
16827        };
16828    }
16829    if let Some(ref local_var_str) = name__nie {
16830        local_var_req_builder = match "multi" {
16831            "multi" => local_var_req_builder.query(
16832                &local_var_str
16833                    .into_iter()
16834                    .map(|p| ("name__nie".to_owned(), p.to_string()))
16835                    .collect::<Vec<(std::string::String, std::string::String)>>(),
16836            ),
16837            _ => local_var_req_builder.query(&[(
16838                "name__nie",
16839                &local_var_str
16840                    .into_iter()
16841                    .map(|p| p.to_string())
16842                    .collect::<Vec<String>>()
16843                    .join(",")
16844                    .to_string(),
16845            )]),
16846        };
16847    }
16848    if let Some(ref local_var_str) = name__niew {
16849        local_var_req_builder = match "multi" {
16850            "multi" => local_var_req_builder.query(
16851                &local_var_str
16852                    .into_iter()
16853                    .map(|p| ("name__niew".to_owned(), p.to_string()))
16854                    .collect::<Vec<(std::string::String, std::string::String)>>(),
16855            ),
16856            _ => local_var_req_builder.query(&[(
16857                "name__niew",
16858                &local_var_str
16859                    .into_iter()
16860                    .map(|p| p.to_string())
16861                    .collect::<Vec<String>>()
16862                    .join(",")
16863                    .to_string(),
16864            )]),
16865        };
16866    }
16867    if let Some(ref local_var_str) = name__nire {
16868        local_var_req_builder = match "multi" {
16869            "multi" => local_var_req_builder.query(
16870                &local_var_str
16871                    .into_iter()
16872                    .map(|p| ("name__nire".to_owned(), p.to_string()))
16873                    .collect::<Vec<(std::string::String, std::string::String)>>(),
16874            ),
16875            _ => local_var_req_builder.query(&[(
16876                "name__nire",
16877                &local_var_str
16878                    .into_iter()
16879                    .map(|p| p.to_string())
16880                    .collect::<Vec<String>>()
16881                    .join(",")
16882                    .to_string(),
16883            )]),
16884        };
16885    }
16886    if let Some(ref local_var_str) = name__nisw {
16887        local_var_req_builder = match "multi" {
16888            "multi" => local_var_req_builder.query(
16889                &local_var_str
16890                    .into_iter()
16891                    .map(|p| ("name__nisw".to_owned(), p.to_string()))
16892                    .collect::<Vec<(std::string::String, std::string::String)>>(),
16893            ),
16894            _ => local_var_req_builder.query(&[(
16895                "name__nisw",
16896                &local_var_str
16897                    .into_iter()
16898                    .map(|p| p.to_string())
16899                    .collect::<Vec<String>>()
16900                    .join(",")
16901                    .to_string(),
16902            )]),
16903        };
16904    }
16905    if let Some(ref local_var_str) = name__nre {
16906        local_var_req_builder = match "multi" {
16907            "multi" => local_var_req_builder.query(
16908                &local_var_str
16909                    .into_iter()
16910                    .map(|p| ("name__nre".to_owned(), p.to_string()))
16911                    .collect::<Vec<(std::string::String, std::string::String)>>(),
16912            ),
16913            _ => local_var_req_builder.query(&[(
16914                "name__nre",
16915                &local_var_str
16916                    .into_iter()
16917                    .map(|p| p.to_string())
16918                    .collect::<Vec<String>>()
16919                    .join(",")
16920                    .to_string(),
16921            )]),
16922        };
16923    }
16924    if let Some(ref local_var_str) = name__re {
16925        local_var_req_builder = match "multi" {
16926            "multi" => local_var_req_builder.query(
16927                &local_var_str
16928                    .into_iter()
16929                    .map(|p| ("name__re".to_owned(), p.to_string()))
16930                    .collect::<Vec<(std::string::String, std::string::String)>>(),
16931            ),
16932            _ => local_var_req_builder.query(&[(
16933                "name__re",
16934                &local_var_str
16935                    .into_iter()
16936                    .map(|p| p.to_string())
16937                    .collect::<Vec<String>>()
16938                    .join(",")
16939                    .to_string(),
16940            )]),
16941        };
16942    }
16943    if let Some(ref local_var_str) = offset {
16944        local_var_req_builder =
16945            local_var_req_builder.query(&[("offset", &local_var_str.to_string())]);
16946    }
16947    if let Some(ref local_var_str) = q {
16948        local_var_req_builder = local_var_req_builder.query(&[("q", &local_var_str.to_string())]);
16949    }
16950    if let Some(ref local_var_str) = role {
16951        local_var_req_builder = match "multi" {
16952            "multi" => local_var_req_builder.query(
16953                &local_var_str
16954                    .into_iter()
16955                    .map(|p| ("role".to_owned(), p.to_string()))
16956                    .collect::<Vec<(std::string::String, std::string::String)>>(),
16957            ),
16958            _ => local_var_req_builder.query(&[(
16959                "role",
16960                &local_var_str
16961                    .into_iter()
16962                    .map(|p| p.to_string())
16963                    .collect::<Vec<String>>()
16964                    .join(",")
16965                    .to_string(),
16966            )]),
16967        };
16968    }
16969    if let Some(ref local_var_str) = role__isnull {
16970        local_var_req_builder =
16971            local_var_req_builder.query(&[("role__isnull", &local_var_str.to_string())]);
16972    }
16973    if let Some(ref local_var_str) = role__n {
16974        local_var_req_builder = match "multi" {
16975            "multi" => local_var_req_builder.query(
16976                &local_var_str
16977                    .into_iter()
16978                    .map(|p| ("role__n".to_owned(), p.to_string()))
16979                    .collect::<Vec<(std::string::String, std::string::String)>>(),
16980            ),
16981            _ => local_var_req_builder.query(&[(
16982                "role__n",
16983                &local_var_str
16984                    .into_iter()
16985                    .map(|p| p.to_string())
16986                    .collect::<Vec<String>>()
16987                    .join(",")
16988                    .to_string(),
16989            )]),
16990        };
16991    }
16992    if let Some(ref local_var_str) = service_type {
16993        local_var_req_builder = match "multi" {
16994            "multi" => local_var_req_builder.query(
16995                &local_var_str
16996                    .into_iter()
16997                    .map(|p| ("service_type".to_owned(), p.to_string()))
16998                    .collect::<Vec<(std::string::String, std::string::String)>>(),
16999            ),
17000            _ => local_var_req_builder.query(&[(
17001                "service_type",
17002                &local_var_str
17003                    .into_iter()
17004                    .map(|p| p.to_string())
17005                    .collect::<Vec<String>>()
17006                    .join(",")
17007                    .to_string(),
17008            )]),
17009        };
17010    }
17011    if let Some(ref local_var_str) = service_type__ic {
17012        local_var_req_builder = match "multi" {
17013            "multi" => local_var_req_builder.query(
17014                &local_var_str
17015                    .into_iter()
17016                    .map(|p| ("service_type__ic".to_owned(), p.to_string()))
17017                    .collect::<Vec<(std::string::String, std::string::String)>>(),
17018            ),
17019            _ => local_var_req_builder.query(&[(
17020                "service_type__ic",
17021                &local_var_str
17022                    .into_iter()
17023                    .map(|p| p.to_string())
17024                    .collect::<Vec<String>>()
17025                    .join(",")
17026                    .to_string(),
17027            )]),
17028        };
17029    }
17030    if let Some(ref local_var_str) = service_type__ie {
17031        local_var_req_builder = match "multi" {
17032            "multi" => local_var_req_builder.query(
17033                &local_var_str
17034                    .into_iter()
17035                    .map(|p| ("service_type__ie".to_owned(), p.to_string()))
17036                    .collect::<Vec<(std::string::String, std::string::String)>>(),
17037            ),
17038            _ => local_var_req_builder.query(&[(
17039                "service_type__ie",
17040                &local_var_str
17041                    .into_iter()
17042                    .map(|p| p.to_string())
17043                    .collect::<Vec<String>>()
17044                    .join(",")
17045                    .to_string(),
17046            )]),
17047        };
17048    }
17049    if let Some(ref local_var_str) = service_type__iew {
17050        local_var_req_builder = match "multi" {
17051            "multi" => local_var_req_builder.query(
17052                &local_var_str
17053                    .into_iter()
17054                    .map(|p| ("service_type__iew".to_owned(), p.to_string()))
17055                    .collect::<Vec<(std::string::String, std::string::String)>>(),
17056            ),
17057            _ => local_var_req_builder.query(&[(
17058                "service_type__iew",
17059                &local_var_str
17060                    .into_iter()
17061                    .map(|p| p.to_string())
17062                    .collect::<Vec<String>>()
17063                    .join(",")
17064                    .to_string(),
17065            )]),
17066        };
17067    }
17068    if let Some(ref local_var_str) = service_type__ire {
17069        local_var_req_builder = match "multi" {
17070            "multi" => local_var_req_builder.query(
17071                &local_var_str
17072                    .into_iter()
17073                    .map(|p| ("service_type__ire".to_owned(), p.to_string()))
17074                    .collect::<Vec<(std::string::String, std::string::String)>>(),
17075            ),
17076            _ => local_var_req_builder.query(&[(
17077                "service_type__ire",
17078                &local_var_str
17079                    .into_iter()
17080                    .map(|p| p.to_string())
17081                    .collect::<Vec<String>>()
17082                    .join(",")
17083                    .to_string(),
17084            )]),
17085        };
17086    }
17087    if let Some(ref local_var_str) = service_type__isw {
17088        local_var_req_builder = match "multi" {
17089            "multi" => local_var_req_builder.query(
17090                &local_var_str
17091                    .into_iter()
17092                    .map(|p| ("service_type__isw".to_owned(), p.to_string()))
17093                    .collect::<Vec<(std::string::String, std::string::String)>>(),
17094            ),
17095            _ => local_var_req_builder.query(&[(
17096                "service_type__isw",
17097                &local_var_str
17098                    .into_iter()
17099                    .map(|p| p.to_string())
17100                    .collect::<Vec<String>>()
17101                    .join(",")
17102                    .to_string(),
17103            )]),
17104        };
17105    }
17106    if let Some(ref local_var_str) = service_type__n {
17107        local_var_req_builder = match "multi" {
17108            "multi" => local_var_req_builder.query(
17109                &local_var_str
17110                    .into_iter()
17111                    .map(|p| ("service_type__n".to_owned(), p.to_string()))
17112                    .collect::<Vec<(std::string::String, std::string::String)>>(),
17113            ),
17114            _ => local_var_req_builder.query(&[(
17115                "service_type__n",
17116                &local_var_str
17117                    .into_iter()
17118                    .map(|p| p.to_string())
17119                    .collect::<Vec<String>>()
17120                    .join(",")
17121                    .to_string(),
17122            )]),
17123        };
17124    }
17125    if let Some(ref local_var_str) = service_type__nic {
17126        local_var_req_builder = match "multi" {
17127            "multi" => local_var_req_builder.query(
17128                &local_var_str
17129                    .into_iter()
17130                    .map(|p| ("service_type__nic".to_owned(), p.to_string()))
17131                    .collect::<Vec<(std::string::String, std::string::String)>>(),
17132            ),
17133            _ => local_var_req_builder.query(&[(
17134                "service_type__nic",
17135                &local_var_str
17136                    .into_iter()
17137                    .map(|p| p.to_string())
17138                    .collect::<Vec<String>>()
17139                    .join(",")
17140                    .to_string(),
17141            )]),
17142        };
17143    }
17144    if let Some(ref local_var_str) = service_type__nie {
17145        local_var_req_builder = match "multi" {
17146            "multi" => local_var_req_builder.query(
17147                &local_var_str
17148                    .into_iter()
17149                    .map(|p| ("service_type__nie".to_owned(), p.to_string()))
17150                    .collect::<Vec<(std::string::String, std::string::String)>>(),
17151            ),
17152            _ => local_var_req_builder.query(&[(
17153                "service_type__nie",
17154                &local_var_str
17155                    .into_iter()
17156                    .map(|p| p.to_string())
17157                    .collect::<Vec<String>>()
17158                    .join(",")
17159                    .to_string(),
17160            )]),
17161        };
17162    }
17163    if let Some(ref local_var_str) = service_type__niew {
17164        local_var_req_builder = match "multi" {
17165            "multi" => local_var_req_builder.query(
17166                &local_var_str
17167                    .into_iter()
17168                    .map(|p| ("service_type__niew".to_owned(), p.to_string()))
17169                    .collect::<Vec<(std::string::String, std::string::String)>>(),
17170            ),
17171            _ => local_var_req_builder.query(&[(
17172                "service_type__niew",
17173                &local_var_str
17174                    .into_iter()
17175                    .map(|p| p.to_string())
17176                    .collect::<Vec<String>>()
17177                    .join(",")
17178                    .to_string(),
17179            )]),
17180        };
17181    }
17182    if let Some(ref local_var_str) = service_type__nire {
17183        local_var_req_builder = match "multi" {
17184            "multi" => local_var_req_builder.query(
17185                &local_var_str
17186                    .into_iter()
17187                    .map(|p| ("service_type__nire".to_owned(), p.to_string()))
17188                    .collect::<Vec<(std::string::String, std::string::String)>>(),
17189            ),
17190            _ => local_var_req_builder.query(&[(
17191                "service_type__nire",
17192                &local_var_str
17193                    .into_iter()
17194                    .map(|p| p.to_string())
17195                    .collect::<Vec<String>>()
17196                    .join(",")
17197                    .to_string(),
17198            )]),
17199        };
17200    }
17201    if let Some(ref local_var_str) = service_type__nisw {
17202        local_var_req_builder = match "multi" {
17203            "multi" => local_var_req_builder.query(
17204                &local_var_str
17205                    .into_iter()
17206                    .map(|p| ("service_type__nisw".to_owned(), p.to_string()))
17207                    .collect::<Vec<(std::string::String, std::string::String)>>(),
17208            ),
17209            _ => local_var_req_builder.query(&[(
17210                "service_type__nisw",
17211                &local_var_str
17212                    .into_iter()
17213                    .map(|p| p.to_string())
17214                    .collect::<Vec<String>>()
17215                    .join(",")
17216                    .to_string(),
17217            )]),
17218        };
17219    }
17220    if let Some(ref local_var_str) = service_type__nre {
17221        local_var_req_builder = match "multi" {
17222            "multi" => local_var_req_builder.query(
17223                &local_var_str
17224                    .into_iter()
17225                    .map(|p| ("service_type__nre".to_owned(), p.to_string()))
17226                    .collect::<Vec<(std::string::String, std::string::String)>>(),
17227            ),
17228            _ => local_var_req_builder.query(&[(
17229                "service_type__nre",
17230                &local_var_str
17231                    .into_iter()
17232                    .map(|p| p.to_string())
17233                    .collect::<Vec<String>>()
17234                    .join(",")
17235                    .to_string(),
17236            )]),
17237        };
17238    }
17239    if let Some(ref local_var_str) = service_type__re {
17240        local_var_req_builder = match "multi" {
17241            "multi" => local_var_req_builder.query(
17242                &local_var_str
17243                    .into_iter()
17244                    .map(|p| ("service_type__re".to_owned(), p.to_string()))
17245                    .collect::<Vec<(std::string::String, std::string::String)>>(),
17246            ),
17247            _ => local_var_req_builder.query(&[(
17248                "service_type__re",
17249                &local_var_str
17250                    .into_iter()
17251                    .map(|p| p.to_string())
17252                    .collect::<Vec<String>>()
17253                    .join(",")
17254                    .to_string(),
17255            )]),
17256        };
17257    }
17258    if let Some(ref local_var_str) = sort {
17259        local_var_req_builder =
17260            local_var_req_builder.query(&[("sort", &local_var_str.to_string())]);
17261    }
17262    if let Some(ref local_var_str) = status {
17263        local_var_req_builder = match "multi" {
17264            "multi" => local_var_req_builder.query(
17265                &local_var_str
17266                    .into_iter()
17267                    .map(|p| ("status".to_owned(), p.to_string()))
17268                    .collect::<Vec<(std::string::String, std::string::String)>>(),
17269            ),
17270            _ => local_var_req_builder.query(&[(
17271                "status",
17272                &local_var_str
17273                    .into_iter()
17274                    .map(|p| p.to_string())
17275                    .collect::<Vec<String>>()
17276                    .join(",")
17277                    .to_string(),
17278            )]),
17279        };
17280    }
17281    if let Some(ref local_var_str) = status__isnull {
17282        local_var_req_builder =
17283            local_var_req_builder.query(&[("status__isnull", &local_var_str.to_string())]);
17284    }
17285    if let Some(ref local_var_str) = status__n {
17286        local_var_req_builder = match "multi" {
17287            "multi" => local_var_req_builder.query(
17288                &local_var_str
17289                    .into_iter()
17290                    .map(|p| ("status__n".to_owned(), p.to_string()))
17291                    .collect::<Vec<(std::string::String, std::string::String)>>(),
17292            ),
17293            _ => local_var_req_builder.query(&[(
17294                "status__n",
17295                &local_var_str
17296                    .into_iter()
17297                    .map(|p| p.to_string())
17298                    .collect::<Vec<String>>()
17299                    .join(",")
17300                    .to_string(),
17301            )]),
17302        };
17303    }
17304    if let Some(ref local_var_str) = tags {
17305        local_var_req_builder = match "multi" {
17306            "multi" => local_var_req_builder.query(
17307                &local_var_str
17308                    .into_iter()
17309                    .map(|p| ("tags".to_owned(), p.to_string()))
17310                    .collect::<Vec<(std::string::String, std::string::String)>>(),
17311            ),
17312            _ => local_var_req_builder.query(&[(
17313                "tags",
17314                &local_var_str
17315                    .into_iter()
17316                    .map(|p| p.to_string())
17317                    .collect::<Vec<String>>()
17318                    .join(",")
17319                    .to_string(),
17320            )]),
17321        };
17322    }
17323    if let Some(ref local_var_str) = tags__isnull {
17324        local_var_req_builder =
17325            local_var_req_builder.query(&[("tags__isnull", &local_var_str.to_string())]);
17326    }
17327    if let Some(ref local_var_str) = tags__n {
17328        local_var_req_builder = match "multi" {
17329            "multi" => local_var_req_builder.query(
17330                &local_var_str
17331                    .into_iter()
17332                    .map(|p| ("tags__n".to_owned(), p.to_string()))
17333                    .collect::<Vec<(std::string::String, std::string::String)>>(),
17334            ),
17335            _ => local_var_req_builder.query(&[(
17336                "tags__n",
17337                &local_var_str
17338                    .into_iter()
17339                    .map(|p| p.to_string())
17340                    .collect::<Vec<String>>()
17341                    .join(",")
17342                    .to_string(),
17343            )]),
17344        };
17345    }
17346    if let Some(ref local_var_str) = teams {
17347        local_var_req_builder = match "multi" {
17348            "multi" => local_var_req_builder.query(
17349                &local_var_str
17350                    .into_iter()
17351                    .map(|p| ("teams".to_owned(), p.to_string()))
17352                    .collect::<Vec<(std::string::String, std::string::String)>>(),
17353            ),
17354            _ => local_var_req_builder.query(&[(
17355                "teams",
17356                &local_var_str
17357                    .into_iter()
17358                    .map(|p| p.to_string())
17359                    .collect::<Vec<String>>()
17360                    .join(",")
17361                    .to_string(),
17362            )]),
17363        };
17364    }
17365    if let Some(ref local_var_str) = teams__isnull {
17366        local_var_req_builder =
17367            local_var_req_builder.query(&[("teams__isnull", &local_var_str.to_string())]);
17368    }
17369    if let Some(ref local_var_str) = teams__n {
17370        local_var_req_builder = match "multi" {
17371            "multi" => local_var_req_builder.query(
17372                &local_var_str
17373                    .into_iter()
17374                    .map(|p| ("teams__n".to_owned(), p.to_string()))
17375                    .collect::<Vec<(std::string::String, std::string::String)>>(),
17376            ),
17377            _ => local_var_req_builder.query(&[(
17378                "teams__n",
17379                &local_var_str
17380                    .into_iter()
17381                    .map(|p| p.to_string())
17382                    .collect::<Vec<String>>()
17383                    .join(",")
17384                    .to_string(),
17385            )]),
17386        };
17387    }
17388    if let Some(ref local_var_str) = tenant {
17389        local_var_req_builder = match "multi" {
17390            "multi" => local_var_req_builder.query(
17391                &local_var_str
17392                    .into_iter()
17393                    .map(|p| ("tenant".to_owned(), p.to_string()))
17394                    .collect::<Vec<(std::string::String, std::string::String)>>(),
17395            ),
17396            _ => local_var_req_builder.query(&[(
17397                "tenant",
17398                &local_var_str
17399                    .into_iter()
17400                    .map(|p| p.to_string())
17401                    .collect::<Vec<String>>()
17402                    .join(",")
17403                    .to_string(),
17404            )]),
17405        };
17406    }
17407    if let Some(ref local_var_str) = tenant__isnull {
17408        local_var_req_builder =
17409            local_var_req_builder.query(&[("tenant__isnull", &local_var_str.to_string())]);
17410    }
17411    if let Some(ref local_var_str) = tenant__n {
17412        local_var_req_builder = match "multi" {
17413            "multi" => local_var_req_builder.query(
17414                &local_var_str
17415                    .into_iter()
17416                    .map(|p| ("tenant__n".to_owned(), p.to_string()))
17417                    .collect::<Vec<(std::string::String, std::string::String)>>(),
17418            ),
17419            _ => local_var_req_builder.query(&[(
17420                "tenant__n",
17421                &local_var_str
17422                    .into_iter()
17423                    .map(|p| p.to_string())
17424                    .collect::<Vec<String>>()
17425                    .join(",")
17426                    .to_string(),
17427            )]),
17428        };
17429    }
17430    if let Some(ref local_var_str) = tenant_group {
17431        local_var_req_builder = match "multi" {
17432            "multi" => local_var_req_builder.query(
17433                &local_var_str
17434                    .into_iter()
17435                    .map(|p| ("tenant_group".to_owned(), p.to_string()))
17436                    .collect::<Vec<(std::string::String, std::string::String)>>(),
17437            ),
17438            _ => local_var_req_builder.query(&[(
17439                "tenant_group",
17440                &local_var_str
17441                    .into_iter()
17442                    .map(|p| p.to_string())
17443                    .collect::<Vec<String>>()
17444                    .join(",")
17445                    .to_string(),
17446            )]),
17447        };
17448    }
17449    if let Some(ref local_var_str) = tenant_group__isnull {
17450        local_var_req_builder =
17451            local_var_req_builder.query(&[("tenant_group__isnull", &local_var_str.to_string())]);
17452    }
17453    if let Some(ref local_var_str) = tenant_group__n {
17454        local_var_req_builder = match "multi" {
17455            "multi" => local_var_req_builder.query(
17456                &local_var_str
17457                    .into_iter()
17458                    .map(|p| ("tenant_group__n".to_owned(), p.to_string()))
17459                    .collect::<Vec<(std::string::String, std::string::String)>>(),
17460            ),
17461            _ => local_var_req_builder.query(&[(
17462                "tenant_group__n",
17463                &local_var_str
17464                    .into_iter()
17465                    .map(|p| p.to_string())
17466                    .collect::<Vec<String>>()
17467                    .join(",")
17468                    .to_string(),
17469            )]),
17470        };
17471    }
17472    if let Some(ref local_var_str) = tenant_id {
17473        local_var_req_builder = match "multi" {
17474            "multi" => local_var_req_builder.query(
17475                &local_var_str
17476                    .into_iter()
17477                    .map(|p| ("tenant_id".to_owned(), p.to_string()))
17478                    .collect::<Vec<(std::string::String, std::string::String)>>(),
17479            ),
17480            _ => local_var_req_builder.query(&[(
17481                "tenant_id",
17482                &local_var_str
17483                    .into_iter()
17484                    .map(|p| p.to_string())
17485                    .collect::<Vec<String>>()
17486                    .join(",")
17487                    .to_string(),
17488            )]),
17489        };
17490    }
17491    if let Some(ref local_var_str) = tenant_id__isnull {
17492        local_var_req_builder =
17493            local_var_req_builder.query(&[("tenant_id__isnull", &local_var_str.to_string())]);
17494    }
17495    if let Some(ref local_var_str) = tenant_id__n {
17496        local_var_req_builder = match "multi" {
17497            "multi" => local_var_req_builder.query(
17498                &local_var_str
17499                    .into_iter()
17500                    .map(|p| ("tenant_id__n".to_owned(), p.to_string()))
17501                    .collect::<Vec<(std::string::String, std::string::String)>>(),
17502            ),
17503            _ => local_var_req_builder.query(&[(
17504                "tenant_id__n",
17505                &local_var_str
17506                    .into_iter()
17507                    .map(|p| p.to_string())
17508                    .collect::<Vec<String>>()
17509                    .join(",")
17510                    .to_string(),
17511            )]),
17512        };
17513    }
17514    if let Some(ref local_var_str) = vpn_id {
17515        local_var_req_builder = match "multi" {
17516            "multi" => local_var_req_builder.query(
17517                &local_var_str
17518                    .into_iter()
17519                    .map(|p| ("vpn_id".to_owned(), p.to_string()))
17520                    .collect::<Vec<(std::string::String, std::string::String)>>(),
17521            ),
17522            _ => local_var_req_builder.query(&[(
17523                "vpn_id",
17524                &local_var_str
17525                    .into_iter()
17526                    .map(|p| p.to_string())
17527                    .collect::<Vec<String>>()
17528                    .join(",")
17529                    .to_string(),
17530            )]),
17531        };
17532    }
17533    if let Some(ref local_var_str) = vpn_id__ic {
17534        local_var_req_builder = match "multi" {
17535            "multi" => local_var_req_builder.query(
17536                &local_var_str
17537                    .into_iter()
17538                    .map(|p| ("vpn_id__ic".to_owned(), p.to_string()))
17539                    .collect::<Vec<(std::string::String, std::string::String)>>(),
17540            ),
17541            _ => local_var_req_builder.query(&[(
17542                "vpn_id__ic",
17543                &local_var_str
17544                    .into_iter()
17545                    .map(|p| p.to_string())
17546                    .collect::<Vec<String>>()
17547                    .join(",")
17548                    .to_string(),
17549            )]),
17550        };
17551    }
17552    if let Some(ref local_var_str) = vpn_id__ie {
17553        local_var_req_builder = match "multi" {
17554            "multi" => local_var_req_builder.query(
17555                &local_var_str
17556                    .into_iter()
17557                    .map(|p| ("vpn_id__ie".to_owned(), p.to_string()))
17558                    .collect::<Vec<(std::string::String, std::string::String)>>(),
17559            ),
17560            _ => local_var_req_builder.query(&[(
17561                "vpn_id__ie",
17562                &local_var_str
17563                    .into_iter()
17564                    .map(|p| p.to_string())
17565                    .collect::<Vec<String>>()
17566                    .join(",")
17567                    .to_string(),
17568            )]),
17569        };
17570    }
17571    if let Some(ref local_var_str) = vpn_id__iew {
17572        local_var_req_builder = match "multi" {
17573            "multi" => local_var_req_builder.query(
17574                &local_var_str
17575                    .into_iter()
17576                    .map(|p| ("vpn_id__iew".to_owned(), p.to_string()))
17577                    .collect::<Vec<(std::string::String, std::string::String)>>(),
17578            ),
17579            _ => local_var_req_builder.query(&[(
17580                "vpn_id__iew",
17581                &local_var_str
17582                    .into_iter()
17583                    .map(|p| p.to_string())
17584                    .collect::<Vec<String>>()
17585                    .join(",")
17586                    .to_string(),
17587            )]),
17588        };
17589    }
17590    if let Some(ref local_var_str) = vpn_id__ire {
17591        local_var_req_builder = match "multi" {
17592            "multi" => local_var_req_builder.query(
17593                &local_var_str
17594                    .into_iter()
17595                    .map(|p| ("vpn_id__ire".to_owned(), p.to_string()))
17596                    .collect::<Vec<(std::string::String, std::string::String)>>(),
17597            ),
17598            _ => local_var_req_builder.query(&[(
17599                "vpn_id__ire",
17600                &local_var_str
17601                    .into_iter()
17602                    .map(|p| p.to_string())
17603                    .collect::<Vec<String>>()
17604                    .join(",")
17605                    .to_string(),
17606            )]),
17607        };
17608    }
17609    if let Some(ref local_var_str) = vpn_id__isw {
17610        local_var_req_builder = match "multi" {
17611            "multi" => local_var_req_builder.query(
17612                &local_var_str
17613                    .into_iter()
17614                    .map(|p| ("vpn_id__isw".to_owned(), p.to_string()))
17615                    .collect::<Vec<(std::string::String, std::string::String)>>(),
17616            ),
17617            _ => local_var_req_builder.query(&[(
17618                "vpn_id__isw",
17619                &local_var_str
17620                    .into_iter()
17621                    .map(|p| p.to_string())
17622                    .collect::<Vec<String>>()
17623                    .join(",")
17624                    .to_string(),
17625            )]),
17626        };
17627    }
17628    if let Some(ref local_var_str) = vpn_id__n {
17629        local_var_req_builder = match "multi" {
17630            "multi" => local_var_req_builder.query(
17631                &local_var_str
17632                    .into_iter()
17633                    .map(|p| ("vpn_id__n".to_owned(), p.to_string()))
17634                    .collect::<Vec<(std::string::String, std::string::String)>>(),
17635            ),
17636            _ => local_var_req_builder.query(&[(
17637                "vpn_id__n",
17638                &local_var_str
17639                    .into_iter()
17640                    .map(|p| p.to_string())
17641                    .collect::<Vec<String>>()
17642                    .join(",")
17643                    .to_string(),
17644            )]),
17645        };
17646    }
17647    if let Some(ref local_var_str) = vpn_id__nic {
17648        local_var_req_builder = match "multi" {
17649            "multi" => local_var_req_builder.query(
17650                &local_var_str
17651                    .into_iter()
17652                    .map(|p| ("vpn_id__nic".to_owned(), p.to_string()))
17653                    .collect::<Vec<(std::string::String, std::string::String)>>(),
17654            ),
17655            _ => local_var_req_builder.query(&[(
17656                "vpn_id__nic",
17657                &local_var_str
17658                    .into_iter()
17659                    .map(|p| p.to_string())
17660                    .collect::<Vec<String>>()
17661                    .join(",")
17662                    .to_string(),
17663            )]),
17664        };
17665    }
17666    if let Some(ref local_var_str) = vpn_id__nie {
17667        local_var_req_builder = match "multi" {
17668            "multi" => local_var_req_builder.query(
17669                &local_var_str
17670                    .into_iter()
17671                    .map(|p| ("vpn_id__nie".to_owned(), p.to_string()))
17672                    .collect::<Vec<(std::string::String, std::string::String)>>(),
17673            ),
17674            _ => local_var_req_builder.query(&[(
17675                "vpn_id__nie",
17676                &local_var_str
17677                    .into_iter()
17678                    .map(|p| p.to_string())
17679                    .collect::<Vec<String>>()
17680                    .join(",")
17681                    .to_string(),
17682            )]),
17683        };
17684    }
17685    if let Some(ref local_var_str) = vpn_id__niew {
17686        local_var_req_builder = match "multi" {
17687            "multi" => local_var_req_builder.query(
17688                &local_var_str
17689                    .into_iter()
17690                    .map(|p| ("vpn_id__niew".to_owned(), p.to_string()))
17691                    .collect::<Vec<(std::string::String, std::string::String)>>(),
17692            ),
17693            _ => local_var_req_builder.query(&[(
17694                "vpn_id__niew",
17695                &local_var_str
17696                    .into_iter()
17697                    .map(|p| p.to_string())
17698                    .collect::<Vec<String>>()
17699                    .join(",")
17700                    .to_string(),
17701            )]),
17702        };
17703    }
17704    if let Some(ref local_var_str) = vpn_id__nire {
17705        local_var_req_builder = match "multi" {
17706            "multi" => local_var_req_builder.query(
17707                &local_var_str
17708                    .into_iter()
17709                    .map(|p| ("vpn_id__nire".to_owned(), p.to_string()))
17710                    .collect::<Vec<(std::string::String, std::string::String)>>(),
17711            ),
17712            _ => local_var_req_builder.query(&[(
17713                "vpn_id__nire",
17714                &local_var_str
17715                    .into_iter()
17716                    .map(|p| p.to_string())
17717                    .collect::<Vec<String>>()
17718                    .join(",")
17719                    .to_string(),
17720            )]),
17721        };
17722    }
17723    if let Some(ref local_var_str) = vpn_id__nisw {
17724        local_var_req_builder = match "multi" {
17725            "multi" => local_var_req_builder.query(
17726                &local_var_str
17727                    .into_iter()
17728                    .map(|p| ("vpn_id__nisw".to_owned(), p.to_string()))
17729                    .collect::<Vec<(std::string::String, std::string::String)>>(),
17730            ),
17731            _ => local_var_req_builder.query(&[(
17732                "vpn_id__nisw",
17733                &local_var_str
17734                    .into_iter()
17735                    .map(|p| p.to_string())
17736                    .collect::<Vec<String>>()
17737                    .join(",")
17738                    .to_string(),
17739            )]),
17740        };
17741    }
17742    if let Some(ref local_var_str) = vpn_id__nre {
17743        local_var_req_builder = match "multi" {
17744            "multi" => local_var_req_builder.query(
17745                &local_var_str
17746                    .into_iter()
17747                    .map(|p| ("vpn_id__nre".to_owned(), p.to_string()))
17748                    .collect::<Vec<(std::string::String, std::string::String)>>(),
17749            ),
17750            _ => local_var_req_builder.query(&[(
17751                "vpn_id__nre",
17752                &local_var_str
17753                    .into_iter()
17754                    .map(|p| p.to_string())
17755                    .collect::<Vec<String>>()
17756                    .join(",")
17757                    .to_string(),
17758            )]),
17759        };
17760    }
17761    if let Some(ref local_var_str) = vpn_id__re {
17762        local_var_req_builder = match "multi" {
17763            "multi" => local_var_req_builder.query(
17764                &local_var_str
17765                    .into_iter()
17766                    .map(|p| ("vpn_id__re".to_owned(), p.to_string()))
17767                    .collect::<Vec<(std::string::String, std::string::String)>>(),
17768            ),
17769            _ => local_var_req_builder.query(&[(
17770                "vpn_id__re",
17771                &local_var_str
17772                    .into_iter()
17773                    .map(|p| p.to_string())
17774                    .collect::<Vec<String>>()
17775                    .join(",")
17776                    .to_string(),
17777            )]),
17778        };
17779    }
17780    if let Some(ref local_var_str) = vpn_profile {
17781        local_var_req_builder = match "multi" {
17782            "multi" => local_var_req_builder.query(
17783                &local_var_str
17784                    .into_iter()
17785                    .map(|p| ("vpn_profile".to_owned(), p.to_string()))
17786                    .collect::<Vec<(std::string::String, std::string::String)>>(),
17787            ),
17788            _ => local_var_req_builder.query(&[(
17789                "vpn_profile",
17790                &local_var_str
17791                    .into_iter()
17792                    .map(|p| p.to_string())
17793                    .collect::<Vec<String>>()
17794                    .join(",")
17795                    .to_string(),
17796            )]),
17797        };
17798    }
17799    if let Some(ref local_var_str) = vpn_profile__isnull {
17800        local_var_req_builder =
17801            local_var_req_builder.query(&[("vpn_profile__isnull", &local_var_str.to_string())]);
17802    }
17803    if let Some(ref local_var_str) = vpn_profile__n {
17804        local_var_req_builder = match "multi" {
17805            "multi" => local_var_req_builder.query(
17806                &local_var_str
17807                    .into_iter()
17808                    .map(|p| ("vpn_profile__n".to_owned(), p.to_string()))
17809                    .collect::<Vec<(std::string::String, std::string::String)>>(),
17810            ),
17811            _ => local_var_req_builder.query(&[(
17812                "vpn_profile__n",
17813                &local_var_str
17814                    .into_iter()
17815                    .map(|p| p.to_string())
17816                    .collect::<Vec<String>>()
17817                    .join(",")
17818                    .to_string(),
17819            )]),
17820        };
17821    }
17822    if let Some(ref local_var_str) = depth {
17823        local_var_req_builder =
17824            local_var_req_builder.query(&[("depth", &local_var_str.to_string())]);
17825    }
17826    if let Some(ref local_var_str) = exclude_m2m {
17827        local_var_req_builder =
17828            local_var_req_builder.query(&[("exclude_m2m", &local_var_str.to_string())]);
17829    }
17830    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
17831        local_var_req_builder =
17832            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
17833    }
17834    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
17835        let local_var_key = local_var_apikey.key.clone();
17836        let local_var_value = match local_var_apikey.prefix {
17837            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
17838            None => local_var_key,
17839        };
17840        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
17841    };
17842
17843    let local_var_req = local_var_req_builder.build()?;
17844    let local_var_resp = local_var_client.execute(local_var_req).await?;
17845
17846    let local_var_status = local_var_resp.status();
17847    let local_var_content = local_var_resp.text().await?;
17848
17849    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
17850        serde_json::from_str(&local_var_content).map_err(Error::from)
17851    } else {
17852        let local_var_entity: Option<VpnVpnsListError> =
17853            serde_json::from_str(&local_var_content).ok();
17854        let local_var_error = ResponseContent {
17855            status: local_var_status,
17856            content: local_var_content,
17857            entity: local_var_entity,
17858        };
17859        Err(Error::ResponseError(local_var_error))
17860    }
17861}
17862
17863/// API methods for returning or creating notes on an object.
17864pub async fn vpn_vpns_notes_create(
17865    configuration: &configuration::Configuration,
17866    id: &str,
17867    note_input_request: crate::models::NoteInputRequest,
17868    format: Option<&str>,
17869) -> Result<crate::models::Note, Error<VpnVpnsNotesCreateError>> {
17870    let local_var_configuration = configuration;
17871
17872    let local_var_client = &local_var_configuration.client;
17873
17874    let local_var_uri_str = format!(
17875        "{}/vpn/vpns/{id}/notes/",
17876        local_var_configuration.base_path,
17877        id = crate::apis::urlencode(id)
17878    );
17879    let mut local_var_req_builder =
17880        local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
17881
17882    if let Some(ref local_var_str) = format {
17883        local_var_req_builder =
17884            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
17885    }
17886    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
17887        local_var_req_builder =
17888            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
17889    }
17890    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
17891        let local_var_key = local_var_apikey.key.clone();
17892        let local_var_value = match local_var_apikey.prefix {
17893            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
17894            None => local_var_key,
17895        };
17896        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
17897    };
17898    local_var_req_builder = local_var_req_builder.json(&note_input_request);
17899
17900    let local_var_req = local_var_req_builder.build()?;
17901    let local_var_resp = local_var_client.execute(local_var_req).await?;
17902
17903    let local_var_status = local_var_resp.status();
17904    let local_var_content = local_var_resp.text().await?;
17905
17906    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
17907        serde_json::from_str(&local_var_content).map_err(Error::from)
17908    } else {
17909        let local_var_entity: Option<VpnVpnsNotesCreateError> =
17910            serde_json::from_str(&local_var_content).ok();
17911        let local_var_error = ResponseContent {
17912            status: local_var_status,
17913            content: local_var_content,
17914            entity: local_var_entity,
17915        };
17916        Err(Error::ResponseError(local_var_error))
17917    }
17918}
17919
17920/// API methods for returning or creating notes on an object.
17921pub async fn vpn_vpns_notes_list(
17922    configuration: &configuration::Configuration,
17923    id: &str,
17924    format: Option<&str>,
17925    limit: Option<i32>,
17926    offset: Option<i32>,
17927    depth: Option<i32>,
17928    exclude_m2m: Option<bool>,
17929) -> Result<crate::models::PaginatedNoteList, Error<VpnVpnsNotesListError>> {
17930    let local_var_configuration = configuration;
17931
17932    let local_var_client = &local_var_configuration.client;
17933
17934    let local_var_uri_str = format!(
17935        "{}/vpn/vpns/{id}/notes/",
17936        local_var_configuration.base_path,
17937        id = crate::apis::urlencode(id)
17938    );
17939    let mut local_var_req_builder =
17940        local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
17941
17942    if let Some(ref local_var_str) = format {
17943        local_var_req_builder =
17944            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
17945    }
17946    if let Some(ref local_var_str) = limit {
17947        local_var_req_builder =
17948            local_var_req_builder.query(&[("limit", &local_var_str.to_string())]);
17949    }
17950    if let Some(ref local_var_str) = offset {
17951        local_var_req_builder =
17952            local_var_req_builder.query(&[("offset", &local_var_str.to_string())]);
17953    }
17954    if let Some(ref local_var_str) = depth {
17955        local_var_req_builder =
17956            local_var_req_builder.query(&[("depth", &local_var_str.to_string())]);
17957    }
17958    if let Some(ref local_var_str) = exclude_m2m {
17959        local_var_req_builder =
17960            local_var_req_builder.query(&[("exclude_m2m", &local_var_str.to_string())]);
17961    }
17962    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
17963        local_var_req_builder =
17964            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
17965    }
17966    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
17967        let local_var_key = local_var_apikey.key.clone();
17968        let local_var_value = match local_var_apikey.prefix {
17969            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
17970            None => local_var_key,
17971        };
17972        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
17973    };
17974
17975    let local_var_req = local_var_req_builder.build()?;
17976    let local_var_resp = local_var_client.execute(local_var_req).await?;
17977
17978    let local_var_status = local_var_resp.status();
17979    let local_var_content = local_var_resp.text().await?;
17980
17981    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
17982        serde_json::from_str(&local_var_content).map_err(Error::from)
17983    } else {
17984        let local_var_entity: Option<VpnVpnsNotesListError> =
17985            serde_json::from_str(&local_var_content).ok();
17986        let local_var_error = ResponseContent {
17987            status: local_var_status,
17988            content: local_var_content,
17989            entity: local_var_entity,
17990        };
17991        Err(Error::ResponseError(local_var_error))
17992    }
17993}
17994
17995/// VPN viewset.
17996pub async fn vpn_vpns_partial_update(
17997    configuration: &configuration::Configuration,
17998    id: &str,
17999    format: Option<&str>,
18000    patched_vpn_request: Option<crate::models::PatchedVpnRequest>,
18001) -> Result<crate::models::Vpn, Error<VpnVpnsPartialUpdateError>> {
18002    let local_var_configuration = configuration;
18003
18004    let local_var_client = &local_var_configuration.client;
18005
18006    let local_var_uri_str = format!(
18007        "{}/vpn/vpns/{id}/",
18008        local_var_configuration.base_path,
18009        id = crate::apis::urlencode(id)
18010    );
18011    let mut local_var_req_builder =
18012        local_var_client.request(reqwest::Method::PATCH, local_var_uri_str.as_str());
18013
18014    if let Some(ref local_var_str) = format {
18015        local_var_req_builder =
18016            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
18017    }
18018    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
18019        local_var_req_builder =
18020            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
18021    }
18022    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
18023        let local_var_key = local_var_apikey.key.clone();
18024        let local_var_value = match local_var_apikey.prefix {
18025            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
18026            None => local_var_key,
18027        };
18028        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
18029    };
18030    local_var_req_builder = local_var_req_builder.json(&patched_vpn_request);
18031
18032    let local_var_req = local_var_req_builder.build()?;
18033    let local_var_resp = local_var_client.execute(local_var_req).await?;
18034
18035    let local_var_status = local_var_resp.status();
18036    let local_var_content = local_var_resp.text().await?;
18037
18038    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
18039        serde_json::from_str(&local_var_content).map_err(Error::from)
18040    } else {
18041        let local_var_entity: Option<VpnVpnsPartialUpdateError> =
18042            serde_json::from_str(&local_var_content).ok();
18043        let local_var_error = ResponseContent {
18044            status: local_var_status,
18045            content: local_var_content,
18046            entity: local_var_entity,
18047        };
18048        Err(Error::ResponseError(local_var_error))
18049    }
18050}
18051
18052/// VPN viewset.
18053pub async fn vpn_vpns_retrieve(
18054    configuration: &configuration::Configuration,
18055    id: &str,
18056    format: Option<&str>,
18057    depth: Option<i32>,
18058    exclude_m2m: Option<bool>,
18059) -> Result<crate::models::Vpn, Error<VpnVpnsRetrieveError>> {
18060    let local_var_configuration = configuration;
18061
18062    let local_var_client = &local_var_configuration.client;
18063
18064    let local_var_uri_str = format!(
18065        "{}/vpn/vpns/{id}/",
18066        local_var_configuration.base_path,
18067        id = crate::apis::urlencode(id)
18068    );
18069    let mut local_var_req_builder =
18070        local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
18071
18072    if let Some(ref local_var_str) = format {
18073        local_var_req_builder =
18074            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
18075    }
18076    if let Some(ref local_var_str) = depth {
18077        local_var_req_builder =
18078            local_var_req_builder.query(&[("depth", &local_var_str.to_string())]);
18079    }
18080    if let Some(ref local_var_str) = exclude_m2m {
18081        local_var_req_builder =
18082            local_var_req_builder.query(&[("exclude_m2m", &local_var_str.to_string())]);
18083    }
18084    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
18085        local_var_req_builder =
18086            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
18087    }
18088    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
18089        let local_var_key = local_var_apikey.key.clone();
18090        let local_var_value = match local_var_apikey.prefix {
18091            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
18092            None => local_var_key,
18093        };
18094        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
18095    };
18096
18097    let local_var_req = local_var_req_builder.build()?;
18098    let local_var_resp = local_var_client.execute(local_var_req).await?;
18099
18100    let local_var_status = local_var_resp.status();
18101    let local_var_content = local_var_resp.text().await?;
18102
18103    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
18104        serde_json::from_str(&local_var_content).map_err(Error::from)
18105    } else {
18106        let local_var_entity: Option<VpnVpnsRetrieveError> =
18107            serde_json::from_str(&local_var_content).ok();
18108        let local_var_error = ResponseContent {
18109            status: local_var_status,
18110            content: local_var_content,
18111            entity: local_var_entity,
18112        };
18113        Err(Error::ResponseError(local_var_error))
18114    }
18115}
18116
18117/// VPN viewset.
18118pub async fn vpn_vpns_update(
18119    configuration: &configuration::Configuration,
18120    id: &str,
18121    vpn_request: crate::models::VpnRequest,
18122    format: Option<&str>,
18123) -> Result<crate::models::Vpn, Error<VpnVpnsUpdateError>> {
18124    let local_var_configuration = configuration;
18125
18126    let local_var_client = &local_var_configuration.client;
18127
18128    let local_var_uri_str = format!(
18129        "{}/vpn/vpns/{id}/",
18130        local_var_configuration.base_path,
18131        id = crate::apis::urlencode(id)
18132    );
18133    let mut local_var_req_builder =
18134        local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());
18135
18136    if let Some(ref local_var_str) = format {
18137        local_var_req_builder =
18138            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
18139    }
18140    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
18141        local_var_req_builder =
18142            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
18143    }
18144    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
18145        let local_var_key = local_var_apikey.key.clone();
18146        let local_var_value = match local_var_apikey.prefix {
18147            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
18148            None => local_var_key,
18149        };
18150        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
18151    };
18152    local_var_req_builder = local_var_req_builder.json(&vpn_request);
18153
18154    let local_var_req = local_var_req_builder.build()?;
18155    let local_var_resp = local_var_client.execute(local_var_req).await?;
18156
18157    let local_var_status = local_var_resp.status();
18158    let local_var_content = local_var_resp.text().await?;
18159
18160    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
18161        serde_json::from_str(&local_var_content).map_err(Error::from)
18162    } else {
18163        let local_var_entity: Option<VpnVpnsUpdateError> =
18164            serde_json::from_str(&local_var_content).ok();
18165        let local_var_error = ResponseContent {
18166            status: local_var_status,
18167            content: local_var_content,
18168            entity: local_var_entity,
18169        };
18170        Err(Error::ResponseError(local_var_error))
18171    }
18172}
nautobot_openapi/apis/vpn_api.rs

nautobot_openapi/apis/
vpn_api.rs
