nautobot_openapi/apis/
load_balancers_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 [`load_balancers_certificate_profiles_bulk_destroy`]
17#[derive(Debug, Clone, Serialize, Deserialize)]
18#[serde(untagged)]
19pub enum LoadBalancersCertificateProfilesBulkDestroyError {
20    UnknownValue(serde_json::Value),
21}
22
23/// struct for typed errors of method [`load_balancers_certificate_profiles_bulk_partial_update`]
24#[derive(Debug, Clone, Serialize, Deserialize)]
25#[serde(untagged)]
26pub enum LoadBalancersCertificateProfilesBulkPartialUpdateError {
27    UnknownValue(serde_json::Value),
28}
29
30/// struct for typed errors of method [`load_balancers_certificate_profiles_bulk_update`]
31#[derive(Debug, Clone, Serialize, Deserialize)]
32#[serde(untagged)]
33pub enum LoadBalancersCertificateProfilesBulkUpdateError {
34    UnknownValue(serde_json::Value),
35}
36
37/// struct for typed errors of method [`load_balancers_certificate_profiles_create`]
38#[derive(Debug, Clone, Serialize, Deserialize)]
39#[serde(untagged)]
40pub enum LoadBalancersCertificateProfilesCreateError {
41    UnknownValue(serde_json::Value),
42}
43
44/// struct for typed errors of method [`load_balancers_certificate_profiles_destroy`]
45#[derive(Debug, Clone, Serialize, Deserialize)]
46#[serde(untagged)]
47pub enum LoadBalancersCertificateProfilesDestroyError {
48    UnknownValue(serde_json::Value),
49}
50
51/// struct for typed errors of method [`load_balancers_certificate_profiles_list`]
52#[derive(Debug, Clone, Serialize, Deserialize)]
53#[serde(untagged)]
54pub enum LoadBalancersCertificateProfilesListError {
55    UnknownValue(serde_json::Value),
56}
57
58/// struct for typed errors of method [`load_balancers_certificate_profiles_notes_create`]
59#[derive(Debug, Clone, Serialize, Deserialize)]
60#[serde(untagged)]
61pub enum LoadBalancersCertificateProfilesNotesCreateError {
62    UnknownValue(serde_json::Value),
63}
64
65/// struct for typed errors of method [`load_balancers_certificate_profiles_notes_list`]
66#[derive(Debug, Clone, Serialize, Deserialize)]
67#[serde(untagged)]
68pub enum LoadBalancersCertificateProfilesNotesListError {
69    UnknownValue(serde_json::Value),
70}
71
72/// struct for typed errors of method [`load_balancers_certificate_profiles_partial_update`]
73#[derive(Debug, Clone, Serialize, Deserialize)]
74#[serde(untagged)]
75pub enum LoadBalancersCertificateProfilesPartialUpdateError {
76    UnknownValue(serde_json::Value),
77}
78
79/// struct for typed errors of method [`load_balancers_certificate_profiles_retrieve`]
80#[derive(Debug, Clone, Serialize, Deserialize)]
81#[serde(untagged)]
82pub enum LoadBalancersCertificateProfilesRetrieveError {
83    UnknownValue(serde_json::Value),
84}
85
86/// struct for typed errors of method [`load_balancers_certificate_profiles_update`]
87#[derive(Debug, Clone, Serialize, Deserialize)]
88#[serde(untagged)]
89pub enum LoadBalancersCertificateProfilesUpdateError {
90    UnknownValue(serde_json::Value),
91}
92
93/// struct for typed errors of method [`load_balancers_health_check_monitors_bulk_destroy`]
94#[derive(Debug, Clone, Serialize, Deserialize)]
95#[serde(untagged)]
96pub enum LoadBalancersHealthCheckMonitorsBulkDestroyError {
97    UnknownValue(serde_json::Value),
98}
99
100/// struct for typed errors of method [`load_balancers_health_check_monitors_bulk_partial_update`]
101#[derive(Debug, Clone, Serialize, Deserialize)]
102#[serde(untagged)]
103pub enum LoadBalancersHealthCheckMonitorsBulkPartialUpdateError {
104    UnknownValue(serde_json::Value),
105}
106
107/// struct for typed errors of method [`load_balancers_health_check_monitors_bulk_update`]
108#[derive(Debug, Clone, Serialize, Deserialize)]
109#[serde(untagged)]
110pub enum LoadBalancersHealthCheckMonitorsBulkUpdateError {
111    UnknownValue(serde_json::Value),
112}
113
114/// struct for typed errors of method [`load_balancers_health_check_monitors_create`]
115#[derive(Debug, Clone, Serialize, Deserialize)]
116#[serde(untagged)]
117pub enum LoadBalancersHealthCheckMonitorsCreateError {
118    UnknownValue(serde_json::Value),
119}
120
121/// struct for typed errors of method [`load_balancers_health_check_monitors_destroy`]
122#[derive(Debug, Clone, Serialize, Deserialize)]
123#[serde(untagged)]
124pub enum LoadBalancersHealthCheckMonitorsDestroyError {
125    UnknownValue(serde_json::Value),
126}
127
128/// struct for typed errors of method [`load_balancers_health_check_monitors_list`]
129#[derive(Debug, Clone, Serialize, Deserialize)]
130#[serde(untagged)]
131pub enum LoadBalancersHealthCheckMonitorsListError {
132    UnknownValue(serde_json::Value),
133}
134
135/// struct for typed errors of method [`load_balancers_health_check_monitors_notes_create`]
136#[derive(Debug, Clone, Serialize, Deserialize)]
137#[serde(untagged)]
138pub enum LoadBalancersHealthCheckMonitorsNotesCreateError {
139    UnknownValue(serde_json::Value),
140}
141
142/// struct for typed errors of method [`load_balancers_health_check_monitors_notes_list`]
143#[derive(Debug, Clone, Serialize, Deserialize)]
144#[serde(untagged)]
145pub enum LoadBalancersHealthCheckMonitorsNotesListError {
146    UnknownValue(serde_json::Value),
147}
148
149/// struct for typed errors of method [`load_balancers_health_check_monitors_partial_update`]
150#[derive(Debug, Clone, Serialize, Deserialize)]
151#[serde(untagged)]
152pub enum LoadBalancersHealthCheckMonitorsPartialUpdateError {
153    UnknownValue(serde_json::Value),
154}
155
156/// struct for typed errors of method [`load_balancers_health_check_monitors_retrieve`]
157#[derive(Debug, Clone, Serialize, Deserialize)]
158#[serde(untagged)]
159pub enum LoadBalancersHealthCheckMonitorsRetrieveError {
160    UnknownValue(serde_json::Value),
161}
162
163/// struct for typed errors of method [`load_balancers_health_check_monitors_update`]
164#[derive(Debug, Clone, Serialize, Deserialize)]
165#[serde(untagged)]
166pub enum LoadBalancersHealthCheckMonitorsUpdateError {
167    UnknownValue(serde_json::Value),
168}
169
170/// struct for typed errors of method [`load_balancers_load_balancer_pool_member_certificate_profile_assignments_bulk_destroy`]
171#[derive(Debug, Clone, Serialize, Deserialize)]
172#[serde(untagged)]
173pub enum LoadBalancersLoadBalancerPoolMemberCertificateProfileAssignmentsBulkDestroyError {
174    UnknownValue(serde_json::Value),
175}
176
177/// struct for typed errors of method [`load_balancers_load_balancer_pool_member_certificate_profile_assignments_bulk_partial_update`]
178#[derive(Debug, Clone, Serialize, Deserialize)]
179#[serde(untagged)]
180pub enum LoadBalancersLoadBalancerPoolMemberCertificateProfileAssignmentsBulkPartialUpdateError {
181    UnknownValue(serde_json::Value),
182}
183
184/// struct for typed errors of method [`load_balancers_load_balancer_pool_member_certificate_profile_assignments_bulk_update`]
185#[derive(Debug, Clone, Serialize, Deserialize)]
186#[serde(untagged)]
187pub enum LoadBalancersLoadBalancerPoolMemberCertificateProfileAssignmentsBulkUpdateError {
188    UnknownValue(serde_json::Value),
189}
190
191/// struct for typed errors of method [`load_balancers_load_balancer_pool_member_certificate_profile_assignments_create`]
192#[derive(Debug, Clone, Serialize, Deserialize)]
193#[serde(untagged)]
194pub enum LoadBalancersLoadBalancerPoolMemberCertificateProfileAssignmentsCreateError {
195    UnknownValue(serde_json::Value),
196}
197
198/// struct for typed errors of method [`load_balancers_load_balancer_pool_member_certificate_profile_assignments_destroy`]
199#[derive(Debug, Clone, Serialize, Deserialize)]
200#[serde(untagged)]
201pub enum LoadBalancersLoadBalancerPoolMemberCertificateProfileAssignmentsDestroyError {
202    UnknownValue(serde_json::Value),
203}
204
205/// struct for typed errors of method [`load_balancers_load_balancer_pool_member_certificate_profile_assignments_list`]
206#[derive(Debug, Clone, Serialize, Deserialize)]
207#[serde(untagged)]
208pub enum LoadBalancersLoadBalancerPoolMemberCertificateProfileAssignmentsListError {
209    UnknownValue(serde_json::Value),
210}
211
212/// struct for typed errors of method [`load_balancers_load_balancer_pool_member_certificate_profile_assignments_partial_update`]
213#[derive(Debug, Clone, Serialize, Deserialize)]
214#[serde(untagged)]
215pub enum LoadBalancersLoadBalancerPoolMemberCertificateProfileAssignmentsPartialUpdateError {
216    UnknownValue(serde_json::Value),
217}
218
219/// struct for typed errors of method [`load_balancers_load_balancer_pool_member_certificate_profile_assignments_retrieve`]
220#[derive(Debug, Clone, Serialize, Deserialize)]
221#[serde(untagged)]
222pub enum LoadBalancersLoadBalancerPoolMemberCertificateProfileAssignmentsRetrieveError {
223    UnknownValue(serde_json::Value),
224}
225
226/// struct for typed errors of method [`load_balancers_load_balancer_pool_member_certificate_profile_assignments_update`]
227#[derive(Debug, Clone, Serialize, Deserialize)]
228#[serde(untagged)]
229pub enum LoadBalancersLoadBalancerPoolMemberCertificateProfileAssignmentsUpdateError {
230    UnknownValue(serde_json::Value),
231}
232
233/// struct for typed errors of method [`load_balancers_load_balancer_pool_members_bulk_destroy`]
234#[derive(Debug, Clone, Serialize, Deserialize)]
235#[serde(untagged)]
236pub enum LoadBalancersLoadBalancerPoolMembersBulkDestroyError {
237    UnknownValue(serde_json::Value),
238}
239
240/// struct for typed errors of method [`load_balancers_load_balancer_pool_members_bulk_partial_update`]
241#[derive(Debug, Clone, Serialize, Deserialize)]
242#[serde(untagged)]
243pub enum LoadBalancersLoadBalancerPoolMembersBulkPartialUpdateError {
244    UnknownValue(serde_json::Value),
245}
246
247/// struct for typed errors of method [`load_balancers_load_balancer_pool_members_bulk_update`]
248#[derive(Debug, Clone, Serialize, Deserialize)]
249#[serde(untagged)]
250pub enum LoadBalancersLoadBalancerPoolMembersBulkUpdateError {
251    UnknownValue(serde_json::Value),
252}
253
254/// struct for typed errors of method [`load_balancers_load_balancer_pool_members_create`]
255#[derive(Debug, Clone, Serialize, Deserialize)]
256#[serde(untagged)]
257pub enum LoadBalancersLoadBalancerPoolMembersCreateError {
258    UnknownValue(serde_json::Value),
259}
260
261/// struct for typed errors of method [`load_balancers_load_balancer_pool_members_destroy`]
262#[derive(Debug, Clone, Serialize, Deserialize)]
263#[serde(untagged)]
264pub enum LoadBalancersLoadBalancerPoolMembersDestroyError {
265    UnknownValue(serde_json::Value),
266}
267
268/// struct for typed errors of method [`load_balancers_load_balancer_pool_members_list`]
269#[derive(Debug, Clone, Serialize, Deserialize)]
270#[serde(untagged)]
271pub enum LoadBalancersLoadBalancerPoolMembersListError {
272    UnknownValue(serde_json::Value),
273}
274
275/// struct for typed errors of method [`load_balancers_load_balancer_pool_members_notes_create`]
276#[derive(Debug, Clone, Serialize, Deserialize)]
277#[serde(untagged)]
278pub enum LoadBalancersLoadBalancerPoolMembersNotesCreateError {
279    UnknownValue(serde_json::Value),
280}
281
282/// struct for typed errors of method [`load_balancers_load_balancer_pool_members_notes_list`]
283#[derive(Debug, Clone, Serialize, Deserialize)]
284#[serde(untagged)]
285pub enum LoadBalancersLoadBalancerPoolMembersNotesListError {
286    UnknownValue(serde_json::Value),
287}
288
289/// struct for typed errors of method [`load_balancers_load_balancer_pool_members_partial_update`]
290#[derive(Debug, Clone, Serialize, Deserialize)]
291#[serde(untagged)]
292pub enum LoadBalancersLoadBalancerPoolMembersPartialUpdateError {
293    UnknownValue(serde_json::Value),
294}
295
296/// struct for typed errors of method [`load_balancers_load_balancer_pool_members_retrieve`]
297#[derive(Debug, Clone, Serialize, Deserialize)]
298#[serde(untagged)]
299pub enum LoadBalancersLoadBalancerPoolMembersRetrieveError {
300    UnknownValue(serde_json::Value),
301}
302
303/// struct for typed errors of method [`load_balancers_load_balancer_pool_members_update`]
304#[derive(Debug, Clone, Serialize, Deserialize)]
305#[serde(untagged)]
306pub enum LoadBalancersLoadBalancerPoolMembersUpdateError {
307    UnknownValue(serde_json::Value),
308}
309
310/// struct for typed errors of method [`load_balancers_load_balancer_pools_bulk_destroy`]
311#[derive(Debug, Clone, Serialize, Deserialize)]
312#[serde(untagged)]
313pub enum LoadBalancersLoadBalancerPoolsBulkDestroyError {
314    UnknownValue(serde_json::Value),
315}
316
317/// struct for typed errors of method [`load_balancers_load_balancer_pools_bulk_partial_update`]
318#[derive(Debug, Clone, Serialize, Deserialize)]
319#[serde(untagged)]
320pub enum LoadBalancersLoadBalancerPoolsBulkPartialUpdateError {
321    UnknownValue(serde_json::Value),
322}
323
324/// struct for typed errors of method [`load_balancers_load_balancer_pools_bulk_update`]
325#[derive(Debug, Clone, Serialize, Deserialize)]
326#[serde(untagged)]
327pub enum LoadBalancersLoadBalancerPoolsBulkUpdateError {
328    UnknownValue(serde_json::Value),
329}
330
331/// struct for typed errors of method [`load_balancers_load_balancer_pools_create`]
332#[derive(Debug, Clone, Serialize, Deserialize)]
333#[serde(untagged)]
334pub enum LoadBalancersLoadBalancerPoolsCreateError {
335    UnknownValue(serde_json::Value),
336}
337
338/// struct for typed errors of method [`load_balancers_load_balancer_pools_destroy`]
339#[derive(Debug, Clone, Serialize, Deserialize)]
340#[serde(untagged)]
341pub enum LoadBalancersLoadBalancerPoolsDestroyError {
342    UnknownValue(serde_json::Value),
343}
344
345/// struct for typed errors of method [`load_balancers_load_balancer_pools_list`]
346#[derive(Debug, Clone, Serialize, Deserialize)]
347#[serde(untagged)]
348pub enum LoadBalancersLoadBalancerPoolsListError {
349    UnknownValue(serde_json::Value),
350}
351
352/// struct for typed errors of method [`load_balancers_load_balancer_pools_notes_create`]
353#[derive(Debug, Clone, Serialize, Deserialize)]
354#[serde(untagged)]
355pub enum LoadBalancersLoadBalancerPoolsNotesCreateError {
356    UnknownValue(serde_json::Value),
357}
358
359/// struct for typed errors of method [`load_balancers_load_balancer_pools_notes_list`]
360#[derive(Debug, Clone, Serialize, Deserialize)]
361#[serde(untagged)]
362pub enum LoadBalancersLoadBalancerPoolsNotesListError {
363    UnknownValue(serde_json::Value),
364}
365
366/// struct for typed errors of method [`load_balancers_load_balancer_pools_partial_update`]
367#[derive(Debug, Clone, Serialize, Deserialize)]
368#[serde(untagged)]
369pub enum LoadBalancersLoadBalancerPoolsPartialUpdateError {
370    UnknownValue(serde_json::Value),
371}
372
373/// struct for typed errors of method [`load_balancers_load_balancer_pools_retrieve`]
374#[derive(Debug, Clone, Serialize, Deserialize)]
375#[serde(untagged)]
376pub enum LoadBalancersLoadBalancerPoolsRetrieveError {
377    UnknownValue(serde_json::Value),
378}
379
380/// struct for typed errors of method [`load_balancers_load_balancer_pools_update`]
381#[derive(Debug, Clone, Serialize, Deserialize)]
382#[serde(untagged)]
383pub enum LoadBalancersLoadBalancerPoolsUpdateError {
384    UnknownValue(serde_json::Value),
385}
386
387/// struct for typed errors of method [`load_balancers_virtual_server_certificate_profile_assignments_bulk_destroy`]
388#[derive(Debug, Clone, Serialize, Deserialize)]
389#[serde(untagged)]
390pub enum LoadBalancersVirtualServerCertificateProfileAssignmentsBulkDestroyError {
391    UnknownValue(serde_json::Value),
392}
393
394/// struct for typed errors of method [`load_balancers_virtual_server_certificate_profile_assignments_bulk_partial_update`]
395#[derive(Debug, Clone, Serialize, Deserialize)]
396#[serde(untagged)]
397pub enum LoadBalancersVirtualServerCertificateProfileAssignmentsBulkPartialUpdateError {
398    UnknownValue(serde_json::Value),
399}
400
401/// struct for typed errors of method [`load_balancers_virtual_server_certificate_profile_assignments_bulk_update`]
402#[derive(Debug, Clone, Serialize, Deserialize)]
403#[serde(untagged)]
404pub enum LoadBalancersVirtualServerCertificateProfileAssignmentsBulkUpdateError {
405    UnknownValue(serde_json::Value),
406}
407
408/// struct for typed errors of method [`load_balancers_virtual_server_certificate_profile_assignments_create`]
409#[derive(Debug, Clone, Serialize, Deserialize)]
410#[serde(untagged)]
411pub enum LoadBalancersVirtualServerCertificateProfileAssignmentsCreateError {
412    UnknownValue(serde_json::Value),
413}
414
415/// struct for typed errors of method [`load_balancers_virtual_server_certificate_profile_assignments_destroy`]
416#[derive(Debug, Clone, Serialize, Deserialize)]
417#[serde(untagged)]
418pub enum LoadBalancersVirtualServerCertificateProfileAssignmentsDestroyError {
419    UnknownValue(serde_json::Value),
420}
421
422/// struct for typed errors of method [`load_balancers_virtual_server_certificate_profile_assignments_list`]
423#[derive(Debug, Clone, Serialize, Deserialize)]
424#[serde(untagged)]
425pub enum LoadBalancersVirtualServerCertificateProfileAssignmentsListError {
426    UnknownValue(serde_json::Value),
427}
428
429/// struct for typed errors of method [`load_balancers_virtual_server_certificate_profile_assignments_partial_update`]
430#[derive(Debug, Clone, Serialize, Deserialize)]
431#[serde(untagged)]
432pub enum LoadBalancersVirtualServerCertificateProfileAssignmentsPartialUpdateError {
433    UnknownValue(serde_json::Value),
434}
435
436/// struct for typed errors of method [`load_balancers_virtual_server_certificate_profile_assignments_retrieve`]
437#[derive(Debug, Clone, Serialize, Deserialize)]
438#[serde(untagged)]
439pub enum LoadBalancersVirtualServerCertificateProfileAssignmentsRetrieveError {
440    UnknownValue(serde_json::Value),
441}
442
443/// struct for typed errors of method [`load_balancers_virtual_server_certificate_profile_assignments_update`]
444#[derive(Debug, Clone, Serialize, Deserialize)]
445#[serde(untagged)]
446pub enum LoadBalancersVirtualServerCertificateProfileAssignmentsUpdateError {
447    UnknownValue(serde_json::Value),
448}
449
450/// struct for typed errors of method [`load_balancers_virtual_servers_bulk_destroy`]
451#[derive(Debug, Clone, Serialize, Deserialize)]
452#[serde(untagged)]
453pub enum LoadBalancersVirtualServersBulkDestroyError {
454    UnknownValue(serde_json::Value),
455}
456
457/// struct for typed errors of method [`load_balancers_virtual_servers_bulk_partial_update`]
458#[derive(Debug, Clone, Serialize, Deserialize)]
459#[serde(untagged)]
460pub enum LoadBalancersVirtualServersBulkPartialUpdateError {
461    UnknownValue(serde_json::Value),
462}
463
464/// struct for typed errors of method [`load_balancers_virtual_servers_bulk_update`]
465#[derive(Debug, Clone, Serialize, Deserialize)]
466#[serde(untagged)]
467pub enum LoadBalancersVirtualServersBulkUpdateError {
468    UnknownValue(serde_json::Value),
469}
470
471/// struct for typed errors of method [`load_balancers_virtual_servers_create`]
472#[derive(Debug, Clone, Serialize, Deserialize)]
473#[serde(untagged)]
474pub enum LoadBalancersVirtualServersCreateError {
475    UnknownValue(serde_json::Value),
476}
477
478/// struct for typed errors of method [`load_balancers_virtual_servers_destroy`]
479#[derive(Debug, Clone, Serialize, Deserialize)]
480#[serde(untagged)]
481pub enum LoadBalancersVirtualServersDestroyError {
482    UnknownValue(serde_json::Value),
483}
484
485/// struct for typed errors of method [`load_balancers_virtual_servers_list`]
486#[derive(Debug, Clone, Serialize, Deserialize)]
487#[serde(untagged)]
488pub enum LoadBalancersVirtualServersListError {
489    UnknownValue(serde_json::Value),
490}
491
492/// struct for typed errors of method [`load_balancers_virtual_servers_notes_create`]
493#[derive(Debug, Clone, Serialize, Deserialize)]
494#[serde(untagged)]
495pub enum LoadBalancersVirtualServersNotesCreateError {
496    UnknownValue(serde_json::Value),
497}
498
499/// struct for typed errors of method [`load_balancers_virtual_servers_notes_list`]
500#[derive(Debug, Clone, Serialize, Deserialize)]
501#[serde(untagged)]
502pub enum LoadBalancersVirtualServersNotesListError {
503    UnknownValue(serde_json::Value),
504}
505
506/// struct for typed errors of method [`load_balancers_virtual_servers_partial_update`]
507#[derive(Debug, Clone, Serialize, Deserialize)]
508#[serde(untagged)]
509pub enum LoadBalancersVirtualServersPartialUpdateError {
510    UnknownValue(serde_json::Value),
511}
512
513/// struct for typed errors of method [`load_balancers_virtual_servers_retrieve`]
514#[derive(Debug, Clone, Serialize, Deserialize)]
515#[serde(untagged)]
516pub enum LoadBalancersVirtualServersRetrieveError {
517    UnknownValue(serde_json::Value),
518}
519
520/// struct for typed errors of method [`load_balancers_virtual_servers_update`]
521#[derive(Debug, Clone, Serialize, Deserialize)]
522#[serde(untagged)]
523pub enum LoadBalancersVirtualServersUpdateError {
524    UnknownValue(serde_json::Value),
525}
526
527/// CertificateProfile viewset.
528pub async fn load_balancers_certificate_profiles_bulk_destroy(
529    configuration: &configuration::Configuration,
530    bulk_operation_request: Vec<crate::models::BulkOperationRequest>,
531    format: Option<&str>,
532) -> Result<(), Error<LoadBalancersCertificateProfilesBulkDestroyError>> {
533    let local_var_configuration = configuration;
534
535    let local_var_client = &local_var_configuration.client;
536
537    let local_var_uri_str = format!(
538        "{}/load-balancers/certificate-profiles/",
539        local_var_configuration.base_path
540    );
541    let mut local_var_req_builder =
542        local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());
543
544    if let Some(ref local_var_str) = format {
545        local_var_req_builder =
546            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
547    }
548    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
549        local_var_req_builder =
550            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
551    }
552    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
553        let local_var_key = local_var_apikey.key.clone();
554        let local_var_value = match local_var_apikey.prefix {
555            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
556            None => local_var_key,
557        };
558        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
559    };
560    local_var_req_builder = local_var_req_builder.json(&bulk_operation_request);
561
562    let local_var_req = local_var_req_builder.build()?;
563    let local_var_resp = local_var_client.execute(local_var_req).await?;
564
565    let local_var_status = local_var_resp.status();
566    let local_var_content = local_var_resp.text().await?;
567
568    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
569        Ok(())
570    } else {
571        let local_var_entity: Option<LoadBalancersCertificateProfilesBulkDestroyError> =
572            serde_json::from_str(&local_var_content).ok();
573        let local_var_error = ResponseContent {
574            status: local_var_status,
575            content: local_var_content,
576            entity: local_var_entity,
577        };
578        Err(Error::ResponseError(local_var_error))
579    }
580}
581
582/// CertificateProfile viewset.
583pub async fn load_balancers_certificate_profiles_bulk_partial_update(
584    configuration: &configuration::Configuration,
585    patched_bulk_writable_certificate_profile_request: Vec<
586        crate::models::PatchedBulkWritableCertificateProfileRequest,
587    >,
588    format: Option<&str>,
589) -> Result<
590    Vec<crate::models::CertificateProfile>,
591    Error<LoadBalancersCertificateProfilesBulkPartialUpdateError>,
592> {
593    let local_var_configuration = configuration;
594
595    let local_var_client = &local_var_configuration.client;
596
597    let local_var_uri_str = format!(
598        "{}/load-balancers/certificate-profiles/",
599        local_var_configuration.base_path
600    );
601    let mut local_var_req_builder =
602        local_var_client.request(reqwest::Method::PATCH, local_var_uri_str.as_str());
603
604    if let Some(ref local_var_str) = format {
605        local_var_req_builder =
606            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
607    }
608    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
609        local_var_req_builder =
610            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
611    }
612    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
613        let local_var_key = local_var_apikey.key.clone();
614        let local_var_value = match local_var_apikey.prefix {
615            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
616            None => local_var_key,
617        };
618        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
619    };
620    local_var_req_builder =
621        local_var_req_builder.json(&patched_bulk_writable_certificate_profile_request);
622
623    let local_var_req = local_var_req_builder.build()?;
624    let local_var_resp = local_var_client.execute(local_var_req).await?;
625
626    let local_var_status = local_var_resp.status();
627    let local_var_content = local_var_resp.text().await?;
628
629    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
630        serde_json::from_str(&local_var_content).map_err(Error::from)
631    } else {
632        let local_var_entity: Option<LoadBalancersCertificateProfilesBulkPartialUpdateError> =
633            serde_json::from_str(&local_var_content).ok();
634        let local_var_error = ResponseContent {
635            status: local_var_status,
636            content: local_var_content,
637            entity: local_var_entity,
638        };
639        Err(Error::ResponseError(local_var_error))
640    }
641}
642
643/// CertificateProfile viewset.
644pub async fn load_balancers_certificate_profiles_bulk_update(
645    configuration: &configuration::Configuration,
646    bulk_writable_certificate_profile_request: Vec<
647        crate::models::BulkWritableCertificateProfileRequest,
648    >,
649    format: Option<&str>,
650) -> Result<
651    Vec<crate::models::CertificateProfile>,
652    Error<LoadBalancersCertificateProfilesBulkUpdateError>,
653> {
654    let local_var_configuration = configuration;
655
656    let local_var_client = &local_var_configuration.client;
657
658    let local_var_uri_str = format!(
659        "{}/load-balancers/certificate-profiles/",
660        local_var_configuration.base_path
661    );
662    let mut local_var_req_builder =
663        local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());
664
665    if let Some(ref local_var_str) = format {
666        local_var_req_builder =
667            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
668    }
669    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
670        local_var_req_builder =
671            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
672    }
673    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
674        let local_var_key = local_var_apikey.key.clone();
675        let local_var_value = match local_var_apikey.prefix {
676            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
677            None => local_var_key,
678        };
679        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
680    };
681    local_var_req_builder = local_var_req_builder.json(&bulk_writable_certificate_profile_request);
682
683    let local_var_req = local_var_req_builder.build()?;
684    let local_var_resp = local_var_client.execute(local_var_req).await?;
685
686    let local_var_status = local_var_resp.status();
687    let local_var_content = local_var_resp.text().await?;
688
689    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
690        serde_json::from_str(&local_var_content).map_err(Error::from)
691    } else {
692        let local_var_entity: Option<LoadBalancersCertificateProfilesBulkUpdateError> =
693            serde_json::from_str(&local_var_content).ok();
694        let local_var_error = ResponseContent {
695            status: local_var_status,
696            content: local_var_content,
697            entity: local_var_entity,
698        };
699        Err(Error::ResponseError(local_var_error))
700    }
701}
702
703/// CertificateProfile viewset.
704pub async fn load_balancers_certificate_profiles_create(
705    configuration: &configuration::Configuration,
706    certificate_profile_request: crate::models::CertificateProfileRequest,
707    format: Option<&str>,
708) -> Result<crate::models::CertificateProfile, Error<LoadBalancersCertificateProfilesCreateError>> {
709    let local_var_configuration = configuration;
710
711    let local_var_client = &local_var_configuration.client;
712
713    let local_var_uri_str = format!(
714        "{}/load-balancers/certificate-profiles/",
715        local_var_configuration.base_path
716    );
717    let mut local_var_req_builder =
718        local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
719
720    if let Some(ref local_var_str) = format {
721        local_var_req_builder =
722            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
723    }
724    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
725        local_var_req_builder =
726            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
727    }
728    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
729        let local_var_key = local_var_apikey.key.clone();
730        let local_var_value = match local_var_apikey.prefix {
731            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
732            None => local_var_key,
733        };
734        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
735    };
736    local_var_req_builder = local_var_req_builder.json(&certificate_profile_request);
737
738    let local_var_req = local_var_req_builder.build()?;
739    let local_var_resp = local_var_client.execute(local_var_req).await?;
740
741    let local_var_status = local_var_resp.status();
742    let local_var_content = local_var_resp.text().await?;
743
744    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
745        serde_json::from_str(&local_var_content).map_err(Error::from)
746    } else {
747        let local_var_entity: Option<LoadBalancersCertificateProfilesCreateError> =
748            serde_json::from_str(&local_var_content).ok();
749        let local_var_error = ResponseContent {
750            status: local_var_status,
751            content: local_var_content,
752            entity: local_var_entity,
753        };
754        Err(Error::ResponseError(local_var_error))
755    }
756}
757
758/// CertificateProfile viewset.
759pub async fn load_balancers_certificate_profiles_destroy(
760    configuration: &configuration::Configuration,
761    id: &str,
762    format: Option<&str>,
763) -> Result<(), Error<LoadBalancersCertificateProfilesDestroyError>> {
764    let local_var_configuration = configuration;
765
766    let local_var_client = &local_var_configuration.client;
767
768    let local_var_uri_str = format!(
769        "{}/load-balancers/certificate-profiles/{id}/",
770        local_var_configuration.base_path,
771        id = crate::apis::urlencode(id)
772    );
773    let mut local_var_req_builder =
774        local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());
775
776    if let Some(ref local_var_str) = format {
777        local_var_req_builder =
778            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
779    }
780    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
781        local_var_req_builder =
782            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
783    }
784    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
785        let local_var_key = local_var_apikey.key.clone();
786        let local_var_value = match local_var_apikey.prefix {
787            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
788            None => local_var_key,
789        };
790        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
791    };
792
793    let local_var_req = local_var_req_builder.build()?;
794    let local_var_resp = local_var_client.execute(local_var_req).await?;
795
796    let local_var_status = local_var_resp.status();
797    let local_var_content = local_var_resp.text().await?;
798
799    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
800        Ok(())
801    } else {
802        let local_var_entity: Option<LoadBalancersCertificateProfilesDestroyError> =
803            serde_json::from_str(&local_var_content).ok();
804        let local_var_error = ResponseContent {
805            status: local_var_status,
806            content: local_var_content,
807            entity: local_var_entity,
808        };
809        Err(Error::ResponseError(local_var_error))
810    }
811}
812
813/// CertificateProfile viewset.
814pub async fn load_balancers_certificate_profiles_list(
815    configuration: &configuration::Configuration,
816    certificate_file_path: Option<Vec<String>>,
817    certificate_file_path__ic: Option<Vec<String>>,
818    certificate_file_path__ie: Option<Vec<String>>,
819    certificate_file_path__iew: Option<Vec<String>>,
820    certificate_file_path__ire: Option<Vec<String>>,
821    certificate_file_path__isw: Option<Vec<String>>,
822    certificate_file_path__n: Option<Vec<String>>,
823    certificate_file_path__nic: Option<Vec<String>>,
824    certificate_file_path__nie: Option<Vec<String>>,
825    certificate_file_path__niew: Option<Vec<String>>,
826    certificate_file_path__nire: Option<Vec<String>>,
827    certificate_file_path__nisw: Option<Vec<String>>,
828    certificate_file_path__nre: Option<Vec<String>>,
829    certificate_file_path__re: Option<Vec<String>>,
830    certificate_type: Option<Vec<String>>,
831    certificate_type__ic: Option<Vec<String>>,
832    certificate_type__ie: Option<Vec<String>>,
833    certificate_type__iew: Option<Vec<String>>,
834    certificate_type__ire: Option<Vec<String>>,
835    certificate_type__isw: Option<Vec<String>>,
836    certificate_type__n: Option<Vec<String>>,
837    certificate_type__nic: Option<Vec<String>>,
838    certificate_type__nie: Option<Vec<String>>,
839    certificate_type__niew: Option<Vec<String>>,
840    certificate_type__nire: Option<Vec<String>>,
841    certificate_type__nisw: Option<Vec<String>>,
842    certificate_type__nre: Option<Vec<String>>,
843    certificate_type__re: Option<Vec<String>>,
844    chain_file_path: Option<Vec<String>>,
845    chain_file_path__ic: Option<Vec<String>>,
846    chain_file_path__ie: Option<Vec<String>>,
847    chain_file_path__iew: Option<Vec<String>>,
848    chain_file_path__ire: Option<Vec<String>>,
849    chain_file_path__isw: Option<Vec<String>>,
850    chain_file_path__n: Option<Vec<String>>,
851    chain_file_path__nic: Option<Vec<String>>,
852    chain_file_path__nie: Option<Vec<String>>,
853    chain_file_path__niew: Option<Vec<String>>,
854    chain_file_path__nire: Option<Vec<String>>,
855    chain_file_path__nisw: Option<Vec<String>>,
856    chain_file_path__nre: Option<Vec<String>>,
857    chain_file_path__re: Option<Vec<String>>,
858    cipher: Option<Vec<String>>,
859    cipher__ic: Option<Vec<String>>,
860    cipher__ie: Option<Vec<String>>,
861    cipher__iew: Option<Vec<String>>,
862    cipher__ire: Option<Vec<String>>,
863    cipher__isw: Option<Vec<String>>,
864    cipher__n: Option<Vec<String>>,
865    cipher__nic: Option<Vec<String>>,
866    cipher__nie: Option<Vec<String>>,
867    cipher__niew: Option<Vec<String>>,
868    cipher__nire: Option<Vec<String>>,
869    cipher__nisw: Option<Vec<String>>,
870    cipher__nre: Option<Vec<String>>,
871    cipher__re: Option<Vec<String>>,
872    contacts: Option<Vec<String>>,
873    contacts__isnull: Option<bool>,
874    contacts__n: Option<Vec<String>>,
875    created: Option<Vec<String>>,
876    created__gt: Option<Vec<String>>,
877    created__gte: Option<Vec<String>>,
878    created__isnull: Option<bool>,
879    created__lt: Option<Vec<String>>,
880    created__lte: Option<Vec<String>>,
881    created__n: Option<Vec<String>>,
882    dynamic_groups: Option<Vec<String>>,
883    dynamic_groups__n: Option<Vec<String>>,
884    expiration_date: Option<Vec<String>>,
885    expiration_date__gt: Option<Vec<String>>,
886    expiration_date__gte: Option<Vec<String>>,
887    expiration_date__isnull: Option<bool>,
888    expiration_date__lt: Option<Vec<String>>,
889    expiration_date__lte: Option<Vec<String>>,
890    expiration_date__n: Option<Vec<String>>,
891    format: Option<&str>,
892    id: Option<Vec<uuid::Uuid>>,
893    id__n: Option<Vec<uuid::Uuid>>,
894    key_file_path: Option<Vec<String>>,
895    key_file_path__ic: Option<Vec<String>>,
896    key_file_path__ie: Option<Vec<String>>,
897    key_file_path__iew: Option<Vec<String>>,
898    key_file_path__ire: Option<Vec<String>>,
899    key_file_path__isw: Option<Vec<String>>,
900    key_file_path__n: Option<Vec<String>>,
901    key_file_path__nic: Option<Vec<String>>,
902    key_file_path__nie: Option<Vec<String>>,
903    key_file_path__niew: Option<Vec<String>>,
904    key_file_path__nire: Option<Vec<String>>,
905    key_file_path__nisw: Option<Vec<String>>,
906    key_file_path__nre: Option<Vec<String>>,
907    key_file_path__re: Option<Vec<String>>,
908    last_updated: Option<Vec<String>>,
909    last_updated__gt: Option<Vec<String>>,
910    last_updated__gte: Option<Vec<String>>,
911    last_updated__isnull: Option<bool>,
912    last_updated__lt: Option<Vec<String>>,
913    last_updated__lte: Option<Vec<String>>,
914    last_updated__n: Option<Vec<String>>,
915    limit: Option<i32>,
916    load_balancer_pool_members: Option<Vec<String>>,
917    load_balancer_pool_members__isnull: Option<bool>,
918    load_balancer_pool_members__n: Option<Vec<String>>,
919    name: Option<Vec<String>>,
920    name__ic: Option<Vec<String>>,
921    name__ie: Option<Vec<String>>,
922    name__iew: Option<Vec<String>>,
923    name__ire: Option<Vec<String>>,
924    name__isw: Option<Vec<String>>,
925    name__n: Option<Vec<String>>,
926    name__nic: Option<Vec<String>>,
927    name__nie: Option<Vec<String>>,
928    name__niew: Option<Vec<String>>,
929    name__nire: Option<Vec<String>>,
930    name__nisw: Option<Vec<String>>,
931    name__nre: Option<Vec<String>>,
932    name__re: Option<Vec<String>>,
933    offset: Option<i32>,
934    q: Option<&str>,
935    sort: Option<&str>,
936    tags: Option<Vec<String>>,
937    tags__isnull: Option<bool>,
938    tags__n: Option<Vec<String>>,
939    teams: Option<Vec<String>>,
940    teams__isnull: Option<bool>,
941    teams__n: Option<Vec<String>>,
942    tenant: Option<Vec<String>>,
943    tenant__isnull: Option<bool>,
944    tenant__n: Option<Vec<String>>,
945    tenant_group: Option<Vec<String>>,
946    tenant_group__isnull: Option<bool>,
947    tenant_group__n: Option<Vec<String>>,
948    tenant_id: Option<Vec<uuid::Uuid>>,
949    tenant_id__isnull: Option<bool>,
950    tenant_id__n: Option<Vec<uuid::Uuid>>,
951    virtual_servers: Option<Vec<String>>,
952    virtual_servers__isnull: Option<bool>,
953    virtual_servers__n: Option<Vec<String>>,
954    depth: Option<i32>,
955    exclude_m2m: Option<bool>,
956) -> Result<
957    crate::models::PaginatedCertificateProfileList,
958    Error<LoadBalancersCertificateProfilesListError>,
959> {
960    let local_var_configuration = configuration;
961
962    let local_var_client = &local_var_configuration.client;
963
964    let local_var_uri_str = format!(
965        "{}/load-balancers/certificate-profiles/",
966        local_var_configuration.base_path
967    );
968    let mut local_var_req_builder =
969        local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
970
971    if let Some(ref local_var_str) = certificate_file_path {
972        local_var_req_builder = match "multi" {
973            "multi" => local_var_req_builder.query(
974                &local_var_str
975                    .into_iter()
976                    .map(|p| ("certificate_file_path".to_owned(), p.to_string()))
977                    .collect::<Vec<(std::string::String, std::string::String)>>(),
978            ),
979            _ => local_var_req_builder.query(&[(
980                "certificate_file_path",
981                &local_var_str
982                    .into_iter()
983                    .map(|p| p.to_string())
984                    .collect::<Vec<String>>()
985                    .join(",")
986                    .to_string(),
987            )]),
988        };
989    }
990    if let Some(ref local_var_str) = certificate_file_path__ic {
991        local_var_req_builder = match "multi" {
992            "multi" => local_var_req_builder.query(
993                &local_var_str
994                    .into_iter()
995                    .map(|p| ("certificate_file_path__ic".to_owned(), p.to_string()))
996                    .collect::<Vec<(std::string::String, std::string::String)>>(),
997            ),
998            _ => local_var_req_builder.query(&[(
999                "certificate_file_path__ic",
1000                &local_var_str
1001                    .into_iter()
1002                    .map(|p| p.to_string())
1003                    .collect::<Vec<String>>()
1004                    .join(",")
1005                    .to_string(),
1006            )]),
1007        };
1008    }
1009    if let Some(ref local_var_str) = certificate_file_path__ie {
1010        local_var_req_builder = match "multi" {
1011            "multi" => local_var_req_builder.query(
1012                &local_var_str
1013                    .into_iter()
1014                    .map(|p| ("certificate_file_path__ie".to_owned(), p.to_string()))
1015                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1016            ),
1017            _ => local_var_req_builder.query(&[(
1018                "certificate_file_path__ie",
1019                &local_var_str
1020                    .into_iter()
1021                    .map(|p| p.to_string())
1022                    .collect::<Vec<String>>()
1023                    .join(",")
1024                    .to_string(),
1025            )]),
1026        };
1027    }
1028    if let Some(ref local_var_str) = certificate_file_path__iew {
1029        local_var_req_builder = match "multi" {
1030            "multi" => local_var_req_builder.query(
1031                &local_var_str
1032                    .into_iter()
1033                    .map(|p| ("certificate_file_path__iew".to_owned(), p.to_string()))
1034                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1035            ),
1036            _ => local_var_req_builder.query(&[(
1037                "certificate_file_path__iew",
1038                &local_var_str
1039                    .into_iter()
1040                    .map(|p| p.to_string())
1041                    .collect::<Vec<String>>()
1042                    .join(",")
1043                    .to_string(),
1044            )]),
1045        };
1046    }
1047    if let Some(ref local_var_str) = certificate_file_path__ire {
1048        local_var_req_builder = match "multi" {
1049            "multi" => local_var_req_builder.query(
1050                &local_var_str
1051                    .into_iter()
1052                    .map(|p| ("certificate_file_path__ire".to_owned(), p.to_string()))
1053                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1054            ),
1055            _ => local_var_req_builder.query(&[(
1056                "certificate_file_path__ire",
1057                &local_var_str
1058                    .into_iter()
1059                    .map(|p| p.to_string())
1060                    .collect::<Vec<String>>()
1061                    .join(",")
1062                    .to_string(),
1063            )]),
1064        };
1065    }
1066    if let Some(ref local_var_str) = certificate_file_path__isw {
1067        local_var_req_builder = match "multi" {
1068            "multi" => local_var_req_builder.query(
1069                &local_var_str
1070                    .into_iter()
1071                    .map(|p| ("certificate_file_path__isw".to_owned(), p.to_string()))
1072                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1073            ),
1074            _ => local_var_req_builder.query(&[(
1075                "certificate_file_path__isw",
1076                &local_var_str
1077                    .into_iter()
1078                    .map(|p| p.to_string())
1079                    .collect::<Vec<String>>()
1080                    .join(",")
1081                    .to_string(),
1082            )]),
1083        };
1084    }
1085    if let Some(ref local_var_str) = certificate_file_path__n {
1086        local_var_req_builder = match "multi" {
1087            "multi" => local_var_req_builder.query(
1088                &local_var_str
1089                    .into_iter()
1090                    .map(|p| ("certificate_file_path__n".to_owned(), p.to_string()))
1091                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1092            ),
1093            _ => local_var_req_builder.query(&[(
1094                "certificate_file_path__n",
1095                &local_var_str
1096                    .into_iter()
1097                    .map(|p| p.to_string())
1098                    .collect::<Vec<String>>()
1099                    .join(",")
1100                    .to_string(),
1101            )]),
1102        };
1103    }
1104    if let Some(ref local_var_str) = certificate_file_path__nic {
1105        local_var_req_builder = match "multi" {
1106            "multi" => local_var_req_builder.query(
1107                &local_var_str
1108                    .into_iter()
1109                    .map(|p| ("certificate_file_path__nic".to_owned(), p.to_string()))
1110                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1111            ),
1112            _ => local_var_req_builder.query(&[(
1113                "certificate_file_path__nic",
1114                &local_var_str
1115                    .into_iter()
1116                    .map(|p| p.to_string())
1117                    .collect::<Vec<String>>()
1118                    .join(",")
1119                    .to_string(),
1120            )]),
1121        };
1122    }
1123    if let Some(ref local_var_str) = certificate_file_path__nie {
1124        local_var_req_builder = match "multi" {
1125            "multi" => local_var_req_builder.query(
1126                &local_var_str
1127                    .into_iter()
1128                    .map(|p| ("certificate_file_path__nie".to_owned(), p.to_string()))
1129                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1130            ),
1131            _ => local_var_req_builder.query(&[(
1132                "certificate_file_path__nie",
1133                &local_var_str
1134                    .into_iter()
1135                    .map(|p| p.to_string())
1136                    .collect::<Vec<String>>()
1137                    .join(",")
1138                    .to_string(),
1139            )]),
1140        };
1141    }
1142    if let Some(ref local_var_str) = certificate_file_path__niew {
1143        local_var_req_builder = match "multi" {
1144            "multi" => local_var_req_builder.query(
1145                &local_var_str
1146                    .into_iter()
1147                    .map(|p| ("certificate_file_path__niew".to_owned(), p.to_string()))
1148                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1149            ),
1150            _ => local_var_req_builder.query(&[(
1151                "certificate_file_path__niew",
1152                &local_var_str
1153                    .into_iter()
1154                    .map(|p| p.to_string())
1155                    .collect::<Vec<String>>()
1156                    .join(",")
1157                    .to_string(),
1158            )]),
1159        };
1160    }
1161    if let Some(ref local_var_str) = certificate_file_path__nire {
1162        local_var_req_builder = match "multi" {
1163            "multi" => local_var_req_builder.query(
1164                &local_var_str
1165                    .into_iter()
1166                    .map(|p| ("certificate_file_path__nire".to_owned(), p.to_string()))
1167                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1168            ),
1169            _ => local_var_req_builder.query(&[(
1170                "certificate_file_path__nire",
1171                &local_var_str
1172                    .into_iter()
1173                    .map(|p| p.to_string())
1174                    .collect::<Vec<String>>()
1175                    .join(",")
1176                    .to_string(),
1177            )]),
1178        };
1179    }
1180    if let Some(ref local_var_str) = certificate_file_path__nisw {
1181        local_var_req_builder = match "multi" {
1182            "multi" => local_var_req_builder.query(
1183                &local_var_str
1184                    .into_iter()
1185                    .map(|p| ("certificate_file_path__nisw".to_owned(), p.to_string()))
1186                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1187            ),
1188            _ => local_var_req_builder.query(&[(
1189                "certificate_file_path__nisw",
1190                &local_var_str
1191                    .into_iter()
1192                    .map(|p| p.to_string())
1193                    .collect::<Vec<String>>()
1194                    .join(",")
1195                    .to_string(),
1196            )]),
1197        };
1198    }
1199    if let Some(ref local_var_str) = certificate_file_path__nre {
1200        local_var_req_builder = match "multi" {
1201            "multi" => local_var_req_builder.query(
1202                &local_var_str
1203                    .into_iter()
1204                    .map(|p| ("certificate_file_path__nre".to_owned(), p.to_string()))
1205                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1206            ),
1207            _ => local_var_req_builder.query(&[(
1208                "certificate_file_path__nre",
1209                &local_var_str
1210                    .into_iter()
1211                    .map(|p| p.to_string())
1212                    .collect::<Vec<String>>()
1213                    .join(",")
1214                    .to_string(),
1215            )]),
1216        };
1217    }
1218    if let Some(ref local_var_str) = certificate_file_path__re {
1219        local_var_req_builder = match "multi" {
1220            "multi" => local_var_req_builder.query(
1221                &local_var_str
1222                    .into_iter()
1223                    .map(|p| ("certificate_file_path__re".to_owned(), p.to_string()))
1224                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1225            ),
1226            _ => local_var_req_builder.query(&[(
1227                "certificate_file_path__re",
1228                &local_var_str
1229                    .into_iter()
1230                    .map(|p| p.to_string())
1231                    .collect::<Vec<String>>()
1232                    .join(",")
1233                    .to_string(),
1234            )]),
1235        };
1236    }
1237    if let Some(ref local_var_str) = certificate_type {
1238        local_var_req_builder = match "multi" {
1239            "multi" => local_var_req_builder.query(
1240                &local_var_str
1241                    .into_iter()
1242                    .map(|p| ("certificate_type".to_owned(), p.to_string()))
1243                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1244            ),
1245            _ => local_var_req_builder.query(&[(
1246                "certificate_type",
1247                &local_var_str
1248                    .into_iter()
1249                    .map(|p| p.to_string())
1250                    .collect::<Vec<String>>()
1251                    .join(",")
1252                    .to_string(),
1253            )]),
1254        };
1255    }
1256    if let Some(ref local_var_str) = certificate_type__ic {
1257        local_var_req_builder = match "multi" {
1258            "multi" => local_var_req_builder.query(
1259                &local_var_str
1260                    .into_iter()
1261                    .map(|p| ("certificate_type__ic".to_owned(), p.to_string()))
1262                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1263            ),
1264            _ => local_var_req_builder.query(&[(
1265                "certificate_type__ic",
1266                &local_var_str
1267                    .into_iter()
1268                    .map(|p| p.to_string())
1269                    .collect::<Vec<String>>()
1270                    .join(",")
1271                    .to_string(),
1272            )]),
1273        };
1274    }
1275    if let Some(ref local_var_str) = certificate_type__ie {
1276        local_var_req_builder = match "multi" {
1277            "multi" => local_var_req_builder.query(
1278                &local_var_str
1279                    .into_iter()
1280                    .map(|p| ("certificate_type__ie".to_owned(), p.to_string()))
1281                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1282            ),
1283            _ => local_var_req_builder.query(&[(
1284                "certificate_type__ie",
1285                &local_var_str
1286                    .into_iter()
1287                    .map(|p| p.to_string())
1288                    .collect::<Vec<String>>()
1289                    .join(",")
1290                    .to_string(),
1291            )]),
1292        };
1293    }
1294    if let Some(ref local_var_str) = certificate_type__iew {
1295        local_var_req_builder = match "multi" {
1296            "multi" => local_var_req_builder.query(
1297                &local_var_str
1298                    .into_iter()
1299                    .map(|p| ("certificate_type__iew".to_owned(), p.to_string()))
1300                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1301            ),
1302            _ => local_var_req_builder.query(&[(
1303                "certificate_type__iew",
1304                &local_var_str
1305                    .into_iter()
1306                    .map(|p| p.to_string())
1307                    .collect::<Vec<String>>()
1308                    .join(",")
1309                    .to_string(),
1310            )]),
1311        };
1312    }
1313    if let Some(ref local_var_str) = certificate_type__ire {
1314        local_var_req_builder = match "multi" {
1315            "multi" => local_var_req_builder.query(
1316                &local_var_str
1317                    .into_iter()
1318                    .map(|p| ("certificate_type__ire".to_owned(), p.to_string()))
1319                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1320            ),
1321            _ => local_var_req_builder.query(&[(
1322                "certificate_type__ire",
1323                &local_var_str
1324                    .into_iter()
1325                    .map(|p| p.to_string())
1326                    .collect::<Vec<String>>()
1327                    .join(",")
1328                    .to_string(),
1329            )]),
1330        };
1331    }
1332    if let Some(ref local_var_str) = certificate_type__isw {
1333        local_var_req_builder = match "multi" {
1334            "multi" => local_var_req_builder.query(
1335                &local_var_str
1336                    .into_iter()
1337                    .map(|p| ("certificate_type__isw".to_owned(), p.to_string()))
1338                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1339            ),
1340            _ => local_var_req_builder.query(&[(
1341                "certificate_type__isw",
1342                &local_var_str
1343                    .into_iter()
1344                    .map(|p| p.to_string())
1345                    .collect::<Vec<String>>()
1346                    .join(",")
1347                    .to_string(),
1348            )]),
1349        };
1350    }
1351    if let Some(ref local_var_str) = certificate_type__n {
1352        local_var_req_builder = match "multi" {
1353            "multi" => local_var_req_builder.query(
1354                &local_var_str
1355                    .into_iter()
1356                    .map(|p| ("certificate_type__n".to_owned(), p.to_string()))
1357                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1358            ),
1359            _ => local_var_req_builder.query(&[(
1360                "certificate_type__n",
1361                &local_var_str
1362                    .into_iter()
1363                    .map(|p| p.to_string())
1364                    .collect::<Vec<String>>()
1365                    .join(",")
1366                    .to_string(),
1367            )]),
1368        };
1369    }
1370    if let Some(ref local_var_str) = certificate_type__nic {
1371        local_var_req_builder = match "multi" {
1372            "multi" => local_var_req_builder.query(
1373                &local_var_str
1374                    .into_iter()
1375                    .map(|p| ("certificate_type__nic".to_owned(), p.to_string()))
1376                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1377            ),
1378            _ => local_var_req_builder.query(&[(
1379                "certificate_type__nic",
1380                &local_var_str
1381                    .into_iter()
1382                    .map(|p| p.to_string())
1383                    .collect::<Vec<String>>()
1384                    .join(",")
1385                    .to_string(),
1386            )]),
1387        };
1388    }
1389    if let Some(ref local_var_str) = certificate_type__nie {
1390        local_var_req_builder = match "multi" {
1391            "multi" => local_var_req_builder.query(
1392                &local_var_str
1393                    .into_iter()
1394                    .map(|p| ("certificate_type__nie".to_owned(), p.to_string()))
1395                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1396            ),
1397            _ => local_var_req_builder.query(&[(
1398                "certificate_type__nie",
1399                &local_var_str
1400                    .into_iter()
1401                    .map(|p| p.to_string())
1402                    .collect::<Vec<String>>()
1403                    .join(",")
1404                    .to_string(),
1405            )]),
1406        };
1407    }
1408    if let Some(ref local_var_str) = certificate_type__niew {
1409        local_var_req_builder = match "multi" {
1410            "multi" => local_var_req_builder.query(
1411                &local_var_str
1412                    .into_iter()
1413                    .map(|p| ("certificate_type__niew".to_owned(), p.to_string()))
1414                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1415            ),
1416            _ => local_var_req_builder.query(&[(
1417                "certificate_type__niew",
1418                &local_var_str
1419                    .into_iter()
1420                    .map(|p| p.to_string())
1421                    .collect::<Vec<String>>()
1422                    .join(",")
1423                    .to_string(),
1424            )]),
1425        };
1426    }
1427    if let Some(ref local_var_str) = certificate_type__nire {
1428        local_var_req_builder = match "multi" {
1429            "multi" => local_var_req_builder.query(
1430                &local_var_str
1431                    .into_iter()
1432                    .map(|p| ("certificate_type__nire".to_owned(), p.to_string()))
1433                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1434            ),
1435            _ => local_var_req_builder.query(&[(
1436                "certificate_type__nire",
1437                &local_var_str
1438                    .into_iter()
1439                    .map(|p| p.to_string())
1440                    .collect::<Vec<String>>()
1441                    .join(",")
1442                    .to_string(),
1443            )]),
1444        };
1445    }
1446    if let Some(ref local_var_str) = certificate_type__nisw {
1447        local_var_req_builder = match "multi" {
1448            "multi" => local_var_req_builder.query(
1449                &local_var_str
1450                    .into_iter()
1451                    .map(|p| ("certificate_type__nisw".to_owned(), p.to_string()))
1452                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1453            ),
1454            _ => local_var_req_builder.query(&[(
1455                "certificate_type__nisw",
1456                &local_var_str
1457                    .into_iter()
1458                    .map(|p| p.to_string())
1459                    .collect::<Vec<String>>()
1460                    .join(",")
1461                    .to_string(),
1462            )]),
1463        };
1464    }
1465    if let Some(ref local_var_str) = certificate_type__nre {
1466        local_var_req_builder = match "multi" {
1467            "multi" => local_var_req_builder.query(
1468                &local_var_str
1469                    .into_iter()
1470                    .map(|p| ("certificate_type__nre".to_owned(), p.to_string()))
1471                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1472            ),
1473            _ => local_var_req_builder.query(&[(
1474                "certificate_type__nre",
1475                &local_var_str
1476                    .into_iter()
1477                    .map(|p| p.to_string())
1478                    .collect::<Vec<String>>()
1479                    .join(",")
1480                    .to_string(),
1481            )]),
1482        };
1483    }
1484    if let Some(ref local_var_str) = certificate_type__re {
1485        local_var_req_builder = match "multi" {
1486            "multi" => local_var_req_builder.query(
1487                &local_var_str
1488                    .into_iter()
1489                    .map(|p| ("certificate_type__re".to_owned(), p.to_string()))
1490                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1491            ),
1492            _ => local_var_req_builder.query(&[(
1493                "certificate_type__re",
1494                &local_var_str
1495                    .into_iter()
1496                    .map(|p| p.to_string())
1497                    .collect::<Vec<String>>()
1498                    .join(",")
1499                    .to_string(),
1500            )]),
1501        };
1502    }
1503    if let Some(ref local_var_str) = chain_file_path {
1504        local_var_req_builder = match "multi" {
1505            "multi" => local_var_req_builder.query(
1506                &local_var_str
1507                    .into_iter()
1508                    .map(|p| ("chain_file_path".to_owned(), p.to_string()))
1509                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1510            ),
1511            _ => local_var_req_builder.query(&[(
1512                "chain_file_path",
1513                &local_var_str
1514                    .into_iter()
1515                    .map(|p| p.to_string())
1516                    .collect::<Vec<String>>()
1517                    .join(",")
1518                    .to_string(),
1519            )]),
1520        };
1521    }
1522    if let Some(ref local_var_str) = chain_file_path__ic {
1523        local_var_req_builder = match "multi" {
1524            "multi" => local_var_req_builder.query(
1525                &local_var_str
1526                    .into_iter()
1527                    .map(|p| ("chain_file_path__ic".to_owned(), p.to_string()))
1528                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1529            ),
1530            _ => local_var_req_builder.query(&[(
1531                "chain_file_path__ic",
1532                &local_var_str
1533                    .into_iter()
1534                    .map(|p| p.to_string())
1535                    .collect::<Vec<String>>()
1536                    .join(",")
1537                    .to_string(),
1538            )]),
1539        };
1540    }
1541    if let Some(ref local_var_str) = chain_file_path__ie {
1542        local_var_req_builder = match "multi" {
1543            "multi" => local_var_req_builder.query(
1544                &local_var_str
1545                    .into_iter()
1546                    .map(|p| ("chain_file_path__ie".to_owned(), p.to_string()))
1547                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1548            ),
1549            _ => local_var_req_builder.query(&[(
1550                "chain_file_path__ie",
1551                &local_var_str
1552                    .into_iter()
1553                    .map(|p| p.to_string())
1554                    .collect::<Vec<String>>()
1555                    .join(",")
1556                    .to_string(),
1557            )]),
1558        };
1559    }
1560    if let Some(ref local_var_str) = chain_file_path__iew {
1561        local_var_req_builder = match "multi" {
1562            "multi" => local_var_req_builder.query(
1563                &local_var_str
1564                    .into_iter()
1565                    .map(|p| ("chain_file_path__iew".to_owned(), p.to_string()))
1566                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1567            ),
1568            _ => local_var_req_builder.query(&[(
1569                "chain_file_path__iew",
1570                &local_var_str
1571                    .into_iter()
1572                    .map(|p| p.to_string())
1573                    .collect::<Vec<String>>()
1574                    .join(",")
1575                    .to_string(),
1576            )]),
1577        };
1578    }
1579    if let Some(ref local_var_str) = chain_file_path__ire {
1580        local_var_req_builder = match "multi" {
1581            "multi" => local_var_req_builder.query(
1582                &local_var_str
1583                    .into_iter()
1584                    .map(|p| ("chain_file_path__ire".to_owned(), p.to_string()))
1585                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1586            ),
1587            _ => local_var_req_builder.query(&[(
1588                "chain_file_path__ire",
1589                &local_var_str
1590                    .into_iter()
1591                    .map(|p| p.to_string())
1592                    .collect::<Vec<String>>()
1593                    .join(",")
1594                    .to_string(),
1595            )]),
1596        };
1597    }
1598    if let Some(ref local_var_str) = chain_file_path__isw {
1599        local_var_req_builder = match "multi" {
1600            "multi" => local_var_req_builder.query(
1601                &local_var_str
1602                    .into_iter()
1603                    .map(|p| ("chain_file_path__isw".to_owned(), p.to_string()))
1604                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1605            ),
1606            _ => local_var_req_builder.query(&[(
1607                "chain_file_path__isw",
1608                &local_var_str
1609                    .into_iter()
1610                    .map(|p| p.to_string())
1611                    .collect::<Vec<String>>()
1612                    .join(",")
1613                    .to_string(),
1614            )]),
1615        };
1616    }
1617    if let Some(ref local_var_str) = chain_file_path__n {
1618        local_var_req_builder = match "multi" {
1619            "multi" => local_var_req_builder.query(
1620                &local_var_str
1621                    .into_iter()
1622                    .map(|p| ("chain_file_path__n".to_owned(), p.to_string()))
1623                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1624            ),
1625            _ => local_var_req_builder.query(&[(
1626                "chain_file_path__n",
1627                &local_var_str
1628                    .into_iter()
1629                    .map(|p| p.to_string())
1630                    .collect::<Vec<String>>()
1631                    .join(",")
1632                    .to_string(),
1633            )]),
1634        };
1635    }
1636    if let Some(ref local_var_str) = chain_file_path__nic {
1637        local_var_req_builder = match "multi" {
1638            "multi" => local_var_req_builder.query(
1639                &local_var_str
1640                    .into_iter()
1641                    .map(|p| ("chain_file_path__nic".to_owned(), p.to_string()))
1642                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1643            ),
1644            _ => local_var_req_builder.query(&[(
1645                "chain_file_path__nic",
1646                &local_var_str
1647                    .into_iter()
1648                    .map(|p| p.to_string())
1649                    .collect::<Vec<String>>()
1650                    .join(",")
1651                    .to_string(),
1652            )]),
1653        };
1654    }
1655    if let Some(ref local_var_str) = chain_file_path__nie {
1656        local_var_req_builder = match "multi" {
1657            "multi" => local_var_req_builder.query(
1658                &local_var_str
1659                    .into_iter()
1660                    .map(|p| ("chain_file_path__nie".to_owned(), p.to_string()))
1661                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1662            ),
1663            _ => local_var_req_builder.query(&[(
1664                "chain_file_path__nie",
1665                &local_var_str
1666                    .into_iter()
1667                    .map(|p| p.to_string())
1668                    .collect::<Vec<String>>()
1669                    .join(",")
1670                    .to_string(),
1671            )]),
1672        };
1673    }
1674    if let Some(ref local_var_str) = chain_file_path__niew {
1675        local_var_req_builder = match "multi" {
1676            "multi" => local_var_req_builder.query(
1677                &local_var_str
1678                    .into_iter()
1679                    .map(|p| ("chain_file_path__niew".to_owned(), p.to_string()))
1680                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1681            ),
1682            _ => local_var_req_builder.query(&[(
1683                "chain_file_path__niew",
1684                &local_var_str
1685                    .into_iter()
1686                    .map(|p| p.to_string())
1687                    .collect::<Vec<String>>()
1688                    .join(",")
1689                    .to_string(),
1690            )]),
1691        };
1692    }
1693    if let Some(ref local_var_str) = chain_file_path__nire {
1694        local_var_req_builder = match "multi" {
1695            "multi" => local_var_req_builder.query(
1696                &local_var_str
1697                    .into_iter()
1698                    .map(|p| ("chain_file_path__nire".to_owned(), p.to_string()))
1699                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1700            ),
1701            _ => local_var_req_builder.query(&[(
1702                "chain_file_path__nire",
1703                &local_var_str
1704                    .into_iter()
1705                    .map(|p| p.to_string())
1706                    .collect::<Vec<String>>()
1707                    .join(",")
1708                    .to_string(),
1709            )]),
1710        };
1711    }
1712    if let Some(ref local_var_str) = chain_file_path__nisw {
1713        local_var_req_builder = match "multi" {
1714            "multi" => local_var_req_builder.query(
1715                &local_var_str
1716                    .into_iter()
1717                    .map(|p| ("chain_file_path__nisw".to_owned(), p.to_string()))
1718                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1719            ),
1720            _ => local_var_req_builder.query(&[(
1721                "chain_file_path__nisw",
1722                &local_var_str
1723                    .into_iter()
1724                    .map(|p| p.to_string())
1725                    .collect::<Vec<String>>()
1726                    .join(",")
1727                    .to_string(),
1728            )]),
1729        };
1730    }
1731    if let Some(ref local_var_str) = chain_file_path__nre {
1732        local_var_req_builder = match "multi" {
1733            "multi" => local_var_req_builder.query(
1734                &local_var_str
1735                    .into_iter()
1736                    .map(|p| ("chain_file_path__nre".to_owned(), p.to_string()))
1737                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1738            ),
1739            _ => local_var_req_builder.query(&[(
1740                "chain_file_path__nre",
1741                &local_var_str
1742                    .into_iter()
1743                    .map(|p| p.to_string())
1744                    .collect::<Vec<String>>()
1745                    .join(",")
1746                    .to_string(),
1747            )]),
1748        };
1749    }
1750    if let Some(ref local_var_str) = chain_file_path__re {
1751        local_var_req_builder = match "multi" {
1752            "multi" => local_var_req_builder.query(
1753                &local_var_str
1754                    .into_iter()
1755                    .map(|p| ("chain_file_path__re".to_owned(), p.to_string()))
1756                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1757            ),
1758            _ => local_var_req_builder.query(&[(
1759                "chain_file_path__re",
1760                &local_var_str
1761                    .into_iter()
1762                    .map(|p| p.to_string())
1763                    .collect::<Vec<String>>()
1764                    .join(",")
1765                    .to_string(),
1766            )]),
1767        };
1768    }
1769    if let Some(ref local_var_str) = cipher {
1770        local_var_req_builder = match "multi" {
1771            "multi" => local_var_req_builder.query(
1772                &local_var_str
1773                    .into_iter()
1774                    .map(|p| ("cipher".to_owned(), p.to_string()))
1775                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1776            ),
1777            _ => local_var_req_builder.query(&[(
1778                "cipher",
1779                &local_var_str
1780                    .into_iter()
1781                    .map(|p| p.to_string())
1782                    .collect::<Vec<String>>()
1783                    .join(",")
1784                    .to_string(),
1785            )]),
1786        };
1787    }
1788    if let Some(ref local_var_str) = cipher__ic {
1789        local_var_req_builder = match "multi" {
1790            "multi" => local_var_req_builder.query(
1791                &local_var_str
1792                    .into_iter()
1793                    .map(|p| ("cipher__ic".to_owned(), p.to_string()))
1794                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1795            ),
1796            _ => local_var_req_builder.query(&[(
1797                "cipher__ic",
1798                &local_var_str
1799                    .into_iter()
1800                    .map(|p| p.to_string())
1801                    .collect::<Vec<String>>()
1802                    .join(",")
1803                    .to_string(),
1804            )]),
1805        };
1806    }
1807    if let Some(ref local_var_str) = cipher__ie {
1808        local_var_req_builder = match "multi" {
1809            "multi" => local_var_req_builder.query(
1810                &local_var_str
1811                    .into_iter()
1812                    .map(|p| ("cipher__ie".to_owned(), p.to_string()))
1813                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1814            ),
1815            _ => local_var_req_builder.query(&[(
1816                "cipher__ie",
1817                &local_var_str
1818                    .into_iter()
1819                    .map(|p| p.to_string())
1820                    .collect::<Vec<String>>()
1821                    .join(",")
1822                    .to_string(),
1823            )]),
1824        };
1825    }
1826    if let Some(ref local_var_str) = cipher__iew {
1827        local_var_req_builder = match "multi" {
1828            "multi" => local_var_req_builder.query(
1829                &local_var_str
1830                    .into_iter()
1831                    .map(|p| ("cipher__iew".to_owned(), p.to_string()))
1832                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1833            ),
1834            _ => local_var_req_builder.query(&[(
1835                "cipher__iew",
1836                &local_var_str
1837                    .into_iter()
1838                    .map(|p| p.to_string())
1839                    .collect::<Vec<String>>()
1840                    .join(",")
1841                    .to_string(),
1842            )]),
1843        };
1844    }
1845    if let Some(ref local_var_str) = cipher__ire {
1846        local_var_req_builder = match "multi" {
1847            "multi" => local_var_req_builder.query(
1848                &local_var_str
1849                    .into_iter()
1850                    .map(|p| ("cipher__ire".to_owned(), p.to_string()))
1851                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1852            ),
1853            _ => local_var_req_builder.query(&[(
1854                "cipher__ire",
1855                &local_var_str
1856                    .into_iter()
1857                    .map(|p| p.to_string())
1858                    .collect::<Vec<String>>()
1859                    .join(",")
1860                    .to_string(),
1861            )]),
1862        };
1863    }
1864    if let Some(ref local_var_str) = cipher__isw {
1865        local_var_req_builder = match "multi" {
1866            "multi" => local_var_req_builder.query(
1867                &local_var_str
1868                    .into_iter()
1869                    .map(|p| ("cipher__isw".to_owned(), p.to_string()))
1870                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1871            ),
1872            _ => local_var_req_builder.query(&[(
1873                "cipher__isw",
1874                &local_var_str
1875                    .into_iter()
1876                    .map(|p| p.to_string())
1877                    .collect::<Vec<String>>()
1878                    .join(",")
1879                    .to_string(),
1880            )]),
1881        };
1882    }
1883    if let Some(ref local_var_str) = cipher__n {
1884        local_var_req_builder = match "multi" {
1885            "multi" => local_var_req_builder.query(
1886                &local_var_str
1887                    .into_iter()
1888                    .map(|p| ("cipher__n".to_owned(), p.to_string()))
1889                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1890            ),
1891            _ => local_var_req_builder.query(&[(
1892                "cipher__n",
1893                &local_var_str
1894                    .into_iter()
1895                    .map(|p| p.to_string())
1896                    .collect::<Vec<String>>()
1897                    .join(",")
1898                    .to_string(),
1899            )]),
1900        };
1901    }
1902    if let Some(ref local_var_str) = cipher__nic {
1903        local_var_req_builder = match "multi" {
1904            "multi" => local_var_req_builder.query(
1905                &local_var_str
1906                    .into_iter()
1907                    .map(|p| ("cipher__nic".to_owned(), p.to_string()))
1908                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1909            ),
1910            _ => local_var_req_builder.query(&[(
1911                "cipher__nic",
1912                &local_var_str
1913                    .into_iter()
1914                    .map(|p| p.to_string())
1915                    .collect::<Vec<String>>()
1916                    .join(",")
1917                    .to_string(),
1918            )]),
1919        };
1920    }
1921    if let Some(ref local_var_str) = cipher__nie {
1922        local_var_req_builder = match "multi" {
1923            "multi" => local_var_req_builder.query(
1924                &local_var_str
1925                    .into_iter()
1926                    .map(|p| ("cipher__nie".to_owned(), p.to_string()))
1927                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1928            ),
1929            _ => local_var_req_builder.query(&[(
1930                "cipher__nie",
1931                &local_var_str
1932                    .into_iter()
1933                    .map(|p| p.to_string())
1934                    .collect::<Vec<String>>()
1935                    .join(",")
1936                    .to_string(),
1937            )]),
1938        };
1939    }
1940    if let Some(ref local_var_str) = cipher__niew {
1941        local_var_req_builder = match "multi" {
1942            "multi" => local_var_req_builder.query(
1943                &local_var_str
1944                    .into_iter()
1945                    .map(|p| ("cipher__niew".to_owned(), p.to_string()))
1946                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1947            ),
1948            _ => local_var_req_builder.query(&[(
1949                "cipher__niew",
1950                &local_var_str
1951                    .into_iter()
1952                    .map(|p| p.to_string())
1953                    .collect::<Vec<String>>()
1954                    .join(",")
1955                    .to_string(),
1956            )]),
1957        };
1958    }
1959    if let Some(ref local_var_str) = cipher__nire {
1960        local_var_req_builder = match "multi" {
1961            "multi" => local_var_req_builder.query(
1962                &local_var_str
1963                    .into_iter()
1964                    .map(|p| ("cipher__nire".to_owned(), p.to_string()))
1965                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1966            ),
1967            _ => local_var_req_builder.query(&[(
1968                "cipher__nire",
1969                &local_var_str
1970                    .into_iter()
1971                    .map(|p| p.to_string())
1972                    .collect::<Vec<String>>()
1973                    .join(",")
1974                    .to_string(),
1975            )]),
1976        };
1977    }
1978    if let Some(ref local_var_str) = cipher__nisw {
1979        local_var_req_builder = match "multi" {
1980            "multi" => local_var_req_builder.query(
1981                &local_var_str
1982                    .into_iter()
1983                    .map(|p| ("cipher__nisw".to_owned(), p.to_string()))
1984                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1985            ),
1986            _ => local_var_req_builder.query(&[(
1987                "cipher__nisw",
1988                &local_var_str
1989                    .into_iter()
1990                    .map(|p| p.to_string())
1991                    .collect::<Vec<String>>()
1992                    .join(",")
1993                    .to_string(),
1994            )]),
1995        };
1996    }
1997    if let Some(ref local_var_str) = cipher__nre {
1998        local_var_req_builder = match "multi" {
1999            "multi" => local_var_req_builder.query(
2000                &local_var_str
2001                    .into_iter()
2002                    .map(|p| ("cipher__nre".to_owned(), p.to_string()))
2003                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2004            ),
2005            _ => local_var_req_builder.query(&[(
2006                "cipher__nre",
2007                &local_var_str
2008                    .into_iter()
2009                    .map(|p| p.to_string())
2010                    .collect::<Vec<String>>()
2011                    .join(",")
2012                    .to_string(),
2013            )]),
2014        };
2015    }
2016    if let Some(ref local_var_str) = cipher__re {
2017        local_var_req_builder = match "multi" {
2018            "multi" => local_var_req_builder.query(
2019                &local_var_str
2020                    .into_iter()
2021                    .map(|p| ("cipher__re".to_owned(), p.to_string()))
2022                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2023            ),
2024            _ => local_var_req_builder.query(&[(
2025                "cipher__re",
2026                &local_var_str
2027                    .into_iter()
2028                    .map(|p| p.to_string())
2029                    .collect::<Vec<String>>()
2030                    .join(",")
2031                    .to_string(),
2032            )]),
2033        };
2034    }
2035    if let Some(ref local_var_str) = contacts {
2036        local_var_req_builder = match "multi" {
2037            "multi" => local_var_req_builder.query(
2038                &local_var_str
2039                    .into_iter()
2040                    .map(|p| ("contacts".to_owned(), p.to_string()))
2041                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2042            ),
2043            _ => local_var_req_builder.query(&[(
2044                "contacts",
2045                &local_var_str
2046                    .into_iter()
2047                    .map(|p| p.to_string())
2048                    .collect::<Vec<String>>()
2049                    .join(",")
2050                    .to_string(),
2051            )]),
2052        };
2053    }
2054    if let Some(ref local_var_str) = contacts__isnull {
2055        local_var_req_builder =
2056            local_var_req_builder.query(&[("contacts__isnull", &local_var_str.to_string())]);
2057    }
2058    if let Some(ref local_var_str) = contacts__n {
2059        local_var_req_builder = match "multi" {
2060            "multi" => local_var_req_builder.query(
2061                &local_var_str
2062                    .into_iter()
2063                    .map(|p| ("contacts__n".to_owned(), p.to_string()))
2064                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2065            ),
2066            _ => local_var_req_builder.query(&[(
2067                "contacts__n",
2068                &local_var_str
2069                    .into_iter()
2070                    .map(|p| p.to_string())
2071                    .collect::<Vec<String>>()
2072                    .join(",")
2073                    .to_string(),
2074            )]),
2075        };
2076    }
2077    if let Some(ref local_var_str) = created {
2078        local_var_req_builder = match "multi" {
2079            "multi" => local_var_req_builder.query(
2080                &local_var_str
2081                    .into_iter()
2082                    .map(|p| ("created".to_owned(), p.to_string()))
2083                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2084            ),
2085            _ => local_var_req_builder.query(&[(
2086                "created",
2087                &local_var_str
2088                    .into_iter()
2089                    .map(|p| p.to_string())
2090                    .collect::<Vec<String>>()
2091                    .join(",")
2092                    .to_string(),
2093            )]),
2094        };
2095    }
2096    if let Some(ref local_var_str) = created__gt {
2097        local_var_req_builder = match "multi" {
2098            "multi" => local_var_req_builder.query(
2099                &local_var_str
2100                    .into_iter()
2101                    .map(|p| ("created__gt".to_owned(), p.to_string()))
2102                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2103            ),
2104            _ => local_var_req_builder.query(&[(
2105                "created__gt",
2106                &local_var_str
2107                    .into_iter()
2108                    .map(|p| p.to_string())
2109                    .collect::<Vec<String>>()
2110                    .join(",")
2111                    .to_string(),
2112            )]),
2113        };
2114    }
2115    if let Some(ref local_var_str) = created__gte {
2116        local_var_req_builder = match "multi" {
2117            "multi" => local_var_req_builder.query(
2118                &local_var_str
2119                    .into_iter()
2120                    .map(|p| ("created__gte".to_owned(), p.to_string()))
2121                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2122            ),
2123            _ => local_var_req_builder.query(&[(
2124                "created__gte",
2125                &local_var_str
2126                    .into_iter()
2127                    .map(|p| p.to_string())
2128                    .collect::<Vec<String>>()
2129                    .join(",")
2130                    .to_string(),
2131            )]),
2132        };
2133    }
2134    if let Some(ref local_var_str) = created__isnull {
2135        local_var_req_builder =
2136            local_var_req_builder.query(&[("created__isnull", &local_var_str.to_string())]);
2137    }
2138    if let Some(ref local_var_str) = created__lt {
2139        local_var_req_builder = match "multi" {
2140            "multi" => local_var_req_builder.query(
2141                &local_var_str
2142                    .into_iter()
2143                    .map(|p| ("created__lt".to_owned(), p.to_string()))
2144                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2145            ),
2146            _ => local_var_req_builder.query(&[(
2147                "created__lt",
2148                &local_var_str
2149                    .into_iter()
2150                    .map(|p| p.to_string())
2151                    .collect::<Vec<String>>()
2152                    .join(",")
2153                    .to_string(),
2154            )]),
2155        };
2156    }
2157    if let Some(ref local_var_str) = created__lte {
2158        local_var_req_builder = match "multi" {
2159            "multi" => local_var_req_builder.query(
2160                &local_var_str
2161                    .into_iter()
2162                    .map(|p| ("created__lte".to_owned(), p.to_string()))
2163                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2164            ),
2165            _ => local_var_req_builder.query(&[(
2166                "created__lte",
2167                &local_var_str
2168                    .into_iter()
2169                    .map(|p| p.to_string())
2170                    .collect::<Vec<String>>()
2171                    .join(",")
2172                    .to_string(),
2173            )]),
2174        };
2175    }
2176    if let Some(ref local_var_str) = created__n {
2177        local_var_req_builder = match "multi" {
2178            "multi" => local_var_req_builder.query(
2179                &local_var_str
2180                    .into_iter()
2181                    .map(|p| ("created__n".to_owned(), p.to_string()))
2182                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2183            ),
2184            _ => local_var_req_builder.query(&[(
2185                "created__n",
2186                &local_var_str
2187                    .into_iter()
2188                    .map(|p| p.to_string())
2189                    .collect::<Vec<String>>()
2190                    .join(",")
2191                    .to_string(),
2192            )]),
2193        };
2194    }
2195    if let Some(ref local_var_str) = dynamic_groups {
2196        local_var_req_builder = match "multi" {
2197            "multi" => local_var_req_builder.query(
2198                &local_var_str
2199                    .into_iter()
2200                    .map(|p| ("dynamic_groups".to_owned(), p.to_string()))
2201                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2202            ),
2203            _ => local_var_req_builder.query(&[(
2204                "dynamic_groups",
2205                &local_var_str
2206                    .into_iter()
2207                    .map(|p| p.to_string())
2208                    .collect::<Vec<String>>()
2209                    .join(",")
2210                    .to_string(),
2211            )]),
2212        };
2213    }
2214    if let Some(ref local_var_str) = dynamic_groups__n {
2215        local_var_req_builder = match "multi" {
2216            "multi" => local_var_req_builder.query(
2217                &local_var_str
2218                    .into_iter()
2219                    .map(|p| ("dynamic_groups__n".to_owned(), p.to_string()))
2220                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2221            ),
2222            _ => local_var_req_builder.query(&[(
2223                "dynamic_groups__n",
2224                &local_var_str
2225                    .into_iter()
2226                    .map(|p| p.to_string())
2227                    .collect::<Vec<String>>()
2228                    .join(",")
2229                    .to_string(),
2230            )]),
2231        };
2232    }
2233    if let Some(ref local_var_str) = expiration_date {
2234        local_var_req_builder = match "multi" {
2235            "multi" => local_var_req_builder.query(
2236                &local_var_str
2237                    .into_iter()
2238                    .map(|p| ("expiration_date".to_owned(), p.to_string()))
2239                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2240            ),
2241            _ => local_var_req_builder.query(&[(
2242                "expiration_date",
2243                &local_var_str
2244                    .into_iter()
2245                    .map(|p| p.to_string())
2246                    .collect::<Vec<String>>()
2247                    .join(",")
2248                    .to_string(),
2249            )]),
2250        };
2251    }
2252    if let Some(ref local_var_str) = expiration_date__gt {
2253        local_var_req_builder = match "multi" {
2254            "multi" => local_var_req_builder.query(
2255                &local_var_str
2256                    .into_iter()
2257                    .map(|p| ("expiration_date__gt".to_owned(), p.to_string()))
2258                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2259            ),
2260            _ => local_var_req_builder.query(&[(
2261                "expiration_date__gt",
2262                &local_var_str
2263                    .into_iter()
2264                    .map(|p| p.to_string())
2265                    .collect::<Vec<String>>()
2266                    .join(",")
2267                    .to_string(),
2268            )]),
2269        };
2270    }
2271    if let Some(ref local_var_str) = expiration_date__gte {
2272        local_var_req_builder = match "multi" {
2273            "multi" => local_var_req_builder.query(
2274                &local_var_str
2275                    .into_iter()
2276                    .map(|p| ("expiration_date__gte".to_owned(), p.to_string()))
2277                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2278            ),
2279            _ => local_var_req_builder.query(&[(
2280                "expiration_date__gte",
2281                &local_var_str
2282                    .into_iter()
2283                    .map(|p| p.to_string())
2284                    .collect::<Vec<String>>()
2285                    .join(",")
2286                    .to_string(),
2287            )]),
2288        };
2289    }
2290    if let Some(ref local_var_str) = expiration_date__isnull {
2291        local_var_req_builder =
2292            local_var_req_builder.query(&[("expiration_date__isnull", &local_var_str.to_string())]);
2293    }
2294    if let Some(ref local_var_str) = expiration_date__lt {
2295        local_var_req_builder = match "multi" {
2296            "multi" => local_var_req_builder.query(
2297                &local_var_str
2298                    .into_iter()
2299                    .map(|p| ("expiration_date__lt".to_owned(), p.to_string()))
2300                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2301            ),
2302            _ => local_var_req_builder.query(&[(
2303                "expiration_date__lt",
2304                &local_var_str
2305                    .into_iter()
2306                    .map(|p| p.to_string())
2307                    .collect::<Vec<String>>()
2308                    .join(",")
2309                    .to_string(),
2310            )]),
2311        };
2312    }
2313    if let Some(ref local_var_str) = expiration_date__lte {
2314        local_var_req_builder = match "multi" {
2315            "multi" => local_var_req_builder.query(
2316                &local_var_str
2317                    .into_iter()
2318                    .map(|p| ("expiration_date__lte".to_owned(), p.to_string()))
2319                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2320            ),
2321            _ => local_var_req_builder.query(&[(
2322                "expiration_date__lte",
2323                &local_var_str
2324                    .into_iter()
2325                    .map(|p| p.to_string())
2326                    .collect::<Vec<String>>()
2327                    .join(",")
2328                    .to_string(),
2329            )]),
2330        };
2331    }
2332    if let Some(ref local_var_str) = expiration_date__n {
2333        local_var_req_builder = match "multi" {
2334            "multi" => local_var_req_builder.query(
2335                &local_var_str
2336                    .into_iter()
2337                    .map(|p| ("expiration_date__n".to_owned(), p.to_string()))
2338                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2339            ),
2340            _ => local_var_req_builder.query(&[(
2341                "expiration_date__n",
2342                &local_var_str
2343                    .into_iter()
2344                    .map(|p| p.to_string())
2345                    .collect::<Vec<String>>()
2346                    .join(",")
2347                    .to_string(),
2348            )]),
2349        };
2350    }
2351    if let Some(ref local_var_str) = format {
2352        local_var_req_builder =
2353            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
2354    }
2355    if let Some(ref local_var_str) = id {
2356        local_var_req_builder = match "multi" {
2357            "multi" => local_var_req_builder.query(
2358                &local_var_str
2359                    .into_iter()
2360                    .map(|p| ("id".to_owned(), p.to_string()))
2361                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2362            ),
2363            _ => local_var_req_builder.query(&[(
2364                "id",
2365                &local_var_str
2366                    .into_iter()
2367                    .map(|p| p.to_string())
2368                    .collect::<Vec<String>>()
2369                    .join(",")
2370                    .to_string(),
2371            )]),
2372        };
2373    }
2374    if let Some(ref local_var_str) = id__n {
2375        local_var_req_builder = match "multi" {
2376            "multi" => local_var_req_builder.query(
2377                &local_var_str
2378                    .into_iter()
2379                    .map(|p| ("id__n".to_owned(), p.to_string()))
2380                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2381            ),
2382            _ => local_var_req_builder.query(&[(
2383                "id__n",
2384                &local_var_str
2385                    .into_iter()
2386                    .map(|p| p.to_string())
2387                    .collect::<Vec<String>>()
2388                    .join(",")
2389                    .to_string(),
2390            )]),
2391        };
2392    }
2393    if let Some(ref local_var_str) = key_file_path {
2394        local_var_req_builder = match "multi" {
2395            "multi" => local_var_req_builder.query(
2396                &local_var_str
2397                    .into_iter()
2398                    .map(|p| ("key_file_path".to_owned(), p.to_string()))
2399                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2400            ),
2401            _ => local_var_req_builder.query(&[(
2402                "key_file_path",
2403                &local_var_str
2404                    .into_iter()
2405                    .map(|p| p.to_string())
2406                    .collect::<Vec<String>>()
2407                    .join(",")
2408                    .to_string(),
2409            )]),
2410        };
2411    }
2412    if let Some(ref local_var_str) = key_file_path__ic {
2413        local_var_req_builder = match "multi" {
2414            "multi" => local_var_req_builder.query(
2415                &local_var_str
2416                    .into_iter()
2417                    .map(|p| ("key_file_path__ic".to_owned(), p.to_string()))
2418                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2419            ),
2420            _ => local_var_req_builder.query(&[(
2421                "key_file_path__ic",
2422                &local_var_str
2423                    .into_iter()
2424                    .map(|p| p.to_string())
2425                    .collect::<Vec<String>>()
2426                    .join(",")
2427                    .to_string(),
2428            )]),
2429        };
2430    }
2431    if let Some(ref local_var_str) = key_file_path__ie {
2432        local_var_req_builder = match "multi" {
2433            "multi" => local_var_req_builder.query(
2434                &local_var_str
2435                    .into_iter()
2436                    .map(|p| ("key_file_path__ie".to_owned(), p.to_string()))
2437                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2438            ),
2439            _ => local_var_req_builder.query(&[(
2440                "key_file_path__ie",
2441                &local_var_str
2442                    .into_iter()
2443                    .map(|p| p.to_string())
2444                    .collect::<Vec<String>>()
2445                    .join(",")
2446                    .to_string(),
2447            )]),
2448        };
2449    }
2450    if let Some(ref local_var_str) = key_file_path__iew {
2451        local_var_req_builder = match "multi" {
2452            "multi" => local_var_req_builder.query(
2453                &local_var_str
2454                    .into_iter()
2455                    .map(|p| ("key_file_path__iew".to_owned(), p.to_string()))
2456                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2457            ),
2458            _ => local_var_req_builder.query(&[(
2459                "key_file_path__iew",
2460                &local_var_str
2461                    .into_iter()
2462                    .map(|p| p.to_string())
2463                    .collect::<Vec<String>>()
2464                    .join(",")
2465                    .to_string(),
2466            )]),
2467        };
2468    }
2469    if let Some(ref local_var_str) = key_file_path__ire {
2470        local_var_req_builder = match "multi" {
2471            "multi" => local_var_req_builder.query(
2472                &local_var_str
2473                    .into_iter()
2474                    .map(|p| ("key_file_path__ire".to_owned(), p.to_string()))
2475                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2476            ),
2477            _ => local_var_req_builder.query(&[(
2478                "key_file_path__ire",
2479                &local_var_str
2480                    .into_iter()
2481                    .map(|p| p.to_string())
2482                    .collect::<Vec<String>>()
2483                    .join(",")
2484                    .to_string(),
2485            )]),
2486        };
2487    }
2488    if let Some(ref local_var_str) = key_file_path__isw {
2489        local_var_req_builder = match "multi" {
2490            "multi" => local_var_req_builder.query(
2491                &local_var_str
2492                    .into_iter()
2493                    .map(|p| ("key_file_path__isw".to_owned(), p.to_string()))
2494                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2495            ),
2496            _ => local_var_req_builder.query(&[(
2497                "key_file_path__isw",
2498                &local_var_str
2499                    .into_iter()
2500                    .map(|p| p.to_string())
2501                    .collect::<Vec<String>>()
2502                    .join(",")
2503                    .to_string(),
2504            )]),
2505        };
2506    }
2507    if let Some(ref local_var_str) = key_file_path__n {
2508        local_var_req_builder = match "multi" {
2509            "multi" => local_var_req_builder.query(
2510                &local_var_str
2511                    .into_iter()
2512                    .map(|p| ("key_file_path__n".to_owned(), p.to_string()))
2513                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2514            ),
2515            _ => local_var_req_builder.query(&[(
2516                "key_file_path__n",
2517                &local_var_str
2518                    .into_iter()
2519                    .map(|p| p.to_string())
2520                    .collect::<Vec<String>>()
2521                    .join(",")
2522                    .to_string(),
2523            )]),
2524        };
2525    }
2526    if let Some(ref local_var_str) = key_file_path__nic {
2527        local_var_req_builder = match "multi" {
2528            "multi" => local_var_req_builder.query(
2529                &local_var_str
2530                    .into_iter()
2531                    .map(|p| ("key_file_path__nic".to_owned(), p.to_string()))
2532                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2533            ),
2534            _ => local_var_req_builder.query(&[(
2535                "key_file_path__nic",
2536                &local_var_str
2537                    .into_iter()
2538                    .map(|p| p.to_string())
2539                    .collect::<Vec<String>>()
2540                    .join(",")
2541                    .to_string(),
2542            )]),
2543        };
2544    }
2545    if let Some(ref local_var_str) = key_file_path__nie {
2546        local_var_req_builder = match "multi" {
2547            "multi" => local_var_req_builder.query(
2548                &local_var_str
2549                    .into_iter()
2550                    .map(|p| ("key_file_path__nie".to_owned(), p.to_string()))
2551                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2552            ),
2553            _ => local_var_req_builder.query(&[(
2554                "key_file_path__nie",
2555                &local_var_str
2556                    .into_iter()
2557                    .map(|p| p.to_string())
2558                    .collect::<Vec<String>>()
2559                    .join(",")
2560                    .to_string(),
2561            )]),
2562        };
2563    }
2564    if let Some(ref local_var_str) = key_file_path__niew {
2565        local_var_req_builder = match "multi" {
2566            "multi" => local_var_req_builder.query(
2567                &local_var_str
2568                    .into_iter()
2569                    .map(|p| ("key_file_path__niew".to_owned(), p.to_string()))
2570                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2571            ),
2572            _ => local_var_req_builder.query(&[(
2573                "key_file_path__niew",
2574                &local_var_str
2575                    .into_iter()
2576                    .map(|p| p.to_string())
2577                    .collect::<Vec<String>>()
2578                    .join(",")
2579                    .to_string(),
2580            )]),
2581        };
2582    }
2583    if let Some(ref local_var_str) = key_file_path__nire {
2584        local_var_req_builder = match "multi" {
2585            "multi" => local_var_req_builder.query(
2586                &local_var_str
2587                    .into_iter()
2588                    .map(|p| ("key_file_path__nire".to_owned(), p.to_string()))
2589                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2590            ),
2591            _ => local_var_req_builder.query(&[(
2592                "key_file_path__nire",
2593                &local_var_str
2594                    .into_iter()
2595                    .map(|p| p.to_string())
2596                    .collect::<Vec<String>>()
2597                    .join(",")
2598                    .to_string(),
2599            )]),
2600        };
2601    }
2602    if let Some(ref local_var_str) = key_file_path__nisw {
2603        local_var_req_builder = match "multi" {
2604            "multi" => local_var_req_builder.query(
2605                &local_var_str
2606                    .into_iter()
2607                    .map(|p| ("key_file_path__nisw".to_owned(), p.to_string()))
2608                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2609            ),
2610            _ => local_var_req_builder.query(&[(
2611                "key_file_path__nisw",
2612                &local_var_str
2613                    .into_iter()
2614                    .map(|p| p.to_string())
2615                    .collect::<Vec<String>>()
2616                    .join(",")
2617                    .to_string(),
2618            )]),
2619        };
2620    }
2621    if let Some(ref local_var_str) = key_file_path__nre {
2622        local_var_req_builder = match "multi" {
2623            "multi" => local_var_req_builder.query(
2624                &local_var_str
2625                    .into_iter()
2626                    .map(|p| ("key_file_path__nre".to_owned(), p.to_string()))
2627                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2628            ),
2629            _ => local_var_req_builder.query(&[(
2630                "key_file_path__nre",
2631                &local_var_str
2632                    .into_iter()
2633                    .map(|p| p.to_string())
2634                    .collect::<Vec<String>>()
2635                    .join(",")
2636                    .to_string(),
2637            )]),
2638        };
2639    }
2640    if let Some(ref local_var_str) = key_file_path__re {
2641        local_var_req_builder = match "multi" {
2642            "multi" => local_var_req_builder.query(
2643                &local_var_str
2644                    .into_iter()
2645                    .map(|p| ("key_file_path__re".to_owned(), p.to_string()))
2646                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2647            ),
2648            _ => local_var_req_builder.query(&[(
2649                "key_file_path__re",
2650                &local_var_str
2651                    .into_iter()
2652                    .map(|p| p.to_string())
2653                    .collect::<Vec<String>>()
2654                    .join(",")
2655                    .to_string(),
2656            )]),
2657        };
2658    }
2659    if let Some(ref local_var_str) = last_updated {
2660        local_var_req_builder = match "multi" {
2661            "multi" => local_var_req_builder.query(
2662                &local_var_str
2663                    .into_iter()
2664                    .map(|p| ("last_updated".to_owned(), p.to_string()))
2665                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2666            ),
2667            _ => local_var_req_builder.query(&[(
2668                "last_updated",
2669                &local_var_str
2670                    .into_iter()
2671                    .map(|p| p.to_string())
2672                    .collect::<Vec<String>>()
2673                    .join(",")
2674                    .to_string(),
2675            )]),
2676        };
2677    }
2678    if let Some(ref local_var_str) = last_updated__gt {
2679        local_var_req_builder = match "multi" {
2680            "multi" => local_var_req_builder.query(
2681                &local_var_str
2682                    .into_iter()
2683                    .map(|p| ("last_updated__gt".to_owned(), p.to_string()))
2684                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2685            ),
2686            _ => local_var_req_builder.query(&[(
2687                "last_updated__gt",
2688                &local_var_str
2689                    .into_iter()
2690                    .map(|p| p.to_string())
2691                    .collect::<Vec<String>>()
2692                    .join(",")
2693                    .to_string(),
2694            )]),
2695        };
2696    }
2697    if let Some(ref local_var_str) = last_updated__gte {
2698        local_var_req_builder = match "multi" {
2699            "multi" => local_var_req_builder.query(
2700                &local_var_str
2701                    .into_iter()
2702                    .map(|p| ("last_updated__gte".to_owned(), p.to_string()))
2703                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2704            ),
2705            _ => local_var_req_builder.query(&[(
2706                "last_updated__gte",
2707                &local_var_str
2708                    .into_iter()
2709                    .map(|p| p.to_string())
2710                    .collect::<Vec<String>>()
2711                    .join(",")
2712                    .to_string(),
2713            )]),
2714        };
2715    }
2716    if let Some(ref local_var_str) = last_updated__isnull {
2717        local_var_req_builder =
2718            local_var_req_builder.query(&[("last_updated__isnull", &local_var_str.to_string())]);
2719    }
2720    if let Some(ref local_var_str) = last_updated__lt {
2721        local_var_req_builder = match "multi" {
2722            "multi" => local_var_req_builder.query(
2723                &local_var_str
2724                    .into_iter()
2725                    .map(|p| ("last_updated__lt".to_owned(), p.to_string()))
2726                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2727            ),
2728            _ => local_var_req_builder.query(&[(
2729                "last_updated__lt",
2730                &local_var_str
2731                    .into_iter()
2732                    .map(|p| p.to_string())
2733                    .collect::<Vec<String>>()
2734                    .join(",")
2735                    .to_string(),
2736            )]),
2737        };
2738    }
2739    if let Some(ref local_var_str) = last_updated__lte {
2740        local_var_req_builder = match "multi" {
2741            "multi" => local_var_req_builder.query(
2742                &local_var_str
2743                    .into_iter()
2744                    .map(|p| ("last_updated__lte".to_owned(), p.to_string()))
2745                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2746            ),
2747            _ => local_var_req_builder.query(&[(
2748                "last_updated__lte",
2749                &local_var_str
2750                    .into_iter()
2751                    .map(|p| p.to_string())
2752                    .collect::<Vec<String>>()
2753                    .join(",")
2754                    .to_string(),
2755            )]),
2756        };
2757    }
2758    if let Some(ref local_var_str) = last_updated__n {
2759        local_var_req_builder = match "multi" {
2760            "multi" => local_var_req_builder.query(
2761                &local_var_str
2762                    .into_iter()
2763                    .map(|p| ("last_updated__n".to_owned(), p.to_string()))
2764                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2765            ),
2766            _ => local_var_req_builder.query(&[(
2767                "last_updated__n",
2768                &local_var_str
2769                    .into_iter()
2770                    .map(|p| p.to_string())
2771                    .collect::<Vec<String>>()
2772                    .join(",")
2773                    .to_string(),
2774            )]),
2775        };
2776    }
2777    if let Some(ref local_var_str) = limit {
2778        local_var_req_builder =
2779            local_var_req_builder.query(&[("limit", &local_var_str.to_string())]);
2780    }
2781    if let Some(ref local_var_str) = load_balancer_pool_members {
2782        local_var_req_builder = match "multi" {
2783            "multi" => local_var_req_builder.query(
2784                &local_var_str
2785                    .into_iter()
2786                    .map(|p| ("load_balancer_pool_members".to_owned(), p.to_string()))
2787                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2788            ),
2789            _ => local_var_req_builder.query(&[(
2790                "load_balancer_pool_members",
2791                &local_var_str
2792                    .into_iter()
2793                    .map(|p| p.to_string())
2794                    .collect::<Vec<String>>()
2795                    .join(",")
2796                    .to_string(),
2797            )]),
2798        };
2799    }
2800    if let Some(ref local_var_str) = load_balancer_pool_members__isnull {
2801        local_var_req_builder = local_var_req_builder.query(&[(
2802            "load_balancer_pool_members__isnull",
2803            &local_var_str.to_string(),
2804        )]);
2805    }
2806    if let Some(ref local_var_str) = load_balancer_pool_members__n {
2807        local_var_req_builder = match "multi" {
2808            "multi" => local_var_req_builder.query(
2809                &local_var_str
2810                    .into_iter()
2811                    .map(|p| ("load_balancer_pool_members__n".to_owned(), p.to_string()))
2812                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2813            ),
2814            _ => local_var_req_builder.query(&[(
2815                "load_balancer_pool_members__n",
2816                &local_var_str
2817                    .into_iter()
2818                    .map(|p| p.to_string())
2819                    .collect::<Vec<String>>()
2820                    .join(",")
2821                    .to_string(),
2822            )]),
2823        };
2824    }
2825    if let Some(ref local_var_str) = name {
2826        local_var_req_builder = match "multi" {
2827            "multi" => local_var_req_builder.query(
2828                &local_var_str
2829                    .into_iter()
2830                    .map(|p| ("name".to_owned(), p.to_string()))
2831                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2832            ),
2833            _ => local_var_req_builder.query(&[(
2834                "name",
2835                &local_var_str
2836                    .into_iter()
2837                    .map(|p| p.to_string())
2838                    .collect::<Vec<String>>()
2839                    .join(",")
2840                    .to_string(),
2841            )]),
2842        };
2843    }
2844    if let Some(ref local_var_str) = name__ic {
2845        local_var_req_builder = match "multi" {
2846            "multi" => local_var_req_builder.query(
2847                &local_var_str
2848                    .into_iter()
2849                    .map(|p| ("name__ic".to_owned(), p.to_string()))
2850                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2851            ),
2852            _ => local_var_req_builder.query(&[(
2853                "name__ic",
2854                &local_var_str
2855                    .into_iter()
2856                    .map(|p| p.to_string())
2857                    .collect::<Vec<String>>()
2858                    .join(",")
2859                    .to_string(),
2860            )]),
2861        };
2862    }
2863    if let Some(ref local_var_str) = name__ie {
2864        local_var_req_builder = match "multi" {
2865            "multi" => local_var_req_builder.query(
2866                &local_var_str
2867                    .into_iter()
2868                    .map(|p| ("name__ie".to_owned(), p.to_string()))
2869                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2870            ),
2871            _ => local_var_req_builder.query(&[(
2872                "name__ie",
2873                &local_var_str
2874                    .into_iter()
2875                    .map(|p| p.to_string())
2876                    .collect::<Vec<String>>()
2877                    .join(",")
2878                    .to_string(),
2879            )]),
2880        };
2881    }
2882    if let Some(ref local_var_str) = name__iew {
2883        local_var_req_builder = match "multi" {
2884            "multi" => local_var_req_builder.query(
2885                &local_var_str
2886                    .into_iter()
2887                    .map(|p| ("name__iew".to_owned(), p.to_string()))
2888                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2889            ),
2890            _ => local_var_req_builder.query(&[(
2891                "name__iew",
2892                &local_var_str
2893                    .into_iter()
2894                    .map(|p| p.to_string())
2895                    .collect::<Vec<String>>()
2896                    .join(",")
2897                    .to_string(),
2898            )]),
2899        };
2900    }
2901    if let Some(ref local_var_str) = name__ire {
2902        local_var_req_builder = match "multi" {
2903            "multi" => local_var_req_builder.query(
2904                &local_var_str
2905                    .into_iter()
2906                    .map(|p| ("name__ire".to_owned(), p.to_string()))
2907                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2908            ),
2909            _ => local_var_req_builder.query(&[(
2910                "name__ire",
2911                &local_var_str
2912                    .into_iter()
2913                    .map(|p| p.to_string())
2914                    .collect::<Vec<String>>()
2915                    .join(",")
2916                    .to_string(),
2917            )]),
2918        };
2919    }
2920    if let Some(ref local_var_str) = name__isw {
2921        local_var_req_builder = match "multi" {
2922            "multi" => local_var_req_builder.query(
2923                &local_var_str
2924                    .into_iter()
2925                    .map(|p| ("name__isw".to_owned(), p.to_string()))
2926                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2927            ),
2928            _ => local_var_req_builder.query(&[(
2929                "name__isw",
2930                &local_var_str
2931                    .into_iter()
2932                    .map(|p| p.to_string())
2933                    .collect::<Vec<String>>()
2934                    .join(",")
2935                    .to_string(),
2936            )]),
2937        };
2938    }
2939    if let Some(ref local_var_str) = name__n {
2940        local_var_req_builder = match "multi" {
2941            "multi" => local_var_req_builder.query(
2942                &local_var_str
2943                    .into_iter()
2944                    .map(|p| ("name__n".to_owned(), p.to_string()))
2945                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2946            ),
2947            _ => local_var_req_builder.query(&[(
2948                "name__n",
2949                &local_var_str
2950                    .into_iter()
2951                    .map(|p| p.to_string())
2952                    .collect::<Vec<String>>()
2953                    .join(",")
2954                    .to_string(),
2955            )]),
2956        };
2957    }
2958    if let Some(ref local_var_str) = name__nic {
2959        local_var_req_builder = match "multi" {
2960            "multi" => local_var_req_builder.query(
2961                &local_var_str
2962                    .into_iter()
2963                    .map(|p| ("name__nic".to_owned(), p.to_string()))
2964                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2965            ),
2966            _ => local_var_req_builder.query(&[(
2967                "name__nic",
2968                &local_var_str
2969                    .into_iter()
2970                    .map(|p| p.to_string())
2971                    .collect::<Vec<String>>()
2972                    .join(",")
2973                    .to_string(),
2974            )]),
2975        };
2976    }
2977    if let Some(ref local_var_str) = name__nie {
2978        local_var_req_builder = match "multi" {
2979            "multi" => local_var_req_builder.query(
2980                &local_var_str
2981                    .into_iter()
2982                    .map(|p| ("name__nie".to_owned(), p.to_string()))
2983                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2984            ),
2985            _ => local_var_req_builder.query(&[(
2986                "name__nie",
2987                &local_var_str
2988                    .into_iter()
2989                    .map(|p| p.to_string())
2990                    .collect::<Vec<String>>()
2991                    .join(",")
2992                    .to_string(),
2993            )]),
2994        };
2995    }
2996    if let Some(ref local_var_str) = name__niew {
2997        local_var_req_builder = match "multi" {
2998            "multi" => local_var_req_builder.query(
2999                &local_var_str
3000                    .into_iter()
3001                    .map(|p| ("name__niew".to_owned(), p.to_string()))
3002                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3003            ),
3004            _ => local_var_req_builder.query(&[(
3005                "name__niew",
3006                &local_var_str
3007                    .into_iter()
3008                    .map(|p| p.to_string())
3009                    .collect::<Vec<String>>()
3010                    .join(",")
3011                    .to_string(),
3012            )]),
3013        };
3014    }
3015    if let Some(ref local_var_str) = name__nire {
3016        local_var_req_builder = match "multi" {
3017            "multi" => local_var_req_builder.query(
3018                &local_var_str
3019                    .into_iter()
3020                    .map(|p| ("name__nire".to_owned(), p.to_string()))
3021                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3022            ),
3023            _ => local_var_req_builder.query(&[(
3024                "name__nire",
3025                &local_var_str
3026                    .into_iter()
3027                    .map(|p| p.to_string())
3028                    .collect::<Vec<String>>()
3029                    .join(",")
3030                    .to_string(),
3031            )]),
3032        };
3033    }
3034    if let Some(ref local_var_str) = name__nisw {
3035        local_var_req_builder = match "multi" {
3036            "multi" => local_var_req_builder.query(
3037                &local_var_str
3038                    .into_iter()
3039                    .map(|p| ("name__nisw".to_owned(), p.to_string()))
3040                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3041            ),
3042            _ => local_var_req_builder.query(&[(
3043                "name__nisw",
3044                &local_var_str
3045                    .into_iter()
3046                    .map(|p| p.to_string())
3047                    .collect::<Vec<String>>()
3048                    .join(",")
3049                    .to_string(),
3050            )]),
3051        };
3052    }
3053    if let Some(ref local_var_str) = name__nre {
3054        local_var_req_builder = match "multi" {
3055            "multi" => local_var_req_builder.query(
3056                &local_var_str
3057                    .into_iter()
3058                    .map(|p| ("name__nre".to_owned(), p.to_string()))
3059                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3060            ),
3061            _ => local_var_req_builder.query(&[(
3062                "name__nre",
3063                &local_var_str
3064                    .into_iter()
3065                    .map(|p| p.to_string())
3066                    .collect::<Vec<String>>()
3067                    .join(",")
3068                    .to_string(),
3069            )]),
3070        };
3071    }
3072    if let Some(ref local_var_str) = name__re {
3073        local_var_req_builder = match "multi" {
3074            "multi" => local_var_req_builder.query(
3075                &local_var_str
3076                    .into_iter()
3077                    .map(|p| ("name__re".to_owned(), p.to_string()))
3078                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3079            ),
3080            _ => local_var_req_builder.query(&[(
3081                "name__re",
3082                &local_var_str
3083                    .into_iter()
3084                    .map(|p| p.to_string())
3085                    .collect::<Vec<String>>()
3086                    .join(",")
3087                    .to_string(),
3088            )]),
3089        };
3090    }
3091    if let Some(ref local_var_str) = offset {
3092        local_var_req_builder =
3093            local_var_req_builder.query(&[("offset", &local_var_str.to_string())]);
3094    }
3095    if let Some(ref local_var_str) = q {
3096        local_var_req_builder = local_var_req_builder.query(&[("q", &local_var_str.to_string())]);
3097    }
3098    if let Some(ref local_var_str) = sort {
3099        local_var_req_builder =
3100            local_var_req_builder.query(&[("sort", &local_var_str.to_string())]);
3101    }
3102    if let Some(ref local_var_str) = tags {
3103        local_var_req_builder = match "multi" {
3104            "multi" => local_var_req_builder.query(
3105                &local_var_str
3106                    .into_iter()
3107                    .map(|p| ("tags".to_owned(), p.to_string()))
3108                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3109            ),
3110            _ => local_var_req_builder.query(&[(
3111                "tags",
3112                &local_var_str
3113                    .into_iter()
3114                    .map(|p| p.to_string())
3115                    .collect::<Vec<String>>()
3116                    .join(",")
3117                    .to_string(),
3118            )]),
3119        };
3120    }
3121    if let Some(ref local_var_str) = tags__isnull {
3122        local_var_req_builder =
3123            local_var_req_builder.query(&[("tags__isnull", &local_var_str.to_string())]);
3124    }
3125    if let Some(ref local_var_str) = tags__n {
3126        local_var_req_builder = match "multi" {
3127            "multi" => local_var_req_builder.query(
3128                &local_var_str
3129                    .into_iter()
3130                    .map(|p| ("tags__n".to_owned(), p.to_string()))
3131                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3132            ),
3133            _ => local_var_req_builder.query(&[(
3134                "tags__n",
3135                &local_var_str
3136                    .into_iter()
3137                    .map(|p| p.to_string())
3138                    .collect::<Vec<String>>()
3139                    .join(",")
3140                    .to_string(),
3141            )]),
3142        };
3143    }
3144    if let Some(ref local_var_str) = teams {
3145        local_var_req_builder = match "multi" {
3146            "multi" => local_var_req_builder.query(
3147                &local_var_str
3148                    .into_iter()
3149                    .map(|p| ("teams".to_owned(), p.to_string()))
3150                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3151            ),
3152            _ => local_var_req_builder.query(&[(
3153                "teams",
3154                &local_var_str
3155                    .into_iter()
3156                    .map(|p| p.to_string())
3157                    .collect::<Vec<String>>()
3158                    .join(",")
3159                    .to_string(),
3160            )]),
3161        };
3162    }
3163    if let Some(ref local_var_str) = teams__isnull {
3164        local_var_req_builder =
3165            local_var_req_builder.query(&[("teams__isnull", &local_var_str.to_string())]);
3166    }
3167    if let Some(ref local_var_str) = teams__n {
3168        local_var_req_builder = match "multi" {
3169            "multi" => local_var_req_builder.query(
3170                &local_var_str
3171                    .into_iter()
3172                    .map(|p| ("teams__n".to_owned(), p.to_string()))
3173                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3174            ),
3175            _ => local_var_req_builder.query(&[(
3176                "teams__n",
3177                &local_var_str
3178                    .into_iter()
3179                    .map(|p| p.to_string())
3180                    .collect::<Vec<String>>()
3181                    .join(",")
3182                    .to_string(),
3183            )]),
3184        };
3185    }
3186    if let Some(ref local_var_str) = tenant {
3187        local_var_req_builder = match "multi" {
3188            "multi" => local_var_req_builder.query(
3189                &local_var_str
3190                    .into_iter()
3191                    .map(|p| ("tenant".to_owned(), p.to_string()))
3192                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3193            ),
3194            _ => local_var_req_builder.query(&[(
3195                "tenant",
3196                &local_var_str
3197                    .into_iter()
3198                    .map(|p| p.to_string())
3199                    .collect::<Vec<String>>()
3200                    .join(",")
3201                    .to_string(),
3202            )]),
3203        };
3204    }
3205    if let Some(ref local_var_str) = tenant__isnull {
3206        local_var_req_builder =
3207            local_var_req_builder.query(&[("tenant__isnull", &local_var_str.to_string())]);
3208    }
3209    if let Some(ref local_var_str) = tenant__n {
3210        local_var_req_builder = match "multi" {
3211            "multi" => local_var_req_builder.query(
3212                &local_var_str
3213                    .into_iter()
3214                    .map(|p| ("tenant__n".to_owned(), p.to_string()))
3215                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3216            ),
3217            _ => local_var_req_builder.query(&[(
3218                "tenant__n",
3219                &local_var_str
3220                    .into_iter()
3221                    .map(|p| p.to_string())
3222                    .collect::<Vec<String>>()
3223                    .join(",")
3224                    .to_string(),
3225            )]),
3226        };
3227    }
3228    if let Some(ref local_var_str) = tenant_group {
3229        local_var_req_builder = match "multi" {
3230            "multi" => local_var_req_builder.query(
3231                &local_var_str
3232                    .into_iter()
3233                    .map(|p| ("tenant_group".to_owned(), p.to_string()))
3234                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3235            ),
3236            _ => local_var_req_builder.query(&[(
3237                "tenant_group",
3238                &local_var_str
3239                    .into_iter()
3240                    .map(|p| p.to_string())
3241                    .collect::<Vec<String>>()
3242                    .join(",")
3243                    .to_string(),
3244            )]),
3245        };
3246    }
3247    if let Some(ref local_var_str) = tenant_group__isnull {
3248        local_var_req_builder =
3249            local_var_req_builder.query(&[("tenant_group__isnull", &local_var_str.to_string())]);
3250    }
3251    if let Some(ref local_var_str) = tenant_group__n {
3252        local_var_req_builder = match "multi" {
3253            "multi" => local_var_req_builder.query(
3254                &local_var_str
3255                    .into_iter()
3256                    .map(|p| ("tenant_group__n".to_owned(), p.to_string()))
3257                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3258            ),
3259            _ => local_var_req_builder.query(&[(
3260                "tenant_group__n",
3261                &local_var_str
3262                    .into_iter()
3263                    .map(|p| p.to_string())
3264                    .collect::<Vec<String>>()
3265                    .join(",")
3266                    .to_string(),
3267            )]),
3268        };
3269    }
3270    if let Some(ref local_var_str) = tenant_id {
3271        local_var_req_builder = match "multi" {
3272            "multi" => local_var_req_builder.query(
3273                &local_var_str
3274                    .into_iter()
3275                    .map(|p| ("tenant_id".to_owned(), p.to_string()))
3276                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3277            ),
3278            _ => local_var_req_builder.query(&[(
3279                "tenant_id",
3280                &local_var_str
3281                    .into_iter()
3282                    .map(|p| p.to_string())
3283                    .collect::<Vec<String>>()
3284                    .join(",")
3285                    .to_string(),
3286            )]),
3287        };
3288    }
3289    if let Some(ref local_var_str) = tenant_id__isnull {
3290        local_var_req_builder =
3291            local_var_req_builder.query(&[("tenant_id__isnull", &local_var_str.to_string())]);
3292    }
3293    if let Some(ref local_var_str) = tenant_id__n {
3294        local_var_req_builder = match "multi" {
3295            "multi" => local_var_req_builder.query(
3296                &local_var_str
3297                    .into_iter()
3298                    .map(|p| ("tenant_id__n".to_owned(), p.to_string()))
3299                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3300            ),
3301            _ => local_var_req_builder.query(&[(
3302                "tenant_id__n",
3303                &local_var_str
3304                    .into_iter()
3305                    .map(|p| p.to_string())
3306                    .collect::<Vec<String>>()
3307                    .join(",")
3308                    .to_string(),
3309            )]),
3310        };
3311    }
3312    if let Some(ref local_var_str) = virtual_servers {
3313        local_var_req_builder = match "multi" {
3314            "multi" => local_var_req_builder.query(
3315                &local_var_str
3316                    .into_iter()
3317                    .map(|p| ("virtual_servers".to_owned(), p.to_string()))
3318                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3319            ),
3320            _ => local_var_req_builder.query(&[(
3321                "virtual_servers",
3322                &local_var_str
3323                    .into_iter()
3324                    .map(|p| p.to_string())
3325                    .collect::<Vec<String>>()
3326                    .join(",")
3327                    .to_string(),
3328            )]),
3329        };
3330    }
3331    if let Some(ref local_var_str) = virtual_servers__isnull {
3332        local_var_req_builder =
3333            local_var_req_builder.query(&[("virtual_servers__isnull", &local_var_str.to_string())]);
3334    }
3335    if let Some(ref local_var_str) = virtual_servers__n {
3336        local_var_req_builder = match "multi" {
3337            "multi" => local_var_req_builder.query(
3338                &local_var_str
3339                    .into_iter()
3340                    .map(|p| ("virtual_servers__n".to_owned(), p.to_string()))
3341                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3342            ),
3343            _ => local_var_req_builder.query(&[(
3344                "virtual_servers__n",
3345                &local_var_str
3346                    .into_iter()
3347                    .map(|p| p.to_string())
3348                    .collect::<Vec<String>>()
3349                    .join(",")
3350                    .to_string(),
3351            )]),
3352        };
3353    }
3354    if let Some(ref local_var_str) = depth {
3355        local_var_req_builder =
3356            local_var_req_builder.query(&[("depth", &local_var_str.to_string())]);
3357    }
3358    if let Some(ref local_var_str) = exclude_m2m {
3359        local_var_req_builder =
3360            local_var_req_builder.query(&[("exclude_m2m", &local_var_str.to_string())]);
3361    }
3362    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
3363        local_var_req_builder =
3364            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
3365    }
3366    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
3367        let local_var_key = local_var_apikey.key.clone();
3368        let local_var_value = match local_var_apikey.prefix {
3369            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
3370            None => local_var_key,
3371        };
3372        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
3373    };
3374
3375    let local_var_req = local_var_req_builder.build()?;
3376    let local_var_resp = local_var_client.execute(local_var_req).await?;
3377
3378    let local_var_status = local_var_resp.status();
3379    let local_var_content = local_var_resp.text().await?;
3380
3381    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
3382        serde_json::from_str(&local_var_content).map_err(Error::from)
3383    } else {
3384        let local_var_entity: Option<LoadBalancersCertificateProfilesListError> =
3385            serde_json::from_str(&local_var_content).ok();
3386        let local_var_error = ResponseContent {
3387            status: local_var_status,
3388            content: local_var_content,
3389            entity: local_var_entity,
3390        };
3391        Err(Error::ResponseError(local_var_error))
3392    }
3393}
3394
3395/// API methods for returning or creating notes on an object.
3396pub async fn load_balancers_certificate_profiles_notes_create(
3397    configuration: &configuration::Configuration,
3398    id: &str,
3399    note_input_request: crate::models::NoteInputRequest,
3400    format: Option<&str>,
3401) -> Result<crate::models::Note, Error<LoadBalancersCertificateProfilesNotesCreateError>> {
3402    let local_var_configuration = configuration;
3403
3404    let local_var_client = &local_var_configuration.client;
3405
3406    let local_var_uri_str = format!(
3407        "{}/load-balancers/certificate-profiles/{id}/notes/",
3408        local_var_configuration.base_path,
3409        id = crate::apis::urlencode(id)
3410    );
3411    let mut local_var_req_builder =
3412        local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
3413
3414    if let Some(ref local_var_str) = format {
3415        local_var_req_builder =
3416            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
3417    }
3418    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
3419        local_var_req_builder =
3420            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
3421    }
3422    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
3423        let local_var_key = local_var_apikey.key.clone();
3424        let local_var_value = match local_var_apikey.prefix {
3425            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
3426            None => local_var_key,
3427        };
3428        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
3429    };
3430    local_var_req_builder = local_var_req_builder.json(&note_input_request);
3431
3432    let local_var_req = local_var_req_builder.build()?;
3433    let local_var_resp = local_var_client.execute(local_var_req).await?;
3434
3435    let local_var_status = local_var_resp.status();
3436    let local_var_content = local_var_resp.text().await?;
3437
3438    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
3439        serde_json::from_str(&local_var_content).map_err(Error::from)
3440    } else {
3441        let local_var_entity: Option<LoadBalancersCertificateProfilesNotesCreateError> =
3442            serde_json::from_str(&local_var_content).ok();
3443        let local_var_error = ResponseContent {
3444            status: local_var_status,
3445            content: local_var_content,
3446            entity: local_var_entity,
3447        };
3448        Err(Error::ResponseError(local_var_error))
3449    }
3450}
3451
3452/// API methods for returning or creating notes on an object.
3453pub async fn load_balancers_certificate_profiles_notes_list(
3454    configuration: &configuration::Configuration,
3455    id: &str,
3456    format: Option<&str>,
3457    limit: Option<i32>,
3458    offset: Option<i32>,
3459    depth: Option<i32>,
3460    exclude_m2m: Option<bool>,
3461) -> Result<crate::models::PaginatedNoteList, Error<LoadBalancersCertificateProfilesNotesListError>>
3462{
3463    let local_var_configuration = configuration;
3464
3465    let local_var_client = &local_var_configuration.client;
3466
3467    let local_var_uri_str = format!(
3468        "{}/load-balancers/certificate-profiles/{id}/notes/",
3469        local_var_configuration.base_path,
3470        id = crate::apis::urlencode(id)
3471    );
3472    let mut local_var_req_builder =
3473        local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
3474
3475    if let Some(ref local_var_str) = format {
3476        local_var_req_builder =
3477            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
3478    }
3479    if let Some(ref local_var_str) = limit {
3480        local_var_req_builder =
3481            local_var_req_builder.query(&[("limit", &local_var_str.to_string())]);
3482    }
3483    if let Some(ref local_var_str) = offset {
3484        local_var_req_builder =
3485            local_var_req_builder.query(&[("offset", &local_var_str.to_string())]);
3486    }
3487    if let Some(ref local_var_str) = depth {
3488        local_var_req_builder =
3489            local_var_req_builder.query(&[("depth", &local_var_str.to_string())]);
3490    }
3491    if let Some(ref local_var_str) = exclude_m2m {
3492        local_var_req_builder =
3493            local_var_req_builder.query(&[("exclude_m2m", &local_var_str.to_string())]);
3494    }
3495    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
3496        local_var_req_builder =
3497            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
3498    }
3499    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
3500        let local_var_key = local_var_apikey.key.clone();
3501        let local_var_value = match local_var_apikey.prefix {
3502            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
3503            None => local_var_key,
3504        };
3505        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
3506    };
3507
3508    let local_var_req = local_var_req_builder.build()?;
3509    let local_var_resp = local_var_client.execute(local_var_req).await?;
3510
3511    let local_var_status = local_var_resp.status();
3512    let local_var_content = local_var_resp.text().await?;
3513
3514    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
3515        serde_json::from_str(&local_var_content).map_err(Error::from)
3516    } else {
3517        let local_var_entity: Option<LoadBalancersCertificateProfilesNotesListError> =
3518            serde_json::from_str(&local_var_content).ok();
3519        let local_var_error = ResponseContent {
3520            status: local_var_status,
3521            content: local_var_content,
3522            entity: local_var_entity,
3523        };
3524        Err(Error::ResponseError(local_var_error))
3525    }
3526}
3527
3528/// CertificateProfile viewset.
3529pub async fn load_balancers_certificate_profiles_partial_update(
3530    configuration: &configuration::Configuration,
3531    id: &str,
3532    format: Option<&str>,
3533    patched_certificate_profile_request: Option<crate::models::PatchedCertificateProfileRequest>,
3534) -> Result<
3535    crate::models::CertificateProfile,
3536    Error<LoadBalancersCertificateProfilesPartialUpdateError>,
3537> {
3538    let local_var_configuration = configuration;
3539
3540    let local_var_client = &local_var_configuration.client;
3541
3542    let local_var_uri_str = format!(
3543        "{}/load-balancers/certificate-profiles/{id}/",
3544        local_var_configuration.base_path,
3545        id = crate::apis::urlencode(id)
3546    );
3547    let mut local_var_req_builder =
3548        local_var_client.request(reqwest::Method::PATCH, local_var_uri_str.as_str());
3549
3550    if let Some(ref local_var_str) = format {
3551        local_var_req_builder =
3552            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
3553    }
3554    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
3555        local_var_req_builder =
3556            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
3557    }
3558    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
3559        let local_var_key = local_var_apikey.key.clone();
3560        let local_var_value = match local_var_apikey.prefix {
3561            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
3562            None => local_var_key,
3563        };
3564        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
3565    };
3566    local_var_req_builder = local_var_req_builder.json(&patched_certificate_profile_request);
3567
3568    let local_var_req = local_var_req_builder.build()?;
3569    let local_var_resp = local_var_client.execute(local_var_req).await?;
3570
3571    let local_var_status = local_var_resp.status();
3572    let local_var_content = local_var_resp.text().await?;
3573
3574    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
3575        serde_json::from_str(&local_var_content).map_err(Error::from)
3576    } else {
3577        let local_var_entity: Option<LoadBalancersCertificateProfilesPartialUpdateError> =
3578            serde_json::from_str(&local_var_content).ok();
3579        let local_var_error = ResponseContent {
3580            status: local_var_status,
3581            content: local_var_content,
3582            entity: local_var_entity,
3583        };
3584        Err(Error::ResponseError(local_var_error))
3585    }
3586}
3587
3588/// CertificateProfile viewset.
3589pub async fn load_balancers_certificate_profiles_retrieve(
3590    configuration: &configuration::Configuration,
3591    id: &str,
3592    format: Option<&str>,
3593    depth: Option<i32>,
3594    exclude_m2m: Option<bool>,
3595) -> Result<crate::models::CertificateProfile, Error<LoadBalancersCertificateProfilesRetrieveError>>
3596{
3597    let local_var_configuration = configuration;
3598
3599    let local_var_client = &local_var_configuration.client;
3600
3601    let local_var_uri_str = format!(
3602        "{}/load-balancers/certificate-profiles/{id}/",
3603        local_var_configuration.base_path,
3604        id = crate::apis::urlencode(id)
3605    );
3606    let mut local_var_req_builder =
3607        local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
3608
3609    if let Some(ref local_var_str) = format {
3610        local_var_req_builder =
3611            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
3612    }
3613    if let Some(ref local_var_str) = depth {
3614        local_var_req_builder =
3615            local_var_req_builder.query(&[("depth", &local_var_str.to_string())]);
3616    }
3617    if let Some(ref local_var_str) = exclude_m2m {
3618        local_var_req_builder =
3619            local_var_req_builder.query(&[("exclude_m2m", &local_var_str.to_string())]);
3620    }
3621    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
3622        local_var_req_builder =
3623            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
3624    }
3625    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
3626        let local_var_key = local_var_apikey.key.clone();
3627        let local_var_value = match local_var_apikey.prefix {
3628            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
3629            None => local_var_key,
3630        };
3631        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
3632    };
3633
3634    let local_var_req = local_var_req_builder.build()?;
3635    let local_var_resp = local_var_client.execute(local_var_req).await?;
3636
3637    let local_var_status = local_var_resp.status();
3638    let local_var_content = local_var_resp.text().await?;
3639
3640    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
3641        serde_json::from_str(&local_var_content).map_err(Error::from)
3642    } else {
3643        let local_var_entity: Option<LoadBalancersCertificateProfilesRetrieveError> =
3644            serde_json::from_str(&local_var_content).ok();
3645        let local_var_error = ResponseContent {
3646            status: local_var_status,
3647            content: local_var_content,
3648            entity: local_var_entity,
3649        };
3650        Err(Error::ResponseError(local_var_error))
3651    }
3652}
3653
3654/// CertificateProfile viewset.
3655pub async fn load_balancers_certificate_profiles_update(
3656    configuration: &configuration::Configuration,
3657    id: &str,
3658    certificate_profile_request: crate::models::CertificateProfileRequest,
3659    format: Option<&str>,
3660) -> Result<crate::models::CertificateProfile, Error<LoadBalancersCertificateProfilesUpdateError>> {
3661    let local_var_configuration = configuration;
3662
3663    let local_var_client = &local_var_configuration.client;
3664
3665    let local_var_uri_str = format!(
3666        "{}/load-balancers/certificate-profiles/{id}/",
3667        local_var_configuration.base_path,
3668        id = crate::apis::urlencode(id)
3669    );
3670    let mut local_var_req_builder =
3671        local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());
3672
3673    if let Some(ref local_var_str) = format {
3674        local_var_req_builder =
3675            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
3676    }
3677    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
3678        local_var_req_builder =
3679            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
3680    }
3681    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
3682        let local_var_key = local_var_apikey.key.clone();
3683        let local_var_value = match local_var_apikey.prefix {
3684            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
3685            None => local_var_key,
3686        };
3687        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
3688    };
3689    local_var_req_builder = local_var_req_builder.json(&certificate_profile_request);
3690
3691    let local_var_req = local_var_req_builder.build()?;
3692    let local_var_resp = local_var_client.execute(local_var_req).await?;
3693
3694    let local_var_status = local_var_resp.status();
3695    let local_var_content = local_var_resp.text().await?;
3696
3697    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
3698        serde_json::from_str(&local_var_content).map_err(Error::from)
3699    } else {
3700        let local_var_entity: Option<LoadBalancersCertificateProfilesUpdateError> =
3701            serde_json::from_str(&local_var_content).ok();
3702        let local_var_error = ResponseContent {
3703            status: local_var_status,
3704            content: local_var_content,
3705            entity: local_var_entity,
3706        };
3707        Err(Error::ResponseError(local_var_error))
3708    }
3709}
3710
3711/// HealthCheckMonitor viewset.
3712pub async fn load_balancers_health_check_monitors_bulk_destroy(
3713    configuration: &configuration::Configuration,
3714    bulk_operation_request: Vec<crate::models::BulkOperationRequest>,
3715    format: Option<&str>,
3716) -> Result<(), Error<LoadBalancersHealthCheckMonitorsBulkDestroyError>> {
3717    let local_var_configuration = configuration;
3718
3719    let local_var_client = &local_var_configuration.client;
3720
3721    let local_var_uri_str = format!(
3722        "{}/load-balancers/health-check-monitors/",
3723        local_var_configuration.base_path
3724    );
3725    let mut local_var_req_builder =
3726        local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());
3727
3728    if let Some(ref local_var_str) = format {
3729        local_var_req_builder =
3730            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
3731    }
3732    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
3733        local_var_req_builder =
3734            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
3735    }
3736    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
3737        let local_var_key = local_var_apikey.key.clone();
3738        let local_var_value = match local_var_apikey.prefix {
3739            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
3740            None => local_var_key,
3741        };
3742        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
3743    };
3744    local_var_req_builder = local_var_req_builder.json(&bulk_operation_request);
3745
3746    let local_var_req = local_var_req_builder.build()?;
3747    let local_var_resp = local_var_client.execute(local_var_req).await?;
3748
3749    let local_var_status = local_var_resp.status();
3750    let local_var_content = local_var_resp.text().await?;
3751
3752    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
3753        Ok(())
3754    } else {
3755        let local_var_entity: Option<LoadBalancersHealthCheckMonitorsBulkDestroyError> =
3756            serde_json::from_str(&local_var_content).ok();
3757        let local_var_error = ResponseContent {
3758            status: local_var_status,
3759            content: local_var_content,
3760            entity: local_var_entity,
3761        };
3762        Err(Error::ResponseError(local_var_error))
3763    }
3764}
3765
3766/// HealthCheckMonitor viewset.
3767pub async fn load_balancers_health_check_monitors_bulk_partial_update(
3768    configuration: &configuration::Configuration,
3769    patched_bulk_writable_health_check_monitor_request: Vec<
3770        crate::models::PatchedBulkWritableHealthCheckMonitorRequest,
3771    >,
3772    format: Option<&str>,
3773) -> Result<
3774    Vec<crate::models::HealthCheckMonitor>,
3775    Error<LoadBalancersHealthCheckMonitorsBulkPartialUpdateError>,
3776> {
3777    let local_var_configuration = configuration;
3778
3779    let local_var_client = &local_var_configuration.client;
3780
3781    let local_var_uri_str = format!(
3782        "{}/load-balancers/health-check-monitors/",
3783        local_var_configuration.base_path
3784    );
3785    let mut local_var_req_builder =
3786        local_var_client.request(reqwest::Method::PATCH, local_var_uri_str.as_str());
3787
3788    if let Some(ref local_var_str) = format {
3789        local_var_req_builder =
3790            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
3791    }
3792    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
3793        local_var_req_builder =
3794            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
3795    }
3796    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
3797        let local_var_key = local_var_apikey.key.clone();
3798        let local_var_value = match local_var_apikey.prefix {
3799            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
3800            None => local_var_key,
3801        };
3802        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
3803    };
3804    local_var_req_builder =
3805        local_var_req_builder.json(&patched_bulk_writable_health_check_monitor_request);
3806
3807    let local_var_req = local_var_req_builder.build()?;
3808    let local_var_resp = local_var_client.execute(local_var_req).await?;
3809
3810    let local_var_status = local_var_resp.status();
3811    let local_var_content = local_var_resp.text().await?;
3812
3813    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
3814        serde_json::from_str(&local_var_content).map_err(Error::from)
3815    } else {
3816        let local_var_entity: Option<LoadBalancersHealthCheckMonitorsBulkPartialUpdateError> =
3817            serde_json::from_str(&local_var_content).ok();
3818        let local_var_error = ResponseContent {
3819            status: local_var_status,
3820            content: local_var_content,
3821            entity: local_var_entity,
3822        };
3823        Err(Error::ResponseError(local_var_error))
3824    }
3825}
3826
3827/// HealthCheckMonitor viewset.
3828pub async fn load_balancers_health_check_monitors_bulk_update(
3829    configuration: &configuration::Configuration,
3830    bulk_writable_health_check_monitor_request: Vec<
3831        crate::models::BulkWritableHealthCheckMonitorRequest,
3832    >,
3833    format: Option<&str>,
3834) -> Result<
3835    Vec<crate::models::HealthCheckMonitor>,
3836    Error<LoadBalancersHealthCheckMonitorsBulkUpdateError>,
3837> {
3838    let local_var_configuration = configuration;
3839
3840    let local_var_client = &local_var_configuration.client;
3841
3842    let local_var_uri_str = format!(
3843        "{}/load-balancers/health-check-monitors/",
3844        local_var_configuration.base_path
3845    );
3846    let mut local_var_req_builder =
3847        local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());
3848
3849    if let Some(ref local_var_str) = format {
3850        local_var_req_builder =
3851            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
3852    }
3853    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
3854        local_var_req_builder =
3855            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
3856    }
3857    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
3858        let local_var_key = local_var_apikey.key.clone();
3859        let local_var_value = match local_var_apikey.prefix {
3860            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
3861            None => local_var_key,
3862        };
3863        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
3864    };
3865    local_var_req_builder = local_var_req_builder.json(&bulk_writable_health_check_monitor_request);
3866
3867    let local_var_req = local_var_req_builder.build()?;
3868    let local_var_resp = local_var_client.execute(local_var_req).await?;
3869
3870    let local_var_status = local_var_resp.status();
3871    let local_var_content = local_var_resp.text().await?;
3872
3873    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
3874        serde_json::from_str(&local_var_content).map_err(Error::from)
3875    } else {
3876        let local_var_entity: Option<LoadBalancersHealthCheckMonitorsBulkUpdateError> =
3877            serde_json::from_str(&local_var_content).ok();
3878        let local_var_error = ResponseContent {
3879            status: local_var_status,
3880            content: local_var_content,
3881            entity: local_var_entity,
3882        };
3883        Err(Error::ResponseError(local_var_error))
3884    }
3885}
3886
3887/// HealthCheckMonitor viewset.
3888pub async fn load_balancers_health_check_monitors_create(
3889    configuration: &configuration::Configuration,
3890    health_check_monitor_request: crate::models::HealthCheckMonitorRequest,
3891    format: Option<&str>,
3892) -> Result<crate::models::HealthCheckMonitor, Error<LoadBalancersHealthCheckMonitorsCreateError>> {
3893    let local_var_configuration = configuration;
3894
3895    let local_var_client = &local_var_configuration.client;
3896
3897    let local_var_uri_str = format!(
3898        "{}/load-balancers/health-check-monitors/",
3899        local_var_configuration.base_path
3900    );
3901    let mut local_var_req_builder =
3902        local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
3903
3904    if let Some(ref local_var_str) = format {
3905        local_var_req_builder =
3906            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
3907    }
3908    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
3909        local_var_req_builder =
3910            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
3911    }
3912    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
3913        let local_var_key = local_var_apikey.key.clone();
3914        let local_var_value = match local_var_apikey.prefix {
3915            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
3916            None => local_var_key,
3917        };
3918        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
3919    };
3920    local_var_req_builder = local_var_req_builder.json(&health_check_monitor_request);
3921
3922    let local_var_req = local_var_req_builder.build()?;
3923    let local_var_resp = local_var_client.execute(local_var_req).await?;
3924
3925    let local_var_status = local_var_resp.status();
3926    let local_var_content = local_var_resp.text().await?;
3927
3928    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
3929        serde_json::from_str(&local_var_content).map_err(Error::from)
3930    } else {
3931        let local_var_entity: Option<LoadBalancersHealthCheckMonitorsCreateError> =
3932            serde_json::from_str(&local_var_content).ok();
3933        let local_var_error = ResponseContent {
3934            status: local_var_status,
3935            content: local_var_content,
3936            entity: local_var_entity,
3937        };
3938        Err(Error::ResponseError(local_var_error))
3939    }
3940}
3941
3942/// HealthCheckMonitor viewset.
3943pub async fn load_balancers_health_check_monitors_destroy(
3944    configuration: &configuration::Configuration,
3945    id: &str,
3946    format: Option<&str>,
3947) -> Result<(), Error<LoadBalancersHealthCheckMonitorsDestroyError>> {
3948    let local_var_configuration = configuration;
3949
3950    let local_var_client = &local_var_configuration.client;
3951
3952    let local_var_uri_str = format!(
3953        "{}/load-balancers/health-check-monitors/{id}/",
3954        local_var_configuration.base_path,
3955        id = crate::apis::urlencode(id)
3956    );
3957    let mut local_var_req_builder =
3958        local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());
3959
3960    if let Some(ref local_var_str) = format {
3961        local_var_req_builder =
3962            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
3963    }
3964    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
3965        local_var_req_builder =
3966            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
3967    }
3968    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
3969        let local_var_key = local_var_apikey.key.clone();
3970        let local_var_value = match local_var_apikey.prefix {
3971            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
3972            None => local_var_key,
3973        };
3974        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
3975    };
3976
3977    let local_var_req = local_var_req_builder.build()?;
3978    let local_var_resp = local_var_client.execute(local_var_req).await?;
3979
3980    let local_var_status = local_var_resp.status();
3981    let local_var_content = local_var_resp.text().await?;
3982
3983    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
3984        Ok(())
3985    } else {
3986        let local_var_entity: Option<LoadBalancersHealthCheckMonitorsDestroyError> =
3987            serde_json::from_str(&local_var_content).ok();
3988        let local_var_error = ResponseContent {
3989            status: local_var_status,
3990            content: local_var_content,
3991            entity: local_var_entity,
3992        };
3993        Err(Error::ResponseError(local_var_error))
3994    }
3995}
3996
3997/// HealthCheckMonitor viewset.
3998pub async fn load_balancers_health_check_monitors_list(
3999    configuration: &configuration::Configuration,
4000    contacts: Option<Vec<String>>,
4001    contacts__isnull: Option<bool>,
4002    contacts__n: Option<Vec<String>>,
4003    created: Option<Vec<String>>,
4004    created__gt: Option<Vec<String>>,
4005    created__gte: Option<Vec<String>>,
4006    created__isnull: Option<bool>,
4007    created__lt: Option<Vec<String>>,
4008    created__lte: Option<Vec<String>>,
4009    created__n: Option<Vec<String>>,
4010    dynamic_groups: Option<Vec<String>>,
4011    dynamic_groups__n: Option<Vec<String>>,
4012    format: Option<&str>,
4013    health_check_type: Option<Vec<String>>,
4014    health_check_type__ic: Option<Vec<String>>,
4015    health_check_type__ie: Option<Vec<String>>,
4016    health_check_type__iew: Option<Vec<String>>,
4017    health_check_type__ire: Option<Vec<String>>,
4018    health_check_type__isw: Option<Vec<String>>,
4019    health_check_type__n: Option<Vec<String>>,
4020    health_check_type__nic: Option<Vec<String>>,
4021    health_check_type__nie: Option<Vec<String>>,
4022    health_check_type__niew: Option<Vec<String>>,
4023    health_check_type__nire: Option<Vec<String>>,
4024    health_check_type__nisw: Option<Vec<String>>,
4025    health_check_type__nre: Option<Vec<String>>,
4026    health_check_type__re: Option<Vec<String>>,
4027    id: Option<Vec<uuid::Uuid>>,
4028    id__n: Option<Vec<uuid::Uuid>>,
4029    interval: Option<Vec<i32>>,
4030    interval__gt: Option<Vec<i32>>,
4031    interval__gte: Option<Vec<i32>>,
4032    interval__isnull: Option<bool>,
4033    interval__lt: Option<Vec<i32>>,
4034    interval__lte: Option<Vec<i32>>,
4035    interval__n: Option<Vec<i32>>,
4036    last_updated: Option<Vec<String>>,
4037    last_updated__gt: Option<Vec<String>>,
4038    last_updated__gte: Option<Vec<String>>,
4039    last_updated__isnull: Option<bool>,
4040    last_updated__lt: Option<Vec<String>>,
4041    last_updated__lte: Option<Vec<String>>,
4042    last_updated__n: Option<Vec<String>>,
4043    limit: Option<i32>,
4044    name: Option<Vec<String>>,
4045    name__ic: Option<Vec<String>>,
4046    name__ie: Option<Vec<String>>,
4047    name__iew: Option<Vec<String>>,
4048    name__ire: Option<Vec<String>>,
4049    name__isw: Option<Vec<String>>,
4050    name__n: Option<Vec<String>>,
4051    name__nic: Option<Vec<String>>,
4052    name__nie: Option<Vec<String>>,
4053    name__niew: Option<Vec<String>>,
4054    name__nire: Option<Vec<String>>,
4055    name__nisw: Option<Vec<String>>,
4056    name__nre: Option<Vec<String>>,
4057    name__re: Option<Vec<String>>,
4058    offset: Option<i32>,
4059    port: Option<Vec<i32>>,
4060    port__gt: Option<Vec<i32>>,
4061    port__gte: Option<Vec<i32>>,
4062    port__isnull: Option<bool>,
4063    port__lt: Option<Vec<i32>>,
4064    port__lte: Option<Vec<i32>>,
4065    port__n: Option<Vec<i32>>,
4066    q: Option<&str>,
4067    retry: Option<Vec<i32>>,
4068    retry__gt: Option<Vec<i32>>,
4069    retry__gte: Option<Vec<i32>>,
4070    retry__isnull: Option<bool>,
4071    retry__lt: Option<Vec<i32>>,
4072    retry__lte: Option<Vec<i32>>,
4073    retry__n: Option<Vec<i32>>,
4074    sort: Option<&str>,
4075    tags: Option<Vec<String>>,
4076    tags__isnull: Option<bool>,
4077    tags__n: Option<Vec<String>>,
4078    teams: Option<Vec<String>>,
4079    teams__isnull: Option<bool>,
4080    teams__n: Option<Vec<String>>,
4081    tenant: Option<Vec<String>>,
4082    tenant__isnull: Option<bool>,
4083    tenant__n: Option<Vec<String>>,
4084    tenant_group: Option<Vec<String>>,
4085    tenant_group__isnull: Option<bool>,
4086    tenant_group__n: Option<Vec<String>>,
4087    tenant_id: Option<Vec<uuid::Uuid>>,
4088    tenant_id__isnull: Option<bool>,
4089    tenant_id__n: Option<Vec<uuid::Uuid>>,
4090    timeout: Option<Vec<i32>>,
4091    timeout__gt: Option<Vec<i32>>,
4092    timeout__gte: Option<Vec<i32>>,
4093    timeout__isnull: Option<bool>,
4094    timeout__lt: Option<Vec<i32>>,
4095    timeout__lte: Option<Vec<i32>>,
4096    timeout__n: Option<Vec<i32>>,
4097    depth: Option<i32>,
4098    exclude_m2m: Option<bool>,
4099) -> Result<
4100    crate::models::PaginatedHealthCheckMonitorList,
4101    Error<LoadBalancersHealthCheckMonitorsListError>,
4102> {
4103    let local_var_configuration = configuration;
4104
4105    let local_var_client = &local_var_configuration.client;
4106
4107    let local_var_uri_str = format!(
4108        "{}/load-balancers/health-check-monitors/",
4109        local_var_configuration.base_path
4110    );
4111    let mut local_var_req_builder =
4112        local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
4113
4114    if let Some(ref local_var_str) = contacts {
4115        local_var_req_builder = match "multi" {
4116            "multi" => local_var_req_builder.query(
4117                &local_var_str
4118                    .into_iter()
4119                    .map(|p| ("contacts".to_owned(), p.to_string()))
4120                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4121            ),
4122            _ => local_var_req_builder.query(&[(
4123                "contacts",
4124                &local_var_str
4125                    .into_iter()
4126                    .map(|p| p.to_string())
4127                    .collect::<Vec<String>>()
4128                    .join(",")
4129                    .to_string(),
4130            )]),
4131        };
4132    }
4133    if let Some(ref local_var_str) = contacts__isnull {
4134        local_var_req_builder =
4135            local_var_req_builder.query(&[("contacts__isnull", &local_var_str.to_string())]);
4136    }
4137    if let Some(ref local_var_str) = contacts__n {
4138        local_var_req_builder = match "multi" {
4139            "multi" => local_var_req_builder.query(
4140                &local_var_str
4141                    .into_iter()
4142                    .map(|p| ("contacts__n".to_owned(), p.to_string()))
4143                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4144            ),
4145            _ => local_var_req_builder.query(&[(
4146                "contacts__n",
4147                &local_var_str
4148                    .into_iter()
4149                    .map(|p| p.to_string())
4150                    .collect::<Vec<String>>()
4151                    .join(",")
4152                    .to_string(),
4153            )]),
4154        };
4155    }
4156    if let Some(ref local_var_str) = created {
4157        local_var_req_builder = match "multi" {
4158            "multi" => local_var_req_builder.query(
4159                &local_var_str
4160                    .into_iter()
4161                    .map(|p| ("created".to_owned(), p.to_string()))
4162                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4163            ),
4164            _ => local_var_req_builder.query(&[(
4165                "created",
4166                &local_var_str
4167                    .into_iter()
4168                    .map(|p| p.to_string())
4169                    .collect::<Vec<String>>()
4170                    .join(",")
4171                    .to_string(),
4172            )]),
4173        };
4174    }
4175    if let Some(ref local_var_str) = created__gt {
4176        local_var_req_builder = match "multi" {
4177            "multi" => local_var_req_builder.query(
4178                &local_var_str
4179                    .into_iter()
4180                    .map(|p| ("created__gt".to_owned(), p.to_string()))
4181                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4182            ),
4183            _ => local_var_req_builder.query(&[(
4184                "created__gt",
4185                &local_var_str
4186                    .into_iter()
4187                    .map(|p| p.to_string())
4188                    .collect::<Vec<String>>()
4189                    .join(",")
4190                    .to_string(),
4191            )]),
4192        };
4193    }
4194    if let Some(ref local_var_str) = created__gte {
4195        local_var_req_builder = match "multi" {
4196            "multi" => local_var_req_builder.query(
4197                &local_var_str
4198                    .into_iter()
4199                    .map(|p| ("created__gte".to_owned(), p.to_string()))
4200                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4201            ),
4202            _ => local_var_req_builder.query(&[(
4203                "created__gte",
4204                &local_var_str
4205                    .into_iter()
4206                    .map(|p| p.to_string())
4207                    .collect::<Vec<String>>()
4208                    .join(",")
4209                    .to_string(),
4210            )]),
4211        };
4212    }
4213    if let Some(ref local_var_str) = created__isnull {
4214        local_var_req_builder =
4215            local_var_req_builder.query(&[("created__isnull", &local_var_str.to_string())]);
4216    }
4217    if let Some(ref local_var_str) = created__lt {
4218        local_var_req_builder = match "multi" {
4219            "multi" => local_var_req_builder.query(
4220                &local_var_str
4221                    .into_iter()
4222                    .map(|p| ("created__lt".to_owned(), p.to_string()))
4223                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4224            ),
4225            _ => local_var_req_builder.query(&[(
4226                "created__lt",
4227                &local_var_str
4228                    .into_iter()
4229                    .map(|p| p.to_string())
4230                    .collect::<Vec<String>>()
4231                    .join(",")
4232                    .to_string(),
4233            )]),
4234        };
4235    }
4236    if let Some(ref local_var_str) = created__lte {
4237        local_var_req_builder = match "multi" {
4238            "multi" => local_var_req_builder.query(
4239                &local_var_str
4240                    .into_iter()
4241                    .map(|p| ("created__lte".to_owned(), p.to_string()))
4242                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4243            ),
4244            _ => local_var_req_builder.query(&[(
4245                "created__lte",
4246                &local_var_str
4247                    .into_iter()
4248                    .map(|p| p.to_string())
4249                    .collect::<Vec<String>>()
4250                    .join(",")
4251                    .to_string(),
4252            )]),
4253        };
4254    }
4255    if let Some(ref local_var_str) = created__n {
4256        local_var_req_builder = match "multi" {
4257            "multi" => local_var_req_builder.query(
4258                &local_var_str
4259                    .into_iter()
4260                    .map(|p| ("created__n".to_owned(), p.to_string()))
4261                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4262            ),
4263            _ => local_var_req_builder.query(&[(
4264                "created__n",
4265                &local_var_str
4266                    .into_iter()
4267                    .map(|p| p.to_string())
4268                    .collect::<Vec<String>>()
4269                    .join(",")
4270                    .to_string(),
4271            )]),
4272        };
4273    }
4274    if let Some(ref local_var_str) = dynamic_groups {
4275        local_var_req_builder = match "multi" {
4276            "multi" => local_var_req_builder.query(
4277                &local_var_str
4278                    .into_iter()
4279                    .map(|p| ("dynamic_groups".to_owned(), p.to_string()))
4280                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4281            ),
4282            _ => local_var_req_builder.query(&[(
4283                "dynamic_groups",
4284                &local_var_str
4285                    .into_iter()
4286                    .map(|p| p.to_string())
4287                    .collect::<Vec<String>>()
4288                    .join(",")
4289                    .to_string(),
4290            )]),
4291        };
4292    }
4293    if let Some(ref local_var_str) = dynamic_groups__n {
4294        local_var_req_builder = match "multi" {
4295            "multi" => local_var_req_builder.query(
4296                &local_var_str
4297                    .into_iter()
4298                    .map(|p| ("dynamic_groups__n".to_owned(), p.to_string()))
4299                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4300            ),
4301            _ => local_var_req_builder.query(&[(
4302                "dynamic_groups__n",
4303                &local_var_str
4304                    .into_iter()
4305                    .map(|p| p.to_string())
4306                    .collect::<Vec<String>>()
4307                    .join(",")
4308                    .to_string(),
4309            )]),
4310        };
4311    }
4312    if let Some(ref local_var_str) = format {
4313        local_var_req_builder =
4314            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
4315    }
4316    if let Some(ref local_var_str) = health_check_type {
4317        local_var_req_builder = match "multi" {
4318            "multi" => local_var_req_builder.query(
4319                &local_var_str
4320                    .into_iter()
4321                    .map(|p| ("health_check_type".to_owned(), p.to_string()))
4322                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4323            ),
4324            _ => local_var_req_builder.query(&[(
4325                "health_check_type",
4326                &local_var_str
4327                    .into_iter()
4328                    .map(|p| p.to_string())
4329                    .collect::<Vec<String>>()
4330                    .join(",")
4331                    .to_string(),
4332            )]),
4333        };
4334    }
4335    if let Some(ref local_var_str) = health_check_type__ic {
4336        local_var_req_builder = match "multi" {
4337            "multi" => local_var_req_builder.query(
4338                &local_var_str
4339                    .into_iter()
4340                    .map(|p| ("health_check_type__ic".to_owned(), p.to_string()))
4341                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4342            ),
4343            _ => local_var_req_builder.query(&[(
4344                "health_check_type__ic",
4345                &local_var_str
4346                    .into_iter()
4347                    .map(|p| p.to_string())
4348                    .collect::<Vec<String>>()
4349                    .join(",")
4350                    .to_string(),
4351            )]),
4352        };
4353    }
4354    if let Some(ref local_var_str) = health_check_type__ie {
4355        local_var_req_builder = match "multi" {
4356            "multi" => local_var_req_builder.query(
4357                &local_var_str
4358                    .into_iter()
4359                    .map(|p| ("health_check_type__ie".to_owned(), p.to_string()))
4360                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4361            ),
4362            _ => local_var_req_builder.query(&[(
4363                "health_check_type__ie",
4364                &local_var_str
4365                    .into_iter()
4366                    .map(|p| p.to_string())
4367                    .collect::<Vec<String>>()
4368                    .join(",")
4369                    .to_string(),
4370            )]),
4371        };
4372    }
4373    if let Some(ref local_var_str) = health_check_type__iew {
4374        local_var_req_builder = match "multi" {
4375            "multi" => local_var_req_builder.query(
4376                &local_var_str
4377                    .into_iter()
4378                    .map(|p| ("health_check_type__iew".to_owned(), p.to_string()))
4379                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4380            ),
4381            _ => local_var_req_builder.query(&[(
4382                "health_check_type__iew",
4383                &local_var_str
4384                    .into_iter()
4385                    .map(|p| p.to_string())
4386                    .collect::<Vec<String>>()
4387                    .join(",")
4388                    .to_string(),
4389            )]),
4390        };
4391    }
4392    if let Some(ref local_var_str) = health_check_type__ire {
4393        local_var_req_builder = match "multi" {
4394            "multi" => local_var_req_builder.query(
4395                &local_var_str
4396                    .into_iter()
4397                    .map(|p| ("health_check_type__ire".to_owned(), p.to_string()))
4398                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4399            ),
4400            _ => local_var_req_builder.query(&[(
4401                "health_check_type__ire",
4402                &local_var_str
4403                    .into_iter()
4404                    .map(|p| p.to_string())
4405                    .collect::<Vec<String>>()
4406                    .join(",")
4407                    .to_string(),
4408            )]),
4409        };
4410    }
4411    if let Some(ref local_var_str) = health_check_type__isw {
4412        local_var_req_builder = match "multi" {
4413            "multi" => local_var_req_builder.query(
4414                &local_var_str
4415                    .into_iter()
4416                    .map(|p| ("health_check_type__isw".to_owned(), p.to_string()))
4417                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4418            ),
4419            _ => local_var_req_builder.query(&[(
4420                "health_check_type__isw",
4421                &local_var_str
4422                    .into_iter()
4423                    .map(|p| p.to_string())
4424                    .collect::<Vec<String>>()
4425                    .join(",")
4426                    .to_string(),
4427            )]),
4428        };
4429    }
4430    if let Some(ref local_var_str) = health_check_type__n {
4431        local_var_req_builder = match "multi" {
4432            "multi" => local_var_req_builder.query(
4433                &local_var_str
4434                    .into_iter()
4435                    .map(|p| ("health_check_type__n".to_owned(), p.to_string()))
4436                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4437            ),
4438            _ => local_var_req_builder.query(&[(
4439                "health_check_type__n",
4440                &local_var_str
4441                    .into_iter()
4442                    .map(|p| p.to_string())
4443                    .collect::<Vec<String>>()
4444                    .join(",")
4445                    .to_string(),
4446            )]),
4447        };
4448    }
4449    if let Some(ref local_var_str) = health_check_type__nic {
4450        local_var_req_builder = match "multi" {
4451            "multi" => local_var_req_builder.query(
4452                &local_var_str
4453                    .into_iter()
4454                    .map(|p| ("health_check_type__nic".to_owned(), p.to_string()))
4455                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4456            ),
4457            _ => local_var_req_builder.query(&[(
4458                "health_check_type__nic",
4459                &local_var_str
4460                    .into_iter()
4461                    .map(|p| p.to_string())
4462                    .collect::<Vec<String>>()
4463                    .join(",")
4464                    .to_string(),
4465            )]),
4466        };
4467    }
4468    if let Some(ref local_var_str) = health_check_type__nie {
4469        local_var_req_builder = match "multi" {
4470            "multi" => local_var_req_builder.query(
4471                &local_var_str
4472                    .into_iter()
4473                    .map(|p| ("health_check_type__nie".to_owned(), p.to_string()))
4474                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4475            ),
4476            _ => local_var_req_builder.query(&[(
4477                "health_check_type__nie",
4478                &local_var_str
4479                    .into_iter()
4480                    .map(|p| p.to_string())
4481                    .collect::<Vec<String>>()
4482                    .join(",")
4483                    .to_string(),
4484            )]),
4485        };
4486    }
4487    if let Some(ref local_var_str) = health_check_type__niew {
4488        local_var_req_builder = match "multi" {
4489            "multi" => local_var_req_builder.query(
4490                &local_var_str
4491                    .into_iter()
4492                    .map(|p| ("health_check_type__niew".to_owned(), p.to_string()))
4493                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4494            ),
4495            _ => local_var_req_builder.query(&[(
4496                "health_check_type__niew",
4497                &local_var_str
4498                    .into_iter()
4499                    .map(|p| p.to_string())
4500                    .collect::<Vec<String>>()
4501                    .join(",")
4502                    .to_string(),
4503            )]),
4504        };
4505    }
4506    if let Some(ref local_var_str) = health_check_type__nire {
4507        local_var_req_builder = match "multi" {
4508            "multi" => local_var_req_builder.query(
4509                &local_var_str
4510                    .into_iter()
4511                    .map(|p| ("health_check_type__nire".to_owned(), p.to_string()))
4512                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4513            ),
4514            _ => local_var_req_builder.query(&[(
4515                "health_check_type__nire",
4516                &local_var_str
4517                    .into_iter()
4518                    .map(|p| p.to_string())
4519                    .collect::<Vec<String>>()
4520                    .join(",")
4521                    .to_string(),
4522            )]),
4523        };
4524    }
4525    if let Some(ref local_var_str) = health_check_type__nisw {
4526        local_var_req_builder = match "multi" {
4527            "multi" => local_var_req_builder.query(
4528                &local_var_str
4529                    .into_iter()
4530                    .map(|p| ("health_check_type__nisw".to_owned(), p.to_string()))
4531                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4532            ),
4533            _ => local_var_req_builder.query(&[(
4534                "health_check_type__nisw",
4535                &local_var_str
4536                    .into_iter()
4537                    .map(|p| p.to_string())
4538                    .collect::<Vec<String>>()
4539                    .join(",")
4540                    .to_string(),
4541            )]),
4542        };
4543    }
4544    if let Some(ref local_var_str) = health_check_type__nre {
4545        local_var_req_builder = match "multi" {
4546            "multi" => local_var_req_builder.query(
4547                &local_var_str
4548                    .into_iter()
4549                    .map(|p| ("health_check_type__nre".to_owned(), p.to_string()))
4550                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4551            ),
4552            _ => local_var_req_builder.query(&[(
4553                "health_check_type__nre",
4554                &local_var_str
4555                    .into_iter()
4556                    .map(|p| p.to_string())
4557                    .collect::<Vec<String>>()
4558                    .join(",")
4559                    .to_string(),
4560            )]),
4561        };
4562    }
4563    if let Some(ref local_var_str) = health_check_type__re {
4564        local_var_req_builder = match "multi" {
4565            "multi" => local_var_req_builder.query(
4566                &local_var_str
4567                    .into_iter()
4568                    .map(|p| ("health_check_type__re".to_owned(), p.to_string()))
4569                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4570            ),
4571            _ => local_var_req_builder.query(&[(
4572                "health_check_type__re",
4573                &local_var_str
4574                    .into_iter()
4575                    .map(|p| p.to_string())
4576                    .collect::<Vec<String>>()
4577                    .join(",")
4578                    .to_string(),
4579            )]),
4580        };
4581    }
4582    if let Some(ref local_var_str) = id {
4583        local_var_req_builder = match "multi" {
4584            "multi" => local_var_req_builder.query(
4585                &local_var_str
4586                    .into_iter()
4587                    .map(|p| ("id".to_owned(), p.to_string()))
4588                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4589            ),
4590            _ => local_var_req_builder.query(&[(
4591                "id",
4592                &local_var_str
4593                    .into_iter()
4594                    .map(|p| p.to_string())
4595                    .collect::<Vec<String>>()
4596                    .join(",")
4597                    .to_string(),
4598            )]),
4599        };
4600    }
4601    if let Some(ref local_var_str) = id__n {
4602        local_var_req_builder = match "multi" {
4603            "multi" => local_var_req_builder.query(
4604                &local_var_str
4605                    .into_iter()
4606                    .map(|p| ("id__n".to_owned(), p.to_string()))
4607                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4608            ),
4609            _ => local_var_req_builder.query(&[(
4610                "id__n",
4611                &local_var_str
4612                    .into_iter()
4613                    .map(|p| p.to_string())
4614                    .collect::<Vec<String>>()
4615                    .join(",")
4616                    .to_string(),
4617            )]),
4618        };
4619    }
4620    if let Some(ref local_var_str) = interval {
4621        local_var_req_builder = match "multi" {
4622            "multi" => local_var_req_builder.query(
4623                &local_var_str
4624                    .into_iter()
4625                    .map(|p| ("interval".to_owned(), p.to_string()))
4626                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4627            ),
4628            _ => local_var_req_builder.query(&[(
4629                "interval",
4630                &local_var_str
4631                    .into_iter()
4632                    .map(|p| p.to_string())
4633                    .collect::<Vec<String>>()
4634                    .join(",")
4635                    .to_string(),
4636            )]),
4637        };
4638    }
4639    if let Some(ref local_var_str) = interval__gt {
4640        local_var_req_builder = match "multi" {
4641            "multi" => local_var_req_builder.query(
4642                &local_var_str
4643                    .into_iter()
4644                    .map(|p| ("interval__gt".to_owned(), p.to_string()))
4645                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4646            ),
4647            _ => local_var_req_builder.query(&[(
4648                "interval__gt",
4649                &local_var_str
4650                    .into_iter()
4651                    .map(|p| p.to_string())
4652                    .collect::<Vec<String>>()
4653                    .join(",")
4654                    .to_string(),
4655            )]),
4656        };
4657    }
4658    if let Some(ref local_var_str) = interval__gte {
4659        local_var_req_builder = match "multi" {
4660            "multi" => local_var_req_builder.query(
4661                &local_var_str
4662                    .into_iter()
4663                    .map(|p| ("interval__gte".to_owned(), p.to_string()))
4664                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4665            ),
4666            _ => local_var_req_builder.query(&[(
4667                "interval__gte",
4668                &local_var_str
4669                    .into_iter()
4670                    .map(|p| p.to_string())
4671                    .collect::<Vec<String>>()
4672                    .join(",")
4673                    .to_string(),
4674            )]),
4675        };
4676    }
4677    if let Some(ref local_var_str) = interval__isnull {
4678        local_var_req_builder =
4679            local_var_req_builder.query(&[("interval__isnull", &local_var_str.to_string())]);
4680    }
4681    if let Some(ref local_var_str) = interval__lt {
4682        local_var_req_builder = match "multi" {
4683            "multi" => local_var_req_builder.query(
4684                &local_var_str
4685                    .into_iter()
4686                    .map(|p| ("interval__lt".to_owned(), p.to_string()))
4687                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4688            ),
4689            _ => local_var_req_builder.query(&[(
4690                "interval__lt",
4691                &local_var_str
4692                    .into_iter()
4693                    .map(|p| p.to_string())
4694                    .collect::<Vec<String>>()
4695                    .join(",")
4696                    .to_string(),
4697            )]),
4698        };
4699    }
4700    if let Some(ref local_var_str) = interval__lte {
4701        local_var_req_builder = match "multi" {
4702            "multi" => local_var_req_builder.query(
4703                &local_var_str
4704                    .into_iter()
4705                    .map(|p| ("interval__lte".to_owned(), p.to_string()))
4706                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4707            ),
4708            _ => local_var_req_builder.query(&[(
4709                "interval__lte",
4710                &local_var_str
4711                    .into_iter()
4712                    .map(|p| p.to_string())
4713                    .collect::<Vec<String>>()
4714                    .join(",")
4715                    .to_string(),
4716            )]),
4717        };
4718    }
4719    if let Some(ref local_var_str) = interval__n {
4720        local_var_req_builder = match "multi" {
4721            "multi" => local_var_req_builder.query(
4722                &local_var_str
4723                    .into_iter()
4724                    .map(|p| ("interval__n".to_owned(), p.to_string()))
4725                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4726            ),
4727            _ => local_var_req_builder.query(&[(
4728                "interval__n",
4729                &local_var_str
4730                    .into_iter()
4731                    .map(|p| p.to_string())
4732                    .collect::<Vec<String>>()
4733                    .join(",")
4734                    .to_string(),
4735            )]),
4736        };
4737    }
4738    if let Some(ref local_var_str) = last_updated {
4739        local_var_req_builder = match "multi" {
4740            "multi" => local_var_req_builder.query(
4741                &local_var_str
4742                    .into_iter()
4743                    .map(|p| ("last_updated".to_owned(), p.to_string()))
4744                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4745            ),
4746            _ => local_var_req_builder.query(&[(
4747                "last_updated",
4748                &local_var_str
4749                    .into_iter()
4750                    .map(|p| p.to_string())
4751                    .collect::<Vec<String>>()
4752                    .join(",")
4753                    .to_string(),
4754            )]),
4755        };
4756    }
4757    if let Some(ref local_var_str) = last_updated__gt {
4758        local_var_req_builder = match "multi" {
4759            "multi" => local_var_req_builder.query(
4760                &local_var_str
4761                    .into_iter()
4762                    .map(|p| ("last_updated__gt".to_owned(), p.to_string()))
4763                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4764            ),
4765            _ => local_var_req_builder.query(&[(
4766                "last_updated__gt",
4767                &local_var_str
4768                    .into_iter()
4769                    .map(|p| p.to_string())
4770                    .collect::<Vec<String>>()
4771                    .join(",")
4772                    .to_string(),
4773            )]),
4774        };
4775    }
4776    if let Some(ref local_var_str) = last_updated__gte {
4777        local_var_req_builder = match "multi" {
4778            "multi" => local_var_req_builder.query(
4779                &local_var_str
4780                    .into_iter()
4781                    .map(|p| ("last_updated__gte".to_owned(), p.to_string()))
4782                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4783            ),
4784            _ => local_var_req_builder.query(&[(
4785                "last_updated__gte",
4786                &local_var_str
4787                    .into_iter()
4788                    .map(|p| p.to_string())
4789                    .collect::<Vec<String>>()
4790                    .join(",")
4791                    .to_string(),
4792            )]),
4793        };
4794    }
4795    if let Some(ref local_var_str) = last_updated__isnull {
4796        local_var_req_builder =
4797            local_var_req_builder.query(&[("last_updated__isnull", &local_var_str.to_string())]);
4798    }
4799    if let Some(ref local_var_str) = last_updated__lt {
4800        local_var_req_builder = match "multi" {
4801            "multi" => local_var_req_builder.query(
4802                &local_var_str
4803                    .into_iter()
4804                    .map(|p| ("last_updated__lt".to_owned(), p.to_string()))
4805                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4806            ),
4807            _ => local_var_req_builder.query(&[(
4808                "last_updated__lt",
4809                &local_var_str
4810                    .into_iter()
4811                    .map(|p| p.to_string())
4812                    .collect::<Vec<String>>()
4813                    .join(",")
4814                    .to_string(),
4815            )]),
4816        };
4817    }
4818    if let Some(ref local_var_str) = last_updated__lte {
4819        local_var_req_builder = match "multi" {
4820            "multi" => local_var_req_builder.query(
4821                &local_var_str
4822                    .into_iter()
4823                    .map(|p| ("last_updated__lte".to_owned(), p.to_string()))
4824                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4825            ),
4826            _ => local_var_req_builder.query(&[(
4827                "last_updated__lte",
4828                &local_var_str
4829                    .into_iter()
4830                    .map(|p| p.to_string())
4831                    .collect::<Vec<String>>()
4832                    .join(",")
4833                    .to_string(),
4834            )]),
4835        };
4836    }
4837    if let Some(ref local_var_str) = last_updated__n {
4838        local_var_req_builder = match "multi" {
4839            "multi" => local_var_req_builder.query(
4840                &local_var_str
4841                    .into_iter()
4842                    .map(|p| ("last_updated__n".to_owned(), p.to_string()))
4843                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4844            ),
4845            _ => local_var_req_builder.query(&[(
4846                "last_updated__n",
4847                &local_var_str
4848                    .into_iter()
4849                    .map(|p| p.to_string())
4850                    .collect::<Vec<String>>()
4851                    .join(",")
4852                    .to_string(),
4853            )]),
4854        };
4855    }
4856    if let Some(ref local_var_str) = limit {
4857        local_var_req_builder =
4858            local_var_req_builder.query(&[("limit", &local_var_str.to_string())]);
4859    }
4860    if let Some(ref local_var_str) = name {
4861        local_var_req_builder = match "multi" {
4862            "multi" => local_var_req_builder.query(
4863                &local_var_str
4864                    .into_iter()
4865                    .map(|p| ("name".to_owned(), p.to_string()))
4866                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4867            ),
4868            _ => local_var_req_builder.query(&[(
4869                "name",
4870                &local_var_str
4871                    .into_iter()
4872                    .map(|p| p.to_string())
4873                    .collect::<Vec<String>>()
4874                    .join(",")
4875                    .to_string(),
4876            )]),
4877        };
4878    }
4879    if let Some(ref local_var_str) = name__ic {
4880        local_var_req_builder = match "multi" {
4881            "multi" => local_var_req_builder.query(
4882                &local_var_str
4883                    .into_iter()
4884                    .map(|p| ("name__ic".to_owned(), p.to_string()))
4885                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4886            ),
4887            _ => local_var_req_builder.query(&[(
4888                "name__ic",
4889                &local_var_str
4890                    .into_iter()
4891                    .map(|p| p.to_string())
4892                    .collect::<Vec<String>>()
4893                    .join(",")
4894                    .to_string(),
4895            )]),
4896        };
4897    }
4898    if let Some(ref local_var_str) = name__ie {
4899        local_var_req_builder = match "multi" {
4900            "multi" => local_var_req_builder.query(
4901                &local_var_str
4902                    .into_iter()
4903                    .map(|p| ("name__ie".to_owned(), p.to_string()))
4904                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4905            ),
4906            _ => local_var_req_builder.query(&[(
4907                "name__ie",
4908                &local_var_str
4909                    .into_iter()
4910                    .map(|p| p.to_string())
4911                    .collect::<Vec<String>>()
4912                    .join(",")
4913                    .to_string(),
4914            )]),
4915        };
4916    }
4917    if let Some(ref local_var_str) = name__iew {
4918        local_var_req_builder = match "multi" {
4919            "multi" => local_var_req_builder.query(
4920                &local_var_str
4921                    .into_iter()
4922                    .map(|p| ("name__iew".to_owned(), p.to_string()))
4923                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4924            ),
4925            _ => local_var_req_builder.query(&[(
4926                "name__iew",
4927                &local_var_str
4928                    .into_iter()
4929                    .map(|p| p.to_string())
4930                    .collect::<Vec<String>>()
4931                    .join(",")
4932                    .to_string(),
4933            )]),
4934        };
4935    }
4936    if let Some(ref local_var_str) = name__ire {
4937        local_var_req_builder = match "multi" {
4938            "multi" => local_var_req_builder.query(
4939                &local_var_str
4940                    .into_iter()
4941                    .map(|p| ("name__ire".to_owned(), p.to_string()))
4942                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4943            ),
4944            _ => local_var_req_builder.query(&[(
4945                "name__ire",
4946                &local_var_str
4947                    .into_iter()
4948                    .map(|p| p.to_string())
4949                    .collect::<Vec<String>>()
4950                    .join(",")
4951                    .to_string(),
4952            )]),
4953        };
4954    }
4955    if let Some(ref local_var_str) = name__isw {
4956        local_var_req_builder = match "multi" {
4957            "multi" => local_var_req_builder.query(
4958                &local_var_str
4959                    .into_iter()
4960                    .map(|p| ("name__isw".to_owned(), p.to_string()))
4961                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4962            ),
4963            _ => local_var_req_builder.query(&[(
4964                "name__isw",
4965                &local_var_str
4966                    .into_iter()
4967                    .map(|p| p.to_string())
4968                    .collect::<Vec<String>>()
4969                    .join(",")
4970                    .to_string(),
4971            )]),
4972        };
4973    }
4974    if let Some(ref local_var_str) = name__n {
4975        local_var_req_builder = match "multi" {
4976            "multi" => local_var_req_builder.query(
4977                &local_var_str
4978                    .into_iter()
4979                    .map(|p| ("name__n".to_owned(), p.to_string()))
4980                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4981            ),
4982            _ => local_var_req_builder.query(&[(
4983                "name__n",
4984                &local_var_str
4985                    .into_iter()
4986                    .map(|p| p.to_string())
4987                    .collect::<Vec<String>>()
4988                    .join(",")
4989                    .to_string(),
4990            )]),
4991        };
4992    }
4993    if let Some(ref local_var_str) = name__nic {
4994        local_var_req_builder = match "multi" {
4995            "multi" => local_var_req_builder.query(
4996                &local_var_str
4997                    .into_iter()
4998                    .map(|p| ("name__nic".to_owned(), p.to_string()))
4999                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5000            ),
5001            _ => local_var_req_builder.query(&[(
5002                "name__nic",
5003                &local_var_str
5004                    .into_iter()
5005                    .map(|p| p.to_string())
5006                    .collect::<Vec<String>>()
5007                    .join(",")
5008                    .to_string(),
5009            )]),
5010        };
5011    }
5012    if let Some(ref local_var_str) = name__nie {
5013        local_var_req_builder = match "multi" {
5014            "multi" => local_var_req_builder.query(
5015                &local_var_str
5016                    .into_iter()
5017                    .map(|p| ("name__nie".to_owned(), p.to_string()))
5018                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5019            ),
5020            _ => local_var_req_builder.query(&[(
5021                "name__nie",
5022                &local_var_str
5023                    .into_iter()
5024                    .map(|p| p.to_string())
5025                    .collect::<Vec<String>>()
5026                    .join(",")
5027                    .to_string(),
5028            )]),
5029        };
5030    }
5031    if let Some(ref local_var_str) = name__niew {
5032        local_var_req_builder = match "multi" {
5033            "multi" => local_var_req_builder.query(
5034                &local_var_str
5035                    .into_iter()
5036                    .map(|p| ("name__niew".to_owned(), p.to_string()))
5037                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5038            ),
5039            _ => local_var_req_builder.query(&[(
5040                "name__niew",
5041                &local_var_str
5042                    .into_iter()
5043                    .map(|p| p.to_string())
5044                    .collect::<Vec<String>>()
5045                    .join(",")
5046                    .to_string(),
5047            )]),
5048        };
5049    }
5050    if let Some(ref local_var_str) = name__nire {
5051        local_var_req_builder = match "multi" {
5052            "multi" => local_var_req_builder.query(
5053                &local_var_str
5054                    .into_iter()
5055                    .map(|p| ("name__nire".to_owned(), p.to_string()))
5056                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5057            ),
5058            _ => local_var_req_builder.query(&[(
5059                "name__nire",
5060                &local_var_str
5061                    .into_iter()
5062                    .map(|p| p.to_string())
5063                    .collect::<Vec<String>>()
5064                    .join(",")
5065                    .to_string(),
5066            )]),
5067        };
5068    }
5069    if let Some(ref local_var_str) = name__nisw {
5070        local_var_req_builder = match "multi" {
5071            "multi" => local_var_req_builder.query(
5072                &local_var_str
5073                    .into_iter()
5074                    .map(|p| ("name__nisw".to_owned(), p.to_string()))
5075                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5076            ),
5077            _ => local_var_req_builder.query(&[(
5078                "name__nisw",
5079                &local_var_str
5080                    .into_iter()
5081                    .map(|p| p.to_string())
5082                    .collect::<Vec<String>>()
5083                    .join(",")
5084                    .to_string(),
5085            )]),
5086        };
5087    }
5088    if let Some(ref local_var_str) = name__nre {
5089        local_var_req_builder = match "multi" {
5090            "multi" => local_var_req_builder.query(
5091                &local_var_str
5092                    .into_iter()
5093                    .map(|p| ("name__nre".to_owned(), p.to_string()))
5094                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5095            ),
5096            _ => local_var_req_builder.query(&[(
5097                "name__nre",
5098                &local_var_str
5099                    .into_iter()
5100                    .map(|p| p.to_string())
5101                    .collect::<Vec<String>>()
5102                    .join(",")
5103                    .to_string(),
5104            )]),
5105        };
5106    }
5107    if let Some(ref local_var_str) = name__re {
5108        local_var_req_builder = match "multi" {
5109            "multi" => local_var_req_builder.query(
5110                &local_var_str
5111                    .into_iter()
5112                    .map(|p| ("name__re".to_owned(), p.to_string()))
5113                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5114            ),
5115            _ => local_var_req_builder.query(&[(
5116                "name__re",
5117                &local_var_str
5118                    .into_iter()
5119                    .map(|p| p.to_string())
5120                    .collect::<Vec<String>>()
5121                    .join(",")
5122                    .to_string(),
5123            )]),
5124        };
5125    }
5126    if let Some(ref local_var_str) = offset {
5127        local_var_req_builder =
5128            local_var_req_builder.query(&[("offset", &local_var_str.to_string())]);
5129    }
5130    if let Some(ref local_var_str) = port {
5131        local_var_req_builder = match "multi" {
5132            "multi" => local_var_req_builder.query(
5133                &local_var_str
5134                    .into_iter()
5135                    .map(|p| ("port".to_owned(), p.to_string()))
5136                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5137            ),
5138            _ => local_var_req_builder.query(&[(
5139                "port",
5140                &local_var_str
5141                    .into_iter()
5142                    .map(|p| p.to_string())
5143                    .collect::<Vec<String>>()
5144                    .join(",")
5145                    .to_string(),
5146            )]),
5147        };
5148    }
5149    if let Some(ref local_var_str) = port__gt {
5150        local_var_req_builder = match "multi" {
5151            "multi" => local_var_req_builder.query(
5152                &local_var_str
5153                    .into_iter()
5154                    .map(|p| ("port__gt".to_owned(), p.to_string()))
5155                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5156            ),
5157            _ => local_var_req_builder.query(&[(
5158                "port__gt",
5159                &local_var_str
5160                    .into_iter()
5161                    .map(|p| p.to_string())
5162                    .collect::<Vec<String>>()
5163                    .join(",")
5164                    .to_string(),
5165            )]),
5166        };
5167    }
5168    if let Some(ref local_var_str) = port__gte {
5169        local_var_req_builder = match "multi" {
5170            "multi" => local_var_req_builder.query(
5171                &local_var_str
5172                    .into_iter()
5173                    .map(|p| ("port__gte".to_owned(), p.to_string()))
5174                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5175            ),
5176            _ => local_var_req_builder.query(&[(
5177                "port__gte",
5178                &local_var_str
5179                    .into_iter()
5180                    .map(|p| p.to_string())
5181                    .collect::<Vec<String>>()
5182                    .join(",")
5183                    .to_string(),
5184            )]),
5185        };
5186    }
5187    if let Some(ref local_var_str) = port__isnull {
5188        local_var_req_builder =
5189            local_var_req_builder.query(&[("port__isnull", &local_var_str.to_string())]);
5190    }
5191    if let Some(ref local_var_str) = port__lt {
5192        local_var_req_builder = match "multi" {
5193            "multi" => local_var_req_builder.query(
5194                &local_var_str
5195                    .into_iter()
5196                    .map(|p| ("port__lt".to_owned(), p.to_string()))
5197                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5198            ),
5199            _ => local_var_req_builder.query(&[(
5200                "port__lt",
5201                &local_var_str
5202                    .into_iter()
5203                    .map(|p| p.to_string())
5204                    .collect::<Vec<String>>()
5205                    .join(",")
5206                    .to_string(),
5207            )]),
5208        };
5209    }
5210    if let Some(ref local_var_str) = port__lte {
5211        local_var_req_builder = match "multi" {
5212            "multi" => local_var_req_builder.query(
5213                &local_var_str
5214                    .into_iter()
5215                    .map(|p| ("port__lte".to_owned(), p.to_string()))
5216                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5217            ),
5218            _ => local_var_req_builder.query(&[(
5219                "port__lte",
5220                &local_var_str
5221                    .into_iter()
5222                    .map(|p| p.to_string())
5223                    .collect::<Vec<String>>()
5224                    .join(",")
5225                    .to_string(),
5226            )]),
5227        };
5228    }
5229    if let Some(ref local_var_str) = port__n {
5230        local_var_req_builder = match "multi" {
5231            "multi" => local_var_req_builder.query(
5232                &local_var_str
5233                    .into_iter()
5234                    .map(|p| ("port__n".to_owned(), p.to_string()))
5235                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5236            ),
5237            _ => local_var_req_builder.query(&[(
5238                "port__n",
5239                &local_var_str
5240                    .into_iter()
5241                    .map(|p| p.to_string())
5242                    .collect::<Vec<String>>()
5243                    .join(",")
5244                    .to_string(),
5245            )]),
5246        };
5247    }
5248    if let Some(ref local_var_str) = q {
5249        local_var_req_builder = local_var_req_builder.query(&[("q", &local_var_str.to_string())]);
5250    }
5251    if let Some(ref local_var_str) = retry {
5252        local_var_req_builder = match "multi" {
5253            "multi" => local_var_req_builder.query(
5254                &local_var_str
5255                    .into_iter()
5256                    .map(|p| ("retry".to_owned(), p.to_string()))
5257                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5258            ),
5259            _ => local_var_req_builder.query(&[(
5260                "retry",
5261                &local_var_str
5262                    .into_iter()
5263                    .map(|p| p.to_string())
5264                    .collect::<Vec<String>>()
5265                    .join(",")
5266                    .to_string(),
5267            )]),
5268        };
5269    }
5270    if let Some(ref local_var_str) = retry__gt {
5271        local_var_req_builder = match "multi" {
5272            "multi" => local_var_req_builder.query(
5273                &local_var_str
5274                    .into_iter()
5275                    .map(|p| ("retry__gt".to_owned(), p.to_string()))
5276                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5277            ),
5278            _ => local_var_req_builder.query(&[(
5279                "retry__gt",
5280                &local_var_str
5281                    .into_iter()
5282                    .map(|p| p.to_string())
5283                    .collect::<Vec<String>>()
5284                    .join(",")
5285                    .to_string(),
5286            )]),
5287        };
5288    }
5289    if let Some(ref local_var_str) = retry__gte {
5290        local_var_req_builder = match "multi" {
5291            "multi" => local_var_req_builder.query(
5292                &local_var_str
5293                    .into_iter()
5294                    .map(|p| ("retry__gte".to_owned(), p.to_string()))
5295                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5296            ),
5297            _ => local_var_req_builder.query(&[(
5298                "retry__gte",
5299                &local_var_str
5300                    .into_iter()
5301                    .map(|p| p.to_string())
5302                    .collect::<Vec<String>>()
5303                    .join(",")
5304                    .to_string(),
5305            )]),
5306        };
5307    }
5308    if let Some(ref local_var_str) = retry__isnull {
5309        local_var_req_builder =
5310            local_var_req_builder.query(&[("retry__isnull", &local_var_str.to_string())]);
5311    }
5312    if let Some(ref local_var_str) = retry__lt {
5313        local_var_req_builder = match "multi" {
5314            "multi" => local_var_req_builder.query(
5315                &local_var_str
5316                    .into_iter()
5317                    .map(|p| ("retry__lt".to_owned(), p.to_string()))
5318                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5319            ),
5320            _ => local_var_req_builder.query(&[(
5321                "retry__lt",
5322                &local_var_str
5323                    .into_iter()
5324                    .map(|p| p.to_string())
5325                    .collect::<Vec<String>>()
5326                    .join(",")
5327                    .to_string(),
5328            )]),
5329        };
5330    }
5331    if let Some(ref local_var_str) = retry__lte {
5332        local_var_req_builder = match "multi" {
5333            "multi" => local_var_req_builder.query(
5334                &local_var_str
5335                    .into_iter()
5336                    .map(|p| ("retry__lte".to_owned(), p.to_string()))
5337                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5338            ),
5339            _ => local_var_req_builder.query(&[(
5340                "retry__lte",
5341                &local_var_str
5342                    .into_iter()
5343                    .map(|p| p.to_string())
5344                    .collect::<Vec<String>>()
5345                    .join(",")
5346                    .to_string(),
5347            )]),
5348        };
5349    }
5350    if let Some(ref local_var_str) = retry__n {
5351        local_var_req_builder = match "multi" {
5352            "multi" => local_var_req_builder.query(
5353                &local_var_str
5354                    .into_iter()
5355                    .map(|p| ("retry__n".to_owned(), p.to_string()))
5356                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5357            ),
5358            _ => local_var_req_builder.query(&[(
5359                "retry__n",
5360                &local_var_str
5361                    .into_iter()
5362                    .map(|p| p.to_string())
5363                    .collect::<Vec<String>>()
5364                    .join(",")
5365                    .to_string(),
5366            )]),
5367        };
5368    }
5369    if let Some(ref local_var_str) = sort {
5370        local_var_req_builder =
5371            local_var_req_builder.query(&[("sort", &local_var_str.to_string())]);
5372    }
5373    if let Some(ref local_var_str) = tags {
5374        local_var_req_builder = match "multi" {
5375            "multi" => local_var_req_builder.query(
5376                &local_var_str
5377                    .into_iter()
5378                    .map(|p| ("tags".to_owned(), p.to_string()))
5379                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5380            ),
5381            _ => local_var_req_builder.query(&[(
5382                "tags",
5383                &local_var_str
5384                    .into_iter()
5385                    .map(|p| p.to_string())
5386                    .collect::<Vec<String>>()
5387                    .join(",")
5388                    .to_string(),
5389            )]),
5390        };
5391    }
5392    if let Some(ref local_var_str) = tags__isnull {
5393        local_var_req_builder =
5394            local_var_req_builder.query(&[("tags__isnull", &local_var_str.to_string())]);
5395    }
5396    if let Some(ref local_var_str) = tags__n {
5397        local_var_req_builder = match "multi" {
5398            "multi" => local_var_req_builder.query(
5399                &local_var_str
5400                    .into_iter()
5401                    .map(|p| ("tags__n".to_owned(), p.to_string()))
5402                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5403            ),
5404            _ => local_var_req_builder.query(&[(
5405                "tags__n",
5406                &local_var_str
5407                    .into_iter()
5408                    .map(|p| p.to_string())
5409                    .collect::<Vec<String>>()
5410                    .join(",")
5411                    .to_string(),
5412            )]),
5413        };
5414    }
5415    if let Some(ref local_var_str) = teams {
5416        local_var_req_builder = match "multi" {
5417            "multi" => local_var_req_builder.query(
5418                &local_var_str
5419                    .into_iter()
5420                    .map(|p| ("teams".to_owned(), p.to_string()))
5421                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5422            ),
5423            _ => local_var_req_builder.query(&[(
5424                "teams",
5425                &local_var_str
5426                    .into_iter()
5427                    .map(|p| p.to_string())
5428                    .collect::<Vec<String>>()
5429                    .join(",")
5430                    .to_string(),
5431            )]),
5432        };
5433    }
5434    if let Some(ref local_var_str) = teams__isnull {
5435        local_var_req_builder =
5436            local_var_req_builder.query(&[("teams__isnull", &local_var_str.to_string())]);
5437    }
5438    if let Some(ref local_var_str) = teams__n {
5439        local_var_req_builder = match "multi" {
5440            "multi" => local_var_req_builder.query(
5441                &local_var_str
5442                    .into_iter()
5443                    .map(|p| ("teams__n".to_owned(), p.to_string()))
5444                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5445            ),
5446            _ => local_var_req_builder.query(&[(
5447                "teams__n",
5448                &local_var_str
5449                    .into_iter()
5450                    .map(|p| p.to_string())
5451                    .collect::<Vec<String>>()
5452                    .join(",")
5453                    .to_string(),
5454            )]),
5455        };
5456    }
5457    if let Some(ref local_var_str) = tenant {
5458        local_var_req_builder = match "multi" {
5459            "multi" => local_var_req_builder.query(
5460                &local_var_str
5461                    .into_iter()
5462                    .map(|p| ("tenant".to_owned(), p.to_string()))
5463                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5464            ),
5465            _ => local_var_req_builder.query(&[(
5466                "tenant",
5467                &local_var_str
5468                    .into_iter()
5469                    .map(|p| p.to_string())
5470                    .collect::<Vec<String>>()
5471                    .join(",")
5472                    .to_string(),
5473            )]),
5474        };
5475    }
5476    if let Some(ref local_var_str) = tenant__isnull {
5477        local_var_req_builder =
5478            local_var_req_builder.query(&[("tenant__isnull", &local_var_str.to_string())]);
5479    }
5480    if let Some(ref local_var_str) = tenant__n {
5481        local_var_req_builder = match "multi" {
5482            "multi" => local_var_req_builder.query(
5483                &local_var_str
5484                    .into_iter()
5485                    .map(|p| ("tenant__n".to_owned(), p.to_string()))
5486                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5487            ),
5488            _ => local_var_req_builder.query(&[(
5489                "tenant__n",
5490                &local_var_str
5491                    .into_iter()
5492                    .map(|p| p.to_string())
5493                    .collect::<Vec<String>>()
5494                    .join(",")
5495                    .to_string(),
5496            )]),
5497        };
5498    }
5499    if let Some(ref local_var_str) = tenant_group {
5500        local_var_req_builder = match "multi" {
5501            "multi" => local_var_req_builder.query(
5502                &local_var_str
5503                    .into_iter()
5504                    .map(|p| ("tenant_group".to_owned(), p.to_string()))
5505                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5506            ),
5507            _ => local_var_req_builder.query(&[(
5508                "tenant_group",
5509                &local_var_str
5510                    .into_iter()
5511                    .map(|p| p.to_string())
5512                    .collect::<Vec<String>>()
5513                    .join(",")
5514                    .to_string(),
5515            )]),
5516        };
5517    }
5518    if let Some(ref local_var_str) = tenant_group__isnull {
5519        local_var_req_builder =
5520            local_var_req_builder.query(&[("tenant_group__isnull", &local_var_str.to_string())]);
5521    }
5522    if let Some(ref local_var_str) = tenant_group__n {
5523        local_var_req_builder = match "multi" {
5524            "multi" => local_var_req_builder.query(
5525                &local_var_str
5526                    .into_iter()
5527                    .map(|p| ("tenant_group__n".to_owned(), p.to_string()))
5528                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5529            ),
5530            _ => local_var_req_builder.query(&[(
5531                "tenant_group__n",
5532                &local_var_str
5533                    .into_iter()
5534                    .map(|p| p.to_string())
5535                    .collect::<Vec<String>>()
5536                    .join(",")
5537                    .to_string(),
5538            )]),
5539        };
5540    }
5541    if let Some(ref local_var_str) = tenant_id {
5542        local_var_req_builder = match "multi" {
5543            "multi" => local_var_req_builder.query(
5544                &local_var_str
5545                    .into_iter()
5546                    .map(|p| ("tenant_id".to_owned(), p.to_string()))
5547                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5548            ),
5549            _ => local_var_req_builder.query(&[(
5550                "tenant_id",
5551                &local_var_str
5552                    .into_iter()
5553                    .map(|p| p.to_string())
5554                    .collect::<Vec<String>>()
5555                    .join(",")
5556                    .to_string(),
5557            )]),
5558        };
5559    }
5560    if let Some(ref local_var_str) = tenant_id__isnull {
5561        local_var_req_builder =
5562            local_var_req_builder.query(&[("tenant_id__isnull", &local_var_str.to_string())]);
5563    }
5564    if let Some(ref local_var_str) = tenant_id__n {
5565        local_var_req_builder = match "multi" {
5566            "multi" => local_var_req_builder.query(
5567                &local_var_str
5568                    .into_iter()
5569                    .map(|p| ("tenant_id__n".to_owned(), p.to_string()))
5570                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5571            ),
5572            _ => local_var_req_builder.query(&[(
5573                "tenant_id__n",
5574                &local_var_str
5575                    .into_iter()
5576                    .map(|p| p.to_string())
5577                    .collect::<Vec<String>>()
5578                    .join(",")
5579                    .to_string(),
5580            )]),
5581        };
5582    }
5583    if let Some(ref local_var_str) = timeout {
5584        local_var_req_builder = match "multi" {
5585            "multi" => local_var_req_builder.query(
5586                &local_var_str
5587                    .into_iter()
5588                    .map(|p| ("timeout".to_owned(), p.to_string()))
5589                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5590            ),
5591            _ => local_var_req_builder.query(&[(
5592                "timeout",
5593                &local_var_str
5594                    .into_iter()
5595                    .map(|p| p.to_string())
5596                    .collect::<Vec<String>>()
5597                    .join(",")
5598                    .to_string(),
5599            )]),
5600        };
5601    }
5602    if let Some(ref local_var_str) = timeout__gt {
5603        local_var_req_builder = match "multi" {
5604            "multi" => local_var_req_builder.query(
5605                &local_var_str
5606                    .into_iter()
5607                    .map(|p| ("timeout__gt".to_owned(), p.to_string()))
5608                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5609            ),
5610            _ => local_var_req_builder.query(&[(
5611                "timeout__gt",
5612                &local_var_str
5613                    .into_iter()
5614                    .map(|p| p.to_string())
5615                    .collect::<Vec<String>>()
5616                    .join(",")
5617                    .to_string(),
5618            )]),
5619        };
5620    }
5621    if let Some(ref local_var_str) = timeout__gte {
5622        local_var_req_builder = match "multi" {
5623            "multi" => local_var_req_builder.query(
5624                &local_var_str
5625                    .into_iter()
5626                    .map(|p| ("timeout__gte".to_owned(), p.to_string()))
5627                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5628            ),
5629            _ => local_var_req_builder.query(&[(
5630                "timeout__gte",
5631                &local_var_str
5632                    .into_iter()
5633                    .map(|p| p.to_string())
5634                    .collect::<Vec<String>>()
5635                    .join(",")
5636                    .to_string(),
5637            )]),
5638        };
5639    }
5640    if let Some(ref local_var_str) = timeout__isnull {
5641        local_var_req_builder =
5642            local_var_req_builder.query(&[("timeout__isnull", &local_var_str.to_string())]);
5643    }
5644    if let Some(ref local_var_str) = timeout__lt {
5645        local_var_req_builder = match "multi" {
5646            "multi" => local_var_req_builder.query(
5647                &local_var_str
5648                    .into_iter()
5649                    .map(|p| ("timeout__lt".to_owned(), p.to_string()))
5650                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5651            ),
5652            _ => local_var_req_builder.query(&[(
5653                "timeout__lt",
5654                &local_var_str
5655                    .into_iter()
5656                    .map(|p| p.to_string())
5657                    .collect::<Vec<String>>()
5658                    .join(",")
5659                    .to_string(),
5660            )]),
5661        };
5662    }
5663    if let Some(ref local_var_str) = timeout__lte {
5664        local_var_req_builder = match "multi" {
5665            "multi" => local_var_req_builder.query(
5666                &local_var_str
5667                    .into_iter()
5668                    .map(|p| ("timeout__lte".to_owned(), p.to_string()))
5669                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5670            ),
5671            _ => local_var_req_builder.query(&[(
5672                "timeout__lte",
5673                &local_var_str
5674                    .into_iter()
5675                    .map(|p| p.to_string())
5676                    .collect::<Vec<String>>()
5677                    .join(",")
5678                    .to_string(),
5679            )]),
5680        };
5681    }
5682    if let Some(ref local_var_str) = timeout__n {
5683        local_var_req_builder = match "multi" {
5684            "multi" => local_var_req_builder.query(
5685                &local_var_str
5686                    .into_iter()
5687                    .map(|p| ("timeout__n".to_owned(), p.to_string()))
5688                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5689            ),
5690            _ => local_var_req_builder.query(&[(
5691                "timeout__n",
5692                &local_var_str
5693                    .into_iter()
5694                    .map(|p| p.to_string())
5695                    .collect::<Vec<String>>()
5696                    .join(",")
5697                    .to_string(),
5698            )]),
5699        };
5700    }
5701    if let Some(ref local_var_str) = depth {
5702        local_var_req_builder =
5703            local_var_req_builder.query(&[("depth", &local_var_str.to_string())]);
5704    }
5705    if let Some(ref local_var_str) = exclude_m2m {
5706        local_var_req_builder =
5707            local_var_req_builder.query(&[("exclude_m2m", &local_var_str.to_string())]);
5708    }
5709    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
5710        local_var_req_builder =
5711            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
5712    }
5713    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
5714        let local_var_key = local_var_apikey.key.clone();
5715        let local_var_value = match local_var_apikey.prefix {
5716            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
5717            None => local_var_key,
5718        };
5719        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
5720    };
5721
5722    let local_var_req = local_var_req_builder.build()?;
5723    let local_var_resp = local_var_client.execute(local_var_req).await?;
5724
5725    let local_var_status = local_var_resp.status();
5726    let local_var_content = local_var_resp.text().await?;
5727
5728    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
5729        serde_json::from_str(&local_var_content).map_err(Error::from)
5730    } else {
5731        let local_var_entity: Option<LoadBalancersHealthCheckMonitorsListError> =
5732            serde_json::from_str(&local_var_content).ok();
5733        let local_var_error = ResponseContent {
5734            status: local_var_status,
5735            content: local_var_content,
5736            entity: local_var_entity,
5737        };
5738        Err(Error::ResponseError(local_var_error))
5739    }
5740}
5741
5742/// API methods for returning or creating notes on an object.
5743pub async fn load_balancers_health_check_monitors_notes_create(
5744    configuration: &configuration::Configuration,
5745    id: &str,
5746    note_input_request: crate::models::NoteInputRequest,
5747    format: Option<&str>,
5748) -> Result<crate::models::Note, Error<LoadBalancersHealthCheckMonitorsNotesCreateError>> {
5749    let local_var_configuration = configuration;
5750
5751    let local_var_client = &local_var_configuration.client;
5752
5753    let local_var_uri_str = format!(
5754        "{}/load-balancers/health-check-monitors/{id}/notes/",
5755        local_var_configuration.base_path,
5756        id = crate::apis::urlencode(id)
5757    );
5758    let mut local_var_req_builder =
5759        local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
5760
5761    if let Some(ref local_var_str) = format {
5762        local_var_req_builder =
5763            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
5764    }
5765    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
5766        local_var_req_builder =
5767            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
5768    }
5769    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
5770        let local_var_key = local_var_apikey.key.clone();
5771        let local_var_value = match local_var_apikey.prefix {
5772            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
5773            None => local_var_key,
5774        };
5775        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
5776    };
5777    local_var_req_builder = local_var_req_builder.json(&note_input_request);
5778
5779    let local_var_req = local_var_req_builder.build()?;
5780    let local_var_resp = local_var_client.execute(local_var_req).await?;
5781
5782    let local_var_status = local_var_resp.status();
5783    let local_var_content = local_var_resp.text().await?;
5784
5785    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
5786        serde_json::from_str(&local_var_content).map_err(Error::from)
5787    } else {
5788        let local_var_entity: Option<LoadBalancersHealthCheckMonitorsNotesCreateError> =
5789            serde_json::from_str(&local_var_content).ok();
5790        let local_var_error = ResponseContent {
5791            status: local_var_status,
5792            content: local_var_content,
5793            entity: local_var_entity,
5794        };
5795        Err(Error::ResponseError(local_var_error))
5796    }
5797}
5798
5799/// API methods for returning or creating notes on an object.
5800pub async fn load_balancers_health_check_monitors_notes_list(
5801    configuration: &configuration::Configuration,
5802    id: &str,
5803    format: Option<&str>,
5804    limit: Option<i32>,
5805    offset: Option<i32>,
5806    depth: Option<i32>,
5807    exclude_m2m: Option<bool>,
5808) -> Result<crate::models::PaginatedNoteList, Error<LoadBalancersHealthCheckMonitorsNotesListError>>
5809{
5810    let local_var_configuration = configuration;
5811
5812    let local_var_client = &local_var_configuration.client;
5813
5814    let local_var_uri_str = format!(
5815        "{}/load-balancers/health-check-monitors/{id}/notes/",
5816        local_var_configuration.base_path,
5817        id = crate::apis::urlencode(id)
5818    );
5819    let mut local_var_req_builder =
5820        local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
5821
5822    if let Some(ref local_var_str) = format {
5823        local_var_req_builder =
5824            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
5825    }
5826    if let Some(ref local_var_str) = limit {
5827        local_var_req_builder =
5828            local_var_req_builder.query(&[("limit", &local_var_str.to_string())]);
5829    }
5830    if let Some(ref local_var_str) = offset {
5831        local_var_req_builder =
5832            local_var_req_builder.query(&[("offset", &local_var_str.to_string())]);
5833    }
5834    if let Some(ref local_var_str) = depth {
5835        local_var_req_builder =
5836            local_var_req_builder.query(&[("depth", &local_var_str.to_string())]);
5837    }
5838    if let Some(ref local_var_str) = exclude_m2m {
5839        local_var_req_builder =
5840            local_var_req_builder.query(&[("exclude_m2m", &local_var_str.to_string())]);
5841    }
5842    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
5843        local_var_req_builder =
5844            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
5845    }
5846    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
5847        let local_var_key = local_var_apikey.key.clone();
5848        let local_var_value = match local_var_apikey.prefix {
5849            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
5850            None => local_var_key,
5851        };
5852        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
5853    };
5854
5855    let local_var_req = local_var_req_builder.build()?;
5856    let local_var_resp = local_var_client.execute(local_var_req).await?;
5857
5858    let local_var_status = local_var_resp.status();
5859    let local_var_content = local_var_resp.text().await?;
5860
5861    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
5862        serde_json::from_str(&local_var_content).map_err(Error::from)
5863    } else {
5864        let local_var_entity: Option<LoadBalancersHealthCheckMonitorsNotesListError> =
5865            serde_json::from_str(&local_var_content).ok();
5866        let local_var_error = ResponseContent {
5867            status: local_var_status,
5868            content: local_var_content,
5869            entity: local_var_entity,
5870        };
5871        Err(Error::ResponseError(local_var_error))
5872    }
5873}
5874
5875/// HealthCheckMonitor viewset.
5876pub async fn load_balancers_health_check_monitors_partial_update(
5877    configuration: &configuration::Configuration,
5878    id: &str,
5879    format: Option<&str>,
5880    patched_health_check_monitor_request: Option<crate::models::PatchedHealthCheckMonitorRequest>,
5881) -> Result<
5882    crate::models::HealthCheckMonitor,
5883    Error<LoadBalancersHealthCheckMonitorsPartialUpdateError>,
5884> {
5885    let local_var_configuration = configuration;
5886
5887    let local_var_client = &local_var_configuration.client;
5888
5889    let local_var_uri_str = format!(
5890        "{}/load-balancers/health-check-monitors/{id}/",
5891        local_var_configuration.base_path,
5892        id = crate::apis::urlencode(id)
5893    );
5894    let mut local_var_req_builder =
5895        local_var_client.request(reqwest::Method::PATCH, local_var_uri_str.as_str());
5896
5897    if let Some(ref local_var_str) = format {
5898        local_var_req_builder =
5899            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
5900    }
5901    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
5902        local_var_req_builder =
5903            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
5904    }
5905    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
5906        let local_var_key = local_var_apikey.key.clone();
5907        let local_var_value = match local_var_apikey.prefix {
5908            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
5909            None => local_var_key,
5910        };
5911        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
5912    };
5913    local_var_req_builder = local_var_req_builder.json(&patched_health_check_monitor_request);
5914
5915    let local_var_req = local_var_req_builder.build()?;
5916    let local_var_resp = local_var_client.execute(local_var_req).await?;
5917
5918    let local_var_status = local_var_resp.status();
5919    let local_var_content = local_var_resp.text().await?;
5920
5921    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
5922        serde_json::from_str(&local_var_content).map_err(Error::from)
5923    } else {
5924        let local_var_entity: Option<LoadBalancersHealthCheckMonitorsPartialUpdateError> =
5925            serde_json::from_str(&local_var_content).ok();
5926        let local_var_error = ResponseContent {
5927            status: local_var_status,
5928            content: local_var_content,
5929            entity: local_var_entity,
5930        };
5931        Err(Error::ResponseError(local_var_error))
5932    }
5933}
5934
5935/// HealthCheckMonitor viewset.
5936pub async fn load_balancers_health_check_monitors_retrieve(
5937    configuration: &configuration::Configuration,
5938    id: &str,
5939    format: Option<&str>,
5940    depth: Option<i32>,
5941    exclude_m2m: Option<bool>,
5942) -> Result<crate::models::HealthCheckMonitor, Error<LoadBalancersHealthCheckMonitorsRetrieveError>>
5943{
5944    let local_var_configuration = configuration;
5945
5946    let local_var_client = &local_var_configuration.client;
5947
5948    let local_var_uri_str = format!(
5949        "{}/load-balancers/health-check-monitors/{id}/",
5950        local_var_configuration.base_path,
5951        id = crate::apis::urlencode(id)
5952    );
5953    let mut local_var_req_builder =
5954        local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
5955
5956    if let Some(ref local_var_str) = format {
5957        local_var_req_builder =
5958            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
5959    }
5960    if let Some(ref local_var_str) = depth {
5961        local_var_req_builder =
5962            local_var_req_builder.query(&[("depth", &local_var_str.to_string())]);
5963    }
5964    if let Some(ref local_var_str) = exclude_m2m {
5965        local_var_req_builder =
5966            local_var_req_builder.query(&[("exclude_m2m", &local_var_str.to_string())]);
5967    }
5968    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
5969        local_var_req_builder =
5970            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
5971    }
5972    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
5973        let local_var_key = local_var_apikey.key.clone();
5974        let local_var_value = match local_var_apikey.prefix {
5975            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
5976            None => local_var_key,
5977        };
5978        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
5979    };
5980
5981    let local_var_req = local_var_req_builder.build()?;
5982    let local_var_resp = local_var_client.execute(local_var_req).await?;
5983
5984    let local_var_status = local_var_resp.status();
5985    let local_var_content = local_var_resp.text().await?;
5986
5987    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
5988        serde_json::from_str(&local_var_content).map_err(Error::from)
5989    } else {
5990        let local_var_entity: Option<LoadBalancersHealthCheckMonitorsRetrieveError> =
5991            serde_json::from_str(&local_var_content).ok();
5992        let local_var_error = ResponseContent {
5993            status: local_var_status,
5994            content: local_var_content,
5995            entity: local_var_entity,
5996        };
5997        Err(Error::ResponseError(local_var_error))
5998    }
5999}
6000
6001/// HealthCheckMonitor viewset.
6002pub async fn load_balancers_health_check_monitors_update(
6003    configuration: &configuration::Configuration,
6004    id: &str,
6005    health_check_monitor_request: crate::models::HealthCheckMonitorRequest,
6006    format: Option<&str>,
6007) -> Result<crate::models::HealthCheckMonitor, Error<LoadBalancersHealthCheckMonitorsUpdateError>> {
6008    let local_var_configuration = configuration;
6009
6010    let local_var_client = &local_var_configuration.client;
6011
6012    let local_var_uri_str = format!(
6013        "{}/load-balancers/health-check-monitors/{id}/",
6014        local_var_configuration.base_path,
6015        id = crate::apis::urlencode(id)
6016    );
6017    let mut local_var_req_builder =
6018        local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());
6019
6020    if let Some(ref local_var_str) = format {
6021        local_var_req_builder =
6022            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
6023    }
6024    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
6025        local_var_req_builder =
6026            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
6027    }
6028    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
6029        let local_var_key = local_var_apikey.key.clone();
6030        let local_var_value = match local_var_apikey.prefix {
6031            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
6032            None => local_var_key,
6033        };
6034        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
6035    };
6036    local_var_req_builder = local_var_req_builder.json(&health_check_monitor_request);
6037
6038    let local_var_req = local_var_req_builder.build()?;
6039    let local_var_resp = local_var_client.execute(local_var_req).await?;
6040
6041    let local_var_status = local_var_resp.status();
6042    let local_var_content = local_var_resp.text().await?;
6043
6044    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
6045        serde_json::from_str(&local_var_content).map_err(Error::from)
6046    } else {
6047        let local_var_entity: Option<LoadBalancersHealthCheckMonitorsUpdateError> =
6048            serde_json::from_str(&local_var_content).ok();
6049        let local_var_error = ResponseContent {
6050            status: local_var_status,
6051            content: local_var_content,
6052            entity: local_var_entity,
6053        };
6054        Err(Error::ResponseError(local_var_error))
6055    }
6056}
6057
6058/// LoadBalancerPoolMemberCertificateProfileAssignment viewset.
6059pub async fn load_balancers_load_balancer_pool_member_certificate_profile_assignments_bulk_destroy(
6060    configuration: &configuration::Configuration,
6061    bulk_operation_request: Vec<crate::models::BulkOperationRequest>,
6062    format: Option<&str>,
6063) -> Result<
6064    (),
6065    Error<LoadBalancersLoadBalancerPoolMemberCertificateProfileAssignmentsBulkDestroyError>,
6066> {
6067    let local_var_configuration = configuration;
6068
6069    let local_var_client = &local_var_configuration.client;
6070
6071    let local_var_uri_str = format!(
6072        "{}/load-balancers/load-balancer-pool-member-certificate-profile-assignments/",
6073        local_var_configuration.base_path
6074    );
6075    let mut local_var_req_builder =
6076        local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());
6077
6078    if let Some(ref local_var_str) = format {
6079        local_var_req_builder =
6080            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
6081    }
6082    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
6083        local_var_req_builder =
6084            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
6085    }
6086    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
6087        let local_var_key = local_var_apikey.key.clone();
6088        let local_var_value = match local_var_apikey.prefix {
6089            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
6090            None => local_var_key,
6091        };
6092        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
6093    };
6094    local_var_req_builder = local_var_req_builder.json(&bulk_operation_request);
6095
6096    let local_var_req = local_var_req_builder.build()?;
6097    let local_var_resp = local_var_client.execute(local_var_req).await?;
6098
6099    let local_var_status = local_var_resp.status();
6100    let local_var_content = local_var_resp.text().await?;
6101
6102    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
6103        Ok(())
6104    } else {
6105        let local_var_entity: Option<
6106            LoadBalancersLoadBalancerPoolMemberCertificateProfileAssignmentsBulkDestroyError,
6107        > = serde_json::from_str(&local_var_content).ok();
6108        let local_var_error = ResponseContent {
6109            status: local_var_status,
6110            content: local_var_content,
6111            entity: local_var_entity,
6112        };
6113        Err(Error::ResponseError(local_var_error))
6114    }
6115}
6116
6117/// LoadBalancerPoolMemberCertificateProfileAssignment viewset.
6118pub async fn load_balancers_load_balancer_pool_member_certificate_profile_assignments_bulk_partial_update(
6119    configuration: &configuration::Configuration,
6120    patched_bulk_writable_load_balancer_pool_member_certificate_profile_assignment_request: Vec<
6121        crate::models::PatchedBulkWritableLoadBalancerPoolMemberCertificateProfileAssignmentRequest,
6122    >,
6123    format: Option<&str>,
6124) -> Result<
6125    Vec<crate::models::LoadBalancerPoolMemberCertificateProfileAssignment>,
6126    Error<LoadBalancersLoadBalancerPoolMemberCertificateProfileAssignmentsBulkPartialUpdateError>,
6127> {
6128    let local_var_configuration = configuration;
6129
6130    let local_var_client = &local_var_configuration.client;
6131
6132    let local_var_uri_str = format!(
6133        "{}/load-balancers/load-balancer-pool-member-certificate-profile-assignments/",
6134        local_var_configuration.base_path
6135    );
6136    let mut local_var_req_builder =
6137        local_var_client.request(reqwest::Method::PATCH, local_var_uri_str.as_str());
6138
6139    if let Some(ref local_var_str) = format {
6140        local_var_req_builder =
6141            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
6142    }
6143    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
6144        local_var_req_builder =
6145            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
6146    }
6147    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
6148        let local_var_key = local_var_apikey.key.clone();
6149        let local_var_value = match local_var_apikey.prefix {
6150            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
6151            None => local_var_key,
6152        };
6153        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
6154    };
6155    local_var_req_builder = local_var_req_builder.json(
6156        &patched_bulk_writable_load_balancer_pool_member_certificate_profile_assignment_request,
6157    );
6158
6159    let local_var_req = local_var_req_builder.build()?;
6160    let local_var_resp = local_var_client.execute(local_var_req).await?;
6161
6162    let local_var_status = local_var_resp.status();
6163    let local_var_content = local_var_resp.text().await?;
6164
6165    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
6166        serde_json::from_str(&local_var_content).map_err(Error::from)
6167    } else {
6168        let local_var_entity: Option<
6169            LoadBalancersLoadBalancerPoolMemberCertificateProfileAssignmentsBulkPartialUpdateError,
6170        > = serde_json::from_str(&local_var_content).ok();
6171        let local_var_error = ResponseContent {
6172            status: local_var_status,
6173            content: local_var_content,
6174            entity: local_var_entity,
6175        };
6176        Err(Error::ResponseError(local_var_error))
6177    }
6178}
6179
6180/// LoadBalancerPoolMemberCertificateProfileAssignment viewset.
6181pub async fn load_balancers_load_balancer_pool_member_certificate_profile_assignments_bulk_update(
6182    configuration: &configuration::Configuration,
6183    bulk_writable_load_balancer_pool_member_certificate_profile_assignment_request: Vec<
6184        crate::models::BulkWritableLoadBalancerPoolMemberCertificateProfileAssignmentRequest,
6185    >,
6186    format: Option<&str>,
6187) -> Result<
6188    Vec<crate::models::LoadBalancerPoolMemberCertificateProfileAssignment>,
6189    Error<LoadBalancersLoadBalancerPoolMemberCertificateProfileAssignmentsBulkUpdateError>,
6190> {
6191    let local_var_configuration = configuration;
6192
6193    let local_var_client = &local_var_configuration.client;
6194
6195    let local_var_uri_str = format!(
6196        "{}/load-balancers/load-balancer-pool-member-certificate-profile-assignments/",
6197        local_var_configuration.base_path
6198    );
6199    let mut local_var_req_builder =
6200        local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());
6201
6202    if let Some(ref local_var_str) = format {
6203        local_var_req_builder =
6204            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
6205    }
6206    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
6207        local_var_req_builder =
6208            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
6209    }
6210    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
6211        let local_var_key = local_var_apikey.key.clone();
6212        let local_var_value = match local_var_apikey.prefix {
6213            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
6214            None => local_var_key,
6215        };
6216        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
6217    };
6218    local_var_req_builder = local_var_req_builder
6219        .json(&bulk_writable_load_balancer_pool_member_certificate_profile_assignment_request);
6220
6221    let local_var_req = local_var_req_builder.build()?;
6222    let local_var_resp = local_var_client.execute(local_var_req).await?;
6223
6224    let local_var_status = local_var_resp.status();
6225    let local_var_content = local_var_resp.text().await?;
6226
6227    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
6228        serde_json::from_str(&local_var_content).map_err(Error::from)
6229    } else {
6230        let local_var_entity: Option<
6231            LoadBalancersLoadBalancerPoolMemberCertificateProfileAssignmentsBulkUpdateError,
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/// LoadBalancerPoolMemberCertificateProfileAssignment viewset.
6243pub async fn load_balancers_load_balancer_pool_member_certificate_profile_assignments_create(
6244    configuration: &configuration::Configuration,
6245    load_balancer_pool_member_certificate_profile_assignment_request: crate::models::LoadBalancerPoolMemberCertificateProfileAssignmentRequest,
6246    format: Option<&str>,
6247) -> Result<
6248    crate::models::LoadBalancerPoolMemberCertificateProfileAssignment,
6249    Error<LoadBalancersLoadBalancerPoolMemberCertificateProfileAssignmentsCreateError>,
6250> {
6251    let local_var_configuration = configuration;
6252
6253    let local_var_client = &local_var_configuration.client;
6254
6255    let local_var_uri_str = format!(
6256        "{}/load-balancers/load-balancer-pool-member-certificate-profile-assignments/",
6257        local_var_configuration.base_path
6258    );
6259    let mut local_var_req_builder =
6260        local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
6261
6262    if let Some(ref local_var_str) = format {
6263        local_var_req_builder =
6264            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
6265    }
6266    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
6267        local_var_req_builder =
6268            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
6269    }
6270    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
6271        let local_var_key = local_var_apikey.key.clone();
6272        let local_var_value = match local_var_apikey.prefix {
6273            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
6274            None => local_var_key,
6275        };
6276        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
6277    };
6278    local_var_req_builder = local_var_req_builder
6279        .json(&load_balancer_pool_member_certificate_profile_assignment_request);
6280
6281    let local_var_req = local_var_req_builder.build()?;
6282    let local_var_resp = local_var_client.execute(local_var_req).await?;
6283
6284    let local_var_status = local_var_resp.status();
6285    let local_var_content = local_var_resp.text().await?;
6286
6287    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
6288        serde_json::from_str(&local_var_content).map_err(Error::from)
6289    } else {
6290        let local_var_entity: Option<
6291            LoadBalancersLoadBalancerPoolMemberCertificateProfileAssignmentsCreateError,
6292        > = serde_json::from_str(&local_var_content).ok();
6293        let local_var_error = ResponseContent {
6294            status: local_var_status,
6295            content: local_var_content,
6296            entity: local_var_entity,
6297        };
6298        Err(Error::ResponseError(local_var_error))
6299    }
6300}
6301
6302/// LoadBalancerPoolMemberCertificateProfileAssignment viewset.
6303pub async fn load_balancers_load_balancer_pool_member_certificate_profile_assignments_destroy(
6304    configuration: &configuration::Configuration,
6305    id: &str,
6306    format: Option<&str>,
6307) -> Result<(), Error<LoadBalancersLoadBalancerPoolMemberCertificateProfileAssignmentsDestroyError>>
6308{
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        "{}/load-balancers/load-balancer-pool-member-certificate-profile-assignments/{id}/",
6315        local_var_configuration.base_path,
6316        id = crate::apis::urlencode(id)
6317    );
6318    let mut local_var_req_builder =
6319        local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());
6320
6321    if let Some(ref local_var_str) = format {
6322        local_var_req_builder =
6323            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
6324    }
6325    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
6326        local_var_req_builder =
6327            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
6328    }
6329    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
6330        let local_var_key = local_var_apikey.key.clone();
6331        let local_var_value = match local_var_apikey.prefix {
6332            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
6333            None => local_var_key,
6334        };
6335        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
6336    };
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<
6348            LoadBalancersLoadBalancerPoolMemberCertificateProfileAssignmentsDestroyError,
6349        > = serde_json::from_str(&local_var_content).ok();
6350        let local_var_error = ResponseContent {
6351            status: local_var_status,
6352            content: local_var_content,
6353            entity: local_var_entity,
6354        };
6355        Err(Error::ResponseError(local_var_error))
6356    }
6357}
6358
6359/// LoadBalancerPoolMemberCertificateProfileAssignment viewset.
6360pub async fn load_balancers_load_balancer_pool_member_certificate_profile_assignments_list(
6361    configuration: &configuration::Configuration,
6362    certificate_profile: Option<Vec<String>>,
6363    certificate_profile__n: Option<Vec<String>>,
6364    format: Option<&str>,
6365    id: Option<Vec<uuid::Uuid>>,
6366    id__n: Option<Vec<uuid::Uuid>>,
6367    limit: Option<i32>,
6368    load_balancer_pool_member: Option<Vec<String>>,
6369    load_balancer_pool_member__n: Option<Vec<String>>,
6370    offset: Option<i32>,
6371    sort: Option<&str>,
6372    depth: Option<i32>,
6373    exclude_m2m: Option<bool>,
6374) -> Result<
6375    crate::models::PaginatedLoadBalancerPoolMemberCertificateProfileAssignmentList,
6376    Error<LoadBalancersLoadBalancerPoolMemberCertificateProfileAssignmentsListError>,
6377> {
6378    let local_var_configuration = configuration;
6379
6380    let local_var_client = &local_var_configuration.client;
6381
6382    let local_var_uri_str = format!(
6383        "{}/load-balancers/load-balancer-pool-member-certificate-profile-assignments/",
6384        local_var_configuration.base_path
6385    );
6386    let mut local_var_req_builder =
6387        local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
6388
6389    if let Some(ref local_var_str) = certificate_profile {
6390        local_var_req_builder = match "multi" {
6391            "multi" => local_var_req_builder.query(
6392                &local_var_str
6393                    .into_iter()
6394                    .map(|p| ("certificate_profile".to_owned(), p.to_string()))
6395                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6396            ),
6397            _ => local_var_req_builder.query(&[(
6398                "certificate_profile",
6399                &local_var_str
6400                    .into_iter()
6401                    .map(|p| p.to_string())
6402                    .collect::<Vec<String>>()
6403                    .join(",")
6404                    .to_string(),
6405            )]),
6406        };
6407    }
6408    if let Some(ref local_var_str) = certificate_profile__n {
6409        local_var_req_builder = match "multi" {
6410            "multi" => local_var_req_builder.query(
6411                &local_var_str
6412                    .into_iter()
6413                    .map(|p| ("certificate_profile__n".to_owned(), p.to_string()))
6414                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6415            ),
6416            _ => local_var_req_builder.query(&[(
6417                "certificate_profile__n",
6418                &local_var_str
6419                    .into_iter()
6420                    .map(|p| p.to_string())
6421                    .collect::<Vec<String>>()
6422                    .join(",")
6423                    .to_string(),
6424            )]),
6425        };
6426    }
6427    if let Some(ref local_var_str) = format {
6428        local_var_req_builder =
6429            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
6430    }
6431    if let Some(ref local_var_str) = id {
6432        local_var_req_builder = match "multi" {
6433            "multi" => local_var_req_builder.query(
6434                &local_var_str
6435                    .into_iter()
6436                    .map(|p| ("id".to_owned(), p.to_string()))
6437                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6438            ),
6439            _ => local_var_req_builder.query(&[(
6440                "id",
6441                &local_var_str
6442                    .into_iter()
6443                    .map(|p| p.to_string())
6444                    .collect::<Vec<String>>()
6445                    .join(",")
6446                    .to_string(),
6447            )]),
6448        };
6449    }
6450    if let Some(ref local_var_str) = id__n {
6451        local_var_req_builder = match "multi" {
6452            "multi" => local_var_req_builder.query(
6453                &local_var_str
6454                    .into_iter()
6455                    .map(|p| ("id__n".to_owned(), p.to_string()))
6456                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6457            ),
6458            _ => local_var_req_builder.query(&[(
6459                "id__n",
6460                &local_var_str
6461                    .into_iter()
6462                    .map(|p| p.to_string())
6463                    .collect::<Vec<String>>()
6464                    .join(",")
6465                    .to_string(),
6466            )]),
6467        };
6468    }
6469    if let Some(ref local_var_str) = limit {
6470        local_var_req_builder =
6471            local_var_req_builder.query(&[("limit", &local_var_str.to_string())]);
6472    }
6473    if let Some(ref local_var_str) = load_balancer_pool_member {
6474        local_var_req_builder = match "multi" {
6475            "multi" => local_var_req_builder.query(
6476                &local_var_str
6477                    .into_iter()
6478                    .map(|p| ("load_balancer_pool_member".to_owned(), p.to_string()))
6479                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6480            ),
6481            _ => local_var_req_builder.query(&[(
6482                "load_balancer_pool_member",
6483                &local_var_str
6484                    .into_iter()
6485                    .map(|p| p.to_string())
6486                    .collect::<Vec<String>>()
6487                    .join(",")
6488                    .to_string(),
6489            )]),
6490        };
6491    }
6492    if let Some(ref local_var_str) = load_balancer_pool_member__n {
6493        local_var_req_builder = match "multi" {
6494            "multi" => local_var_req_builder.query(
6495                &local_var_str
6496                    .into_iter()
6497                    .map(|p| ("load_balancer_pool_member__n".to_owned(), p.to_string()))
6498                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6499            ),
6500            _ => local_var_req_builder.query(&[(
6501                "load_balancer_pool_member__n",
6502                &local_var_str
6503                    .into_iter()
6504                    .map(|p| p.to_string())
6505                    .collect::<Vec<String>>()
6506                    .join(",")
6507                    .to_string(),
6508            )]),
6509        };
6510    }
6511    if let Some(ref local_var_str) = offset {
6512        local_var_req_builder =
6513            local_var_req_builder.query(&[("offset", &local_var_str.to_string())]);
6514    }
6515    if let Some(ref local_var_str) = sort {
6516        local_var_req_builder =
6517            local_var_req_builder.query(&[("sort", &local_var_str.to_string())]);
6518    }
6519    if let Some(ref local_var_str) = depth {
6520        local_var_req_builder =
6521            local_var_req_builder.query(&[("depth", &local_var_str.to_string())]);
6522    }
6523    if let Some(ref local_var_str) = exclude_m2m {
6524        local_var_req_builder =
6525            local_var_req_builder.query(&[("exclude_m2m", &local_var_str.to_string())]);
6526    }
6527    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
6528        local_var_req_builder =
6529            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
6530    }
6531    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
6532        let local_var_key = local_var_apikey.key.clone();
6533        let local_var_value = match local_var_apikey.prefix {
6534            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
6535            None => local_var_key,
6536        };
6537        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
6538    };
6539
6540    let local_var_req = local_var_req_builder.build()?;
6541    let local_var_resp = local_var_client.execute(local_var_req).await?;
6542
6543    let local_var_status = local_var_resp.status();
6544    let local_var_content = local_var_resp.text().await?;
6545
6546    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
6547        serde_json::from_str(&local_var_content).map_err(Error::from)
6548    } else {
6549        let local_var_entity: Option<
6550            LoadBalancersLoadBalancerPoolMemberCertificateProfileAssignmentsListError,
6551        > = serde_json::from_str(&local_var_content).ok();
6552        let local_var_error = ResponseContent {
6553            status: local_var_status,
6554            content: local_var_content,
6555            entity: local_var_entity,
6556        };
6557        Err(Error::ResponseError(local_var_error))
6558    }
6559}
6560
6561/// LoadBalancerPoolMemberCertificateProfileAssignment viewset.
6562pub async fn load_balancers_load_balancer_pool_member_certificate_profile_assignments_partial_update(
6563    configuration: &configuration::Configuration,
6564    id: &str,
6565    format: Option<&str>,
6566    patched_load_balancer_pool_member_certificate_profile_assignment_request: Option<
6567        crate::models::PatchedLoadBalancerPoolMemberCertificateProfileAssignmentRequest,
6568    >,
6569) -> Result<
6570    crate::models::LoadBalancerPoolMemberCertificateProfileAssignment,
6571    Error<LoadBalancersLoadBalancerPoolMemberCertificateProfileAssignmentsPartialUpdateError>,
6572> {
6573    let local_var_configuration = configuration;
6574
6575    let local_var_client = &local_var_configuration.client;
6576
6577    let local_var_uri_str = format!(
6578        "{}/load-balancers/load-balancer-pool-member-certificate-profile-assignments/{id}/",
6579        local_var_configuration.base_path,
6580        id = crate::apis::urlencode(id)
6581    );
6582    let mut local_var_req_builder =
6583        local_var_client.request(reqwest::Method::PATCH, local_var_uri_str.as_str());
6584
6585    if let Some(ref local_var_str) = format {
6586        local_var_req_builder =
6587            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
6588    }
6589    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
6590        local_var_req_builder =
6591            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
6592    }
6593    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
6594        let local_var_key = local_var_apikey.key.clone();
6595        let local_var_value = match local_var_apikey.prefix {
6596            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
6597            None => local_var_key,
6598        };
6599        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
6600    };
6601    local_var_req_builder = local_var_req_builder
6602        .json(&patched_load_balancer_pool_member_certificate_profile_assignment_request);
6603
6604    let local_var_req = local_var_req_builder.build()?;
6605    let local_var_resp = local_var_client.execute(local_var_req).await?;
6606
6607    let local_var_status = local_var_resp.status();
6608    let local_var_content = local_var_resp.text().await?;
6609
6610    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
6611        serde_json::from_str(&local_var_content).map_err(Error::from)
6612    } else {
6613        let local_var_entity: Option<
6614            LoadBalancersLoadBalancerPoolMemberCertificateProfileAssignmentsPartialUpdateError,
6615        > = serde_json::from_str(&local_var_content).ok();
6616        let local_var_error = ResponseContent {
6617            status: local_var_status,
6618            content: local_var_content,
6619            entity: local_var_entity,
6620        };
6621        Err(Error::ResponseError(local_var_error))
6622    }
6623}
6624
6625/// LoadBalancerPoolMemberCertificateProfileAssignment viewset.
6626pub async fn load_balancers_load_balancer_pool_member_certificate_profile_assignments_retrieve(
6627    configuration: &configuration::Configuration,
6628    id: &str,
6629    format: Option<&str>,
6630    depth: Option<i32>,
6631    exclude_m2m: Option<bool>,
6632) -> Result<
6633    crate::models::LoadBalancerPoolMemberCertificateProfileAssignment,
6634    Error<LoadBalancersLoadBalancerPoolMemberCertificateProfileAssignmentsRetrieveError>,
6635> {
6636    let local_var_configuration = configuration;
6637
6638    let local_var_client = &local_var_configuration.client;
6639
6640    let local_var_uri_str = format!(
6641        "{}/load-balancers/load-balancer-pool-member-certificate-profile-assignments/{id}/",
6642        local_var_configuration.base_path,
6643        id = crate::apis::urlencode(id)
6644    );
6645    let mut local_var_req_builder =
6646        local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
6647
6648    if let Some(ref local_var_str) = format {
6649        local_var_req_builder =
6650            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
6651    }
6652    if let Some(ref local_var_str) = depth {
6653        local_var_req_builder =
6654            local_var_req_builder.query(&[("depth", &local_var_str.to_string())]);
6655    }
6656    if let Some(ref local_var_str) = exclude_m2m {
6657        local_var_req_builder =
6658            local_var_req_builder.query(&[("exclude_m2m", &local_var_str.to_string())]);
6659    }
6660    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
6661        local_var_req_builder =
6662            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
6663    }
6664    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
6665        let local_var_key = local_var_apikey.key.clone();
6666        let local_var_value = match local_var_apikey.prefix {
6667            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
6668            None => local_var_key,
6669        };
6670        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
6671    };
6672
6673    let local_var_req = local_var_req_builder.build()?;
6674    let local_var_resp = local_var_client.execute(local_var_req).await?;
6675
6676    let local_var_status = local_var_resp.status();
6677    let local_var_content = local_var_resp.text().await?;
6678
6679    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
6680        serde_json::from_str(&local_var_content).map_err(Error::from)
6681    } else {
6682        let local_var_entity: Option<
6683            LoadBalancersLoadBalancerPoolMemberCertificateProfileAssignmentsRetrieveError,
6684        > = serde_json::from_str(&local_var_content).ok();
6685        let local_var_error = ResponseContent {
6686            status: local_var_status,
6687            content: local_var_content,
6688            entity: local_var_entity,
6689        };
6690        Err(Error::ResponseError(local_var_error))
6691    }
6692}
6693
6694/// LoadBalancerPoolMemberCertificateProfileAssignment viewset.
6695pub async fn load_balancers_load_balancer_pool_member_certificate_profile_assignments_update(
6696    configuration: &configuration::Configuration,
6697    id: &str,
6698    load_balancer_pool_member_certificate_profile_assignment_request: crate::models::LoadBalancerPoolMemberCertificateProfileAssignmentRequest,
6699    format: Option<&str>,
6700) -> Result<
6701    crate::models::LoadBalancerPoolMemberCertificateProfileAssignment,
6702    Error<LoadBalancersLoadBalancerPoolMemberCertificateProfileAssignmentsUpdateError>,
6703> {
6704    let local_var_configuration = configuration;
6705
6706    let local_var_client = &local_var_configuration.client;
6707
6708    let local_var_uri_str = format!(
6709        "{}/load-balancers/load-balancer-pool-member-certificate-profile-assignments/{id}/",
6710        local_var_configuration.base_path,
6711        id = crate::apis::urlencode(id)
6712    );
6713    let mut local_var_req_builder =
6714        local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());
6715
6716    if let Some(ref local_var_str) = format {
6717        local_var_req_builder =
6718            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
6719    }
6720    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
6721        local_var_req_builder =
6722            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
6723    }
6724    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
6725        let local_var_key = local_var_apikey.key.clone();
6726        let local_var_value = match local_var_apikey.prefix {
6727            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
6728            None => local_var_key,
6729        };
6730        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
6731    };
6732    local_var_req_builder = local_var_req_builder
6733        .json(&load_balancer_pool_member_certificate_profile_assignment_request);
6734
6735    let local_var_req = local_var_req_builder.build()?;
6736    let local_var_resp = local_var_client.execute(local_var_req).await?;
6737
6738    let local_var_status = local_var_resp.status();
6739    let local_var_content = local_var_resp.text().await?;
6740
6741    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
6742        serde_json::from_str(&local_var_content).map_err(Error::from)
6743    } else {
6744        let local_var_entity: Option<
6745            LoadBalancersLoadBalancerPoolMemberCertificateProfileAssignmentsUpdateError,
6746        > = serde_json::from_str(&local_var_content).ok();
6747        let local_var_error = ResponseContent {
6748            status: local_var_status,
6749            content: local_var_content,
6750            entity: local_var_entity,
6751        };
6752        Err(Error::ResponseError(local_var_error))
6753    }
6754}
6755
6756/// LoadBalancerPoolMember viewset.
6757pub async fn load_balancers_load_balancer_pool_members_bulk_destroy(
6758    configuration: &configuration::Configuration,
6759    bulk_operation_request: Vec<crate::models::BulkOperationRequest>,
6760    format: Option<&str>,
6761) -> Result<(), Error<LoadBalancersLoadBalancerPoolMembersBulkDestroyError>> {
6762    let local_var_configuration = configuration;
6763
6764    let local_var_client = &local_var_configuration.client;
6765
6766    let local_var_uri_str = format!(
6767        "{}/load-balancers/load-balancer-pool-members/",
6768        local_var_configuration.base_path
6769    );
6770    let mut local_var_req_builder =
6771        local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());
6772
6773    if let Some(ref local_var_str) = format {
6774        local_var_req_builder =
6775            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
6776    }
6777    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
6778        local_var_req_builder =
6779            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
6780    }
6781    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
6782        let local_var_key = local_var_apikey.key.clone();
6783        let local_var_value = match local_var_apikey.prefix {
6784            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
6785            None => local_var_key,
6786        };
6787        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
6788    };
6789    local_var_req_builder = local_var_req_builder.json(&bulk_operation_request);
6790
6791    let local_var_req = local_var_req_builder.build()?;
6792    let local_var_resp = local_var_client.execute(local_var_req).await?;
6793
6794    let local_var_status = local_var_resp.status();
6795    let local_var_content = local_var_resp.text().await?;
6796
6797    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
6798        Ok(())
6799    } else {
6800        let local_var_entity: Option<LoadBalancersLoadBalancerPoolMembersBulkDestroyError> =
6801            serde_json::from_str(&local_var_content).ok();
6802        let local_var_error = ResponseContent {
6803            status: local_var_status,
6804            content: local_var_content,
6805            entity: local_var_entity,
6806        };
6807        Err(Error::ResponseError(local_var_error))
6808    }
6809}
6810
6811/// LoadBalancerPoolMember viewset.
6812pub async fn load_balancers_load_balancer_pool_members_bulk_partial_update(
6813    configuration: &configuration::Configuration,
6814    patched_bulk_writable_load_balancer_pool_member_request: Vec<
6815        crate::models::PatchedBulkWritableLoadBalancerPoolMemberRequest,
6816    >,
6817    format: Option<&str>,
6818) -> Result<
6819    Vec<crate::models::LoadBalancerPoolMember>,
6820    Error<LoadBalancersLoadBalancerPoolMembersBulkPartialUpdateError>,
6821> {
6822    let local_var_configuration = configuration;
6823
6824    let local_var_client = &local_var_configuration.client;
6825
6826    let local_var_uri_str = format!(
6827        "{}/load-balancers/load-balancer-pool-members/",
6828        local_var_configuration.base_path
6829    );
6830    let mut local_var_req_builder =
6831        local_var_client.request(reqwest::Method::PATCH, local_var_uri_str.as_str());
6832
6833    if let Some(ref local_var_str) = format {
6834        local_var_req_builder =
6835            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
6836    }
6837    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
6838        local_var_req_builder =
6839            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
6840    }
6841    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
6842        let local_var_key = local_var_apikey.key.clone();
6843        let local_var_value = match local_var_apikey.prefix {
6844            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
6845            None => local_var_key,
6846        };
6847        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
6848    };
6849    local_var_req_builder =
6850        local_var_req_builder.json(&patched_bulk_writable_load_balancer_pool_member_request);
6851
6852    let local_var_req = local_var_req_builder.build()?;
6853    let local_var_resp = local_var_client.execute(local_var_req).await?;
6854
6855    let local_var_status = local_var_resp.status();
6856    let local_var_content = local_var_resp.text().await?;
6857
6858    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
6859        serde_json::from_str(&local_var_content).map_err(Error::from)
6860    } else {
6861        let local_var_entity: Option<LoadBalancersLoadBalancerPoolMembersBulkPartialUpdateError> =
6862            serde_json::from_str(&local_var_content).ok();
6863        let local_var_error = ResponseContent {
6864            status: local_var_status,
6865            content: local_var_content,
6866            entity: local_var_entity,
6867        };
6868        Err(Error::ResponseError(local_var_error))
6869    }
6870}
6871
6872/// LoadBalancerPoolMember viewset.
6873pub async fn load_balancers_load_balancer_pool_members_bulk_update(
6874    configuration: &configuration::Configuration,
6875    bulk_writable_load_balancer_pool_member_request: Vec<
6876        crate::models::BulkWritableLoadBalancerPoolMemberRequest,
6877    >,
6878    format: Option<&str>,
6879) -> Result<
6880    Vec<crate::models::LoadBalancerPoolMember>,
6881    Error<LoadBalancersLoadBalancerPoolMembersBulkUpdateError>,
6882> {
6883    let local_var_configuration = configuration;
6884
6885    let local_var_client = &local_var_configuration.client;
6886
6887    let local_var_uri_str = format!(
6888        "{}/load-balancers/load-balancer-pool-members/",
6889        local_var_configuration.base_path
6890    );
6891    let mut local_var_req_builder =
6892        local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());
6893
6894    if let Some(ref local_var_str) = format {
6895        local_var_req_builder =
6896            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
6897    }
6898    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
6899        local_var_req_builder =
6900            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
6901    }
6902    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
6903        let local_var_key = local_var_apikey.key.clone();
6904        let local_var_value = match local_var_apikey.prefix {
6905            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
6906            None => local_var_key,
6907        };
6908        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
6909    };
6910    local_var_req_builder =
6911        local_var_req_builder.json(&bulk_writable_load_balancer_pool_member_request);
6912
6913    let local_var_req = local_var_req_builder.build()?;
6914    let local_var_resp = local_var_client.execute(local_var_req).await?;
6915
6916    let local_var_status = local_var_resp.status();
6917    let local_var_content = local_var_resp.text().await?;
6918
6919    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
6920        serde_json::from_str(&local_var_content).map_err(Error::from)
6921    } else {
6922        let local_var_entity: Option<LoadBalancersLoadBalancerPoolMembersBulkUpdateError> =
6923            serde_json::from_str(&local_var_content).ok();
6924        let local_var_error = ResponseContent {
6925            status: local_var_status,
6926            content: local_var_content,
6927            entity: local_var_entity,
6928        };
6929        Err(Error::ResponseError(local_var_error))
6930    }
6931}
6932
6933/// LoadBalancerPoolMember viewset.
6934pub async fn load_balancers_load_balancer_pool_members_create(
6935    configuration: &configuration::Configuration,
6936    load_balancer_pool_member_request: crate::models::LoadBalancerPoolMemberRequest,
6937    format: Option<&str>,
6938) -> Result<
6939    crate::models::LoadBalancerPoolMember,
6940    Error<LoadBalancersLoadBalancerPoolMembersCreateError>,
6941> {
6942    let local_var_configuration = configuration;
6943
6944    let local_var_client = &local_var_configuration.client;
6945
6946    let local_var_uri_str = format!(
6947        "{}/load-balancers/load-balancer-pool-members/",
6948        local_var_configuration.base_path
6949    );
6950    let mut local_var_req_builder =
6951        local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
6952
6953    if let Some(ref local_var_str) = format {
6954        local_var_req_builder =
6955            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
6956    }
6957    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
6958        local_var_req_builder =
6959            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
6960    }
6961    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
6962        let local_var_key = local_var_apikey.key.clone();
6963        let local_var_value = match local_var_apikey.prefix {
6964            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
6965            None => local_var_key,
6966        };
6967        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
6968    };
6969    local_var_req_builder = local_var_req_builder.json(&load_balancer_pool_member_request);
6970
6971    let local_var_req = local_var_req_builder.build()?;
6972    let local_var_resp = local_var_client.execute(local_var_req).await?;
6973
6974    let local_var_status = local_var_resp.status();
6975    let local_var_content = local_var_resp.text().await?;
6976
6977    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
6978        serde_json::from_str(&local_var_content).map_err(Error::from)
6979    } else {
6980        let local_var_entity: Option<LoadBalancersLoadBalancerPoolMembersCreateError> =
6981            serde_json::from_str(&local_var_content).ok();
6982        let local_var_error = ResponseContent {
6983            status: local_var_status,
6984            content: local_var_content,
6985            entity: local_var_entity,
6986        };
6987        Err(Error::ResponseError(local_var_error))
6988    }
6989}
6990
6991/// LoadBalancerPoolMember viewset.
6992pub async fn load_balancers_load_balancer_pool_members_destroy(
6993    configuration: &configuration::Configuration,
6994    id: &str,
6995    format: Option<&str>,
6996) -> Result<(), Error<LoadBalancersLoadBalancerPoolMembersDestroyError>> {
6997    let local_var_configuration = configuration;
6998
6999    let local_var_client = &local_var_configuration.client;
7000
7001    let local_var_uri_str = format!(
7002        "{}/load-balancers/load-balancer-pool-members/{id}/",
7003        local_var_configuration.base_path,
7004        id = crate::apis::urlencode(id)
7005    );
7006    let mut local_var_req_builder =
7007        local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());
7008
7009    if let Some(ref local_var_str) = format {
7010        local_var_req_builder =
7011            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
7012    }
7013    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
7014        local_var_req_builder =
7015            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
7016    }
7017    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
7018        let local_var_key = local_var_apikey.key.clone();
7019        let local_var_value = match local_var_apikey.prefix {
7020            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
7021            None => local_var_key,
7022        };
7023        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
7024    };
7025
7026    let local_var_req = local_var_req_builder.build()?;
7027    let local_var_resp = local_var_client.execute(local_var_req).await?;
7028
7029    let local_var_status = local_var_resp.status();
7030    let local_var_content = local_var_resp.text().await?;
7031
7032    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
7033        Ok(())
7034    } else {
7035        let local_var_entity: Option<LoadBalancersLoadBalancerPoolMembersDestroyError> =
7036            serde_json::from_str(&local_var_content).ok();
7037        let local_var_error = ResponseContent {
7038            status: local_var_status,
7039            content: local_var_content,
7040            entity: local_var_entity,
7041        };
7042        Err(Error::ResponseError(local_var_error))
7043    }
7044}
7045
7046/// LoadBalancerPoolMember viewset.
7047pub async fn load_balancers_load_balancer_pool_members_list(
7048    configuration: &configuration::Configuration,
7049    certificate_profiles: Option<Vec<String>>,
7050    certificate_profiles__n: Option<Vec<String>>,
7051    contacts: Option<Vec<String>>,
7052    contacts__isnull: Option<bool>,
7053    contacts__n: Option<Vec<String>>,
7054    created: Option<Vec<String>>,
7055    created__gt: Option<Vec<String>>,
7056    created__gte: Option<Vec<String>>,
7057    created__isnull: Option<bool>,
7058    created__lt: Option<Vec<String>>,
7059    created__lte: Option<Vec<String>>,
7060    created__n: Option<Vec<String>>,
7061    dynamic_groups: Option<Vec<String>>,
7062    dynamic_groups__n: Option<Vec<String>>,
7063    format: Option<&str>,
7064    health_check_monitor: Option<Vec<String>>,
7065    health_check_monitor__isnull: Option<bool>,
7066    health_check_monitor__n: Option<Vec<String>>,
7067    id: Option<Vec<uuid::Uuid>>,
7068    id__n: Option<Vec<uuid::Uuid>>,
7069    ip_address: Option<Vec<uuid::Uuid>>,
7070    ip_address__n: Option<Vec<uuid::Uuid>>,
7071    label: Option<Vec<String>>,
7072    label__ic: Option<Vec<String>>,
7073    label__ie: Option<Vec<String>>,
7074    label__iew: Option<Vec<String>>,
7075    label__ire: Option<Vec<String>>,
7076    label__isw: Option<Vec<String>>,
7077    label__n: Option<Vec<String>>,
7078    label__nic: Option<Vec<String>>,
7079    label__nie: Option<Vec<String>>,
7080    label__niew: Option<Vec<String>>,
7081    label__nire: Option<Vec<String>>,
7082    label__nisw: Option<Vec<String>>,
7083    label__nre: Option<Vec<String>>,
7084    label__re: Option<Vec<String>>,
7085    last_updated: Option<Vec<String>>,
7086    last_updated__gt: Option<Vec<String>>,
7087    last_updated__gte: Option<Vec<String>>,
7088    last_updated__isnull: Option<bool>,
7089    last_updated__lt: Option<Vec<String>>,
7090    last_updated__lte: Option<Vec<String>>,
7091    last_updated__n: Option<Vec<String>>,
7092    limit: Option<i32>,
7093    load_balancer_pool: Option<Vec<String>>,
7094    load_balancer_pool__n: Option<Vec<String>>,
7095    offset: Option<i32>,
7096    port: Option<Vec<i32>>,
7097    port__gt: Option<Vec<i32>>,
7098    port__gte: Option<Vec<i32>>,
7099    port__lt: Option<Vec<i32>>,
7100    port__lte: Option<Vec<i32>>,
7101    port__n: Option<Vec<i32>>,
7102    q: Option<&str>,
7103    sort: Option<&str>,
7104    ssl_offload: Option<bool>,
7105    status: Option<Vec<String>>,
7106    status__n: Option<Vec<uuid::Uuid>>,
7107    tags: Option<Vec<String>>,
7108    tags__isnull: Option<bool>,
7109    tags__n: Option<Vec<String>>,
7110    teams: Option<Vec<String>>,
7111    teams__isnull: Option<bool>,
7112    teams__n: Option<Vec<String>>,
7113    tenant: Option<Vec<String>>,
7114    tenant__isnull: Option<bool>,
7115    tenant__n: Option<Vec<String>>,
7116    tenant_group: Option<Vec<String>>,
7117    tenant_group__isnull: Option<bool>,
7118    tenant_group__n: Option<Vec<String>>,
7119    tenant_id: Option<Vec<uuid::Uuid>>,
7120    tenant_id__isnull: Option<bool>,
7121    tenant_id__n: Option<Vec<uuid::Uuid>>,
7122    depth: Option<i32>,
7123    exclude_m2m: Option<bool>,
7124) -> Result<
7125    crate::models::PaginatedLoadBalancerPoolMemberList,
7126    Error<LoadBalancersLoadBalancerPoolMembersListError>,
7127> {
7128    let local_var_configuration = configuration;
7129
7130    let local_var_client = &local_var_configuration.client;
7131
7132    let local_var_uri_str = format!(
7133        "{}/load-balancers/load-balancer-pool-members/",
7134        local_var_configuration.base_path
7135    );
7136    let mut local_var_req_builder =
7137        local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
7138
7139    if let Some(ref local_var_str) = certificate_profiles {
7140        local_var_req_builder = match "multi" {
7141            "multi" => local_var_req_builder.query(
7142                &local_var_str
7143                    .into_iter()
7144                    .map(|p| ("certificate_profiles".to_owned(), p.to_string()))
7145                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7146            ),
7147            _ => local_var_req_builder.query(&[(
7148                "certificate_profiles",
7149                &local_var_str
7150                    .into_iter()
7151                    .map(|p| p.to_string())
7152                    .collect::<Vec<String>>()
7153                    .join(",")
7154                    .to_string(),
7155            )]),
7156        };
7157    }
7158    if let Some(ref local_var_str) = certificate_profiles__n {
7159        local_var_req_builder = match "multi" {
7160            "multi" => local_var_req_builder.query(
7161                &local_var_str
7162                    .into_iter()
7163                    .map(|p| ("certificate_profiles__n".to_owned(), p.to_string()))
7164                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7165            ),
7166            _ => local_var_req_builder.query(&[(
7167                "certificate_profiles__n",
7168                &local_var_str
7169                    .into_iter()
7170                    .map(|p| p.to_string())
7171                    .collect::<Vec<String>>()
7172                    .join(",")
7173                    .to_string(),
7174            )]),
7175        };
7176    }
7177    if let Some(ref local_var_str) = contacts {
7178        local_var_req_builder = match "multi" {
7179            "multi" => local_var_req_builder.query(
7180                &local_var_str
7181                    .into_iter()
7182                    .map(|p| ("contacts".to_owned(), p.to_string()))
7183                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7184            ),
7185            _ => local_var_req_builder.query(&[(
7186                "contacts",
7187                &local_var_str
7188                    .into_iter()
7189                    .map(|p| p.to_string())
7190                    .collect::<Vec<String>>()
7191                    .join(",")
7192                    .to_string(),
7193            )]),
7194        };
7195    }
7196    if let Some(ref local_var_str) = contacts__isnull {
7197        local_var_req_builder =
7198            local_var_req_builder.query(&[("contacts__isnull", &local_var_str.to_string())]);
7199    }
7200    if let Some(ref local_var_str) = contacts__n {
7201        local_var_req_builder = match "multi" {
7202            "multi" => local_var_req_builder.query(
7203                &local_var_str
7204                    .into_iter()
7205                    .map(|p| ("contacts__n".to_owned(), p.to_string()))
7206                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7207            ),
7208            _ => local_var_req_builder.query(&[(
7209                "contacts__n",
7210                &local_var_str
7211                    .into_iter()
7212                    .map(|p| p.to_string())
7213                    .collect::<Vec<String>>()
7214                    .join(",")
7215                    .to_string(),
7216            )]),
7217        };
7218    }
7219    if let Some(ref local_var_str) = created {
7220        local_var_req_builder = match "multi" {
7221            "multi" => local_var_req_builder.query(
7222                &local_var_str
7223                    .into_iter()
7224                    .map(|p| ("created".to_owned(), p.to_string()))
7225                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7226            ),
7227            _ => local_var_req_builder.query(&[(
7228                "created",
7229                &local_var_str
7230                    .into_iter()
7231                    .map(|p| p.to_string())
7232                    .collect::<Vec<String>>()
7233                    .join(",")
7234                    .to_string(),
7235            )]),
7236        };
7237    }
7238    if let Some(ref local_var_str) = created__gt {
7239        local_var_req_builder = match "multi" {
7240            "multi" => local_var_req_builder.query(
7241                &local_var_str
7242                    .into_iter()
7243                    .map(|p| ("created__gt".to_owned(), p.to_string()))
7244                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7245            ),
7246            _ => local_var_req_builder.query(&[(
7247                "created__gt",
7248                &local_var_str
7249                    .into_iter()
7250                    .map(|p| p.to_string())
7251                    .collect::<Vec<String>>()
7252                    .join(",")
7253                    .to_string(),
7254            )]),
7255        };
7256    }
7257    if let Some(ref local_var_str) = created__gte {
7258        local_var_req_builder = match "multi" {
7259            "multi" => local_var_req_builder.query(
7260                &local_var_str
7261                    .into_iter()
7262                    .map(|p| ("created__gte".to_owned(), p.to_string()))
7263                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7264            ),
7265            _ => local_var_req_builder.query(&[(
7266                "created__gte",
7267                &local_var_str
7268                    .into_iter()
7269                    .map(|p| p.to_string())
7270                    .collect::<Vec<String>>()
7271                    .join(",")
7272                    .to_string(),
7273            )]),
7274        };
7275    }
7276    if let Some(ref local_var_str) = created__isnull {
7277        local_var_req_builder =
7278            local_var_req_builder.query(&[("created__isnull", &local_var_str.to_string())]);
7279    }
7280    if let Some(ref local_var_str) = created__lt {
7281        local_var_req_builder = match "multi" {
7282            "multi" => local_var_req_builder.query(
7283                &local_var_str
7284                    .into_iter()
7285                    .map(|p| ("created__lt".to_owned(), p.to_string()))
7286                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7287            ),
7288            _ => local_var_req_builder.query(&[(
7289                "created__lt",
7290                &local_var_str
7291                    .into_iter()
7292                    .map(|p| p.to_string())
7293                    .collect::<Vec<String>>()
7294                    .join(",")
7295                    .to_string(),
7296            )]),
7297        };
7298    }
7299    if let Some(ref local_var_str) = created__lte {
7300        local_var_req_builder = match "multi" {
7301            "multi" => local_var_req_builder.query(
7302                &local_var_str
7303                    .into_iter()
7304                    .map(|p| ("created__lte".to_owned(), p.to_string()))
7305                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7306            ),
7307            _ => local_var_req_builder.query(&[(
7308                "created__lte",
7309                &local_var_str
7310                    .into_iter()
7311                    .map(|p| p.to_string())
7312                    .collect::<Vec<String>>()
7313                    .join(",")
7314                    .to_string(),
7315            )]),
7316        };
7317    }
7318    if let Some(ref local_var_str) = created__n {
7319        local_var_req_builder = match "multi" {
7320            "multi" => local_var_req_builder.query(
7321                &local_var_str
7322                    .into_iter()
7323                    .map(|p| ("created__n".to_owned(), p.to_string()))
7324                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7325            ),
7326            _ => local_var_req_builder.query(&[(
7327                "created__n",
7328                &local_var_str
7329                    .into_iter()
7330                    .map(|p| p.to_string())
7331                    .collect::<Vec<String>>()
7332                    .join(",")
7333                    .to_string(),
7334            )]),
7335        };
7336    }
7337    if let Some(ref local_var_str) = dynamic_groups {
7338        local_var_req_builder = match "multi" {
7339            "multi" => local_var_req_builder.query(
7340                &local_var_str
7341                    .into_iter()
7342                    .map(|p| ("dynamic_groups".to_owned(), p.to_string()))
7343                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7344            ),
7345            _ => local_var_req_builder.query(&[(
7346                "dynamic_groups",
7347                &local_var_str
7348                    .into_iter()
7349                    .map(|p| p.to_string())
7350                    .collect::<Vec<String>>()
7351                    .join(",")
7352                    .to_string(),
7353            )]),
7354        };
7355    }
7356    if let Some(ref local_var_str) = dynamic_groups__n {
7357        local_var_req_builder = match "multi" {
7358            "multi" => local_var_req_builder.query(
7359                &local_var_str
7360                    .into_iter()
7361                    .map(|p| ("dynamic_groups__n".to_owned(), p.to_string()))
7362                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7363            ),
7364            _ => local_var_req_builder.query(&[(
7365                "dynamic_groups__n",
7366                &local_var_str
7367                    .into_iter()
7368                    .map(|p| p.to_string())
7369                    .collect::<Vec<String>>()
7370                    .join(",")
7371                    .to_string(),
7372            )]),
7373        };
7374    }
7375    if let Some(ref local_var_str) = format {
7376        local_var_req_builder =
7377            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
7378    }
7379    if let Some(ref local_var_str) = health_check_monitor {
7380        local_var_req_builder = match "multi" {
7381            "multi" => local_var_req_builder.query(
7382                &local_var_str
7383                    .into_iter()
7384                    .map(|p| ("health_check_monitor".to_owned(), p.to_string()))
7385                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7386            ),
7387            _ => local_var_req_builder.query(&[(
7388                "health_check_monitor",
7389                &local_var_str
7390                    .into_iter()
7391                    .map(|p| p.to_string())
7392                    .collect::<Vec<String>>()
7393                    .join(",")
7394                    .to_string(),
7395            )]),
7396        };
7397    }
7398    if let Some(ref local_var_str) = health_check_monitor__isnull {
7399        local_var_req_builder = local_var_req_builder
7400            .query(&[("health_check_monitor__isnull", &local_var_str.to_string())]);
7401    }
7402    if let Some(ref local_var_str) = health_check_monitor__n {
7403        local_var_req_builder = match "multi" {
7404            "multi" => local_var_req_builder.query(
7405                &local_var_str
7406                    .into_iter()
7407                    .map(|p| ("health_check_monitor__n".to_owned(), p.to_string()))
7408                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7409            ),
7410            _ => local_var_req_builder.query(&[(
7411                "health_check_monitor__n",
7412                &local_var_str
7413                    .into_iter()
7414                    .map(|p| p.to_string())
7415                    .collect::<Vec<String>>()
7416                    .join(",")
7417                    .to_string(),
7418            )]),
7419        };
7420    }
7421    if let Some(ref local_var_str) = id {
7422        local_var_req_builder = match "multi" {
7423            "multi" => local_var_req_builder.query(
7424                &local_var_str
7425                    .into_iter()
7426                    .map(|p| ("id".to_owned(), p.to_string()))
7427                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7428            ),
7429            _ => local_var_req_builder.query(&[(
7430                "id",
7431                &local_var_str
7432                    .into_iter()
7433                    .map(|p| p.to_string())
7434                    .collect::<Vec<String>>()
7435                    .join(",")
7436                    .to_string(),
7437            )]),
7438        };
7439    }
7440    if let Some(ref local_var_str) = id__n {
7441        local_var_req_builder = match "multi" {
7442            "multi" => local_var_req_builder.query(
7443                &local_var_str
7444                    .into_iter()
7445                    .map(|p| ("id__n".to_owned(), p.to_string()))
7446                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7447            ),
7448            _ => local_var_req_builder.query(&[(
7449                "id__n",
7450                &local_var_str
7451                    .into_iter()
7452                    .map(|p| p.to_string())
7453                    .collect::<Vec<String>>()
7454                    .join(",")
7455                    .to_string(),
7456            )]),
7457        };
7458    }
7459    if let Some(ref local_var_str) = ip_address {
7460        local_var_req_builder = match "multi" {
7461            "multi" => local_var_req_builder.query(
7462                &local_var_str
7463                    .into_iter()
7464                    .map(|p| ("ip_address".to_owned(), p.to_string()))
7465                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7466            ),
7467            _ => local_var_req_builder.query(&[(
7468                "ip_address",
7469                &local_var_str
7470                    .into_iter()
7471                    .map(|p| p.to_string())
7472                    .collect::<Vec<String>>()
7473                    .join(",")
7474                    .to_string(),
7475            )]),
7476        };
7477    }
7478    if let Some(ref local_var_str) = ip_address__n {
7479        local_var_req_builder = match "multi" {
7480            "multi" => local_var_req_builder.query(
7481                &local_var_str
7482                    .into_iter()
7483                    .map(|p| ("ip_address__n".to_owned(), p.to_string()))
7484                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7485            ),
7486            _ => local_var_req_builder.query(&[(
7487                "ip_address__n",
7488                &local_var_str
7489                    .into_iter()
7490                    .map(|p| p.to_string())
7491                    .collect::<Vec<String>>()
7492                    .join(",")
7493                    .to_string(),
7494            )]),
7495        };
7496    }
7497    if let Some(ref local_var_str) = label {
7498        local_var_req_builder = match "multi" {
7499            "multi" => local_var_req_builder.query(
7500                &local_var_str
7501                    .into_iter()
7502                    .map(|p| ("label".to_owned(), p.to_string()))
7503                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7504            ),
7505            _ => local_var_req_builder.query(&[(
7506                "label",
7507                &local_var_str
7508                    .into_iter()
7509                    .map(|p| p.to_string())
7510                    .collect::<Vec<String>>()
7511                    .join(",")
7512                    .to_string(),
7513            )]),
7514        };
7515    }
7516    if let Some(ref local_var_str) = label__ic {
7517        local_var_req_builder = match "multi" {
7518            "multi" => local_var_req_builder.query(
7519                &local_var_str
7520                    .into_iter()
7521                    .map(|p| ("label__ic".to_owned(), p.to_string()))
7522                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7523            ),
7524            _ => local_var_req_builder.query(&[(
7525                "label__ic",
7526                &local_var_str
7527                    .into_iter()
7528                    .map(|p| p.to_string())
7529                    .collect::<Vec<String>>()
7530                    .join(",")
7531                    .to_string(),
7532            )]),
7533        };
7534    }
7535    if let Some(ref local_var_str) = label__ie {
7536        local_var_req_builder = match "multi" {
7537            "multi" => local_var_req_builder.query(
7538                &local_var_str
7539                    .into_iter()
7540                    .map(|p| ("label__ie".to_owned(), p.to_string()))
7541                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7542            ),
7543            _ => local_var_req_builder.query(&[(
7544                "label__ie",
7545                &local_var_str
7546                    .into_iter()
7547                    .map(|p| p.to_string())
7548                    .collect::<Vec<String>>()
7549                    .join(",")
7550                    .to_string(),
7551            )]),
7552        };
7553    }
7554    if let Some(ref local_var_str) = label__iew {
7555        local_var_req_builder = match "multi" {
7556            "multi" => local_var_req_builder.query(
7557                &local_var_str
7558                    .into_iter()
7559                    .map(|p| ("label__iew".to_owned(), p.to_string()))
7560                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7561            ),
7562            _ => local_var_req_builder.query(&[(
7563                "label__iew",
7564                &local_var_str
7565                    .into_iter()
7566                    .map(|p| p.to_string())
7567                    .collect::<Vec<String>>()
7568                    .join(",")
7569                    .to_string(),
7570            )]),
7571        };
7572    }
7573    if let Some(ref local_var_str) = label__ire {
7574        local_var_req_builder = match "multi" {
7575            "multi" => local_var_req_builder.query(
7576                &local_var_str
7577                    .into_iter()
7578                    .map(|p| ("label__ire".to_owned(), p.to_string()))
7579                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7580            ),
7581            _ => local_var_req_builder.query(&[(
7582                "label__ire",
7583                &local_var_str
7584                    .into_iter()
7585                    .map(|p| p.to_string())
7586                    .collect::<Vec<String>>()
7587                    .join(",")
7588                    .to_string(),
7589            )]),
7590        };
7591    }
7592    if let Some(ref local_var_str) = label__isw {
7593        local_var_req_builder = match "multi" {
7594            "multi" => local_var_req_builder.query(
7595                &local_var_str
7596                    .into_iter()
7597                    .map(|p| ("label__isw".to_owned(), p.to_string()))
7598                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7599            ),
7600            _ => local_var_req_builder.query(&[(
7601                "label__isw",
7602                &local_var_str
7603                    .into_iter()
7604                    .map(|p| p.to_string())
7605                    .collect::<Vec<String>>()
7606                    .join(",")
7607                    .to_string(),
7608            )]),
7609        };
7610    }
7611    if let Some(ref local_var_str) = label__n {
7612        local_var_req_builder = match "multi" {
7613            "multi" => local_var_req_builder.query(
7614                &local_var_str
7615                    .into_iter()
7616                    .map(|p| ("label__n".to_owned(), p.to_string()))
7617                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7618            ),
7619            _ => local_var_req_builder.query(&[(
7620                "label__n",
7621                &local_var_str
7622                    .into_iter()
7623                    .map(|p| p.to_string())
7624                    .collect::<Vec<String>>()
7625                    .join(",")
7626                    .to_string(),
7627            )]),
7628        };
7629    }
7630    if let Some(ref local_var_str) = label__nic {
7631        local_var_req_builder = match "multi" {
7632            "multi" => local_var_req_builder.query(
7633                &local_var_str
7634                    .into_iter()
7635                    .map(|p| ("label__nic".to_owned(), p.to_string()))
7636                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7637            ),
7638            _ => local_var_req_builder.query(&[(
7639                "label__nic",
7640                &local_var_str
7641                    .into_iter()
7642                    .map(|p| p.to_string())
7643                    .collect::<Vec<String>>()
7644                    .join(",")
7645                    .to_string(),
7646            )]),
7647        };
7648    }
7649    if let Some(ref local_var_str) = label__nie {
7650        local_var_req_builder = match "multi" {
7651            "multi" => local_var_req_builder.query(
7652                &local_var_str
7653                    .into_iter()
7654                    .map(|p| ("label__nie".to_owned(), p.to_string()))
7655                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7656            ),
7657            _ => local_var_req_builder.query(&[(
7658                "label__nie",
7659                &local_var_str
7660                    .into_iter()
7661                    .map(|p| p.to_string())
7662                    .collect::<Vec<String>>()
7663                    .join(",")
7664                    .to_string(),
7665            )]),
7666        };
7667    }
7668    if let Some(ref local_var_str) = label__niew {
7669        local_var_req_builder = match "multi" {
7670            "multi" => local_var_req_builder.query(
7671                &local_var_str
7672                    .into_iter()
7673                    .map(|p| ("label__niew".to_owned(), p.to_string()))
7674                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7675            ),
7676            _ => local_var_req_builder.query(&[(
7677                "label__niew",
7678                &local_var_str
7679                    .into_iter()
7680                    .map(|p| p.to_string())
7681                    .collect::<Vec<String>>()
7682                    .join(",")
7683                    .to_string(),
7684            )]),
7685        };
7686    }
7687    if let Some(ref local_var_str) = label__nire {
7688        local_var_req_builder = match "multi" {
7689            "multi" => local_var_req_builder.query(
7690                &local_var_str
7691                    .into_iter()
7692                    .map(|p| ("label__nire".to_owned(), p.to_string()))
7693                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7694            ),
7695            _ => local_var_req_builder.query(&[(
7696                "label__nire",
7697                &local_var_str
7698                    .into_iter()
7699                    .map(|p| p.to_string())
7700                    .collect::<Vec<String>>()
7701                    .join(",")
7702                    .to_string(),
7703            )]),
7704        };
7705    }
7706    if let Some(ref local_var_str) = label__nisw {
7707        local_var_req_builder = match "multi" {
7708            "multi" => local_var_req_builder.query(
7709                &local_var_str
7710                    .into_iter()
7711                    .map(|p| ("label__nisw".to_owned(), p.to_string()))
7712                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7713            ),
7714            _ => local_var_req_builder.query(&[(
7715                "label__nisw",
7716                &local_var_str
7717                    .into_iter()
7718                    .map(|p| p.to_string())
7719                    .collect::<Vec<String>>()
7720                    .join(",")
7721                    .to_string(),
7722            )]),
7723        };
7724    }
7725    if let Some(ref local_var_str) = label__nre {
7726        local_var_req_builder = match "multi" {
7727            "multi" => local_var_req_builder.query(
7728                &local_var_str
7729                    .into_iter()
7730                    .map(|p| ("label__nre".to_owned(), p.to_string()))
7731                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7732            ),
7733            _ => local_var_req_builder.query(&[(
7734                "label__nre",
7735                &local_var_str
7736                    .into_iter()
7737                    .map(|p| p.to_string())
7738                    .collect::<Vec<String>>()
7739                    .join(",")
7740                    .to_string(),
7741            )]),
7742        };
7743    }
7744    if let Some(ref local_var_str) = label__re {
7745        local_var_req_builder = match "multi" {
7746            "multi" => local_var_req_builder.query(
7747                &local_var_str
7748                    .into_iter()
7749                    .map(|p| ("label__re".to_owned(), p.to_string()))
7750                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7751            ),
7752            _ => local_var_req_builder.query(&[(
7753                "label__re",
7754                &local_var_str
7755                    .into_iter()
7756                    .map(|p| p.to_string())
7757                    .collect::<Vec<String>>()
7758                    .join(",")
7759                    .to_string(),
7760            )]),
7761        };
7762    }
7763    if let Some(ref local_var_str) = last_updated {
7764        local_var_req_builder = match "multi" {
7765            "multi" => local_var_req_builder.query(
7766                &local_var_str
7767                    .into_iter()
7768                    .map(|p| ("last_updated".to_owned(), p.to_string()))
7769                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7770            ),
7771            _ => local_var_req_builder.query(&[(
7772                "last_updated",
7773                &local_var_str
7774                    .into_iter()
7775                    .map(|p| p.to_string())
7776                    .collect::<Vec<String>>()
7777                    .join(",")
7778                    .to_string(),
7779            )]),
7780        };
7781    }
7782    if let Some(ref local_var_str) = last_updated__gt {
7783        local_var_req_builder = match "multi" {
7784            "multi" => local_var_req_builder.query(
7785                &local_var_str
7786                    .into_iter()
7787                    .map(|p| ("last_updated__gt".to_owned(), p.to_string()))
7788                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7789            ),
7790            _ => local_var_req_builder.query(&[(
7791                "last_updated__gt",
7792                &local_var_str
7793                    .into_iter()
7794                    .map(|p| p.to_string())
7795                    .collect::<Vec<String>>()
7796                    .join(",")
7797                    .to_string(),
7798            )]),
7799        };
7800    }
7801    if let Some(ref local_var_str) = last_updated__gte {
7802        local_var_req_builder = match "multi" {
7803            "multi" => local_var_req_builder.query(
7804                &local_var_str
7805                    .into_iter()
7806                    .map(|p| ("last_updated__gte".to_owned(), p.to_string()))
7807                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7808            ),
7809            _ => local_var_req_builder.query(&[(
7810                "last_updated__gte",
7811                &local_var_str
7812                    .into_iter()
7813                    .map(|p| p.to_string())
7814                    .collect::<Vec<String>>()
7815                    .join(",")
7816                    .to_string(),
7817            )]),
7818        };
7819    }
7820    if let Some(ref local_var_str) = last_updated__isnull {
7821        local_var_req_builder =
7822            local_var_req_builder.query(&[("last_updated__isnull", &local_var_str.to_string())]);
7823    }
7824    if let Some(ref local_var_str) = last_updated__lt {
7825        local_var_req_builder = match "multi" {
7826            "multi" => local_var_req_builder.query(
7827                &local_var_str
7828                    .into_iter()
7829                    .map(|p| ("last_updated__lt".to_owned(), p.to_string()))
7830                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7831            ),
7832            _ => local_var_req_builder.query(&[(
7833                "last_updated__lt",
7834                &local_var_str
7835                    .into_iter()
7836                    .map(|p| p.to_string())
7837                    .collect::<Vec<String>>()
7838                    .join(",")
7839                    .to_string(),
7840            )]),
7841        };
7842    }
7843    if let Some(ref local_var_str) = last_updated__lte {
7844        local_var_req_builder = match "multi" {
7845            "multi" => local_var_req_builder.query(
7846                &local_var_str
7847                    .into_iter()
7848                    .map(|p| ("last_updated__lte".to_owned(), p.to_string()))
7849                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7850            ),
7851            _ => local_var_req_builder.query(&[(
7852                "last_updated__lte",
7853                &local_var_str
7854                    .into_iter()
7855                    .map(|p| p.to_string())
7856                    .collect::<Vec<String>>()
7857                    .join(",")
7858                    .to_string(),
7859            )]),
7860        };
7861    }
7862    if let Some(ref local_var_str) = last_updated__n {
7863        local_var_req_builder = match "multi" {
7864            "multi" => local_var_req_builder.query(
7865                &local_var_str
7866                    .into_iter()
7867                    .map(|p| ("last_updated__n".to_owned(), p.to_string()))
7868                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7869            ),
7870            _ => local_var_req_builder.query(&[(
7871                "last_updated__n",
7872                &local_var_str
7873                    .into_iter()
7874                    .map(|p| p.to_string())
7875                    .collect::<Vec<String>>()
7876                    .join(",")
7877                    .to_string(),
7878            )]),
7879        };
7880    }
7881    if let Some(ref local_var_str) = limit {
7882        local_var_req_builder =
7883            local_var_req_builder.query(&[("limit", &local_var_str.to_string())]);
7884    }
7885    if let Some(ref local_var_str) = load_balancer_pool {
7886        local_var_req_builder = match "multi" {
7887            "multi" => local_var_req_builder.query(
7888                &local_var_str
7889                    .into_iter()
7890                    .map(|p| ("load_balancer_pool".to_owned(), p.to_string()))
7891                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7892            ),
7893            _ => local_var_req_builder.query(&[(
7894                "load_balancer_pool",
7895                &local_var_str
7896                    .into_iter()
7897                    .map(|p| p.to_string())
7898                    .collect::<Vec<String>>()
7899                    .join(",")
7900                    .to_string(),
7901            )]),
7902        };
7903    }
7904    if let Some(ref local_var_str) = load_balancer_pool__n {
7905        local_var_req_builder = match "multi" {
7906            "multi" => local_var_req_builder.query(
7907                &local_var_str
7908                    .into_iter()
7909                    .map(|p| ("load_balancer_pool__n".to_owned(), p.to_string()))
7910                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7911            ),
7912            _ => local_var_req_builder.query(&[(
7913                "load_balancer_pool__n",
7914                &local_var_str
7915                    .into_iter()
7916                    .map(|p| p.to_string())
7917                    .collect::<Vec<String>>()
7918                    .join(",")
7919                    .to_string(),
7920            )]),
7921        };
7922    }
7923    if let Some(ref local_var_str) = offset {
7924        local_var_req_builder =
7925            local_var_req_builder.query(&[("offset", &local_var_str.to_string())]);
7926    }
7927    if let Some(ref local_var_str) = port {
7928        local_var_req_builder = match "multi" {
7929            "multi" => local_var_req_builder.query(
7930                &local_var_str
7931                    .into_iter()
7932                    .map(|p| ("port".to_owned(), p.to_string()))
7933                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7934            ),
7935            _ => local_var_req_builder.query(&[(
7936                "port",
7937                &local_var_str
7938                    .into_iter()
7939                    .map(|p| p.to_string())
7940                    .collect::<Vec<String>>()
7941                    .join(",")
7942                    .to_string(),
7943            )]),
7944        };
7945    }
7946    if let Some(ref local_var_str) = port__gt {
7947        local_var_req_builder = match "multi" {
7948            "multi" => local_var_req_builder.query(
7949                &local_var_str
7950                    .into_iter()
7951                    .map(|p| ("port__gt".to_owned(), p.to_string()))
7952                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7953            ),
7954            _ => local_var_req_builder.query(&[(
7955                "port__gt",
7956                &local_var_str
7957                    .into_iter()
7958                    .map(|p| p.to_string())
7959                    .collect::<Vec<String>>()
7960                    .join(",")
7961                    .to_string(),
7962            )]),
7963        };
7964    }
7965    if let Some(ref local_var_str) = port__gte {
7966        local_var_req_builder = match "multi" {
7967            "multi" => local_var_req_builder.query(
7968                &local_var_str
7969                    .into_iter()
7970                    .map(|p| ("port__gte".to_owned(), p.to_string()))
7971                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7972            ),
7973            _ => local_var_req_builder.query(&[(
7974                "port__gte",
7975                &local_var_str
7976                    .into_iter()
7977                    .map(|p| p.to_string())
7978                    .collect::<Vec<String>>()
7979                    .join(",")
7980                    .to_string(),
7981            )]),
7982        };
7983    }
7984    if let Some(ref local_var_str) = port__lt {
7985        local_var_req_builder = match "multi" {
7986            "multi" => local_var_req_builder.query(
7987                &local_var_str
7988                    .into_iter()
7989                    .map(|p| ("port__lt".to_owned(), p.to_string()))
7990                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7991            ),
7992            _ => local_var_req_builder.query(&[(
7993                "port__lt",
7994                &local_var_str
7995                    .into_iter()
7996                    .map(|p| p.to_string())
7997                    .collect::<Vec<String>>()
7998                    .join(",")
7999                    .to_string(),
8000            )]),
8001        };
8002    }
8003    if let Some(ref local_var_str) = port__lte {
8004        local_var_req_builder = match "multi" {
8005            "multi" => local_var_req_builder.query(
8006                &local_var_str
8007                    .into_iter()
8008                    .map(|p| ("port__lte".to_owned(), p.to_string()))
8009                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8010            ),
8011            _ => local_var_req_builder.query(&[(
8012                "port__lte",
8013                &local_var_str
8014                    .into_iter()
8015                    .map(|p| p.to_string())
8016                    .collect::<Vec<String>>()
8017                    .join(",")
8018                    .to_string(),
8019            )]),
8020        };
8021    }
8022    if let Some(ref local_var_str) = port__n {
8023        local_var_req_builder = match "multi" {
8024            "multi" => local_var_req_builder.query(
8025                &local_var_str
8026                    .into_iter()
8027                    .map(|p| ("port__n".to_owned(), p.to_string()))
8028                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8029            ),
8030            _ => local_var_req_builder.query(&[(
8031                "port__n",
8032                &local_var_str
8033                    .into_iter()
8034                    .map(|p| p.to_string())
8035                    .collect::<Vec<String>>()
8036                    .join(",")
8037                    .to_string(),
8038            )]),
8039        };
8040    }
8041    if let Some(ref local_var_str) = q {
8042        local_var_req_builder = local_var_req_builder.query(&[("q", &local_var_str.to_string())]);
8043    }
8044    if let Some(ref local_var_str) = sort {
8045        local_var_req_builder =
8046            local_var_req_builder.query(&[("sort", &local_var_str.to_string())]);
8047    }
8048    if let Some(ref local_var_str) = ssl_offload {
8049        local_var_req_builder =
8050            local_var_req_builder.query(&[("ssl_offload", &local_var_str.to_string())]);
8051    }
8052    if let Some(ref local_var_str) = status {
8053        local_var_req_builder = match "multi" {
8054            "multi" => local_var_req_builder.query(
8055                &local_var_str
8056                    .into_iter()
8057                    .map(|p| ("status".to_owned(), p.to_string()))
8058                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8059            ),
8060            _ => local_var_req_builder.query(&[(
8061                "status",
8062                &local_var_str
8063                    .into_iter()
8064                    .map(|p| p.to_string())
8065                    .collect::<Vec<String>>()
8066                    .join(",")
8067                    .to_string(),
8068            )]),
8069        };
8070    }
8071    if let Some(ref local_var_str) = status__n {
8072        local_var_req_builder = match "multi" {
8073            "multi" => local_var_req_builder.query(
8074                &local_var_str
8075                    .into_iter()
8076                    .map(|p| ("status__n".to_owned(), p.to_string()))
8077                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8078            ),
8079            _ => local_var_req_builder.query(&[(
8080                "status__n",
8081                &local_var_str
8082                    .into_iter()
8083                    .map(|p| p.to_string())
8084                    .collect::<Vec<String>>()
8085                    .join(",")
8086                    .to_string(),
8087            )]),
8088        };
8089    }
8090    if let Some(ref local_var_str) = tags {
8091        local_var_req_builder = match "multi" {
8092            "multi" => local_var_req_builder.query(
8093                &local_var_str
8094                    .into_iter()
8095                    .map(|p| ("tags".to_owned(), p.to_string()))
8096                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8097            ),
8098            _ => local_var_req_builder.query(&[(
8099                "tags",
8100                &local_var_str
8101                    .into_iter()
8102                    .map(|p| p.to_string())
8103                    .collect::<Vec<String>>()
8104                    .join(",")
8105                    .to_string(),
8106            )]),
8107        };
8108    }
8109    if let Some(ref local_var_str) = tags__isnull {
8110        local_var_req_builder =
8111            local_var_req_builder.query(&[("tags__isnull", &local_var_str.to_string())]);
8112    }
8113    if let Some(ref local_var_str) = tags__n {
8114        local_var_req_builder = match "multi" {
8115            "multi" => local_var_req_builder.query(
8116                &local_var_str
8117                    .into_iter()
8118                    .map(|p| ("tags__n".to_owned(), p.to_string()))
8119                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8120            ),
8121            _ => local_var_req_builder.query(&[(
8122                "tags__n",
8123                &local_var_str
8124                    .into_iter()
8125                    .map(|p| p.to_string())
8126                    .collect::<Vec<String>>()
8127                    .join(",")
8128                    .to_string(),
8129            )]),
8130        };
8131    }
8132    if let Some(ref local_var_str) = teams {
8133        local_var_req_builder = match "multi" {
8134            "multi" => local_var_req_builder.query(
8135                &local_var_str
8136                    .into_iter()
8137                    .map(|p| ("teams".to_owned(), p.to_string()))
8138                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8139            ),
8140            _ => local_var_req_builder.query(&[(
8141                "teams",
8142                &local_var_str
8143                    .into_iter()
8144                    .map(|p| p.to_string())
8145                    .collect::<Vec<String>>()
8146                    .join(",")
8147                    .to_string(),
8148            )]),
8149        };
8150    }
8151    if let Some(ref local_var_str) = teams__isnull {
8152        local_var_req_builder =
8153            local_var_req_builder.query(&[("teams__isnull", &local_var_str.to_string())]);
8154    }
8155    if let Some(ref local_var_str) = teams__n {
8156        local_var_req_builder = match "multi" {
8157            "multi" => local_var_req_builder.query(
8158                &local_var_str
8159                    .into_iter()
8160                    .map(|p| ("teams__n".to_owned(), p.to_string()))
8161                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8162            ),
8163            _ => local_var_req_builder.query(&[(
8164                "teams__n",
8165                &local_var_str
8166                    .into_iter()
8167                    .map(|p| p.to_string())
8168                    .collect::<Vec<String>>()
8169                    .join(",")
8170                    .to_string(),
8171            )]),
8172        };
8173    }
8174    if let Some(ref local_var_str) = tenant {
8175        local_var_req_builder = match "multi" {
8176            "multi" => local_var_req_builder.query(
8177                &local_var_str
8178                    .into_iter()
8179                    .map(|p| ("tenant".to_owned(), p.to_string()))
8180                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8181            ),
8182            _ => local_var_req_builder.query(&[(
8183                "tenant",
8184                &local_var_str
8185                    .into_iter()
8186                    .map(|p| p.to_string())
8187                    .collect::<Vec<String>>()
8188                    .join(",")
8189                    .to_string(),
8190            )]),
8191        };
8192    }
8193    if let Some(ref local_var_str) = tenant__isnull {
8194        local_var_req_builder =
8195            local_var_req_builder.query(&[("tenant__isnull", &local_var_str.to_string())]);
8196    }
8197    if let Some(ref local_var_str) = tenant__n {
8198        local_var_req_builder = match "multi" {
8199            "multi" => local_var_req_builder.query(
8200                &local_var_str
8201                    .into_iter()
8202                    .map(|p| ("tenant__n".to_owned(), p.to_string()))
8203                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8204            ),
8205            _ => local_var_req_builder.query(&[(
8206                "tenant__n",
8207                &local_var_str
8208                    .into_iter()
8209                    .map(|p| p.to_string())
8210                    .collect::<Vec<String>>()
8211                    .join(",")
8212                    .to_string(),
8213            )]),
8214        };
8215    }
8216    if let Some(ref local_var_str) = tenant_group {
8217        local_var_req_builder = match "multi" {
8218            "multi" => local_var_req_builder.query(
8219                &local_var_str
8220                    .into_iter()
8221                    .map(|p| ("tenant_group".to_owned(), p.to_string()))
8222                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8223            ),
8224            _ => local_var_req_builder.query(&[(
8225                "tenant_group",
8226                &local_var_str
8227                    .into_iter()
8228                    .map(|p| p.to_string())
8229                    .collect::<Vec<String>>()
8230                    .join(",")
8231                    .to_string(),
8232            )]),
8233        };
8234    }
8235    if let Some(ref local_var_str) = tenant_group__isnull {
8236        local_var_req_builder =
8237            local_var_req_builder.query(&[("tenant_group__isnull", &local_var_str.to_string())]);
8238    }
8239    if let Some(ref local_var_str) = tenant_group__n {
8240        local_var_req_builder = match "multi" {
8241            "multi" => local_var_req_builder.query(
8242                &local_var_str
8243                    .into_iter()
8244                    .map(|p| ("tenant_group__n".to_owned(), p.to_string()))
8245                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8246            ),
8247            _ => local_var_req_builder.query(&[(
8248                "tenant_group__n",
8249                &local_var_str
8250                    .into_iter()
8251                    .map(|p| p.to_string())
8252                    .collect::<Vec<String>>()
8253                    .join(",")
8254                    .to_string(),
8255            )]),
8256        };
8257    }
8258    if let Some(ref local_var_str) = tenant_id {
8259        local_var_req_builder = match "multi" {
8260            "multi" => local_var_req_builder.query(
8261                &local_var_str
8262                    .into_iter()
8263                    .map(|p| ("tenant_id".to_owned(), p.to_string()))
8264                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8265            ),
8266            _ => local_var_req_builder.query(&[(
8267                "tenant_id",
8268                &local_var_str
8269                    .into_iter()
8270                    .map(|p| p.to_string())
8271                    .collect::<Vec<String>>()
8272                    .join(",")
8273                    .to_string(),
8274            )]),
8275        };
8276    }
8277    if let Some(ref local_var_str) = tenant_id__isnull {
8278        local_var_req_builder =
8279            local_var_req_builder.query(&[("tenant_id__isnull", &local_var_str.to_string())]);
8280    }
8281    if let Some(ref local_var_str) = tenant_id__n {
8282        local_var_req_builder = match "multi" {
8283            "multi" => local_var_req_builder.query(
8284                &local_var_str
8285                    .into_iter()
8286                    .map(|p| ("tenant_id__n".to_owned(), p.to_string()))
8287                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8288            ),
8289            _ => local_var_req_builder.query(&[(
8290                "tenant_id__n",
8291                &local_var_str
8292                    .into_iter()
8293                    .map(|p| p.to_string())
8294                    .collect::<Vec<String>>()
8295                    .join(",")
8296                    .to_string(),
8297            )]),
8298        };
8299    }
8300    if let Some(ref local_var_str) = depth {
8301        local_var_req_builder =
8302            local_var_req_builder.query(&[("depth", &local_var_str.to_string())]);
8303    }
8304    if let Some(ref local_var_str) = exclude_m2m {
8305        local_var_req_builder =
8306            local_var_req_builder.query(&[("exclude_m2m", &local_var_str.to_string())]);
8307    }
8308    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
8309        local_var_req_builder =
8310            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
8311    }
8312    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
8313        let local_var_key = local_var_apikey.key.clone();
8314        let local_var_value = match local_var_apikey.prefix {
8315            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
8316            None => local_var_key,
8317        };
8318        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
8319    };
8320
8321    let local_var_req = local_var_req_builder.build()?;
8322    let local_var_resp = local_var_client.execute(local_var_req).await?;
8323
8324    let local_var_status = local_var_resp.status();
8325    let local_var_content = local_var_resp.text().await?;
8326
8327    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
8328        serde_json::from_str(&local_var_content).map_err(Error::from)
8329    } else {
8330        let local_var_entity: Option<LoadBalancersLoadBalancerPoolMembersListError> =
8331            serde_json::from_str(&local_var_content).ok();
8332        let local_var_error = ResponseContent {
8333            status: local_var_status,
8334            content: local_var_content,
8335            entity: local_var_entity,
8336        };
8337        Err(Error::ResponseError(local_var_error))
8338    }
8339}
8340
8341/// API methods for returning or creating notes on an object.
8342pub async fn load_balancers_load_balancer_pool_members_notes_create(
8343    configuration: &configuration::Configuration,
8344    id: &str,
8345    note_input_request: crate::models::NoteInputRequest,
8346    format: Option<&str>,
8347) -> Result<crate::models::Note, Error<LoadBalancersLoadBalancerPoolMembersNotesCreateError>> {
8348    let local_var_configuration = configuration;
8349
8350    let local_var_client = &local_var_configuration.client;
8351
8352    let local_var_uri_str = format!(
8353        "{}/load-balancers/load-balancer-pool-members/{id}/notes/",
8354        local_var_configuration.base_path,
8355        id = crate::apis::urlencode(id)
8356    );
8357    let mut local_var_req_builder =
8358        local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
8359
8360    if let Some(ref local_var_str) = format {
8361        local_var_req_builder =
8362            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
8363    }
8364    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
8365        local_var_req_builder =
8366            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
8367    }
8368    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
8369        let local_var_key = local_var_apikey.key.clone();
8370        let local_var_value = match local_var_apikey.prefix {
8371            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
8372            None => local_var_key,
8373        };
8374        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
8375    };
8376    local_var_req_builder = local_var_req_builder.json(&note_input_request);
8377
8378    let local_var_req = local_var_req_builder.build()?;
8379    let local_var_resp = local_var_client.execute(local_var_req).await?;
8380
8381    let local_var_status = local_var_resp.status();
8382    let local_var_content = local_var_resp.text().await?;
8383
8384    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
8385        serde_json::from_str(&local_var_content).map_err(Error::from)
8386    } else {
8387        let local_var_entity: Option<LoadBalancersLoadBalancerPoolMembersNotesCreateError> =
8388            serde_json::from_str(&local_var_content).ok();
8389        let local_var_error = ResponseContent {
8390            status: local_var_status,
8391            content: local_var_content,
8392            entity: local_var_entity,
8393        };
8394        Err(Error::ResponseError(local_var_error))
8395    }
8396}
8397
8398/// API methods for returning or creating notes on an object.
8399pub async fn load_balancers_load_balancer_pool_members_notes_list(
8400    configuration: &configuration::Configuration,
8401    id: &str,
8402    format: Option<&str>,
8403    limit: Option<i32>,
8404    offset: Option<i32>,
8405    depth: Option<i32>,
8406    exclude_m2m: Option<bool>,
8407) -> Result<
8408    crate::models::PaginatedNoteList,
8409    Error<LoadBalancersLoadBalancerPoolMembersNotesListError>,
8410> {
8411    let local_var_configuration = configuration;
8412
8413    let local_var_client = &local_var_configuration.client;
8414
8415    let local_var_uri_str = format!(
8416        "{}/load-balancers/load-balancer-pool-members/{id}/notes/",
8417        local_var_configuration.base_path,
8418        id = crate::apis::urlencode(id)
8419    );
8420    let mut local_var_req_builder =
8421        local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
8422
8423    if let Some(ref local_var_str) = format {
8424        local_var_req_builder =
8425            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
8426    }
8427    if let Some(ref local_var_str) = limit {
8428        local_var_req_builder =
8429            local_var_req_builder.query(&[("limit", &local_var_str.to_string())]);
8430    }
8431    if let Some(ref local_var_str) = offset {
8432        local_var_req_builder =
8433            local_var_req_builder.query(&[("offset", &local_var_str.to_string())]);
8434    }
8435    if let Some(ref local_var_str) = depth {
8436        local_var_req_builder =
8437            local_var_req_builder.query(&[("depth", &local_var_str.to_string())]);
8438    }
8439    if let Some(ref local_var_str) = exclude_m2m {
8440        local_var_req_builder =
8441            local_var_req_builder.query(&[("exclude_m2m", &local_var_str.to_string())]);
8442    }
8443    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
8444        local_var_req_builder =
8445            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
8446    }
8447    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
8448        let local_var_key = local_var_apikey.key.clone();
8449        let local_var_value = match local_var_apikey.prefix {
8450            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
8451            None => local_var_key,
8452        };
8453        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
8454    };
8455
8456    let local_var_req = local_var_req_builder.build()?;
8457    let local_var_resp = local_var_client.execute(local_var_req).await?;
8458
8459    let local_var_status = local_var_resp.status();
8460    let local_var_content = local_var_resp.text().await?;
8461
8462    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
8463        serde_json::from_str(&local_var_content).map_err(Error::from)
8464    } else {
8465        let local_var_entity: Option<LoadBalancersLoadBalancerPoolMembersNotesListError> =
8466            serde_json::from_str(&local_var_content).ok();
8467        let local_var_error = ResponseContent {
8468            status: local_var_status,
8469            content: local_var_content,
8470            entity: local_var_entity,
8471        };
8472        Err(Error::ResponseError(local_var_error))
8473    }
8474}
8475
8476/// LoadBalancerPoolMember viewset.
8477pub async fn load_balancers_load_balancer_pool_members_partial_update(
8478    configuration: &configuration::Configuration,
8479    id: &str,
8480    format: Option<&str>,
8481    patched_load_balancer_pool_member_request: Option<
8482        crate::models::PatchedLoadBalancerPoolMemberRequest,
8483    >,
8484) -> Result<
8485    crate::models::LoadBalancerPoolMember,
8486    Error<LoadBalancersLoadBalancerPoolMembersPartialUpdateError>,
8487> {
8488    let local_var_configuration = configuration;
8489
8490    let local_var_client = &local_var_configuration.client;
8491
8492    let local_var_uri_str = format!(
8493        "{}/load-balancers/load-balancer-pool-members/{id}/",
8494        local_var_configuration.base_path,
8495        id = crate::apis::urlencode(id)
8496    );
8497    let mut local_var_req_builder =
8498        local_var_client.request(reqwest::Method::PATCH, local_var_uri_str.as_str());
8499
8500    if let Some(ref local_var_str) = format {
8501        local_var_req_builder =
8502            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
8503    }
8504    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
8505        local_var_req_builder =
8506            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
8507    }
8508    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
8509        let local_var_key = local_var_apikey.key.clone();
8510        let local_var_value = match local_var_apikey.prefix {
8511            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
8512            None => local_var_key,
8513        };
8514        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
8515    };
8516    local_var_req_builder = local_var_req_builder.json(&patched_load_balancer_pool_member_request);
8517
8518    let local_var_req = local_var_req_builder.build()?;
8519    let local_var_resp = local_var_client.execute(local_var_req).await?;
8520
8521    let local_var_status = local_var_resp.status();
8522    let local_var_content = local_var_resp.text().await?;
8523
8524    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
8525        serde_json::from_str(&local_var_content).map_err(Error::from)
8526    } else {
8527        let local_var_entity: Option<LoadBalancersLoadBalancerPoolMembersPartialUpdateError> =
8528            serde_json::from_str(&local_var_content).ok();
8529        let local_var_error = ResponseContent {
8530            status: local_var_status,
8531            content: local_var_content,
8532            entity: local_var_entity,
8533        };
8534        Err(Error::ResponseError(local_var_error))
8535    }
8536}
8537
8538/// LoadBalancerPoolMember viewset.
8539pub async fn load_balancers_load_balancer_pool_members_retrieve(
8540    configuration: &configuration::Configuration,
8541    id: &str,
8542    format: Option<&str>,
8543    depth: Option<i32>,
8544    exclude_m2m: Option<bool>,
8545) -> Result<
8546    crate::models::LoadBalancerPoolMember,
8547    Error<LoadBalancersLoadBalancerPoolMembersRetrieveError>,
8548> {
8549    let local_var_configuration = configuration;
8550
8551    let local_var_client = &local_var_configuration.client;
8552
8553    let local_var_uri_str = format!(
8554        "{}/load-balancers/load-balancer-pool-members/{id}/",
8555        local_var_configuration.base_path,
8556        id = crate::apis::urlencode(id)
8557    );
8558    let mut local_var_req_builder =
8559        local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
8560
8561    if let Some(ref local_var_str) = format {
8562        local_var_req_builder =
8563            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
8564    }
8565    if let Some(ref local_var_str) = depth {
8566        local_var_req_builder =
8567            local_var_req_builder.query(&[("depth", &local_var_str.to_string())]);
8568    }
8569    if let Some(ref local_var_str) = exclude_m2m {
8570        local_var_req_builder =
8571            local_var_req_builder.query(&[("exclude_m2m", &local_var_str.to_string())]);
8572    }
8573    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
8574        local_var_req_builder =
8575            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
8576    }
8577    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
8578        let local_var_key = local_var_apikey.key.clone();
8579        let local_var_value = match local_var_apikey.prefix {
8580            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
8581            None => local_var_key,
8582        };
8583        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
8584    };
8585
8586    let local_var_req = local_var_req_builder.build()?;
8587    let local_var_resp = local_var_client.execute(local_var_req).await?;
8588
8589    let local_var_status = local_var_resp.status();
8590    let local_var_content = local_var_resp.text().await?;
8591
8592    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
8593        serde_json::from_str(&local_var_content).map_err(Error::from)
8594    } else {
8595        let local_var_entity: Option<LoadBalancersLoadBalancerPoolMembersRetrieveError> =
8596            serde_json::from_str(&local_var_content).ok();
8597        let local_var_error = ResponseContent {
8598            status: local_var_status,
8599            content: local_var_content,
8600            entity: local_var_entity,
8601        };
8602        Err(Error::ResponseError(local_var_error))
8603    }
8604}
8605
8606/// LoadBalancerPoolMember viewset.
8607pub async fn load_balancers_load_balancer_pool_members_update(
8608    configuration: &configuration::Configuration,
8609    id: &str,
8610    load_balancer_pool_member_request: crate::models::LoadBalancerPoolMemberRequest,
8611    format: Option<&str>,
8612) -> Result<
8613    crate::models::LoadBalancerPoolMember,
8614    Error<LoadBalancersLoadBalancerPoolMembersUpdateError>,
8615> {
8616    let local_var_configuration = configuration;
8617
8618    let local_var_client = &local_var_configuration.client;
8619
8620    let local_var_uri_str = format!(
8621        "{}/load-balancers/load-balancer-pool-members/{id}/",
8622        local_var_configuration.base_path,
8623        id = crate::apis::urlencode(id)
8624    );
8625    let mut local_var_req_builder =
8626        local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());
8627
8628    if let Some(ref local_var_str) = format {
8629        local_var_req_builder =
8630            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
8631    }
8632    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
8633        local_var_req_builder =
8634            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
8635    }
8636    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
8637        let local_var_key = local_var_apikey.key.clone();
8638        let local_var_value = match local_var_apikey.prefix {
8639            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
8640            None => local_var_key,
8641        };
8642        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
8643    };
8644    local_var_req_builder = local_var_req_builder.json(&load_balancer_pool_member_request);
8645
8646    let local_var_req = local_var_req_builder.build()?;
8647    let local_var_resp = local_var_client.execute(local_var_req).await?;
8648
8649    let local_var_status = local_var_resp.status();
8650    let local_var_content = local_var_resp.text().await?;
8651
8652    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
8653        serde_json::from_str(&local_var_content).map_err(Error::from)
8654    } else {
8655        let local_var_entity: Option<LoadBalancersLoadBalancerPoolMembersUpdateError> =
8656            serde_json::from_str(&local_var_content).ok();
8657        let local_var_error = ResponseContent {
8658            status: local_var_status,
8659            content: local_var_content,
8660            entity: local_var_entity,
8661        };
8662        Err(Error::ResponseError(local_var_error))
8663    }
8664}
8665
8666/// LoadBalancerPool viewset.
8667pub async fn load_balancers_load_balancer_pools_bulk_destroy(
8668    configuration: &configuration::Configuration,
8669    bulk_operation_request: Vec<crate::models::BulkOperationRequest>,
8670    format: Option<&str>,
8671) -> Result<(), Error<LoadBalancersLoadBalancerPoolsBulkDestroyError>> {
8672    let local_var_configuration = configuration;
8673
8674    let local_var_client = &local_var_configuration.client;
8675
8676    let local_var_uri_str = format!(
8677        "{}/load-balancers/load-balancer-pools/",
8678        local_var_configuration.base_path
8679    );
8680    let mut local_var_req_builder =
8681        local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());
8682
8683    if let Some(ref local_var_str) = format {
8684        local_var_req_builder =
8685            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
8686    }
8687    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
8688        local_var_req_builder =
8689            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
8690    }
8691    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
8692        let local_var_key = local_var_apikey.key.clone();
8693        let local_var_value = match local_var_apikey.prefix {
8694            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
8695            None => local_var_key,
8696        };
8697        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
8698    };
8699    local_var_req_builder = local_var_req_builder.json(&bulk_operation_request);
8700
8701    let local_var_req = local_var_req_builder.build()?;
8702    let local_var_resp = local_var_client.execute(local_var_req).await?;
8703
8704    let local_var_status = local_var_resp.status();
8705    let local_var_content = local_var_resp.text().await?;
8706
8707    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
8708        Ok(())
8709    } else {
8710        let local_var_entity: Option<LoadBalancersLoadBalancerPoolsBulkDestroyError> =
8711            serde_json::from_str(&local_var_content).ok();
8712        let local_var_error = ResponseContent {
8713            status: local_var_status,
8714            content: local_var_content,
8715            entity: local_var_entity,
8716        };
8717        Err(Error::ResponseError(local_var_error))
8718    }
8719}
8720
8721/// LoadBalancerPool viewset.
8722pub async fn load_balancers_load_balancer_pools_bulk_partial_update(
8723    configuration: &configuration::Configuration,
8724    patched_bulk_writable_load_balancer_pool_request: Vec<
8725        crate::models::PatchedBulkWritableLoadBalancerPoolRequest,
8726    >,
8727    format: Option<&str>,
8728) -> Result<
8729    Vec<crate::models::LoadBalancerPool>,
8730    Error<LoadBalancersLoadBalancerPoolsBulkPartialUpdateError>,
8731> {
8732    let local_var_configuration = configuration;
8733
8734    let local_var_client = &local_var_configuration.client;
8735
8736    let local_var_uri_str = format!(
8737        "{}/load-balancers/load-balancer-pools/",
8738        local_var_configuration.base_path
8739    );
8740    let mut local_var_req_builder =
8741        local_var_client.request(reqwest::Method::PATCH, local_var_uri_str.as_str());
8742
8743    if let Some(ref local_var_str) = format {
8744        local_var_req_builder =
8745            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
8746    }
8747    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
8748        local_var_req_builder =
8749            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
8750    }
8751    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
8752        let local_var_key = local_var_apikey.key.clone();
8753        let local_var_value = match local_var_apikey.prefix {
8754            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
8755            None => local_var_key,
8756        };
8757        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
8758    };
8759    local_var_req_builder =
8760        local_var_req_builder.json(&patched_bulk_writable_load_balancer_pool_request);
8761
8762    let local_var_req = local_var_req_builder.build()?;
8763    let local_var_resp = local_var_client.execute(local_var_req).await?;
8764
8765    let local_var_status = local_var_resp.status();
8766    let local_var_content = local_var_resp.text().await?;
8767
8768    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
8769        serde_json::from_str(&local_var_content).map_err(Error::from)
8770    } else {
8771        let local_var_entity: Option<LoadBalancersLoadBalancerPoolsBulkPartialUpdateError> =
8772            serde_json::from_str(&local_var_content).ok();
8773        let local_var_error = ResponseContent {
8774            status: local_var_status,
8775            content: local_var_content,
8776            entity: local_var_entity,
8777        };
8778        Err(Error::ResponseError(local_var_error))
8779    }
8780}
8781
8782/// LoadBalancerPool viewset.
8783pub async fn load_balancers_load_balancer_pools_bulk_update(
8784    configuration: &configuration::Configuration,
8785    bulk_writable_load_balancer_pool_request: Vec<
8786        crate::models::BulkWritableLoadBalancerPoolRequest,
8787    >,
8788    format: Option<&str>,
8789) -> Result<
8790    Vec<crate::models::LoadBalancerPool>,
8791    Error<LoadBalancersLoadBalancerPoolsBulkUpdateError>,
8792> {
8793    let local_var_configuration = configuration;
8794
8795    let local_var_client = &local_var_configuration.client;
8796
8797    let local_var_uri_str = format!(
8798        "{}/load-balancers/load-balancer-pools/",
8799        local_var_configuration.base_path
8800    );
8801    let mut local_var_req_builder =
8802        local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());
8803
8804    if let Some(ref local_var_str) = format {
8805        local_var_req_builder =
8806            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
8807    }
8808    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
8809        local_var_req_builder =
8810            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
8811    }
8812    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
8813        let local_var_key = local_var_apikey.key.clone();
8814        let local_var_value = match local_var_apikey.prefix {
8815            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
8816            None => local_var_key,
8817        };
8818        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
8819    };
8820    local_var_req_builder = local_var_req_builder.json(&bulk_writable_load_balancer_pool_request);
8821
8822    let local_var_req = local_var_req_builder.build()?;
8823    let local_var_resp = local_var_client.execute(local_var_req).await?;
8824
8825    let local_var_status = local_var_resp.status();
8826    let local_var_content = local_var_resp.text().await?;
8827
8828    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
8829        serde_json::from_str(&local_var_content).map_err(Error::from)
8830    } else {
8831        let local_var_entity: Option<LoadBalancersLoadBalancerPoolsBulkUpdateError> =
8832            serde_json::from_str(&local_var_content).ok();
8833        let local_var_error = ResponseContent {
8834            status: local_var_status,
8835            content: local_var_content,
8836            entity: local_var_entity,
8837        };
8838        Err(Error::ResponseError(local_var_error))
8839    }
8840}
8841
8842/// LoadBalancerPool viewset.
8843pub async fn load_balancers_load_balancer_pools_create(
8844    configuration: &configuration::Configuration,
8845    load_balancer_pool_request: crate::models::LoadBalancerPoolRequest,
8846    format: Option<&str>,
8847) -> Result<crate::models::LoadBalancerPool, Error<LoadBalancersLoadBalancerPoolsCreateError>> {
8848    let local_var_configuration = configuration;
8849
8850    let local_var_client = &local_var_configuration.client;
8851
8852    let local_var_uri_str = format!(
8853        "{}/load-balancers/load-balancer-pools/",
8854        local_var_configuration.base_path
8855    );
8856    let mut local_var_req_builder =
8857        local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
8858
8859    if let Some(ref local_var_str) = format {
8860        local_var_req_builder =
8861            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
8862    }
8863    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
8864        local_var_req_builder =
8865            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
8866    }
8867    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
8868        let local_var_key = local_var_apikey.key.clone();
8869        let local_var_value = match local_var_apikey.prefix {
8870            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
8871            None => local_var_key,
8872        };
8873        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
8874    };
8875    local_var_req_builder = local_var_req_builder.json(&load_balancer_pool_request);
8876
8877    let local_var_req = local_var_req_builder.build()?;
8878    let local_var_resp = local_var_client.execute(local_var_req).await?;
8879
8880    let local_var_status = local_var_resp.status();
8881    let local_var_content = local_var_resp.text().await?;
8882
8883    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
8884        serde_json::from_str(&local_var_content).map_err(Error::from)
8885    } else {
8886        let local_var_entity: Option<LoadBalancersLoadBalancerPoolsCreateError> =
8887            serde_json::from_str(&local_var_content).ok();
8888        let local_var_error = ResponseContent {
8889            status: local_var_status,
8890            content: local_var_content,
8891            entity: local_var_entity,
8892        };
8893        Err(Error::ResponseError(local_var_error))
8894    }
8895}
8896
8897/// LoadBalancerPool viewset.
8898pub async fn load_balancers_load_balancer_pools_destroy(
8899    configuration: &configuration::Configuration,
8900    id: &str,
8901    format: Option<&str>,
8902) -> Result<(), Error<LoadBalancersLoadBalancerPoolsDestroyError>> {
8903    let local_var_configuration = configuration;
8904
8905    let local_var_client = &local_var_configuration.client;
8906
8907    let local_var_uri_str = format!(
8908        "{}/load-balancers/load-balancer-pools/{id}/",
8909        local_var_configuration.base_path,
8910        id = crate::apis::urlencode(id)
8911    );
8912    let mut local_var_req_builder =
8913        local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());
8914
8915    if let Some(ref local_var_str) = format {
8916        local_var_req_builder =
8917            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
8918    }
8919    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
8920        local_var_req_builder =
8921            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
8922    }
8923    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
8924        let local_var_key = local_var_apikey.key.clone();
8925        let local_var_value = match local_var_apikey.prefix {
8926            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
8927            None => local_var_key,
8928        };
8929        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
8930    };
8931
8932    let local_var_req = local_var_req_builder.build()?;
8933    let local_var_resp = local_var_client.execute(local_var_req).await?;
8934
8935    let local_var_status = local_var_resp.status();
8936    let local_var_content = local_var_resp.text().await?;
8937
8938    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
8939        Ok(())
8940    } else {
8941        let local_var_entity: Option<LoadBalancersLoadBalancerPoolsDestroyError> =
8942            serde_json::from_str(&local_var_content).ok();
8943        let local_var_error = ResponseContent {
8944            status: local_var_status,
8945            content: local_var_content,
8946            entity: local_var_entity,
8947        };
8948        Err(Error::ResponseError(local_var_error))
8949    }
8950}
8951
8952/// LoadBalancerPool viewset.
8953pub async fn load_balancers_load_balancer_pools_list(
8954    configuration: &configuration::Configuration,
8955    contacts: Option<Vec<String>>,
8956    contacts__isnull: Option<bool>,
8957    contacts__n: Option<Vec<String>>,
8958    created: Option<Vec<String>>,
8959    created__gt: Option<Vec<String>>,
8960    created__gte: Option<Vec<String>>,
8961    created__isnull: Option<bool>,
8962    created__lt: Option<Vec<String>>,
8963    created__lte: Option<Vec<String>>,
8964    created__n: Option<Vec<String>>,
8965    dynamic_groups: Option<Vec<String>>,
8966    dynamic_groups__n: Option<Vec<String>>,
8967    format: Option<&str>,
8968    health_check_monitor: Option<Vec<String>>,
8969    health_check_monitor__isnull: Option<bool>,
8970    health_check_monitor__n: Option<Vec<String>>,
8971    id: Option<Vec<uuid::Uuid>>,
8972    id__n: Option<Vec<uuid::Uuid>>,
8973    last_updated: Option<Vec<String>>,
8974    last_updated__gt: Option<Vec<String>>,
8975    last_updated__gte: Option<Vec<String>>,
8976    last_updated__isnull: Option<bool>,
8977    last_updated__lt: Option<Vec<String>>,
8978    last_updated__lte: Option<Vec<String>>,
8979    last_updated__n: Option<Vec<String>>,
8980    limit: Option<i32>,
8981    load_balancing_algorithm: Option<Vec<String>>,
8982    load_balancing_algorithm__ic: Option<Vec<String>>,
8983    load_balancing_algorithm__ie: Option<Vec<String>>,
8984    load_balancing_algorithm__iew: Option<Vec<String>>,
8985    load_balancing_algorithm__ire: Option<Vec<String>>,
8986    load_balancing_algorithm__isw: Option<Vec<String>>,
8987    load_balancing_algorithm__n: Option<Vec<String>>,
8988    load_balancing_algorithm__nic: Option<Vec<String>>,
8989    load_balancing_algorithm__nie: Option<Vec<String>>,
8990    load_balancing_algorithm__niew: Option<Vec<String>>,
8991    load_balancing_algorithm__nire: Option<Vec<String>>,
8992    load_balancing_algorithm__nisw: Option<Vec<String>>,
8993    load_balancing_algorithm__nre: Option<Vec<String>>,
8994    load_balancing_algorithm__re: Option<Vec<String>>,
8995    name: Option<Vec<String>>,
8996    name__ic: Option<Vec<String>>,
8997    name__ie: Option<Vec<String>>,
8998    name__iew: Option<Vec<String>>,
8999    name__ire: Option<Vec<String>>,
9000    name__isw: Option<Vec<String>>,
9001    name__n: Option<Vec<String>>,
9002    name__nic: Option<Vec<String>>,
9003    name__nie: Option<Vec<String>>,
9004    name__niew: Option<Vec<String>>,
9005    name__nire: Option<Vec<String>>,
9006    name__nisw: Option<Vec<String>>,
9007    name__nre: Option<Vec<String>>,
9008    name__re: Option<Vec<String>>,
9009    offset: Option<i32>,
9010    q: Option<&str>,
9011    sort: Option<&str>,
9012    tags: Option<Vec<String>>,
9013    tags__isnull: Option<bool>,
9014    tags__n: Option<Vec<String>>,
9015    teams: Option<Vec<String>>,
9016    teams__isnull: Option<bool>,
9017    teams__n: Option<Vec<String>>,
9018    tenant: Option<Vec<String>>,
9019    tenant__isnull: Option<bool>,
9020    tenant__n: Option<Vec<String>>,
9021    tenant_group: Option<Vec<String>>,
9022    tenant_group__isnull: Option<bool>,
9023    tenant_group__n: Option<Vec<String>>,
9024    tenant_id: Option<Vec<uuid::Uuid>>,
9025    tenant_id__isnull: Option<bool>,
9026    tenant_id__n: Option<Vec<uuid::Uuid>>,
9027    depth: Option<i32>,
9028    exclude_m2m: Option<bool>,
9029) -> Result<
9030    crate::models::PaginatedLoadBalancerPoolList,
9031    Error<LoadBalancersLoadBalancerPoolsListError>,
9032> {
9033    let local_var_configuration = configuration;
9034
9035    let local_var_client = &local_var_configuration.client;
9036
9037    let local_var_uri_str = format!(
9038        "{}/load-balancers/load-balancer-pools/",
9039        local_var_configuration.base_path
9040    );
9041    let mut local_var_req_builder =
9042        local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
9043
9044    if let Some(ref local_var_str) = contacts {
9045        local_var_req_builder = match "multi" {
9046            "multi" => local_var_req_builder.query(
9047                &local_var_str
9048                    .into_iter()
9049                    .map(|p| ("contacts".to_owned(), p.to_string()))
9050                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9051            ),
9052            _ => local_var_req_builder.query(&[(
9053                "contacts",
9054                &local_var_str
9055                    .into_iter()
9056                    .map(|p| p.to_string())
9057                    .collect::<Vec<String>>()
9058                    .join(",")
9059                    .to_string(),
9060            )]),
9061        };
9062    }
9063    if let Some(ref local_var_str) = contacts__isnull {
9064        local_var_req_builder =
9065            local_var_req_builder.query(&[("contacts__isnull", &local_var_str.to_string())]);
9066    }
9067    if let Some(ref local_var_str) = contacts__n {
9068        local_var_req_builder = match "multi" {
9069            "multi" => local_var_req_builder.query(
9070                &local_var_str
9071                    .into_iter()
9072                    .map(|p| ("contacts__n".to_owned(), p.to_string()))
9073                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9074            ),
9075            _ => local_var_req_builder.query(&[(
9076                "contacts__n",
9077                &local_var_str
9078                    .into_iter()
9079                    .map(|p| p.to_string())
9080                    .collect::<Vec<String>>()
9081                    .join(",")
9082                    .to_string(),
9083            )]),
9084        };
9085    }
9086    if let Some(ref local_var_str) = created {
9087        local_var_req_builder = match "multi" {
9088            "multi" => local_var_req_builder.query(
9089                &local_var_str
9090                    .into_iter()
9091                    .map(|p| ("created".to_owned(), p.to_string()))
9092                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9093            ),
9094            _ => local_var_req_builder.query(&[(
9095                "created",
9096                &local_var_str
9097                    .into_iter()
9098                    .map(|p| p.to_string())
9099                    .collect::<Vec<String>>()
9100                    .join(",")
9101                    .to_string(),
9102            )]),
9103        };
9104    }
9105    if let Some(ref local_var_str) = created__gt {
9106        local_var_req_builder = match "multi" {
9107            "multi" => local_var_req_builder.query(
9108                &local_var_str
9109                    .into_iter()
9110                    .map(|p| ("created__gt".to_owned(), p.to_string()))
9111                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9112            ),
9113            _ => local_var_req_builder.query(&[(
9114                "created__gt",
9115                &local_var_str
9116                    .into_iter()
9117                    .map(|p| p.to_string())
9118                    .collect::<Vec<String>>()
9119                    .join(",")
9120                    .to_string(),
9121            )]),
9122        };
9123    }
9124    if let Some(ref local_var_str) = created__gte {
9125        local_var_req_builder = match "multi" {
9126            "multi" => local_var_req_builder.query(
9127                &local_var_str
9128                    .into_iter()
9129                    .map(|p| ("created__gte".to_owned(), p.to_string()))
9130                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9131            ),
9132            _ => local_var_req_builder.query(&[(
9133                "created__gte",
9134                &local_var_str
9135                    .into_iter()
9136                    .map(|p| p.to_string())
9137                    .collect::<Vec<String>>()
9138                    .join(",")
9139                    .to_string(),
9140            )]),
9141        };
9142    }
9143    if let Some(ref local_var_str) = created__isnull {
9144        local_var_req_builder =
9145            local_var_req_builder.query(&[("created__isnull", &local_var_str.to_string())]);
9146    }
9147    if let Some(ref local_var_str) = created__lt {
9148        local_var_req_builder = match "multi" {
9149            "multi" => local_var_req_builder.query(
9150                &local_var_str
9151                    .into_iter()
9152                    .map(|p| ("created__lt".to_owned(), p.to_string()))
9153                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9154            ),
9155            _ => local_var_req_builder.query(&[(
9156                "created__lt",
9157                &local_var_str
9158                    .into_iter()
9159                    .map(|p| p.to_string())
9160                    .collect::<Vec<String>>()
9161                    .join(",")
9162                    .to_string(),
9163            )]),
9164        };
9165    }
9166    if let Some(ref local_var_str) = created__lte {
9167        local_var_req_builder = match "multi" {
9168            "multi" => local_var_req_builder.query(
9169                &local_var_str
9170                    .into_iter()
9171                    .map(|p| ("created__lte".to_owned(), p.to_string()))
9172                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9173            ),
9174            _ => local_var_req_builder.query(&[(
9175                "created__lte",
9176                &local_var_str
9177                    .into_iter()
9178                    .map(|p| p.to_string())
9179                    .collect::<Vec<String>>()
9180                    .join(",")
9181                    .to_string(),
9182            )]),
9183        };
9184    }
9185    if let Some(ref local_var_str) = created__n {
9186        local_var_req_builder = match "multi" {
9187            "multi" => local_var_req_builder.query(
9188                &local_var_str
9189                    .into_iter()
9190                    .map(|p| ("created__n".to_owned(), p.to_string()))
9191                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9192            ),
9193            _ => local_var_req_builder.query(&[(
9194                "created__n",
9195                &local_var_str
9196                    .into_iter()
9197                    .map(|p| p.to_string())
9198                    .collect::<Vec<String>>()
9199                    .join(",")
9200                    .to_string(),
9201            )]),
9202        };
9203    }
9204    if let Some(ref local_var_str) = dynamic_groups {
9205        local_var_req_builder = match "multi" {
9206            "multi" => local_var_req_builder.query(
9207                &local_var_str
9208                    .into_iter()
9209                    .map(|p| ("dynamic_groups".to_owned(), p.to_string()))
9210                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9211            ),
9212            _ => local_var_req_builder.query(&[(
9213                "dynamic_groups",
9214                &local_var_str
9215                    .into_iter()
9216                    .map(|p| p.to_string())
9217                    .collect::<Vec<String>>()
9218                    .join(",")
9219                    .to_string(),
9220            )]),
9221        };
9222    }
9223    if let Some(ref local_var_str) = dynamic_groups__n {
9224        local_var_req_builder = match "multi" {
9225            "multi" => local_var_req_builder.query(
9226                &local_var_str
9227                    .into_iter()
9228                    .map(|p| ("dynamic_groups__n".to_owned(), p.to_string()))
9229                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9230            ),
9231            _ => local_var_req_builder.query(&[(
9232                "dynamic_groups__n",
9233                &local_var_str
9234                    .into_iter()
9235                    .map(|p| p.to_string())
9236                    .collect::<Vec<String>>()
9237                    .join(",")
9238                    .to_string(),
9239            )]),
9240        };
9241    }
9242    if let Some(ref local_var_str) = format {
9243        local_var_req_builder =
9244            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
9245    }
9246    if let Some(ref local_var_str) = health_check_monitor {
9247        local_var_req_builder = match "multi" {
9248            "multi" => local_var_req_builder.query(
9249                &local_var_str
9250                    .into_iter()
9251                    .map(|p| ("health_check_monitor".to_owned(), p.to_string()))
9252                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9253            ),
9254            _ => local_var_req_builder.query(&[(
9255                "health_check_monitor",
9256                &local_var_str
9257                    .into_iter()
9258                    .map(|p| p.to_string())
9259                    .collect::<Vec<String>>()
9260                    .join(",")
9261                    .to_string(),
9262            )]),
9263        };
9264    }
9265    if let Some(ref local_var_str) = health_check_monitor__isnull {
9266        local_var_req_builder = local_var_req_builder
9267            .query(&[("health_check_monitor__isnull", &local_var_str.to_string())]);
9268    }
9269    if let Some(ref local_var_str) = health_check_monitor__n {
9270        local_var_req_builder = match "multi" {
9271            "multi" => local_var_req_builder.query(
9272                &local_var_str
9273                    .into_iter()
9274                    .map(|p| ("health_check_monitor__n".to_owned(), p.to_string()))
9275                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9276            ),
9277            _ => local_var_req_builder.query(&[(
9278                "health_check_monitor__n",
9279                &local_var_str
9280                    .into_iter()
9281                    .map(|p| p.to_string())
9282                    .collect::<Vec<String>>()
9283                    .join(",")
9284                    .to_string(),
9285            )]),
9286        };
9287    }
9288    if let Some(ref local_var_str) = id {
9289        local_var_req_builder = match "multi" {
9290            "multi" => local_var_req_builder.query(
9291                &local_var_str
9292                    .into_iter()
9293                    .map(|p| ("id".to_owned(), p.to_string()))
9294                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9295            ),
9296            _ => local_var_req_builder.query(&[(
9297                "id",
9298                &local_var_str
9299                    .into_iter()
9300                    .map(|p| p.to_string())
9301                    .collect::<Vec<String>>()
9302                    .join(",")
9303                    .to_string(),
9304            )]),
9305        };
9306    }
9307    if let Some(ref local_var_str) = id__n {
9308        local_var_req_builder = match "multi" {
9309            "multi" => local_var_req_builder.query(
9310                &local_var_str
9311                    .into_iter()
9312                    .map(|p| ("id__n".to_owned(), p.to_string()))
9313                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9314            ),
9315            _ => local_var_req_builder.query(&[(
9316                "id__n",
9317                &local_var_str
9318                    .into_iter()
9319                    .map(|p| p.to_string())
9320                    .collect::<Vec<String>>()
9321                    .join(",")
9322                    .to_string(),
9323            )]),
9324        };
9325    }
9326    if let Some(ref local_var_str) = last_updated {
9327        local_var_req_builder = match "multi" {
9328            "multi" => local_var_req_builder.query(
9329                &local_var_str
9330                    .into_iter()
9331                    .map(|p| ("last_updated".to_owned(), p.to_string()))
9332                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9333            ),
9334            _ => local_var_req_builder.query(&[(
9335                "last_updated",
9336                &local_var_str
9337                    .into_iter()
9338                    .map(|p| p.to_string())
9339                    .collect::<Vec<String>>()
9340                    .join(",")
9341                    .to_string(),
9342            )]),
9343        };
9344    }
9345    if let Some(ref local_var_str) = last_updated__gt {
9346        local_var_req_builder = match "multi" {
9347            "multi" => local_var_req_builder.query(
9348                &local_var_str
9349                    .into_iter()
9350                    .map(|p| ("last_updated__gt".to_owned(), p.to_string()))
9351                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9352            ),
9353            _ => local_var_req_builder.query(&[(
9354                "last_updated__gt",
9355                &local_var_str
9356                    .into_iter()
9357                    .map(|p| p.to_string())
9358                    .collect::<Vec<String>>()
9359                    .join(",")
9360                    .to_string(),
9361            )]),
9362        };
9363    }
9364    if let Some(ref local_var_str) = last_updated__gte {
9365        local_var_req_builder = match "multi" {
9366            "multi" => local_var_req_builder.query(
9367                &local_var_str
9368                    .into_iter()
9369                    .map(|p| ("last_updated__gte".to_owned(), p.to_string()))
9370                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9371            ),
9372            _ => local_var_req_builder.query(&[(
9373                "last_updated__gte",
9374                &local_var_str
9375                    .into_iter()
9376                    .map(|p| p.to_string())
9377                    .collect::<Vec<String>>()
9378                    .join(",")
9379                    .to_string(),
9380            )]),
9381        };
9382    }
9383    if let Some(ref local_var_str) = last_updated__isnull {
9384        local_var_req_builder =
9385            local_var_req_builder.query(&[("last_updated__isnull", &local_var_str.to_string())]);
9386    }
9387    if let Some(ref local_var_str) = last_updated__lt {
9388        local_var_req_builder = match "multi" {
9389            "multi" => local_var_req_builder.query(
9390                &local_var_str
9391                    .into_iter()
9392                    .map(|p| ("last_updated__lt".to_owned(), p.to_string()))
9393                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9394            ),
9395            _ => local_var_req_builder.query(&[(
9396                "last_updated__lt",
9397                &local_var_str
9398                    .into_iter()
9399                    .map(|p| p.to_string())
9400                    .collect::<Vec<String>>()
9401                    .join(",")
9402                    .to_string(),
9403            )]),
9404        };
9405    }
9406    if let Some(ref local_var_str) = last_updated__lte {
9407        local_var_req_builder = match "multi" {
9408            "multi" => local_var_req_builder.query(
9409                &local_var_str
9410                    .into_iter()
9411                    .map(|p| ("last_updated__lte".to_owned(), p.to_string()))
9412                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9413            ),
9414            _ => local_var_req_builder.query(&[(
9415                "last_updated__lte",
9416                &local_var_str
9417                    .into_iter()
9418                    .map(|p| p.to_string())
9419                    .collect::<Vec<String>>()
9420                    .join(",")
9421                    .to_string(),
9422            )]),
9423        };
9424    }
9425    if let Some(ref local_var_str) = last_updated__n {
9426        local_var_req_builder = match "multi" {
9427            "multi" => local_var_req_builder.query(
9428                &local_var_str
9429                    .into_iter()
9430                    .map(|p| ("last_updated__n".to_owned(), p.to_string()))
9431                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9432            ),
9433            _ => local_var_req_builder.query(&[(
9434                "last_updated__n",
9435                &local_var_str
9436                    .into_iter()
9437                    .map(|p| p.to_string())
9438                    .collect::<Vec<String>>()
9439                    .join(",")
9440                    .to_string(),
9441            )]),
9442        };
9443    }
9444    if let Some(ref local_var_str) = limit {
9445        local_var_req_builder =
9446            local_var_req_builder.query(&[("limit", &local_var_str.to_string())]);
9447    }
9448    if let Some(ref local_var_str) = load_balancing_algorithm {
9449        local_var_req_builder = match "multi" {
9450            "multi" => local_var_req_builder.query(
9451                &local_var_str
9452                    .into_iter()
9453                    .map(|p| ("load_balancing_algorithm".to_owned(), p.to_string()))
9454                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9455            ),
9456            _ => local_var_req_builder.query(&[(
9457                "load_balancing_algorithm",
9458                &local_var_str
9459                    .into_iter()
9460                    .map(|p| p.to_string())
9461                    .collect::<Vec<String>>()
9462                    .join(",")
9463                    .to_string(),
9464            )]),
9465        };
9466    }
9467    if let Some(ref local_var_str) = load_balancing_algorithm__ic {
9468        local_var_req_builder = match "multi" {
9469            "multi" => local_var_req_builder.query(
9470                &local_var_str
9471                    .into_iter()
9472                    .map(|p| ("load_balancing_algorithm__ic".to_owned(), p.to_string()))
9473                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9474            ),
9475            _ => local_var_req_builder.query(&[(
9476                "load_balancing_algorithm__ic",
9477                &local_var_str
9478                    .into_iter()
9479                    .map(|p| p.to_string())
9480                    .collect::<Vec<String>>()
9481                    .join(",")
9482                    .to_string(),
9483            )]),
9484        };
9485    }
9486    if let Some(ref local_var_str) = load_balancing_algorithm__ie {
9487        local_var_req_builder = match "multi" {
9488            "multi" => local_var_req_builder.query(
9489                &local_var_str
9490                    .into_iter()
9491                    .map(|p| ("load_balancing_algorithm__ie".to_owned(), p.to_string()))
9492                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9493            ),
9494            _ => local_var_req_builder.query(&[(
9495                "load_balancing_algorithm__ie",
9496                &local_var_str
9497                    .into_iter()
9498                    .map(|p| p.to_string())
9499                    .collect::<Vec<String>>()
9500                    .join(",")
9501                    .to_string(),
9502            )]),
9503        };
9504    }
9505    if let Some(ref local_var_str) = load_balancing_algorithm__iew {
9506        local_var_req_builder = match "multi" {
9507            "multi" => local_var_req_builder.query(
9508                &local_var_str
9509                    .into_iter()
9510                    .map(|p| ("load_balancing_algorithm__iew".to_owned(), p.to_string()))
9511                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9512            ),
9513            _ => local_var_req_builder.query(&[(
9514                "load_balancing_algorithm__iew",
9515                &local_var_str
9516                    .into_iter()
9517                    .map(|p| p.to_string())
9518                    .collect::<Vec<String>>()
9519                    .join(",")
9520                    .to_string(),
9521            )]),
9522        };
9523    }
9524    if let Some(ref local_var_str) = load_balancing_algorithm__ire {
9525        local_var_req_builder = match "multi" {
9526            "multi" => local_var_req_builder.query(
9527                &local_var_str
9528                    .into_iter()
9529                    .map(|p| ("load_balancing_algorithm__ire".to_owned(), p.to_string()))
9530                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9531            ),
9532            _ => local_var_req_builder.query(&[(
9533                "load_balancing_algorithm__ire",
9534                &local_var_str
9535                    .into_iter()
9536                    .map(|p| p.to_string())
9537                    .collect::<Vec<String>>()
9538                    .join(",")
9539                    .to_string(),
9540            )]),
9541        };
9542    }
9543    if let Some(ref local_var_str) = load_balancing_algorithm__isw {
9544        local_var_req_builder = match "multi" {
9545            "multi" => local_var_req_builder.query(
9546                &local_var_str
9547                    .into_iter()
9548                    .map(|p| ("load_balancing_algorithm__isw".to_owned(), p.to_string()))
9549                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9550            ),
9551            _ => local_var_req_builder.query(&[(
9552                "load_balancing_algorithm__isw",
9553                &local_var_str
9554                    .into_iter()
9555                    .map(|p| p.to_string())
9556                    .collect::<Vec<String>>()
9557                    .join(",")
9558                    .to_string(),
9559            )]),
9560        };
9561    }
9562    if let Some(ref local_var_str) = load_balancing_algorithm__n {
9563        local_var_req_builder = match "multi" {
9564            "multi" => local_var_req_builder.query(
9565                &local_var_str
9566                    .into_iter()
9567                    .map(|p| ("load_balancing_algorithm__n".to_owned(), p.to_string()))
9568                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9569            ),
9570            _ => local_var_req_builder.query(&[(
9571                "load_balancing_algorithm__n",
9572                &local_var_str
9573                    .into_iter()
9574                    .map(|p| p.to_string())
9575                    .collect::<Vec<String>>()
9576                    .join(",")
9577                    .to_string(),
9578            )]),
9579        };
9580    }
9581    if let Some(ref local_var_str) = load_balancing_algorithm__nic {
9582        local_var_req_builder = match "multi" {
9583            "multi" => local_var_req_builder.query(
9584                &local_var_str
9585                    .into_iter()
9586                    .map(|p| ("load_balancing_algorithm__nic".to_owned(), p.to_string()))
9587                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9588            ),
9589            _ => local_var_req_builder.query(&[(
9590                "load_balancing_algorithm__nic",
9591                &local_var_str
9592                    .into_iter()
9593                    .map(|p| p.to_string())
9594                    .collect::<Vec<String>>()
9595                    .join(",")
9596                    .to_string(),
9597            )]),
9598        };
9599    }
9600    if let Some(ref local_var_str) = load_balancing_algorithm__nie {
9601        local_var_req_builder = match "multi" {
9602            "multi" => local_var_req_builder.query(
9603                &local_var_str
9604                    .into_iter()
9605                    .map(|p| ("load_balancing_algorithm__nie".to_owned(), p.to_string()))
9606                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9607            ),
9608            _ => local_var_req_builder.query(&[(
9609                "load_balancing_algorithm__nie",
9610                &local_var_str
9611                    .into_iter()
9612                    .map(|p| p.to_string())
9613                    .collect::<Vec<String>>()
9614                    .join(",")
9615                    .to_string(),
9616            )]),
9617        };
9618    }
9619    if let Some(ref local_var_str) = load_balancing_algorithm__niew {
9620        local_var_req_builder = match "multi" {
9621            "multi" => local_var_req_builder.query(
9622                &local_var_str
9623                    .into_iter()
9624                    .map(|p| ("load_balancing_algorithm__niew".to_owned(), p.to_string()))
9625                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9626            ),
9627            _ => local_var_req_builder.query(&[(
9628                "load_balancing_algorithm__niew",
9629                &local_var_str
9630                    .into_iter()
9631                    .map(|p| p.to_string())
9632                    .collect::<Vec<String>>()
9633                    .join(",")
9634                    .to_string(),
9635            )]),
9636        };
9637    }
9638    if let Some(ref local_var_str) = load_balancing_algorithm__nire {
9639        local_var_req_builder = match "multi" {
9640            "multi" => local_var_req_builder.query(
9641                &local_var_str
9642                    .into_iter()
9643                    .map(|p| ("load_balancing_algorithm__nire".to_owned(), p.to_string()))
9644                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9645            ),
9646            _ => local_var_req_builder.query(&[(
9647                "load_balancing_algorithm__nire",
9648                &local_var_str
9649                    .into_iter()
9650                    .map(|p| p.to_string())
9651                    .collect::<Vec<String>>()
9652                    .join(",")
9653                    .to_string(),
9654            )]),
9655        };
9656    }
9657    if let Some(ref local_var_str) = load_balancing_algorithm__nisw {
9658        local_var_req_builder = match "multi" {
9659            "multi" => local_var_req_builder.query(
9660                &local_var_str
9661                    .into_iter()
9662                    .map(|p| ("load_balancing_algorithm__nisw".to_owned(), p.to_string()))
9663                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9664            ),
9665            _ => local_var_req_builder.query(&[(
9666                "load_balancing_algorithm__nisw",
9667                &local_var_str
9668                    .into_iter()
9669                    .map(|p| p.to_string())
9670                    .collect::<Vec<String>>()
9671                    .join(",")
9672                    .to_string(),
9673            )]),
9674        };
9675    }
9676    if let Some(ref local_var_str) = load_balancing_algorithm__nre {
9677        local_var_req_builder = match "multi" {
9678            "multi" => local_var_req_builder.query(
9679                &local_var_str
9680                    .into_iter()
9681                    .map(|p| ("load_balancing_algorithm__nre".to_owned(), p.to_string()))
9682                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9683            ),
9684            _ => local_var_req_builder.query(&[(
9685                "load_balancing_algorithm__nre",
9686                &local_var_str
9687                    .into_iter()
9688                    .map(|p| p.to_string())
9689                    .collect::<Vec<String>>()
9690                    .join(",")
9691                    .to_string(),
9692            )]),
9693        };
9694    }
9695    if let Some(ref local_var_str) = load_balancing_algorithm__re {
9696        local_var_req_builder = match "multi" {
9697            "multi" => local_var_req_builder.query(
9698                &local_var_str
9699                    .into_iter()
9700                    .map(|p| ("load_balancing_algorithm__re".to_owned(), p.to_string()))
9701                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9702            ),
9703            _ => local_var_req_builder.query(&[(
9704                "load_balancing_algorithm__re",
9705                &local_var_str
9706                    .into_iter()
9707                    .map(|p| p.to_string())
9708                    .collect::<Vec<String>>()
9709                    .join(",")
9710                    .to_string(),
9711            )]),
9712        };
9713    }
9714    if let Some(ref local_var_str) = name {
9715        local_var_req_builder = match "multi" {
9716            "multi" => local_var_req_builder.query(
9717                &local_var_str
9718                    .into_iter()
9719                    .map(|p| ("name".to_owned(), p.to_string()))
9720                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9721            ),
9722            _ => local_var_req_builder.query(&[(
9723                "name",
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) = name__ic {
9734        local_var_req_builder = match "multi" {
9735            "multi" => local_var_req_builder.query(
9736                &local_var_str
9737                    .into_iter()
9738                    .map(|p| ("name__ic".to_owned(), p.to_string()))
9739                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9740            ),
9741            _ => local_var_req_builder.query(&[(
9742                "name__ic",
9743                &local_var_str
9744                    .into_iter()
9745                    .map(|p| p.to_string())
9746                    .collect::<Vec<String>>()
9747                    .join(",")
9748                    .to_string(),
9749            )]),
9750        };
9751    }
9752    if let Some(ref local_var_str) = name__ie {
9753        local_var_req_builder = match "multi" {
9754            "multi" => local_var_req_builder.query(
9755                &local_var_str
9756                    .into_iter()
9757                    .map(|p| ("name__ie".to_owned(), p.to_string()))
9758                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9759            ),
9760            _ => local_var_req_builder.query(&[(
9761                "name__ie",
9762                &local_var_str
9763                    .into_iter()
9764                    .map(|p| p.to_string())
9765                    .collect::<Vec<String>>()
9766                    .join(",")
9767                    .to_string(),
9768            )]),
9769        };
9770    }
9771    if let Some(ref local_var_str) = name__iew {
9772        local_var_req_builder = match "multi" {
9773            "multi" => local_var_req_builder.query(
9774                &local_var_str
9775                    .into_iter()
9776                    .map(|p| ("name__iew".to_owned(), p.to_string()))
9777                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9778            ),
9779            _ => local_var_req_builder.query(&[(
9780                "name__iew",
9781                &local_var_str
9782                    .into_iter()
9783                    .map(|p| p.to_string())
9784                    .collect::<Vec<String>>()
9785                    .join(",")
9786                    .to_string(),
9787            )]),
9788        };
9789    }
9790    if let Some(ref local_var_str) = name__ire {
9791        local_var_req_builder = match "multi" {
9792            "multi" => local_var_req_builder.query(
9793                &local_var_str
9794                    .into_iter()
9795                    .map(|p| ("name__ire".to_owned(), p.to_string()))
9796                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9797            ),
9798            _ => local_var_req_builder.query(&[(
9799                "name__ire",
9800                &local_var_str
9801                    .into_iter()
9802                    .map(|p| p.to_string())
9803                    .collect::<Vec<String>>()
9804                    .join(",")
9805                    .to_string(),
9806            )]),
9807        };
9808    }
9809    if let Some(ref local_var_str) = name__isw {
9810        local_var_req_builder = match "multi" {
9811            "multi" => local_var_req_builder.query(
9812                &local_var_str
9813                    .into_iter()
9814                    .map(|p| ("name__isw".to_owned(), p.to_string()))
9815                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9816            ),
9817            _ => local_var_req_builder.query(&[(
9818                "name__isw",
9819                &local_var_str
9820                    .into_iter()
9821                    .map(|p| p.to_string())
9822                    .collect::<Vec<String>>()
9823                    .join(",")
9824                    .to_string(),
9825            )]),
9826        };
9827    }
9828    if let Some(ref local_var_str) = name__n {
9829        local_var_req_builder = match "multi" {
9830            "multi" => local_var_req_builder.query(
9831                &local_var_str
9832                    .into_iter()
9833                    .map(|p| ("name__n".to_owned(), p.to_string()))
9834                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9835            ),
9836            _ => local_var_req_builder.query(&[(
9837                "name__n",
9838                &local_var_str
9839                    .into_iter()
9840                    .map(|p| p.to_string())
9841                    .collect::<Vec<String>>()
9842                    .join(",")
9843                    .to_string(),
9844            )]),
9845        };
9846    }
9847    if let Some(ref local_var_str) = name__nic {
9848        local_var_req_builder = match "multi" {
9849            "multi" => local_var_req_builder.query(
9850                &local_var_str
9851                    .into_iter()
9852                    .map(|p| ("name__nic".to_owned(), p.to_string()))
9853                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9854            ),
9855            _ => local_var_req_builder.query(&[(
9856                "name__nic",
9857                &local_var_str
9858                    .into_iter()
9859                    .map(|p| p.to_string())
9860                    .collect::<Vec<String>>()
9861                    .join(",")
9862                    .to_string(),
9863            )]),
9864        };
9865    }
9866    if let Some(ref local_var_str) = name__nie {
9867        local_var_req_builder = match "multi" {
9868            "multi" => local_var_req_builder.query(
9869                &local_var_str
9870                    .into_iter()
9871                    .map(|p| ("name__nie".to_owned(), p.to_string()))
9872                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9873            ),
9874            _ => local_var_req_builder.query(&[(
9875                "name__nie",
9876                &local_var_str
9877                    .into_iter()
9878                    .map(|p| p.to_string())
9879                    .collect::<Vec<String>>()
9880                    .join(",")
9881                    .to_string(),
9882            )]),
9883        };
9884    }
9885    if let Some(ref local_var_str) = name__niew {
9886        local_var_req_builder = match "multi" {
9887            "multi" => local_var_req_builder.query(
9888                &local_var_str
9889                    .into_iter()
9890                    .map(|p| ("name__niew".to_owned(), p.to_string()))
9891                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9892            ),
9893            _ => local_var_req_builder.query(&[(
9894                "name__niew",
9895                &local_var_str
9896                    .into_iter()
9897                    .map(|p| p.to_string())
9898                    .collect::<Vec<String>>()
9899                    .join(",")
9900                    .to_string(),
9901            )]),
9902        };
9903    }
9904    if let Some(ref local_var_str) = name__nire {
9905        local_var_req_builder = match "multi" {
9906            "multi" => local_var_req_builder.query(
9907                &local_var_str
9908                    .into_iter()
9909                    .map(|p| ("name__nire".to_owned(), p.to_string()))
9910                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9911            ),
9912            _ => local_var_req_builder.query(&[(
9913                "name__nire",
9914                &local_var_str
9915                    .into_iter()
9916                    .map(|p| p.to_string())
9917                    .collect::<Vec<String>>()
9918                    .join(",")
9919                    .to_string(),
9920            )]),
9921        };
9922    }
9923    if let Some(ref local_var_str) = name__nisw {
9924        local_var_req_builder = match "multi" {
9925            "multi" => local_var_req_builder.query(
9926                &local_var_str
9927                    .into_iter()
9928                    .map(|p| ("name__nisw".to_owned(), p.to_string()))
9929                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9930            ),
9931            _ => local_var_req_builder.query(&[(
9932                "name__nisw",
9933                &local_var_str
9934                    .into_iter()
9935                    .map(|p| p.to_string())
9936                    .collect::<Vec<String>>()
9937                    .join(",")
9938                    .to_string(),
9939            )]),
9940        };
9941    }
9942    if let Some(ref local_var_str) = name__nre {
9943        local_var_req_builder = match "multi" {
9944            "multi" => local_var_req_builder.query(
9945                &local_var_str
9946                    .into_iter()
9947                    .map(|p| ("name__nre".to_owned(), p.to_string()))
9948                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9949            ),
9950            _ => local_var_req_builder.query(&[(
9951                "name__nre",
9952                &local_var_str
9953                    .into_iter()
9954                    .map(|p| p.to_string())
9955                    .collect::<Vec<String>>()
9956                    .join(",")
9957                    .to_string(),
9958            )]),
9959        };
9960    }
9961    if let Some(ref local_var_str) = name__re {
9962        local_var_req_builder = match "multi" {
9963            "multi" => local_var_req_builder.query(
9964                &local_var_str
9965                    .into_iter()
9966                    .map(|p| ("name__re".to_owned(), p.to_string()))
9967                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9968            ),
9969            _ => local_var_req_builder.query(&[(
9970                "name__re",
9971                &local_var_str
9972                    .into_iter()
9973                    .map(|p| p.to_string())
9974                    .collect::<Vec<String>>()
9975                    .join(",")
9976                    .to_string(),
9977            )]),
9978        };
9979    }
9980    if let Some(ref local_var_str) = offset {
9981        local_var_req_builder =
9982            local_var_req_builder.query(&[("offset", &local_var_str.to_string())]);
9983    }
9984    if let Some(ref local_var_str) = q {
9985        local_var_req_builder = local_var_req_builder.query(&[("q", &local_var_str.to_string())]);
9986    }
9987    if let Some(ref local_var_str) = sort {
9988        local_var_req_builder =
9989            local_var_req_builder.query(&[("sort", &local_var_str.to_string())]);
9990    }
9991    if let Some(ref local_var_str) = tags {
9992        local_var_req_builder = match "multi" {
9993            "multi" => local_var_req_builder.query(
9994                &local_var_str
9995                    .into_iter()
9996                    .map(|p| ("tags".to_owned(), p.to_string()))
9997                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9998            ),
9999            _ => local_var_req_builder.query(&[(
10000                "tags",
10001                &local_var_str
10002                    .into_iter()
10003                    .map(|p| p.to_string())
10004                    .collect::<Vec<String>>()
10005                    .join(",")
10006                    .to_string(),
10007            )]),
10008        };
10009    }
10010    if let Some(ref local_var_str) = tags__isnull {
10011        local_var_req_builder =
10012            local_var_req_builder.query(&[("tags__isnull", &local_var_str.to_string())]);
10013    }
10014    if let Some(ref local_var_str) = tags__n {
10015        local_var_req_builder = match "multi" {
10016            "multi" => local_var_req_builder.query(
10017                &local_var_str
10018                    .into_iter()
10019                    .map(|p| ("tags__n".to_owned(), p.to_string()))
10020                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10021            ),
10022            _ => local_var_req_builder.query(&[(
10023                "tags__n",
10024                &local_var_str
10025                    .into_iter()
10026                    .map(|p| p.to_string())
10027                    .collect::<Vec<String>>()
10028                    .join(",")
10029                    .to_string(),
10030            )]),
10031        };
10032    }
10033    if let Some(ref local_var_str) = teams {
10034        local_var_req_builder = match "multi" {
10035            "multi" => local_var_req_builder.query(
10036                &local_var_str
10037                    .into_iter()
10038                    .map(|p| ("teams".to_owned(), p.to_string()))
10039                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10040            ),
10041            _ => local_var_req_builder.query(&[(
10042                "teams",
10043                &local_var_str
10044                    .into_iter()
10045                    .map(|p| p.to_string())
10046                    .collect::<Vec<String>>()
10047                    .join(",")
10048                    .to_string(),
10049            )]),
10050        };
10051    }
10052    if let Some(ref local_var_str) = teams__isnull {
10053        local_var_req_builder =
10054            local_var_req_builder.query(&[("teams__isnull", &local_var_str.to_string())]);
10055    }
10056    if let Some(ref local_var_str) = teams__n {
10057        local_var_req_builder = match "multi" {
10058            "multi" => local_var_req_builder.query(
10059                &local_var_str
10060                    .into_iter()
10061                    .map(|p| ("teams__n".to_owned(), p.to_string()))
10062                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10063            ),
10064            _ => local_var_req_builder.query(&[(
10065                "teams__n",
10066                &local_var_str
10067                    .into_iter()
10068                    .map(|p| p.to_string())
10069                    .collect::<Vec<String>>()
10070                    .join(",")
10071                    .to_string(),
10072            )]),
10073        };
10074    }
10075    if let Some(ref local_var_str) = tenant {
10076        local_var_req_builder = match "multi" {
10077            "multi" => local_var_req_builder.query(
10078                &local_var_str
10079                    .into_iter()
10080                    .map(|p| ("tenant".to_owned(), p.to_string()))
10081                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10082            ),
10083            _ => local_var_req_builder.query(&[(
10084                "tenant",
10085                &local_var_str
10086                    .into_iter()
10087                    .map(|p| p.to_string())
10088                    .collect::<Vec<String>>()
10089                    .join(",")
10090                    .to_string(),
10091            )]),
10092        };
10093    }
10094    if let Some(ref local_var_str) = tenant__isnull {
10095        local_var_req_builder =
10096            local_var_req_builder.query(&[("tenant__isnull", &local_var_str.to_string())]);
10097    }
10098    if let Some(ref local_var_str) = tenant__n {
10099        local_var_req_builder = match "multi" {
10100            "multi" => local_var_req_builder.query(
10101                &local_var_str
10102                    .into_iter()
10103                    .map(|p| ("tenant__n".to_owned(), p.to_string()))
10104                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10105            ),
10106            _ => local_var_req_builder.query(&[(
10107                "tenant__n",
10108                &local_var_str
10109                    .into_iter()
10110                    .map(|p| p.to_string())
10111                    .collect::<Vec<String>>()
10112                    .join(",")
10113                    .to_string(),
10114            )]),
10115        };
10116    }
10117    if let Some(ref local_var_str) = tenant_group {
10118        local_var_req_builder = match "multi" {
10119            "multi" => local_var_req_builder.query(
10120                &local_var_str
10121                    .into_iter()
10122                    .map(|p| ("tenant_group".to_owned(), p.to_string()))
10123                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10124            ),
10125            _ => local_var_req_builder.query(&[(
10126                "tenant_group",
10127                &local_var_str
10128                    .into_iter()
10129                    .map(|p| p.to_string())
10130                    .collect::<Vec<String>>()
10131                    .join(",")
10132                    .to_string(),
10133            )]),
10134        };
10135    }
10136    if let Some(ref local_var_str) = tenant_group__isnull {
10137        local_var_req_builder =
10138            local_var_req_builder.query(&[("tenant_group__isnull", &local_var_str.to_string())]);
10139    }
10140    if let Some(ref local_var_str) = tenant_group__n {
10141        local_var_req_builder = match "multi" {
10142            "multi" => local_var_req_builder.query(
10143                &local_var_str
10144                    .into_iter()
10145                    .map(|p| ("tenant_group__n".to_owned(), p.to_string()))
10146                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10147            ),
10148            _ => local_var_req_builder.query(&[(
10149                "tenant_group__n",
10150                &local_var_str
10151                    .into_iter()
10152                    .map(|p| p.to_string())
10153                    .collect::<Vec<String>>()
10154                    .join(",")
10155                    .to_string(),
10156            )]),
10157        };
10158    }
10159    if let Some(ref local_var_str) = tenant_id {
10160        local_var_req_builder = match "multi" {
10161            "multi" => local_var_req_builder.query(
10162                &local_var_str
10163                    .into_iter()
10164                    .map(|p| ("tenant_id".to_owned(), p.to_string()))
10165                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10166            ),
10167            _ => local_var_req_builder.query(&[(
10168                "tenant_id",
10169                &local_var_str
10170                    .into_iter()
10171                    .map(|p| p.to_string())
10172                    .collect::<Vec<String>>()
10173                    .join(",")
10174                    .to_string(),
10175            )]),
10176        };
10177    }
10178    if let Some(ref local_var_str) = tenant_id__isnull {
10179        local_var_req_builder =
10180            local_var_req_builder.query(&[("tenant_id__isnull", &local_var_str.to_string())]);
10181    }
10182    if let Some(ref local_var_str) = tenant_id__n {
10183        local_var_req_builder = match "multi" {
10184            "multi" => local_var_req_builder.query(
10185                &local_var_str
10186                    .into_iter()
10187                    .map(|p| ("tenant_id__n".to_owned(), p.to_string()))
10188                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10189            ),
10190            _ => local_var_req_builder.query(&[(
10191                "tenant_id__n",
10192                &local_var_str
10193                    .into_iter()
10194                    .map(|p| p.to_string())
10195                    .collect::<Vec<String>>()
10196                    .join(",")
10197                    .to_string(),
10198            )]),
10199        };
10200    }
10201    if let Some(ref local_var_str) = depth {
10202        local_var_req_builder =
10203            local_var_req_builder.query(&[("depth", &local_var_str.to_string())]);
10204    }
10205    if let Some(ref local_var_str) = exclude_m2m {
10206        local_var_req_builder =
10207            local_var_req_builder.query(&[("exclude_m2m", &local_var_str.to_string())]);
10208    }
10209    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
10210        local_var_req_builder =
10211            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
10212    }
10213    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
10214        let local_var_key = local_var_apikey.key.clone();
10215        let local_var_value = match local_var_apikey.prefix {
10216            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
10217            None => local_var_key,
10218        };
10219        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
10220    };
10221
10222    let local_var_req = local_var_req_builder.build()?;
10223    let local_var_resp = local_var_client.execute(local_var_req).await?;
10224
10225    let local_var_status = local_var_resp.status();
10226    let local_var_content = local_var_resp.text().await?;
10227
10228    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
10229        serde_json::from_str(&local_var_content).map_err(Error::from)
10230    } else {
10231        let local_var_entity: Option<LoadBalancersLoadBalancerPoolsListError> =
10232            serde_json::from_str(&local_var_content).ok();
10233        let local_var_error = ResponseContent {
10234            status: local_var_status,
10235            content: local_var_content,
10236            entity: local_var_entity,
10237        };
10238        Err(Error::ResponseError(local_var_error))
10239    }
10240}
10241
10242/// API methods for returning or creating notes on an object.
10243pub async fn load_balancers_load_balancer_pools_notes_create(
10244    configuration: &configuration::Configuration,
10245    id: &str,
10246    note_input_request: crate::models::NoteInputRequest,
10247    format: Option<&str>,
10248) -> Result<crate::models::Note, Error<LoadBalancersLoadBalancerPoolsNotesCreateError>> {
10249    let local_var_configuration = configuration;
10250
10251    let local_var_client = &local_var_configuration.client;
10252
10253    let local_var_uri_str = format!(
10254        "{}/load-balancers/load-balancer-pools/{id}/notes/",
10255        local_var_configuration.base_path,
10256        id = crate::apis::urlencode(id)
10257    );
10258    let mut local_var_req_builder =
10259        local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
10260
10261    if let Some(ref local_var_str) = format {
10262        local_var_req_builder =
10263            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
10264    }
10265    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
10266        local_var_req_builder =
10267            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
10268    }
10269    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
10270        let local_var_key = local_var_apikey.key.clone();
10271        let local_var_value = match local_var_apikey.prefix {
10272            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
10273            None => local_var_key,
10274        };
10275        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
10276    };
10277    local_var_req_builder = local_var_req_builder.json(&note_input_request);
10278
10279    let local_var_req = local_var_req_builder.build()?;
10280    let local_var_resp = local_var_client.execute(local_var_req).await?;
10281
10282    let local_var_status = local_var_resp.status();
10283    let local_var_content = local_var_resp.text().await?;
10284
10285    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
10286        serde_json::from_str(&local_var_content).map_err(Error::from)
10287    } else {
10288        let local_var_entity: Option<LoadBalancersLoadBalancerPoolsNotesCreateError> =
10289            serde_json::from_str(&local_var_content).ok();
10290        let local_var_error = ResponseContent {
10291            status: local_var_status,
10292            content: local_var_content,
10293            entity: local_var_entity,
10294        };
10295        Err(Error::ResponseError(local_var_error))
10296    }
10297}
10298
10299/// API methods for returning or creating notes on an object.
10300pub async fn load_balancers_load_balancer_pools_notes_list(
10301    configuration: &configuration::Configuration,
10302    id: &str,
10303    format: Option<&str>,
10304    limit: Option<i32>,
10305    offset: Option<i32>,
10306    depth: Option<i32>,
10307    exclude_m2m: Option<bool>,
10308) -> Result<crate::models::PaginatedNoteList, Error<LoadBalancersLoadBalancerPoolsNotesListError>> {
10309    let local_var_configuration = configuration;
10310
10311    let local_var_client = &local_var_configuration.client;
10312
10313    let local_var_uri_str = format!(
10314        "{}/load-balancers/load-balancer-pools/{id}/notes/",
10315        local_var_configuration.base_path,
10316        id = crate::apis::urlencode(id)
10317    );
10318    let mut local_var_req_builder =
10319        local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
10320
10321    if let Some(ref local_var_str) = format {
10322        local_var_req_builder =
10323            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
10324    }
10325    if let Some(ref local_var_str) = limit {
10326        local_var_req_builder =
10327            local_var_req_builder.query(&[("limit", &local_var_str.to_string())]);
10328    }
10329    if let Some(ref local_var_str) = offset {
10330        local_var_req_builder =
10331            local_var_req_builder.query(&[("offset", &local_var_str.to_string())]);
10332    }
10333    if let Some(ref local_var_str) = depth {
10334        local_var_req_builder =
10335            local_var_req_builder.query(&[("depth", &local_var_str.to_string())]);
10336    }
10337    if let Some(ref local_var_str) = exclude_m2m {
10338        local_var_req_builder =
10339            local_var_req_builder.query(&[("exclude_m2m", &local_var_str.to_string())]);
10340    }
10341    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
10342        local_var_req_builder =
10343            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
10344    }
10345    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
10346        let local_var_key = local_var_apikey.key.clone();
10347        let local_var_value = match local_var_apikey.prefix {
10348            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
10349            None => local_var_key,
10350        };
10351        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
10352    };
10353
10354    let local_var_req = local_var_req_builder.build()?;
10355    let local_var_resp = local_var_client.execute(local_var_req).await?;
10356
10357    let local_var_status = local_var_resp.status();
10358    let local_var_content = local_var_resp.text().await?;
10359
10360    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
10361        serde_json::from_str(&local_var_content).map_err(Error::from)
10362    } else {
10363        let local_var_entity: Option<LoadBalancersLoadBalancerPoolsNotesListError> =
10364            serde_json::from_str(&local_var_content).ok();
10365        let local_var_error = ResponseContent {
10366            status: local_var_status,
10367            content: local_var_content,
10368            entity: local_var_entity,
10369        };
10370        Err(Error::ResponseError(local_var_error))
10371    }
10372}
10373
10374/// LoadBalancerPool viewset.
10375pub async fn load_balancers_load_balancer_pools_partial_update(
10376    configuration: &configuration::Configuration,
10377    id: &str,
10378    format: Option<&str>,
10379    patched_load_balancer_pool_request: Option<crate::models::PatchedLoadBalancerPoolRequest>,
10380) -> Result<crate::models::LoadBalancerPool, Error<LoadBalancersLoadBalancerPoolsPartialUpdateError>>
10381{
10382    let local_var_configuration = configuration;
10383
10384    let local_var_client = &local_var_configuration.client;
10385
10386    let local_var_uri_str = format!(
10387        "{}/load-balancers/load-balancer-pools/{id}/",
10388        local_var_configuration.base_path,
10389        id = crate::apis::urlencode(id)
10390    );
10391    let mut local_var_req_builder =
10392        local_var_client.request(reqwest::Method::PATCH, local_var_uri_str.as_str());
10393
10394    if let Some(ref local_var_str) = format {
10395        local_var_req_builder =
10396            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
10397    }
10398    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
10399        local_var_req_builder =
10400            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
10401    }
10402    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
10403        let local_var_key = local_var_apikey.key.clone();
10404        let local_var_value = match local_var_apikey.prefix {
10405            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
10406            None => local_var_key,
10407        };
10408        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
10409    };
10410    local_var_req_builder = local_var_req_builder.json(&patched_load_balancer_pool_request);
10411
10412    let local_var_req = local_var_req_builder.build()?;
10413    let local_var_resp = local_var_client.execute(local_var_req).await?;
10414
10415    let local_var_status = local_var_resp.status();
10416    let local_var_content = local_var_resp.text().await?;
10417
10418    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
10419        serde_json::from_str(&local_var_content).map_err(Error::from)
10420    } else {
10421        let local_var_entity: Option<LoadBalancersLoadBalancerPoolsPartialUpdateError> =
10422            serde_json::from_str(&local_var_content).ok();
10423        let local_var_error = ResponseContent {
10424            status: local_var_status,
10425            content: local_var_content,
10426            entity: local_var_entity,
10427        };
10428        Err(Error::ResponseError(local_var_error))
10429    }
10430}
10431
10432/// LoadBalancerPool viewset.
10433pub async fn load_balancers_load_balancer_pools_retrieve(
10434    configuration: &configuration::Configuration,
10435    id: &str,
10436    format: Option<&str>,
10437    depth: Option<i32>,
10438    exclude_m2m: Option<bool>,
10439) -> Result<crate::models::LoadBalancerPool, Error<LoadBalancersLoadBalancerPoolsRetrieveError>> {
10440    let local_var_configuration = configuration;
10441
10442    let local_var_client = &local_var_configuration.client;
10443
10444    let local_var_uri_str = format!(
10445        "{}/load-balancers/load-balancer-pools/{id}/",
10446        local_var_configuration.base_path,
10447        id = crate::apis::urlencode(id)
10448    );
10449    let mut local_var_req_builder =
10450        local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
10451
10452    if let Some(ref local_var_str) = format {
10453        local_var_req_builder =
10454            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
10455    }
10456    if let Some(ref local_var_str) = depth {
10457        local_var_req_builder =
10458            local_var_req_builder.query(&[("depth", &local_var_str.to_string())]);
10459    }
10460    if let Some(ref local_var_str) = exclude_m2m {
10461        local_var_req_builder =
10462            local_var_req_builder.query(&[("exclude_m2m", &local_var_str.to_string())]);
10463    }
10464    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
10465        local_var_req_builder =
10466            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
10467    }
10468    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
10469        let local_var_key = local_var_apikey.key.clone();
10470        let local_var_value = match local_var_apikey.prefix {
10471            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
10472            None => local_var_key,
10473        };
10474        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
10475    };
10476
10477    let local_var_req = local_var_req_builder.build()?;
10478    let local_var_resp = local_var_client.execute(local_var_req).await?;
10479
10480    let local_var_status = local_var_resp.status();
10481    let local_var_content = local_var_resp.text().await?;
10482
10483    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
10484        serde_json::from_str(&local_var_content).map_err(Error::from)
10485    } else {
10486        let local_var_entity: Option<LoadBalancersLoadBalancerPoolsRetrieveError> =
10487            serde_json::from_str(&local_var_content).ok();
10488        let local_var_error = ResponseContent {
10489            status: local_var_status,
10490            content: local_var_content,
10491            entity: local_var_entity,
10492        };
10493        Err(Error::ResponseError(local_var_error))
10494    }
10495}
10496
10497/// LoadBalancerPool viewset.
10498pub async fn load_balancers_load_balancer_pools_update(
10499    configuration: &configuration::Configuration,
10500    id: &str,
10501    load_balancer_pool_request: crate::models::LoadBalancerPoolRequest,
10502    format: Option<&str>,
10503) -> Result<crate::models::LoadBalancerPool, Error<LoadBalancersLoadBalancerPoolsUpdateError>> {
10504    let local_var_configuration = configuration;
10505
10506    let local_var_client = &local_var_configuration.client;
10507
10508    let local_var_uri_str = format!(
10509        "{}/load-balancers/load-balancer-pools/{id}/",
10510        local_var_configuration.base_path,
10511        id = crate::apis::urlencode(id)
10512    );
10513    let mut local_var_req_builder =
10514        local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());
10515
10516    if let Some(ref local_var_str) = format {
10517        local_var_req_builder =
10518            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
10519    }
10520    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
10521        local_var_req_builder =
10522            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
10523    }
10524    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
10525        let local_var_key = local_var_apikey.key.clone();
10526        let local_var_value = match local_var_apikey.prefix {
10527            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
10528            None => local_var_key,
10529        };
10530        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
10531    };
10532    local_var_req_builder = local_var_req_builder.json(&load_balancer_pool_request);
10533
10534    let local_var_req = local_var_req_builder.build()?;
10535    let local_var_resp = local_var_client.execute(local_var_req).await?;
10536
10537    let local_var_status = local_var_resp.status();
10538    let local_var_content = local_var_resp.text().await?;
10539
10540    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
10541        serde_json::from_str(&local_var_content).map_err(Error::from)
10542    } else {
10543        let local_var_entity: Option<LoadBalancersLoadBalancerPoolsUpdateError> =
10544            serde_json::from_str(&local_var_content).ok();
10545        let local_var_error = ResponseContent {
10546            status: local_var_status,
10547            content: local_var_content,
10548            entity: local_var_entity,
10549        };
10550        Err(Error::ResponseError(local_var_error))
10551    }
10552}
10553
10554/// VirtualServerCertificateProfileAssignment viewset.
10555pub async fn load_balancers_virtual_server_certificate_profile_assignments_bulk_destroy(
10556    configuration: &configuration::Configuration,
10557    bulk_operation_request: Vec<crate::models::BulkOperationRequest>,
10558    format: Option<&str>,
10559) -> Result<(), Error<LoadBalancersVirtualServerCertificateProfileAssignmentsBulkDestroyError>> {
10560    let local_var_configuration = configuration;
10561
10562    let local_var_client = &local_var_configuration.client;
10563
10564    let local_var_uri_str = format!(
10565        "{}/load-balancers/virtual-server-certificate-profile-assignments/",
10566        local_var_configuration.base_path
10567    );
10568    let mut local_var_req_builder =
10569        local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());
10570
10571    if let Some(ref local_var_str) = format {
10572        local_var_req_builder =
10573            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
10574    }
10575    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
10576        local_var_req_builder =
10577            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
10578    }
10579    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
10580        let local_var_key = local_var_apikey.key.clone();
10581        let local_var_value = match local_var_apikey.prefix {
10582            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
10583            None => local_var_key,
10584        };
10585        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
10586    };
10587    local_var_req_builder = local_var_req_builder.json(&bulk_operation_request);
10588
10589    let local_var_req = local_var_req_builder.build()?;
10590    let local_var_resp = local_var_client.execute(local_var_req).await?;
10591
10592    let local_var_status = local_var_resp.status();
10593    let local_var_content = local_var_resp.text().await?;
10594
10595    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
10596        Ok(())
10597    } else {
10598        let local_var_entity: Option<
10599            LoadBalancersVirtualServerCertificateProfileAssignmentsBulkDestroyError,
10600        > = serde_json::from_str(&local_var_content).ok();
10601        let local_var_error = ResponseContent {
10602            status: local_var_status,
10603            content: local_var_content,
10604            entity: local_var_entity,
10605        };
10606        Err(Error::ResponseError(local_var_error))
10607    }
10608}
10609
10610/// VirtualServerCertificateProfileAssignment viewset.
10611pub async fn load_balancers_virtual_server_certificate_profile_assignments_bulk_partial_update(
10612    configuration: &configuration::Configuration,
10613    patched_bulk_writable_virtual_server_certificate_profile_assignment_request: Vec<
10614        crate::models::PatchedBulkWritableVirtualServerCertificateProfileAssignmentRequest,
10615    >,
10616    format: Option<&str>,
10617) -> Result<
10618    Vec<crate::models::VirtualServerCertificateProfileAssignment>,
10619    Error<LoadBalancersVirtualServerCertificateProfileAssignmentsBulkPartialUpdateError>,
10620> {
10621    let local_var_configuration = configuration;
10622
10623    let local_var_client = &local_var_configuration.client;
10624
10625    let local_var_uri_str = format!(
10626        "{}/load-balancers/virtual-server-certificate-profile-assignments/",
10627        local_var_configuration.base_path
10628    );
10629    let mut local_var_req_builder =
10630        local_var_client.request(reqwest::Method::PATCH, local_var_uri_str.as_str());
10631
10632    if let Some(ref local_var_str) = format {
10633        local_var_req_builder =
10634            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
10635    }
10636    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
10637        local_var_req_builder =
10638            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
10639    }
10640    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
10641        let local_var_key = local_var_apikey.key.clone();
10642        let local_var_value = match local_var_apikey.prefix {
10643            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
10644            None => local_var_key,
10645        };
10646        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
10647    };
10648    local_var_req_builder = local_var_req_builder
10649        .json(&patched_bulk_writable_virtual_server_certificate_profile_assignment_request);
10650
10651    let local_var_req = local_var_req_builder.build()?;
10652    let local_var_resp = local_var_client.execute(local_var_req).await?;
10653
10654    let local_var_status = local_var_resp.status();
10655    let local_var_content = local_var_resp.text().await?;
10656
10657    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
10658        serde_json::from_str(&local_var_content).map_err(Error::from)
10659    } else {
10660        let local_var_entity: Option<
10661            LoadBalancersVirtualServerCertificateProfileAssignmentsBulkPartialUpdateError,
10662        > = serde_json::from_str(&local_var_content).ok();
10663        let local_var_error = ResponseContent {
10664            status: local_var_status,
10665            content: local_var_content,
10666            entity: local_var_entity,
10667        };
10668        Err(Error::ResponseError(local_var_error))
10669    }
10670}
10671
10672/// VirtualServerCertificateProfileAssignment viewset.
10673pub async fn load_balancers_virtual_server_certificate_profile_assignments_bulk_update(
10674    configuration: &configuration::Configuration,
10675    bulk_writable_virtual_server_certificate_profile_assignment_request: Vec<
10676        crate::models::BulkWritableVirtualServerCertificateProfileAssignmentRequest,
10677    >,
10678    format: Option<&str>,
10679) -> Result<
10680    Vec<crate::models::VirtualServerCertificateProfileAssignment>,
10681    Error<LoadBalancersVirtualServerCertificateProfileAssignmentsBulkUpdateError>,
10682> {
10683    let local_var_configuration = configuration;
10684
10685    let local_var_client = &local_var_configuration.client;
10686
10687    let local_var_uri_str = format!(
10688        "{}/load-balancers/virtual-server-certificate-profile-assignments/",
10689        local_var_configuration.base_path
10690    );
10691    let mut local_var_req_builder =
10692        local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());
10693
10694    if let Some(ref local_var_str) = format {
10695        local_var_req_builder =
10696            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
10697    }
10698    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
10699        local_var_req_builder =
10700            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
10701    }
10702    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
10703        let local_var_key = local_var_apikey.key.clone();
10704        let local_var_value = match local_var_apikey.prefix {
10705            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
10706            None => local_var_key,
10707        };
10708        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
10709    };
10710    local_var_req_builder = local_var_req_builder
10711        .json(&bulk_writable_virtual_server_certificate_profile_assignment_request);
10712
10713    let local_var_req = local_var_req_builder.build()?;
10714    let local_var_resp = local_var_client.execute(local_var_req).await?;
10715
10716    let local_var_status = local_var_resp.status();
10717    let local_var_content = local_var_resp.text().await?;
10718
10719    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
10720        serde_json::from_str(&local_var_content).map_err(Error::from)
10721    } else {
10722        let local_var_entity: Option<
10723            LoadBalancersVirtualServerCertificateProfileAssignmentsBulkUpdateError,
10724        > = serde_json::from_str(&local_var_content).ok();
10725        let local_var_error = ResponseContent {
10726            status: local_var_status,
10727            content: local_var_content,
10728            entity: local_var_entity,
10729        };
10730        Err(Error::ResponseError(local_var_error))
10731    }
10732}
10733
10734/// VirtualServerCertificateProfileAssignment viewset.
10735pub async fn load_balancers_virtual_server_certificate_profile_assignments_create(
10736    configuration: &configuration::Configuration,
10737    virtual_server_certificate_profile_assignment_request: crate::models::VirtualServerCertificateProfileAssignmentRequest,
10738    format: Option<&str>,
10739) -> Result<
10740    crate::models::VirtualServerCertificateProfileAssignment,
10741    Error<LoadBalancersVirtualServerCertificateProfileAssignmentsCreateError>,
10742> {
10743    let local_var_configuration = configuration;
10744
10745    let local_var_client = &local_var_configuration.client;
10746
10747    let local_var_uri_str = format!(
10748        "{}/load-balancers/virtual-server-certificate-profile-assignments/",
10749        local_var_configuration.base_path
10750    );
10751    let mut local_var_req_builder =
10752        local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
10753
10754    if let Some(ref local_var_str) = format {
10755        local_var_req_builder =
10756            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
10757    }
10758    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
10759        local_var_req_builder =
10760            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
10761    }
10762    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
10763        let local_var_key = local_var_apikey.key.clone();
10764        let local_var_value = match local_var_apikey.prefix {
10765            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
10766            None => local_var_key,
10767        };
10768        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
10769    };
10770    local_var_req_builder =
10771        local_var_req_builder.json(&virtual_server_certificate_profile_assignment_request);
10772
10773    let local_var_req = local_var_req_builder.build()?;
10774    let local_var_resp = local_var_client.execute(local_var_req).await?;
10775
10776    let local_var_status = local_var_resp.status();
10777    let local_var_content = local_var_resp.text().await?;
10778
10779    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
10780        serde_json::from_str(&local_var_content).map_err(Error::from)
10781    } else {
10782        let local_var_entity: Option<
10783            LoadBalancersVirtualServerCertificateProfileAssignmentsCreateError,
10784        > = serde_json::from_str(&local_var_content).ok();
10785        let local_var_error = ResponseContent {
10786            status: local_var_status,
10787            content: local_var_content,
10788            entity: local_var_entity,
10789        };
10790        Err(Error::ResponseError(local_var_error))
10791    }
10792}
10793
10794/// VirtualServerCertificateProfileAssignment viewset.
10795pub async fn load_balancers_virtual_server_certificate_profile_assignments_destroy(
10796    configuration: &configuration::Configuration,
10797    id: &str,
10798    format: Option<&str>,
10799) -> Result<(), Error<LoadBalancersVirtualServerCertificateProfileAssignmentsDestroyError>> {
10800    let local_var_configuration = configuration;
10801
10802    let local_var_client = &local_var_configuration.client;
10803
10804    let local_var_uri_str = format!(
10805        "{}/load-balancers/virtual-server-certificate-profile-assignments/{id}/",
10806        local_var_configuration.base_path,
10807        id = crate::apis::urlencode(id)
10808    );
10809    let mut local_var_req_builder =
10810        local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());
10811
10812    if let Some(ref local_var_str) = format {
10813        local_var_req_builder =
10814            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
10815    }
10816    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
10817        local_var_req_builder =
10818            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
10819    }
10820    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
10821        let local_var_key = local_var_apikey.key.clone();
10822        let local_var_value = match local_var_apikey.prefix {
10823            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
10824            None => local_var_key,
10825        };
10826        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
10827    };
10828
10829    let local_var_req = local_var_req_builder.build()?;
10830    let local_var_resp = local_var_client.execute(local_var_req).await?;
10831
10832    let local_var_status = local_var_resp.status();
10833    let local_var_content = local_var_resp.text().await?;
10834
10835    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
10836        Ok(())
10837    } else {
10838        let local_var_entity: Option<
10839            LoadBalancersVirtualServerCertificateProfileAssignmentsDestroyError,
10840        > = serde_json::from_str(&local_var_content).ok();
10841        let local_var_error = ResponseContent {
10842            status: local_var_status,
10843            content: local_var_content,
10844            entity: local_var_entity,
10845        };
10846        Err(Error::ResponseError(local_var_error))
10847    }
10848}
10849
10850/// VirtualServerCertificateProfileAssignment viewset.
10851pub async fn load_balancers_virtual_server_certificate_profile_assignments_list(
10852    configuration: &configuration::Configuration,
10853    certificate_profile: Option<Vec<String>>,
10854    certificate_profile__n: Option<Vec<String>>,
10855    format: Option<&str>,
10856    id: Option<Vec<uuid::Uuid>>,
10857    id__n: Option<Vec<uuid::Uuid>>,
10858    limit: Option<i32>,
10859    offset: Option<i32>,
10860    sort: Option<&str>,
10861    virtual_server: Option<Vec<String>>,
10862    virtual_server__n: Option<Vec<String>>,
10863    depth: Option<i32>,
10864    exclude_m2m: Option<bool>,
10865) -> Result<
10866    crate::models::PaginatedVirtualServerCertificateProfileAssignmentList,
10867    Error<LoadBalancersVirtualServerCertificateProfileAssignmentsListError>,
10868> {
10869    let local_var_configuration = configuration;
10870
10871    let local_var_client = &local_var_configuration.client;
10872
10873    let local_var_uri_str = format!(
10874        "{}/load-balancers/virtual-server-certificate-profile-assignments/",
10875        local_var_configuration.base_path
10876    );
10877    let mut local_var_req_builder =
10878        local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
10879
10880    if let Some(ref local_var_str) = certificate_profile {
10881        local_var_req_builder = match "multi" {
10882            "multi" => local_var_req_builder.query(
10883                &local_var_str
10884                    .into_iter()
10885                    .map(|p| ("certificate_profile".to_owned(), p.to_string()))
10886                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10887            ),
10888            _ => local_var_req_builder.query(&[(
10889                "certificate_profile",
10890                &local_var_str
10891                    .into_iter()
10892                    .map(|p| p.to_string())
10893                    .collect::<Vec<String>>()
10894                    .join(",")
10895                    .to_string(),
10896            )]),
10897        };
10898    }
10899    if let Some(ref local_var_str) = certificate_profile__n {
10900        local_var_req_builder = match "multi" {
10901            "multi" => local_var_req_builder.query(
10902                &local_var_str
10903                    .into_iter()
10904                    .map(|p| ("certificate_profile__n".to_owned(), p.to_string()))
10905                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10906            ),
10907            _ => local_var_req_builder.query(&[(
10908                "certificate_profile__n",
10909                &local_var_str
10910                    .into_iter()
10911                    .map(|p| p.to_string())
10912                    .collect::<Vec<String>>()
10913                    .join(",")
10914                    .to_string(),
10915            )]),
10916        };
10917    }
10918    if let Some(ref local_var_str) = format {
10919        local_var_req_builder =
10920            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
10921    }
10922    if let Some(ref local_var_str) = id {
10923        local_var_req_builder = match "multi" {
10924            "multi" => local_var_req_builder.query(
10925                &local_var_str
10926                    .into_iter()
10927                    .map(|p| ("id".to_owned(), p.to_string()))
10928                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10929            ),
10930            _ => local_var_req_builder.query(&[(
10931                "id",
10932                &local_var_str
10933                    .into_iter()
10934                    .map(|p| p.to_string())
10935                    .collect::<Vec<String>>()
10936                    .join(",")
10937                    .to_string(),
10938            )]),
10939        };
10940    }
10941    if let Some(ref local_var_str) = id__n {
10942        local_var_req_builder = match "multi" {
10943            "multi" => local_var_req_builder.query(
10944                &local_var_str
10945                    .into_iter()
10946                    .map(|p| ("id__n".to_owned(), p.to_string()))
10947                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10948            ),
10949            _ => local_var_req_builder.query(&[(
10950                "id__n",
10951                &local_var_str
10952                    .into_iter()
10953                    .map(|p| p.to_string())
10954                    .collect::<Vec<String>>()
10955                    .join(",")
10956                    .to_string(),
10957            )]),
10958        };
10959    }
10960    if let Some(ref local_var_str) = limit {
10961        local_var_req_builder =
10962            local_var_req_builder.query(&[("limit", &local_var_str.to_string())]);
10963    }
10964    if let Some(ref local_var_str) = offset {
10965        local_var_req_builder =
10966            local_var_req_builder.query(&[("offset", &local_var_str.to_string())]);
10967    }
10968    if let Some(ref local_var_str) = sort {
10969        local_var_req_builder =
10970            local_var_req_builder.query(&[("sort", &local_var_str.to_string())]);
10971    }
10972    if let Some(ref local_var_str) = virtual_server {
10973        local_var_req_builder = match "multi" {
10974            "multi" => local_var_req_builder.query(
10975                &local_var_str
10976                    .into_iter()
10977                    .map(|p| ("virtual_server".to_owned(), p.to_string()))
10978                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10979            ),
10980            _ => local_var_req_builder.query(&[(
10981                "virtual_server",
10982                &local_var_str
10983                    .into_iter()
10984                    .map(|p| p.to_string())
10985                    .collect::<Vec<String>>()
10986                    .join(",")
10987                    .to_string(),
10988            )]),
10989        };
10990    }
10991    if let Some(ref local_var_str) = virtual_server__n {
10992        local_var_req_builder = match "multi" {
10993            "multi" => local_var_req_builder.query(
10994                &local_var_str
10995                    .into_iter()
10996                    .map(|p| ("virtual_server__n".to_owned(), p.to_string()))
10997                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10998            ),
10999            _ => local_var_req_builder.query(&[(
11000                "virtual_server__n",
11001                &local_var_str
11002                    .into_iter()
11003                    .map(|p| p.to_string())
11004                    .collect::<Vec<String>>()
11005                    .join(",")
11006                    .to_string(),
11007            )]),
11008        };
11009    }
11010    if let Some(ref local_var_str) = depth {
11011        local_var_req_builder =
11012            local_var_req_builder.query(&[("depth", &local_var_str.to_string())]);
11013    }
11014    if let Some(ref local_var_str) = exclude_m2m {
11015        local_var_req_builder =
11016            local_var_req_builder.query(&[("exclude_m2m", &local_var_str.to_string())]);
11017    }
11018    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
11019        local_var_req_builder =
11020            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
11021    }
11022    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
11023        let local_var_key = local_var_apikey.key.clone();
11024        let local_var_value = match local_var_apikey.prefix {
11025            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
11026            None => local_var_key,
11027        };
11028        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
11029    };
11030
11031    let local_var_req = local_var_req_builder.build()?;
11032    let local_var_resp = local_var_client.execute(local_var_req).await?;
11033
11034    let local_var_status = local_var_resp.status();
11035    let local_var_content = local_var_resp.text().await?;
11036
11037    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
11038        serde_json::from_str(&local_var_content).map_err(Error::from)
11039    } else {
11040        let local_var_entity: Option<
11041            LoadBalancersVirtualServerCertificateProfileAssignmentsListError,
11042        > = serde_json::from_str(&local_var_content).ok();
11043        let local_var_error = ResponseContent {
11044            status: local_var_status,
11045            content: local_var_content,
11046            entity: local_var_entity,
11047        };
11048        Err(Error::ResponseError(local_var_error))
11049    }
11050}
11051
11052/// VirtualServerCertificateProfileAssignment viewset.
11053pub async fn load_balancers_virtual_server_certificate_profile_assignments_partial_update(
11054    configuration: &configuration::Configuration,
11055    id: &str,
11056    format: Option<&str>,
11057    patched_virtual_server_certificate_profile_assignment_request: Option<
11058        crate::models::PatchedVirtualServerCertificateProfileAssignmentRequest,
11059    >,
11060) -> Result<
11061    crate::models::VirtualServerCertificateProfileAssignment,
11062    Error<LoadBalancersVirtualServerCertificateProfileAssignmentsPartialUpdateError>,
11063> {
11064    let local_var_configuration = configuration;
11065
11066    let local_var_client = &local_var_configuration.client;
11067
11068    let local_var_uri_str = format!(
11069        "{}/load-balancers/virtual-server-certificate-profile-assignments/{id}/",
11070        local_var_configuration.base_path,
11071        id = crate::apis::urlencode(id)
11072    );
11073    let mut local_var_req_builder =
11074        local_var_client.request(reqwest::Method::PATCH, local_var_uri_str.as_str());
11075
11076    if let Some(ref local_var_str) = format {
11077        local_var_req_builder =
11078            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
11079    }
11080    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
11081        local_var_req_builder =
11082            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
11083    }
11084    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
11085        let local_var_key = local_var_apikey.key.clone();
11086        let local_var_value = match local_var_apikey.prefix {
11087            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
11088            None => local_var_key,
11089        };
11090        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
11091    };
11092    local_var_req_builder =
11093        local_var_req_builder.json(&patched_virtual_server_certificate_profile_assignment_request);
11094
11095    let local_var_req = local_var_req_builder.build()?;
11096    let local_var_resp = local_var_client.execute(local_var_req).await?;
11097
11098    let local_var_status = local_var_resp.status();
11099    let local_var_content = local_var_resp.text().await?;
11100
11101    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
11102        serde_json::from_str(&local_var_content).map_err(Error::from)
11103    } else {
11104        let local_var_entity: Option<
11105            LoadBalancersVirtualServerCertificateProfileAssignmentsPartialUpdateError,
11106        > = serde_json::from_str(&local_var_content).ok();
11107        let local_var_error = ResponseContent {
11108            status: local_var_status,
11109            content: local_var_content,
11110            entity: local_var_entity,
11111        };
11112        Err(Error::ResponseError(local_var_error))
11113    }
11114}
11115
11116/// VirtualServerCertificateProfileAssignment viewset.
11117pub async fn load_balancers_virtual_server_certificate_profile_assignments_retrieve(
11118    configuration: &configuration::Configuration,
11119    id: &str,
11120    format: Option<&str>,
11121    depth: Option<i32>,
11122    exclude_m2m: Option<bool>,
11123) -> Result<
11124    crate::models::VirtualServerCertificateProfileAssignment,
11125    Error<LoadBalancersVirtualServerCertificateProfileAssignmentsRetrieveError>,
11126> {
11127    let local_var_configuration = configuration;
11128
11129    let local_var_client = &local_var_configuration.client;
11130
11131    let local_var_uri_str = format!(
11132        "{}/load-balancers/virtual-server-certificate-profile-assignments/{id}/",
11133        local_var_configuration.base_path,
11134        id = crate::apis::urlencode(id)
11135    );
11136    let mut local_var_req_builder =
11137        local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
11138
11139    if let Some(ref local_var_str) = format {
11140        local_var_req_builder =
11141            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
11142    }
11143    if let Some(ref local_var_str) = depth {
11144        local_var_req_builder =
11145            local_var_req_builder.query(&[("depth", &local_var_str.to_string())]);
11146    }
11147    if let Some(ref local_var_str) = exclude_m2m {
11148        local_var_req_builder =
11149            local_var_req_builder.query(&[("exclude_m2m", &local_var_str.to_string())]);
11150    }
11151    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
11152        local_var_req_builder =
11153            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
11154    }
11155    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
11156        let local_var_key = local_var_apikey.key.clone();
11157        let local_var_value = match local_var_apikey.prefix {
11158            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
11159            None => local_var_key,
11160        };
11161        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
11162    };
11163
11164    let local_var_req = local_var_req_builder.build()?;
11165    let local_var_resp = local_var_client.execute(local_var_req).await?;
11166
11167    let local_var_status = local_var_resp.status();
11168    let local_var_content = local_var_resp.text().await?;
11169
11170    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
11171        serde_json::from_str(&local_var_content).map_err(Error::from)
11172    } else {
11173        let local_var_entity: Option<
11174            LoadBalancersVirtualServerCertificateProfileAssignmentsRetrieveError,
11175        > = serde_json::from_str(&local_var_content).ok();
11176        let local_var_error = ResponseContent {
11177            status: local_var_status,
11178            content: local_var_content,
11179            entity: local_var_entity,
11180        };
11181        Err(Error::ResponseError(local_var_error))
11182    }
11183}
11184
11185/// VirtualServerCertificateProfileAssignment viewset.
11186pub async fn load_balancers_virtual_server_certificate_profile_assignments_update(
11187    configuration: &configuration::Configuration,
11188    id: &str,
11189    virtual_server_certificate_profile_assignment_request: crate::models::VirtualServerCertificateProfileAssignmentRequest,
11190    format: Option<&str>,
11191) -> Result<
11192    crate::models::VirtualServerCertificateProfileAssignment,
11193    Error<LoadBalancersVirtualServerCertificateProfileAssignmentsUpdateError>,
11194> {
11195    let local_var_configuration = configuration;
11196
11197    let local_var_client = &local_var_configuration.client;
11198
11199    let local_var_uri_str = format!(
11200        "{}/load-balancers/virtual-server-certificate-profile-assignments/{id}/",
11201        local_var_configuration.base_path,
11202        id = crate::apis::urlencode(id)
11203    );
11204    let mut local_var_req_builder =
11205        local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());
11206
11207    if let Some(ref local_var_str) = format {
11208        local_var_req_builder =
11209            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
11210    }
11211    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
11212        local_var_req_builder =
11213            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
11214    }
11215    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
11216        let local_var_key = local_var_apikey.key.clone();
11217        let local_var_value = match local_var_apikey.prefix {
11218            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
11219            None => local_var_key,
11220        };
11221        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
11222    };
11223    local_var_req_builder =
11224        local_var_req_builder.json(&virtual_server_certificate_profile_assignment_request);
11225
11226    let local_var_req = local_var_req_builder.build()?;
11227    let local_var_resp = local_var_client.execute(local_var_req).await?;
11228
11229    let local_var_status = local_var_resp.status();
11230    let local_var_content = local_var_resp.text().await?;
11231
11232    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
11233        serde_json::from_str(&local_var_content).map_err(Error::from)
11234    } else {
11235        let local_var_entity: Option<
11236            LoadBalancersVirtualServerCertificateProfileAssignmentsUpdateError,
11237        > = serde_json::from_str(&local_var_content).ok();
11238        let local_var_error = ResponseContent {
11239            status: local_var_status,
11240            content: local_var_content,
11241            entity: local_var_entity,
11242        };
11243        Err(Error::ResponseError(local_var_error))
11244    }
11245}
11246
11247/// VirtualServer viewset.
11248pub async fn load_balancers_virtual_servers_bulk_destroy(
11249    configuration: &configuration::Configuration,
11250    bulk_operation_request: Vec<crate::models::BulkOperationRequest>,
11251    format: Option<&str>,
11252) -> Result<(), Error<LoadBalancersVirtualServersBulkDestroyError>> {
11253    let local_var_configuration = configuration;
11254
11255    let local_var_client = &local_var_configuration.client;
11256
11257    let local_var_uri_str = format!(
11258        "{}/load-balancers/virtual-servers/",
11259        local_var_configuration.base_path
11260    );
11261    let mut local_var_req_builder =
11262        local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());
11263
11264    if let Some(ref local_var_str) = format {
11265        local_var_req_builder =
11266            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
11267    }
11268    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
11269        local_var_req_builder =
11270            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
11271    }
11272    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
11273        let local_var_key = local_var_apikey.key.clone();
11274        let local_var_value = match local_var_apikey.prefix {
11275            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
11276            None => local_var_key,
11277        };
11278        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
11279    };
11280    local_var_req_builder = local_var_req_builder.json(&bulk_operation_request);
11281
11282    let local_var_req = local_var_req_builder.build()?;
11283    let local_var_resp = local_var_client.execute(local_var_req).await?;
11284
11285    let local_var_status = local_var_resp.status();
11286    let local_var_content = local_var_resp.text().await?;
11287
11288    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
11289        Ok(())
11290    } else {
11291        let local_var_entity: Option<LoadBalancersVirtualServersBulkDestroyError> =
11292            serde_json::from_str(&local_var_content).ok();
11293        let local_var_error = ResponseContent {
11294            status: local_var_status,
11295            content: local_var_content,
11296            entity: local_var_entity,
11297        };
11298        Err(Error::ResponseError(local_var_error))
11299    }
11300}
11301
11302/// VirtualServer viewset.
11303pub async fn load_balancers_virtual_servers_bulk_partial_update(
11304    configuration: &configuration::Configuration,
11305    patched_bulk_writable_virtual_server_request: Vec<
11306        crate::models::PatchedBulkWritableVirtualServerRequest,
11307    >,
11308    format: Option<&str>,
11309) -> Result<
11310    Vec<crate::models::VirtualServer>,
11311    Error<LoadBalancersVirtualServersBulkPartialUpdateError>,
11312> {
11313    let local_var_configuration = configuration;
11314
11315    let local_var_client = &local_var_configuration.client;
11316
11317    let local_var_uri_str = format!(
11318        "{}/load-balancers/virtual-servers/",
11319        local_var_configuration.base_path
11320    );
11321    let mut local_var_req_builder =
11322        local_var_client.request(reqwest::Method::PATCH, local_var_uri_str.as_str());
11323
11324    if let Some(ref local_var_str) = format {
11325        local_var_req_builder =
11326            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
11327    }
11328    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
11329        local_var_req_builder =
11330            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
11331    }
11332    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
11333        let local_var_key = local_var_apikey.key.clone();
11334        let local_var_value = match local_var_apikey.prefix {
11335            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
11336            None => local_var_key,
11337        };
11338        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
11339    };
11340    local_var_req_builder =
11341        local_var_req_builder.json(&patched_bulk_writable_virtual_server_request);
11342
11343    let local_var_req = local_var_req_builder.build()?;
11344    let local_var_resp = local_var_client.execute(local_var_req).await?;
11345
11346    let local_var_status = local_var_resp.status();
11347    let local_var_content = local_var_resp.text().await?;
11348
11349    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
11350        serde_json::from_str(&local_var_content).map_err(Error::from)
11351    } else {
11352        let local_var_entity: Option<LoadBalancersVirtualServersBulkPartialUpdateError> =
11353            serde_json::from_str(&local_var_content).ok();
11354        let local_var_error = ResponseContent {
11355            status: local_var_status,
11356            content: local_var_content,
11357            entity: local_var_entity,
11358        };
11359        Err(Error::ResponseError(local_var_error))
11360    }
11361}
11362
11363/// VirtualServer viewset.
11364pub async fn load_balancers_virtual_servers_bulk_update(
11365    configuration: &configuration::Configuration,
11366    bulk_writable_virtual_server_request: Vec<crate::models::BulkWritableVirtualServerRequest>,
11367    format: Option<&str>,
11368) -> Result<Vec<crate::models::VirtualServer>, Error<LoadBalancersVirtualServersBulkUpdateError>> {
11369    let local_var_configuration = configuration;
11370
11371    let local_var_client = &local_var_configuration.client;
11372
11373    let local_var_uri_str = format!(
11374        "{}/load-balancers/virtual-servers/",
11375        local_var_configuration.base_path
11376    );
11377    let mut local_var_req_builder =
11378        local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());
11379
11380    if let Some(ref local_var_str) = format {
11381        local_var_req_builder =
11382            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
11383    }
11384    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
11385        local_var_req_builder =
11386            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
11387    }
11388    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
11389        let local_var_key = local_var_apikey.key.clone();
11390        let local_var_value = match local_var_apikey.prefix {
11391            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
11392            None => local_var_key,
11393        };
11394        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
11395    };
11396    local_var_req_builder = local_var_req_builder.json(&bulk_writable_virtual_server_request);
11397
11398    let local_var_req = local_var_req_builder.build()?;
11399    let local_var_resp = local_var_client.execute(local_var_req).await?;
11400
11401    let local_var_status = local_var_resp.status();
11402    let local_var_content = local_var_resp.text().await?;
11403
11404    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
11405        serde_json::from_str(&local_var_content).map_err(Error::from)
11406    } else {
11407        let local_var_entity: Option<LoadBalancersVirtualServersBulkUpdateError> =
11408            serde_json::from_str(&local_var_content).ok();
11409        let local_var_error = ResponseContent {
11410            status: local_var_status,
11411            content: local_var_content,
11412            entity: local_var_entity,
11413        };
11414        Err(Error::ResponseError(local_var_error))
11415    }
11416}
11417
11418/// VirtualServer viewset.
11419pub async fn load_balancers_virtual_servers_create(
11420    configuration: &configuration::Configuration,
11421    virtual_server_request: crate::models::VirtualServerRequest,
11422    format: Option<&str>,
11423) -> Result<crate::models::VirtualServer, Error<LoadBalancersVirtualServersCreateError>> {
11424    let local_var_configuration = configuration;
11425
11426    let local_var_client = &local_var_configuration.client;
11427
11428    let local_var_uri_str = format!(
11429        "{}/load-balancers/virtual-servers/",
11430        local_var_configuration.base_path
11431    );
11432    let mut local_var_req_builder =
11433        local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
11434
11435    if let Some(ref local_var_str) = format {
11436        local_var_req_builder =
11437            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
11438    }
11439    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
11440        local_var_req_builder =
11441            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
11442    }
11443    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
11444        let local_var_key = local_var_apikey.key.clone();
11445        let local_var_value = match local_var_apikey.prefix {
11446            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
11447            None => local_var_key,
11448        };
11449        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
11450    };
11451    local_var_req_builder = local_var_req_builder.json(&virtual_server_request);
11452
11453    let local_var_req = local_var_req_builder.build()?;
11454    let local_var_resp = local_var_client.execute(local_var_req).await?;
11455
11456    let local_var_status = local_var_resp.status();
11457    let local_var_content = local_var_resp.text().await?;
11458
11459    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
11460        serde_json::from_str(&local_var_content).map_err(Error::from)
11461    } else {
11462        let local_var_entity: Option<LoadBalancersVirtualServersCreateError> =
11463            serde_json::from_str(&local_var_content).ok();
11464        let local_var_error = ResponseContent {
11465            status: local_var_status,
11466            content: local_var_content,
11467            entity: local_var_entity,
11468        };
11469        Err(Error::ResponseError(local_var_error))
11470    }
11471}
11472
11473/// VirtualServer viewset.
11474pub async fn load_balancers_virtual_servers_destroy(
11475    configuration: &configuration::Configuration,
11476    id: &str,
11477    format: Option<&str>,
11478) -> Result<(), Error<LoadBalancersVirtualServersDestroyError>> {
11479    let local_var_configuration = configuration;
11480
11481    let local_var_client = &local_var_configuration.client;
11482
11483    let local_var_uri_str = format!(
11484        "{}/load-balancers/virtual-servers/{id}/",
11485        local_var_configuration.base_path,
11486        id = crate::apis::urlencode(id)
11487    );
11488    let mut local_var_req_builder =
11489        local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());
11490
11491    if let Some(ref local_var_str) = format {
11492        local_var_req_builder =
11493            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
11494    }
11495    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
11496        local_var_req_builder =
11497            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
11498    }
11499    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
11500        let local_var_key = local_var_apikey.key.clone();
11501        let local_var_value = match local_var_apikey.prefix {
11502            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
11503            None => local_var_key,
11504        };
11505        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
11506    };
11507
11508    let local_var_req = local_var_req_builder.build()?;
11509    let local_var_resp = local_var_client.execute(local_var_req).await?;
11510
11511    let local_var_status = local_var_resp.status();
11512    let local_var_content = local_var_resp.text().await?;
11513
11514    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
11515        Ok(())
11516    } else {
11517        let local_var_entity: Option<LoadBalancersVirtualServersDestroyError> =
11518            serde_json::from_str(&local_var_content).ok();
11519        let local_var_error = ResponseContent {
11520            status: local_var_status,
11521            content: local_var_content,
11522            entity: local_var_entity,
11523        };
11524        Err(Error::ResponseError(local_var_error))
11525    }
11526}
11527
11528/// VirtualServer viewset.
11529pub async fn load_balancers_virtual_servers_list(
11530    configuration: &configuration::Configuration,
11531    certificate_profiles: Option<Vec<String>>,
11532    certificate_profiles__n: Option<Vec<String>>,
11533    cloud_service: Option<Vec<String>>,
11534    cloud_service__isnull: Option<bool>,
11535    cloud_service__n: Option<Vec<String>>,
11536    contacts: Option<Vec<String>>,
11537    contacts__isnull: Option<bool>,
11538    contacts__n: Option<Vec<String>>,
11539    created: Option<Vec<String>>,
11540    created__gt: Option<Vec<String>>,
11541    created__gte: Option<Vec<String>>,
11542    created__isnull: Option<bool>,
11543    created__lt: Option<Vec<String>>,
11544    created__lte: Option<Vec<String>>,
11545    created__n: Option<Vec<String>>,
11546    device: Option<Vec<String>>,
11547    device__isnull: Option<bool>,
11548    device__n: Option<Vec<String>>,
11549    device_redundancy_group: Option<Vec<String>>,
11550    device_redundancy_group__isnull: Option<bool>,
11551    device_redundancy_group__n: Option<Vec<String>>,
11552    dynamic_groups: Option<Vec<String>>,
11553    dynamic_groups__n: Option<Vec<String>>,
11554    enabled: Option<bool>,
11555    format: Option<&str>,
11556    health_check_monitor: Option<Vec<String>>,
11557    health_check_monitor__isnull: Option<bool>,
11558    health_check_monitor__n: Option<Vec<String>>,
11559    id: Option<Vec<uuid::Uuid>>,
11560    id__n: Option<Vec<uuid::Uuid>>,
11561    last_updated: Option<Vec<String>>,
11562    last_updated__gt: Option<Vec<String>>,
11563    last_updated__gte: Option<Vec<String>>,
11564    last_updated__isnull: Option<bool>,
11565    last_updated__lt: Option<Vec<String>>,
11566    last_updated__lte: Option<Vec<String>>,
11567    last_updated__n: Option<Vec<String>>,
11568    limit: Option<i32>,
11569    load_balancer_pool: Option<Vec<String>>,
11570    load_balancer_pool__isnull: Option<bool>,
11571    load_balancer_pool__n: Option<Vec<String>>,
11572    load_balancer_type: Option<Vec<String>>,
11573    load_balancer_type__ic: Option<Vec<String>>,
11574    load_balancer_type__ie: Option<Vec<String>>,
11575    load_balancer_type__iew: Option<Vec<String>>,
11576    load_balancer_type__ire: Option<Vec<String>>,
11577    load_balancer_type__isw: Option<Vec<String>>,
11578    load_balancer_type__n: Option<Vec<String>>,
11579    load_balancer_type__nic: Option<Vec<String>>,
11580    load_balancer_type__nie: Option<Vec<String>>,
11581    load_balancer_type__niew: Option<Vec<String>>,
11582    load_balancer_type__nire: Option<Vec<String>>,
11583    load_balancer_type__nisw: Option<Vec<String>>,
11584    load_balancer_type__nre: Option<Vec<String>>,
11585    load_balancer_type__re: Option<Vec<String>>,
11586    name: Option<Vec<String>>,
11587    name__ic: Option<Vec<String>>,
11588    name__ie: Option<Vec<String>>,
11589    name__iew: Option<Vec<String>>,
11590    name__ire: Option<Vec<String>>,
11591    name__isw: Option<Vec<String>>,
11592    name__n: Option<Vec<String>>,
11593    name__nic: Option<Vec<String>>,
11594    name__nie: Option<Vec<String>>,
11595    name__niew: Option<Vec<String>>,
11596    name__nire: Option<Vec<String>>,
11597    name__nisw: Option<Vec<String>>,
11598    name__nre: Option<Vec<String>>,
11599    name__re: Option<Vec<String>>,
11600    offset: Option<i32>,
11601    port: Option<Vec<i32>>,
11602    port__gt: Option<Vec<i32>>,
11603    port__gte: Option<Vec<i32>>,
11604    port__isnull: Option<bool>,
11605    port__lt: Option<Vec<i32>>,
11606    port__lte: Option<Vec<i32>>,
11607    port__n: Option<Vec<i32>>,
11608    protocol: Option<Vec<String>>,
11609    protocol__ic: Option<Vec<String>>,
11610    protocol__ie: Option<Vec<String>>,
11611    protocol__iew: Option<Vec<String>>,
11612    protocol__ire: Option<Vec<String>>,
11613    protocol__isw: Option<Vec<String>>,
11614    protocol__n: Option<Vec<String>>,
11615    protocol__nic: Option<Vec<String>>,
11616    protocol__nie: Option<Vec<String>>,
11617    protocol__niew: Option<Vec<String>>,
11618    protocol__nire: Option<Vec<String>>,
11619    protocol__nisw: Option<Vec<String>>,
11620    protocol__nre: Option<Vec<String>>,
11621    protocol__re: Option<Vec<String>>,
11622    q: Option<&str>,
11623    sort: Option<&str>,
11624    source_nat_pool: Option<Vec<String>>,
11625    source_nat_pool__isnull: Option<bool>,
11626    source_nat_pool__n: Option<Vec<String>>,
11627    source_nat_type: Option<Vec<String>>,
11628    source_nat_type__ic: Option<Vec<String>>,
11629    source_nat_type__ie: Option<Vec<String>>,
11630    source_nat_type__iew: Option<Vec<String>>,
11631    source_nat_type__ire: Option<Vec<String>>,
11632    source_nat_type__isw: Option<Vec<String>>,
11633    source_nat_type__n: Option<Vec<String>>,
11634    source_nat_type__nic: Option<Vec<String>>,
11635    source_nat_type__nie: Option<Vec<String>>,
11636    source_nat_type__niew: Option<Vec<String>>,
11637    source_nat_type__nire: Option<Vec<String>>,
11638    source_nat_type__nisw: Option<Vec<String>>,
11639    source_nat_type__nre: Option<Vec<String>>,
11640    source_nat_type__re: Option<Vec<String>>,
11641    ssl_offload: Option<bool>,
11642    tags: Option<Vec<String>>,
11643    tags__isnull: Option<bool>,
11644    tags__n: Option<Vec<String>>,
11645    teams: Option<Vec<String>>,
11646    teams__isnull: Option<bool>,
11647    teams__n: Option<Vec<String>>,
11648    tenant: Option<Vec<String>>,
11649    tenant__isnull: Option<bool>,
11650    tenant__n: Option<Vec<String>>,
11651    tenant_group: Option<Vec<String>>,
11652    tenant_group__isnull: Option<bool>,
11653    tenant_group__n: Option<Vec<String>>,
11654    tenant_id: Option<Vec<uuid::Uuid>>,
11655    tenant_id__isnull: Option<bool>,
11656    tenant_id__n: Option<Vec<uuid::Uuid>>,
11657    vip: Option<Vec<uuid::Uuid>>,
11658    vip__n: Option<Vec<uuid::Uuid>>,
11659    virtual_chassis: Option<Vec<String>>,
11660    virtual_chassis__isnull: Option<bool>,
11661    virtual_chassis__n: Option<Vec<String>>,
11662    depth: Option<i32>,
11663    exclude_m2m: Option<bool>,
11664) -> Result<crate::models::PaginatedVirtualServerList, Error<LoadBalancersVirtualServersListError>>
11665{
11666    let local_var_configuration = configuration;
11667
11668    let local_var_client = &local_var_configuration.client;
11669
11670    let local_var_uri_str = format!(
11671        "{}/load-balancers/virtual-servers/",
11672        local_var_configuration.base_path
11673    );
11674    let mut local_var_req_builder =
11675        local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
11676
11677    if let Some(ref local_var_str) = certificate_profiles {
11678        local_var_req_builder = match "multi" {
11679            "multi" => local_var_req_builder.query(
11680                &local_var_str
11681                    .into_iter()
11682                    .map(|p| ("certificate_profiles".to_owned(), p.to_string()))
11683                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11684            ),
11685            _ => local_var_req_builder.query(&[(
11686                "certificate_profiles",
11687                &local_var_str
11688                    .into_iter()
11689                    .map(|p| p.to_string())
11690                    .collect::<Vec<String>>()
11691                    .join(",")
11692                    .to_string(),
11693            )]),
11694        };
11695    }
11696    if let Some(ref local_var_str) = certificate_profiles__n {
11697        local_var_req_builder = match "multi" {
11698            "multi" => local_var_req_builder.query(
11699                &local_var_str
11700                    .into_iter()
11701                    .map(|p| ("certificate_profiles__n".to_owned(), p.to_string()))
11702                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11703            ),
11704            _ => local_var_req_builder.query(&[(
11705                "certificate_profiles__n",
11706                &local_var_str
11707                    .into_iter()
11708                    .map(|p| p.to_string())
11709                    .collect::<Vec<String>>()
11710                    .join(",")
11711                    .to_string(),
11712            )]),
11713        };
11714    }
11715    if let Some(ref local_var_str) = cloud_service {
11716        local_var_req_builder = match "multi" {
11717            "multi" => local_var_req_builder.query(
11718                &local_var_str
11719                    .into_iter()
11720                    .map(|p| ("cloud_service".to_owned(), p.to_string()))
11721                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11722            ),
11723            _ => local_var_req_builder.query(&[(
11724                "cloud_service",
11725                &local_var_str
11726                    .into_iter()
11727                    .map(|p| p.to_string())
11728                    .collect::<Vec<String>>()
11729                    .join(",")
11730                    .to_string(),
11731            )]),
11732        };
11733    }
11734    if let Some(ref local_var_str) = cloud_service__isnull {
11735        local_var_req_builder =
11736            local_var_req_builder.query(&[("cloud_service__isnull", &local_var_str.to_string())]);
11737    }
11738    if let Some(ref local_var_str) = cloud_service__n {
11739        local_var_req_builder = match "multi" {
11740            "multi" => local_var_req_builder.query(
11741                &local_var_str
11742                    .into_iter()
11743                    .map(|p| ("cloud_service__n".to_owned(), p.to_string()))
11744                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11745            ),
11746            _ => local_var_req_builder.query(&[(
11747                "cloud_service__n",
11748                &local_var_str
11749                    .into_iter()
11750                    .map(|p| p.to_string())
11751                    .collect::<Vec<String>>()
11752                    .join(",")
11753                    .to_string(),
11754            )]),
11755        };
11756    }
11757    if let Some(ref local_var_str) = contacts {
11758        local_var_req_builder = match "multi" {
11759            "multi" => local_var_req_builder.query(
11760                &local_var_str
11761                    .into_iter()
11762                    .map(|p| ("contacts".to_owned(), p.to_string()))
11763                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11764            ),
11765            _ => local_var_req_builder.query(&[(
11766                "contacts",
11767                &local_var_str
11768                    .into_iter()
11769                    .map(|p| p.to_string())
11770                    .collect::<Vec<String>>()
11771                    .join(",")
11772                    .to_string(),
11773            )]),
11774        };
11775    }
11776    if let Some(ref local_var_str) = contacts__isnull {
11777        local_var_req_builder =
11778            local_var_req_builder.query(&[("contacts__isnull", &local_var_str.to_string())]);
11779    }
11780    if let Some(ref local_var_str) = contacts__n {
11781        local_var_req_builder = match "multi" {
11782            "multi" => local_var_req_builder.query(
11783                &local_var_str
11784                    .into_iter()
11785                    .map(|p| ("contacts__n".to_owned(), p.to_string()))
11786                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11787            ),
11788            _ => local_var_req_builder.query(&[(
11789                "contacts__n",
11790                &local_var_str
11791                    .into_iter()
11792                    .map(|p| p.to_string())
11793                    .collect::<Vec<String>>()
11794                    .join(",")
11795                    .to_string(),
11796            )]),
11797        };
11798    }
11799    if let Some(ref local_var_str) = created {
11800        local_var_req_builder = match "multi" {
11801            "multi" => local_var_req_builder.query(
11802                &local_var_str
11803                    .into_iter()
11804                    .map(|p| ("created".to_owned(), p.to_string()))
11805                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11806            ),
11807            _ => local_var_req_builder.query(&[(
11808                "created",
11809                &local_var_str
11810                    .into_iter()
11811                    .map(|p| p.to_string())
11812                    .collect::<Vec<String>>()
11813                    .join(",")
11814                    .to_string(),
11815            )]),
11816        };
11817    }
11818    if let Some(ref local_var_str) = created__gt {
11819        local_var_req_builder = match "multi" {
11820            "multi" => local_var_req_builder.query(
11821                &local_var_str
11822                    .into_iter()
11823                    .map(|p| ("created__gt".to_owned(), p.to_string()))
11824                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11825            ),
11826            _ => local_var_req_builder.query(&[(
11827                "created__gt",
11828                &local_var_str
11829                    .into_iter()
11830                    .map(|p| p.to_string())
11831                    .collect::<Vec<String>>()
11832                    .join(",")
11833                    .to_string(),
11834            )]),
11835        };
11836    }
11837    if let Some(ref local_var_str) = created__gte {
11838        local_var_req_builder = match "multi" {
11839            "multi" => local_var_req_builder.query(
11840                &local_var_str
11841                    .into_iter()
11842                    .map(|p| ("created__gte".to_owned(), p.to_string()))
11843                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11844            ),
11845            _ => local_var_req_builder.query(&[(
11846                "created__gte",
11847                &local_var_str
11848                    .into_iter()
11849                    .map(|p| p.to_string())
11850                    .collect::<Vec<String>>()
11851                    .join(",")
11852                    .to_string(),
11853            )]),
11854        };
11855    }
11856    if let Some(ref local_var_str) = created__isnull {
11857        local_var_req_builder =
11858            local_var_req_builder.query(&[("created__isnull", &local_var_str.to_string())]);
11859    }
11860    if let Some(ref local_var_str) = created__lt {
11861        local_var_req_builder = match "multi" {
11862            "multi" => local_var_req_builder.query(
11863                &local_var_str
11864                    .into_iter()
11865                    .map(|p| ("created__lt".to_owned(), p.to_string()))
11866                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11867            ),
11868            _ => local_var_req_builder.query(&[(
11869                "created__lt",
11870                &local_var_str
11871                    .into_iter()
11872                    .map(|p| p.to_string())
11873                    .collect::<Vec<String>>()
11874                    .join(",")
11875                    .to_string(),
11876            )]),
11877        };
11878    }
11879    if let Some(ref local_var_str) = created__lte {
11880        local_var_req_builder = match "multi" {
11881            "multi" => local_var_req_builder.query(
11882                &local_var_str
11883                    .into_iter()
11884                    .map(|p| ("created__lte".to_owned(), p.to_string()))
11885                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11886            ),
11887            _ => local_var_req_builder.query(&[(
11888                "created__lte",
11889                &local_var_str
11890                    .into_iter()
11891                    .map(|p| p.to_string())
11892                    .collect::<Vec<String>>()
11893                    .join(",")
11894                    .to_string(),
11895            )]),
11896        };
11897    }
11898    if let Some(ref local_var_str) = created__n {
11899        local_var_req_builder = match "multi" {
11900            "multi" => local_var_req_builder.query(
11901                &local_var_str
11902                    .into_iter()
11903                    .map(|p| ("created__n".to_owned(), p.to_string()))
11904                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11905            ),
11906            _ => local_var_req_builder.query(&[(
11907                "created__n",
11908                &local_var_str
11909                    .into_iter()
11910                    .map(|p| p.to_string())
11911                    .collect::<Vec<String>>()
11912                    .join(",")
11913                    .to_string(),
11914            )]),
11915        };
11916    }
11917    if let Some(ref local_var_str) = device {
11918        local_var_req_builder = match "multi" {
11919            "multi" => local_var_req_builder.query(
11920                &local_var_str
11921                    .into_iter()
11922                    .map(|p| ("device".to_owned(), p.to_string()))
11923                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11924            ),
11925            _ => local_var_req_builder.query(&[(
11926                "device",
11927                &local_var_str
11928                    .into_iter()
11929                    .map(|p| p.to_string())
11930                    .collect::<Vec<String>>()
11931                    .join(",")
11932                    .to_string(),
11933            )]),
11934        };
11935    }
11936    if let Some(ref local_var_str) = device__isnull {
11937        local_var_req_builder =
11938            local_var_req_builder.query(&[("device__isnull", &local_var_str.to_string())]);
11939    }
11940    if let Some(ref local_var_str) = device__n {
11941        local_var_req_builder = match "multi" {
11942            "multi" => local_var_req_builder.query(
11943                &local_var_str
11944                    .into_iter()
11945                    .map(|p| ("device__n".to_owned(), p.to_string()))
11946                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11947            ),
11948            _ => local_var_req_builder.query(&[(
11949                "device__n",
11950                &local_var_str
11951                    .into_iter()
11952                    .map(|p| p.to_string())
11953                    .collect::<Vec<String>>()
11954                    .join(",")
11955                    .to_string(),
11956            )]),
11957        };
11958    }
11959    if let Some(ref local_var_str) = device_redundancy_group {
11960        local_var_req_builder = match "multi" {
11961            "multi" => local_var_req_builder.query(
11962                &local_var_str
11963                    .into_iter()
11964                    .map(|p| ("device_redundancy_group".to_owned(), p.to_string()))
11965                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11966            ),
11967            _ => local_var_req_builder.query(&[(
11968                "device_redundancy_group",
11969                &local_var_str
11970                    .into_iter()
11971                    .map(|p| p.to_string())
11972                    .collect::<Vec<String>>()
11973                    .join(",")
11974                    .to_string(),
11975            )]),
11976        };
11977    }
11978    if let Some(ref local_var_str) = device_redundancy_group__isnull {
11979        local_var_req_builder = local_var_req_builder.query(&[(
11980            "device_redundancy_group__isnull",
11981            &local_var_str.to_string(),
11982        )]);
11983    }
11984    if let Some(ref local_var_str) = device_redundancy_group__n {
11985        local_var_req_builder = match "multi" {
11986            "multi" => local_var_req_builder.query(
11987                &local_var_str
11988                    .into_iter()
11989                    .map(|p| ("device_redundancy_group__n".to_owned(), p.to_string()))
11990                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11991            ),
11992            _ => local_var_req_builder.query(&[(
11993                "device_redundancy_group__n",
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) = dynamic_groups {
12004        local_var_req_builder = match "multi" {
12005            "multi" => local_var_req_builder.query(
12006                &local_var_str
12007                    .into_iter()
12008                    .map(|p| ("dynamic_groups".to_owned(), p.to_string()))
12009                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12010            ),
12011            _ => local_var_req_builder.query(&[(
12012                "dynamic_groups",
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) = dynamic_groups__n {
12023        local_var_req_builder = match "multi" {
12024            "multi" => local_var_req_builder.query(
12025                &local_var_str
12026                    .into_iter()
12027                    .map(|p| ("dynamic_groups__n".to_owned(), p.to_string()))
12028                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12029            ),
12030            _ => local_var_req_builder.query(&[(
12031                "dynamic_groups__n",
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) = enabled {
12042        local_var_req_builder =
12043            local_var_req_builder.query(&[("enabled", &local_var_str.to_string())]);
12044    }
12045    if let Some(ref local_var_str) = format {
12046        local_var_req_builder =
12047            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
12048    }
12049    if let Some(ref local_var_str) = health_check_monitor {
12050        local_var_req_builder = match "multi" {
12051            "multi" => local_var_req_builder.query(
12052                &local_var_str
12053                    .into_iter()
12054                    .map(|p| ("health_check_monitor".to_owned(), p.to_string()))
12055                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12056            ),
12057            _ => local_var_req_builder.query(&[(
12058                "health_check_monitor",
12059                &local_var_str
12060                    .into_iter()
12061                    .map(|p| p.to_string())
12062                    .collect::<Vec<String>>()
12063                    .join(",")
12064                    .to_string(),
12065            )]),
12066        };
12067    }
12068    if let Some(ref local_var_str) = health_check_monitor__isnull {
12069        local_var_req_builder = local_var_req_builder
12070            .query(&[("health_check_monitor__isnull", &local_var_str.to_string())]);
12071    }
12072    if let Some(ref local_var_str) = health_check_monitor__n {
12073        local_var_req_builder = match "multi" {
12074            "multi" => local_var_req_builder.query(
12075                &local_var_str
12076                    .into_iter()
12077                    .map(|p| ("health_check_monitor__n".to_owned(), p.to_string()))
12078                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12079            ),
12080            _ => local_var_req_builder.query(&[(
12081                "health_check_monitor__n",
12082                &local_var_str
12083                    .into_iter()
12084                    .map(|p| p.to_string())
12085                    .collect::<Vec<String>>()
12086                    .join(",")
12087                    .to_string(),
12088            )]),
12089        };
12090    }
12091    if let Some(ref local_var_str) = id {
12092        local_var_req_builder = match "multi" {
12093            "multi" => local_var_req_builder.query(
12094                &local_var_str
12095                    .into_iter()
12096                    .map(|p| ("id".to_owned(), p.to_string()))
12097                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12098            ),
12099            _ => local_var_req_builder.query(&[(
12100                "id",
12101                &local_var_str
12102                    .into_iter()
12103                    .map(|p| p.to_string())
12104                    .collect::<Vec<String>>()
12105                    .join(",")
12106                    .to_string(),
12107            )]),
12108        };
12109    }
12110    if let Some(ref local_var_str) = id__n {
12111        local_var_req_builder = match "multi" {
12112            "multi" => local_var_req_builder.query(
12113                &local_var_str
12114                    .into_iter()
12115                    .map(|p| ("id__n".to_owned(), p.to_string()))
12116                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12117            ),
12118            _ => local_var_req_builder.query(&[(
12119                "id__n",
12120                &local_var_str
12121                    .into_iter()
12122                    .map(|p| p.to_string())
12123                    .collect::<Vec<String>>()
12124                    .join(",")
12125                    .to_string(),
12126            )]),
12127        };
12128    }
12129    if let Some(ref local_var_str) = last_updated {
12130        local_var_req_builder = match "multi" {
12131            "multi" => local_var_req_builder.query(
12132                &local_var_str
12133                    .into_iter()
12134                    .map(|p| ("last_updated".to_owned(), p.to_string()))
12135                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12136            ),
12137            _ => local_var_req_builder.query(&[(
12138                "last_updated",
12139                &local_var_str
12140                    .into_iter()
12141                    .map(|p| p.to_string())
12142                    .collect::<Vec<String>>()
12143                    .join(",")
12144                    .to_string(),
12145            )]),
12146        };
12147    }
12148    if let Some(ref local_var_str) = last_updated__gt {
12149        local_var_req_builder = match "multi" {
12150            "multi" => local_var_req_builder.query(
12151                &local_var_str
12152                    .into_iter()
12153                    .map(|p| ("last_updated__gt".to_owned(), p.to_string()))
12154                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12155            ),
12156            _ => local_var_req_builder.query(&[(
12157                "last_updated__gt",
12158                &local_var_str
12159                    .into_iter()
12160                    .map(|p| p.to_string())
12161                    .collect::<Vec<String>>()
12162                    .join(",")
12163                    .to_string(),
12164            )]),
12165        };
12166    }
12167    if let Some(ref local_var_str) = last_updated__gte {
12168        local_var_req_builder = match "multi" {
12169            "multi" => local_var_req_builder.query(
12170                &local_var_str
12171                    .into_iter()
12172                    .map(|p| ("last_updated__gte".to_owned(), p.to_string()))
12173                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12174            ),
12175            _ => local_var_req_builder.query(&[(
12176                "last_updated__gte",
12177                &local_var_str
12178                    .into_iter()
12179                    .map(|p| p.to_string())
12180                    .collect::<Vec<String>>()
12181                    .join(",")
12182                    .to_string(),
12183            )]),
12184        };
12185    }
12186    if let Some(ref local_var_str) = last_updated__isnull {
12187        local_var_req_builder =
12188            local_var_req_builder.query(&[("last_updated__isnull", &local_var_str.to_string())]);
12189    }
12190    if let Some(ref local_var_str) = last_updated__lt {
12191        local_var_req_builder = match "multi" {
12192            "multi" => local_var_req_builder.query(
12193                &local_var_str
12194                    .into_iter()
12195                    .map(|p| ("last_updated__lt".to_owned(), p.to_string()))
12196                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12197            ),
12198            _ => local_var_req_builder.query(&[(
12199                "last_updated__lt",
12200                &local_var_str
12201                    .into_iter()
12202                    .map(|p| p.to_string())
12203                    .collect::<Vec<String>>()
12204                    .join(",")
12205                    .to_string(),
12206            )]),
12207        };
12208    }
12209    if let Some(ref local_var_str) = last_updated__lte {
12210        local_var_req_builder = match "multi" {
12211            "multi" => local_var_req_builder.query(
12212                &local_var_str
12213                    .into_iter()
12214                    .map(|p| ("last_updated__lte".to_owned(), p.to_string()))
12215                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12216            ),
12217            _ => local_var_req_builder.query(&[(
12218                "last_updated__lte",
12219                &local_var_str
12220                    .into_iter()
12221                    .map(|p| p.to_string())
12222                    .collect::<Vec<String>>()
12223                    .join(",")
12224                    .to_string(),
12225            )]),
12226        };
12227    }
12228    if let Some(ref local_var_str) = last_updated__n {
12229        local_var_req_builder = match "multi" {
12230            "multi" => local_var_req_builder.query(
12231                &local_var_str
12232                    .into_iter()
12233                    .map(|p| ("last_updated__n".to_owned(), p.to_string()))
12234                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12235            ),
12236            _ => local_var_req_builder.query(&[(
12237                "last_updated__n",
12238                &local_var_str
12239                    .into_iter()
12240                    .map(|p| p.to_string())
12241                    .collect::<Vec<String>>()
12242                    .join(",")
12243                    .to_string(),
12244            )]),
12245        };
12246    }
12247    if let Some(ref local_var_str) = limit {
12248        local_var_req_builder =
12249            local_var_req_builder.query(&[("limit", &local_var_str.to_string())]);
12250    }
12251    if let Some(ref local_var_str) = load_balancer_pool {
12252        local_var_req_builder = match "multi" {
12253            "multi" => local_var_req_builder.query(
12254                &local_var_str
12255                    .into_iter()
12256                    .map(|p| ("load_balancer_pool".to_owned(), p.to_string()))
12257                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12258            ),
12259            _ => local_var_req_builder.query(&[(
12260                "load_balancer_pool",
12261                &local_var_str
12262                    .into_iter()
12263                    .map(|p| p.to_string())
12264                    .collect::<Vec<String>>()
12265                    .join(",")
12266                    .to_string(),
12267            )]),
12268        };
12269    }
12270    if let Some(ref local_var_str) = load_balancer_pool__isnull {
12271        local_var_req_builder = local_var_req_builder
12272            .query(&[("load_balancer_pool__isnull", &local_var_str.to_string())]);
12273    }
12274    if let Some(ref local_var_str) = load_balancer_pool__n {
12275        local_var_req_builder = match "multi" {
12276            "multi" => local_var_req_builder.query(
12277                &local_var_str
12278                    .into_iter()
12279                    .map(|p| ("load_balancer_pool__n".to_owned(), p.to_string()))
12280                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12281            ),
12282            _ => local_var_req_builder.query(&[(
12283                "load_balancer_pool__n",
12284                &local_var_str
12285                    .into_iter()
12286                    .map(|p| p.to_string())
12287                    .collect::<Vec<String>>()
12288                    .join(",")
12289                    .to_string(),
12290            )]),
12291        };
12292    }
12293    if let Some(ref local_var_str) = load_balancer_type {
12294        local_var_req_builder = match "multi" {
12295            "multi" => local_var_req_builder.query(
12296                &local_var_str
12297                    .into_iter()
12298                    .map(|p| ("load_balancer_type".to_owned(), p.to_string()))
12299                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12300            ),
12301            _ => local_var_req_builder.query(&[(
12302                "load_balancer_type",
12303                &local_var_str
12304                    .into_iter()
12305                    .map(|p| p.to_string())
12306                    .collect::<Vec<String>>()
12307                    .join(",")
12308                    .to_string(),
12309            )]),
12310        };
12311    }
12312    if let Some(ref local_var_str) = load_balancer_type__ic {
12313        local_var_req_builder = match "multi" {
12314            "multi" => local_var_req_builder.query(
12315                &local_var_str
12316                    .into_iter()
12317                    .map(|p| ("load_balancer_type__ic".to_owned(), p.to_string()))
12318                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12319            ),
12320            _ => local_var_req_builder.query(&[(
12321                "load_balancer_type__ic",
12322                &local_var_str
12323                    .into_iter()
12324                    .map(|p| p.to_string())
12325                    .collect::<Vec<String>>()
12326                    .join(",")
12327                    .to_string(),
12328            )]),
12329        };
12330    }
12331    if let Some(ref local_var_str) = load_balancer_type__ie {
12332        local_var_req_builder = match "multi" {
12333            "multi" => local_var_req_builder.query(
12334                &local_var_str
12335                    .into_iter()
12336                    .map(|p| ("load_balancer_type__ie".to_owned(), p.to_string()))
12337                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12338            ),
12339            _ => local_var_req_builder.query(&[(
12340                "load_balancer_type__ie",
12341                &local_var_str
12342                    .into_iter()
12343                    .map(|p| p.to_string())
12344                    .collect::<Vec<String>>()
12345                    .join(",")
12346                    .to_string(),
12347            )]),
12348        };
12349    }
12350    if let Some(ref local_var_str) = load_balancer_type__iew {
12351        local_var_req_builder = match "multi" {
12352            "multi" => local_var_req_builder.query(
12353                &local_var_str
12354                    .into_iter()
12355                    .map(|p| ("load_balancer_type__iew".to_owned(), p.to_string()))
12356                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12357            ),
12358            _ => local_var_req_builder.query(&[(
12359                "load_balancer_type__iew",
12360                &local_var_str
12361                    .into_iter()
12362                    .map(|p| p.to_string())
12363                    .collect::<Vec<String>>()
12364                    .join(",")
12365                    .to_string(),
12366            )]),
12367        };
12368    }
12369    if let Some(ref local_var_str) = load_balancer_type__ire {
12370        local_var_req_builder = match "multi" {
12371            "multi" => local_var_req_builder.query(
12372                &local_var_str
12373                    .into_iter()
12374                    .map(|p| ("load_balancer_type__ire".to_owned(), p.to_string()))
12375                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12376            ),
12377            _ => local_var_req_builder.query(&[(
12378                "load_balancer_type__ire",
12379                &local_var_str
12380                    .into_iter()
12381                    .map(|p| p.to_string())
12382                    .collect::<Vec<String>>()
12383                    .join(",")
12384                    .to_string(),
12385            )]),
12386        };
12387    }
12388    if let Some(ref local_var_str) = load_balancer_type__isw {
12389        local_var_req_builder = match "multi" {
12390            "multi" => local_var_req_builder.query(
12391                &local_var_str
12392                    .into_iter()
12393                    .map(|p| ("load_balancer_type__isw".to_owned(), p.to_string()))
12394                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12395            ),
12396            _ => local_var_req_builder.query(&[(
12397                "load_balancer_type__isw",
12398                &local_var_str
12399                    .into_iter()
12400                    .map(|p| p.to_string())
12401                    .collect::<Vec<String>>()
12402                    .join(",")
12403                    .to_string(),
12404            )]),
12405        };
12406    }
12407    if let Some(ref local_var_str) = load_balancer_type__n {
12408        local_var_req_builder = match "multi" {
12409            "multi" => local_var_req_builder.query(
12410                &local_var_str
12411                    .into_iter()
12412                    .map(|p| ("load_balancer_type__n".to_owned(), p.to_string()))
12413                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12414            ),
12415            _ => local_var_req_builder.query(&[(
12416                "load_balancer_type__n",
12417                &local_var_str
12418                    .into_iter()
12419                    .map(|p| p.to_string())
12420                    .collect::<Vec<String>>()
12421                    .join(",")
12422                    .to_string(),
12423            )]),
12424        };
12425    }
12426    if let Some(ref local_var_str) = load_balancer_type__nic {
12427        local_var_req_builder = match "multi" {
12428            "multi" => local_var_req_builder.query(
12429                &local_var_str
12430                    .into_iter()
12431                    .map(|p| ("load_balancer_type__nic".to_owned(), p.to_string()))
12432                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12433            ),
12434            _ => local_var_req_builder.query(&[(
12435                "load_balancer_type__nic",
12436                &local_var_str
12437                    .into_iter()
12438                    .map(|p| p.to_string())
12439                    .collect::<Vec<String>>()
12440                    .join(",")
12441                    .to_string(),
12442            )]),
12443        };
12444    }
12445    if let Some(ref local_var_str) = load_balancer_type__nie {
12446        local_var_req_builder = match "multi" {
12447            "multi" => local_var_req_builder.query(
12448                &local_var_str
12449                    .into_iter()
12450                    .map(|p| ("load_balancer_type__nie".to_owned(), p.to_string()))
12451                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12452            ),
12453            _ => local_var_req_builder.query(&[(
12454                "load_balancer_type__nie",
12455                &local_var_str
12456                    .into_iter()
12457                    .map(|p| p.to_string())
12458                    .collect::<Vec<String>>()
12459                    .join(",")
12460                    .to_string(),
12461            )]),
12462        };
12463    }
12464    if let Some(ref local_var_str) = load_balancer_type__niew {
12465        local_var_req_builder = match "multi" {
12466            "multi" => local_var_req_builder.query(
12467                &local_var_str
12468                    .into_iter()
12469                    .map(|p| ("load_balancer_type__niew".to_owned(), p.to_string()))
12470                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12471            ),
12472            _ => local_var_req_builder.query(&[(
12473                "load_balancer_type__niew",
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) = load_balancer_type__nire {
12484        local_var_req_builder = match "multi" {
12485            "multi" => local_var_req_builder.query(
12486                &local_var_str
12487                    .into_iter()
12488                    .map(|p| ("load_balancer_type__nire".to_owned(), p.to_string()))
12489                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12490            ),
12491            _ => local_var_req_builder.query(&[(
12492                "load_balancer_type__nire",
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) = load_balancer_type__nisw {
12503        local_var_req_builder = match "multi" {
12504            "multi" => local_var_req_builder.query(
12505                &local_var_str
12506                    .into_iter()
12507                    .map(|p| ("load_balancer_type__nisw".to_owned(), p.to_string()))
12508                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12509            ),
12510            _ => local_var_req_builder.query(&[(
12511                "load_balancer_type__nisw",
12512                &local_var_str
12513                    .into_iter()
12514                    .map(|p| p.to_string())
12515                    .collect::<Vec<String>>()
12516                    .join(",")
12517                    .to_string(),
12518            )]),
12519        };
12520    }
12521    if let Some(ref local_var_str) = load_balancer_type__nre {
12522        local_var_req_builder = match "multi" {
12523            "multi" => local_var_req_builder.query(
12524                &local_var_str
12525                    .into_iter()
12526                    .map(|p| ("load_balancer_type__nre".to_owned(), p.to_string()))
12527                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12528            ),
12529            _ => local_var_req_builder.query(&[(
12530                "load_balancer_type__nre",
12531                &local_var_str
12532                    .into_iter()
12533                    .map(|p| p.to_string())
12534                    .collect::<Vec<String>>()
12535                    .join(",")
12536                    .to_string(),
12537            )]),
12538        };
12539    }
12540    if let Some(ref local_var_str) = load_balancer_type__re {
12541        local_var_req_builder = match "multi" {
12542            "multi" => local_var_req_builder.query(
12543                &local_var_str
12544                    .into_iter()
12545                    .map(|p| ("load_balancer_type__re".to_owned(), p.to_string()))
12546                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12547            ),
12548            _ => local_var_req_builder.query(&[(
12549                "load_balancer_type__re",
12550                &local_var_str
12551                    .into_iter()
12552                    .map(|p| p.to_string())
12553                    .collect::<Vec<String>>()
12554                    .join(",")
12555                    .to_string(),
12556            )]),
12557        };
12558    }
12559    if let Some(ref local_var_str) = name {
12560        local_var_req_builder = match "multi" {
12561            "multi" => local_var_req_builder.query(
12562                &local_var_str
12563                    .into_iter()
12564                    .map(|p| ("name".to_owned(), p.to_string()))
12565                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12566            ),
12567            _ => local_var_req_builder.query(&[(
12568                "name",
12569                &local_var_str
12570                    .into_iter()
12571                    .map(|p| p.to_string())
12572                    .collect::<Vec<String>>()
12573                    .join(",")
12574                    .to_string(),
12575            )]),
12576        };
12577    }
12578    if let Some(ref local_var_str) = name__ic {
12579        local_var_req_builder = match "multi" {
12580            "multi" => local_var_req_builder.query(
12581                &local_var_str
12582                    .into_iter()
12583                    .map(|p| ("name__ic".to_owned(), p.to_string()))
12584                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12585            ),
12586            _ => local_var_req_builder.query(&[(
12587                "name__ic",
12588                &local_var_str
12589                    .into_iter()
12590                    .map(|p| p.to_string())
12591                    .collect::<Vec<String>>()
12592                    .join(",")
12593                    .to_string(),
12594            )]),
12595        };
12596    }
12597    if let Some(ref local_var_str) = name__ie {
12598        local_var_req_builder = match "multi" {
12599            "multi" => local_var_req_builder.query(
12600                &local_var_str
12601                    .into_iter()
12602                    .map(|p| ("name__ie".to_owned(), p.to_string()))
12603                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12604            ),
12605            _ => local_var_req_builder.query(&[(
12606                "name__ie",
12607                &local_var_str
12608                    .into_iter()
12609                    .map(|p| p.to_string())
12610                    .collect::<Vec<String>>()
12611                    .join(",")
12612                    .to_string(),
12613            )]),
12614        };
12615    }
12616    if let Some(ref local_var_str) = name__iew {
12617        local_var_req_builder = match "multi" {
12618            "multi" => local_var_req_builder.query(
12619                &local_var_str
12620                    .into_iter()
12621                    .map(|p| ("name__iew".to_owned(), p.to_string()))
12622                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12623            ),
12624            _ => local_var_req_builder.query(&[(
12625                "name__iew",
12626                &local_var_str
12627                    .into_iter()
12628                    .map(|p| p.to_string())
12629                    .collect::<Vec<String>>()
12630                    .join(",")
12631                    .to_string(),
12632            )]),
12633        };
12634    }
12635    if let Some(ref local_var_str) = name__ire {
12636        local_var_req_builder = match "multi" {
12637            "multi" => local_var_req_builder.query(
12638                &local_var_str
12639                    .into_iter()
12640                    .map(|p| ("name__ire".to_owned(), p.to_string()))
12641                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12642            ),
12643            _ => local_var_req_builder.query(&[(
12644                "name__ire",
12645                &local_var_str
12646                    .into_iter()
12647                    .map(|p| p.to_string())
12648                    .collect::<Vec<String>>()
12649                    .join(",")
12650                    .to_string(),
12651            )]),
12652        };
12653    }
12654    if let Some(ref local_var_str) = name__isw {
12655        local_var_req_builder = match "multi" {
12656            "multi" => local_var_req_builder.query(
12657                &local_var_str
12658                    .into_iter()
12659                    .map(|p| ("name__isw".to_owned(), p.to_string()))
12660                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12661            ),
12662            _ => local_var_req_builder.query(&[(
12663                "name__isw",
12664                &local_var_str
12665                    .into_iter()
12666                    .map(|p| p.to_string())
12667                    .collect::<Vec<String>>()
12668                    .join(",")
12669                    .to_string(),
12670            )]),
12671        };
12672    }
12673    if let Some(ref local_var_str) = name__n {
12674        local_var_req_builder = match "multi" {
12675            "multi" => local_var_req_builder.query(
12676                &local_var_str
12677                    .into_iter()
12678                    .map(|p| ("name__n".to_owned(), p.to_string()))
12679                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12680            ),
12681            _ => local_var_req_builder.query(&[(
12682                "name__n",
12683                &local_var_str
12684                    .into_iter()
12685                    .map(|p| p.to_string())
12686                    .collect::<Vec<String>>()
12687                    .join(",")
12688                    .to_string(),
12689            )]),
12690        };
12691    }
12692    if let Some(ref local_var_str) = name__nic {
12693        local_var_req_builder = match "multi" {
12694            "multi" => local_var_req_builder.query(
12695                &local_var_str
12696                    .into_iter()
12697                    .map(|p| ("name__nic".to_owned(), p.to_string()))
12698                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12699            ),
12700            _ => local_var_req_builder.query(&[(
12701                "name__nic",
12702                &local_var_str
12703                    .into_iter()
12704                    .map(|p| p.to_string())
12705                    .collect::<Vec<String>>()
12706                    .join(",")
12707                    .to_string(),
12708            )]),
12709        };
12710    }
12711    if let Some(ref local_var_str) = name__nie {
12712        local_var_req_builder = match "multi" {
12713            "multi" => local_var_req_builder.query(
12714                &local_var_str
12715                    .into_iter()
12716                    .map(|p| ("name__nie".to_owned(), p.to_string()))
12717                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12718            ),
12719            _ => local_var_req_builder.query(&[(
12720                "name__nie",
12721                &local_var_str
12722                    .into_iter()
12723                    .map(|p| p.to_string())
12724                    .collect::<Vec<String>>()
12725                    .join(",")
12726                    .to_string(),
12727            )]),
12728        };
12729    }
12730    if let Some(ref local_var_str) = name__niew {
12731        local_var_req_builder = match "multi" {
12732            "multi" => local_var_req_builder.query(
12733                &local_var_str
12734                    .into_iter()
12735                    .map(|p| ("name__niew".to_owned(), p.to_string()))
12736                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12737            ),
12738            _ => local_var_req_builder.query(&[(
12739                "name__niew",
12740                &local_var_str
12741                    .into_iter()
12742                    .map(|p| p.to_string())
12743                    .collect::<Vec<String>>()
12744                    .join(",")
12745                    .to_string(),
12746            )]),
12747        };
12748    }
12749    if let Some(ref local_var_str) = name__nire {
12750        local_var_req_builder = match "multi" {
12751            "multi" => local_var_req_builder.query(
12752                &local_var_str
12753                    .into_iter()
12754                    .map(|p| ("name__nire".to_owned(), p.to_string()))
12755                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12756            ),
12757            _ => local_var_req_builder.query(&[(
12758                "name__nire",
12759                &local_var_str
12760                    .into_iter()
12761                    .map(|p| p.to_string())
12762                    .collect::<Vec<String>>()
12763                    .join(",")
12764                    .to_string(),
12765            )]),
12766        };
12767    }
12768    if let Some(ref local_var_str) = name__nisw {
12769        local_var_req_builder = match "multi" {
12770            "multi" => local_var_req_builder.query(
12771                &local_var_str
12772                    .into_iter()
12773                    .map(|p| ("name__nisw".to_owned(), p.to_string()))
12774                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12775            ),
12776            _ => local_var_req_builder.query(&[(
12777                "name__nisw",
12778                &local_var_str
12779                    .into_iter()
12780                    .map(|p| p.to_string())
12781                    .collect::<Vec<String>>()
12782                    .join(",")
12783                    .to_string(),
12784            )]),
12785        };
12786    }
12787    if let Some(ref local_var_str) = name__nre {
12788        local_var_req_builder = match "multi" {
12789            "multi" => local_var_req_builder.query(
12790                &local_var_str
12791                    .into_iter()
12792                    .map(|p| ("name__nre".to_owned(), p.to_string()))
12793                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12794            ),
12795            _ => local_var_req_builder.query(&[(
12796                "name__nre",
12797                &local_var_str
12798                    .into_iter()
12799                    .map(|p| p.to_string())
12800                    .collect::<Vec<String>>()
12801                    .join(",")
12802                    .to_string(),
12803            )]),
12804        };
12805    }
12806    if let Some(ref local_var_str) = name__re {
12807        local_var_req_builder = match "multi" {
12808            "multi" => local_var_req_builder.query(
12809                &local_var_str
12810                    .into_iter()
12811                    .map(|p| ("name__re".to_owned(), p.to_string()))
12812                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12813            ),
12814            _ => local_var_req_builder.query(&[(
12815                "name__re",
12816                &local_var_str
12817                    .into_iter()
12818                    .map(|p| p.to_string())
12819                    .collect::<Vec<String>>()
12820                    .join(",")
12821                    .to_string(),
12822            )]),
12823        };
12824    }
12825    if let Some(ref local_var_str) = offset {
12826        local_var_req_builder =
12827            local_var_req_builder.query(&[("offset", &local_var_str.to_string())]);
12828    }
12829    if let Some(ref local_var_str) = port {
12830        local_var_req_builder = match "multi" {
12831            "multi" => local_var_req_builder.query(
12832                &local_var_str
12833                    .into_iter()
12834                    .map(|p| ("port".to_owned(), p.to_string()))
12835                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12836            ),
12837            _ => local_var_req_builder.query(&[(
12838                "port",
12839                &local_var_str
12840                    .into_iter()
12841                    .map(|p| p.to_string())
12842                    .collect::<Vec<String>>()
12843                    .join(",")
12844                    .to_string(),
12845            )]),
12846        };
12847    }
12848    if let Some(ref local_var_str) = port__gt {
12849        local_var_req_builder = match "multi" {
12850            "multi" => local_var_req_builder.query(
12851                &local_var_str
12852                    .into_iter()
12853                    .map(|p| ("port__gt".to_owned(), p.to_string()))
12854                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12855            ),
12856            _ => local_var_req_builder.query(&[(
12857                "port__gt",
12858                &local_var_str
12859                    .into_iter()
12860                    .map(|p| p.to_string())
12861                    .collect::<Vec<String>>()
12862                    .join(",")
12863                    .to_string(),
12864            )]),
12865        };
12866    }
12867    if let Some(ref local_var_str) = port__gte {
12868        local_var_req_builder = match "multi" {
12869            "multi" => local_var_req_builder.query(
12870                &local_var_str
12871                    .into_iter()
12872                    .map(|p| ("port__gte".to_owned(), p.to_string()))
12873                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12874            ),
12875            _ => local_var_req_builder.query(&[(
12876                "port__gte",
12877                &local_var_str
12878                    .into_iter()
12879                    .map(|p| p.to_string())
12880                    .collect::<Vec<String>>()
12881                    .join(",")
12882                    .to_string(),
12883            )]),
12884        };
12885    }
12886    if let Some(ref local_var_str) = port__isnull {
12887        local_var_req_builder =
12888            local_var_req_builder.query(&[("port__isnull", &local_var_str.to_string())]);
12889    }
12890    if let Some(ref local_var_str) = port__lt {
12891        local_var_req_builder = match "multi" {
12892            "multi" => local_var_req_builder.query(
12893                &local_var_str
12894                    .into_iter()
12895                    .map(|p| ("port__lt".to_owned(), p.to_string()))
12896                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12897            ),
12898            _ => local_var_req_builder.query(&[(
12899                "port__lt",
12900                &local_var_str
12901                    .into_iter()
12902                    .map(|p| p.to_string())
12903                    .collect::<Vec<String>>()
12904                    .join(",")
12905                    .to_string(),
12906            )]),
12907        };
12908    }
12909    if let Some(ref local_var_str) = port__lte {
12910        local_var_req_builder = match "multi" {
12911            "multi" => local_var_req_builder.query(
12912                &local_var_str
12913                    .into_iter()
12914                    .map(|p| ("port__lte".to_owned(), p.to_string()))
12915                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12916            ),
12917            _ => local_var_req_builder.query(&[(
12918                "port__lte",
12919                &local_var_str
12920                    .into_iter()
12921                    .map(|p| p.to_string())
12922                    .collect::<Vec<String>>()
12923                    .join(",")
12924                    .to_string(),
12925            )]),
12926        };
12927    }
12928    if let Some(ref local_var_str) = port__n {
12929        local_var_req_builder = match "multi" {
12930            "multi" => local_var_req_builder.query(
12931                &local_var_str
12932                    .into_iter()
12933                    .map(|p| ("port__n".to_owned(), p.to_string()))
12934                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12935            ),
12936            _ => local_var_req_builder.query(&[(
12937                "port__n",
12938                &local_var_str
12939                    .into_iter()
12940                    .map(|p| p.to_string())
12941                    .collect::<Vec<String>>()
12942                    .join(",")
12943                    .to_string(),
12944            )]),
12945        };
12946    }
12947    if let Some(ref local_var_str) = protocol {
12948        local_var_req_builder = match "multi" {
12949            "multi" => local_var_req_builder.query(
12950                &local_var_str
12951                    .into_iter()
12952                    .map(|p| ("protocol".to_owned(), p.to_string()))
12953                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12954            ),
12955            _ => local_var_req_builder.query(&[(
12956                "protocol",
12957                &local_var_str
12958                    .into_iter()
12959                    .map(|p| p.to_string())
12960                    .collect::<Vec<String>>()
12961                    .join(",")
12962                    .to_string(),
12963            )]),
12964        };
12965    }
12966    if let Some(ref local_var_str) = protocol__ic {
12967        local_var_req_builder = match "multi" {
12968            "multi" => local_var_req_builder.query(
12969                &local_var_str
12970                    .into_iter()
12971                    .map(|p| ("protocol__ic".to_owned(), p.to_string()))
12972                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12973            ),
12974            _ => local_var_req_builder.query(&[(
12975                "protocol__ic",
12976                &local_var_str
12977                    .into_iter()
12978                    .map(|p| p.to_string())
12979                    .collect::<Vec<String>>()
12980                    .join(",")
12981                    .to_string(),
12982            )]),
12983        };
12984    }
12985    if let Some(ref local_var_str) = protocol__ie {
12986        local_var_req_builder = match "multi" {
12987            "multi" => local_var_req_builder.query(
12988                &local_var_str
12989                    .into_iter()
12990                    .map(|p| ("protocol__ie".to_owned(), p.to_string()))
12991                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12992            ),
12993            _ => local_var_req_builder.query(&[(
12994                "protocol__ie",
12995                &local_var_str
12996                    .into_iter()
12997                    .map(|p| p.to_string())
12998                    .collect::<Vec<String>>()
12999                    .join(",")
13000                    .to_string(),
13001            )]),
13002        };
13003    }
13004    if let Some(ref local_var_str) = protocol__iew {
13005        local_var_req_builder = match "multi" {
13006            "multi" => local_var_req_builder.query(
13007                &local_var_str
13008                    .into_iter()
13009                    .map(|p| ("protocol__iew".to_owned(), p.to_string()))
13010                    .collect::<Vec<(std::string::String, std::string::String)>>(),
13011            ),
13012            _ => local_var_req_builder.query(&[(
13013                "protocol__iew",
13014                &local_var_str
13015                    .into_iter()
13016                    .map(|p| p.to_string())
13017                    .collect::<Vec<String>>()
13018                    .join(",")
13019                    .to_string(),
13020            )]),
13021        };
13022    }
13023    if let Some(ref local_var_str) = protocol__ire {
13024        local_var_req_builder = match "multi" {
13025            "multi" => local_var_req_builder.query(
13026                &local_var_str
13027                    .into_iter()
13028                    .map(|p| ("protocol__ire".to_owned(), p.to_string()))
13029                    .collect::<Vec<(std::string::String, std::string::String)>>(),
13030            ),
13031            _ => local_var_req_builder.query(&[(
13032                "protocol__ire",
13033                &local_var_str
13034                    .into_iter()
13035                    .map(|p| p.to_string())
13036                    .collect::<Vec<String>>()
13037                    .join(",")
13038                    .to_string(),
13039            )]),
13040        };
13041    }
13042    if let Some(ref local_var_str) = protocol__isw {
13043        local_var_req_builder = match "multi" {
13044            "multi" => local_var_req_builder.query(
13045                &local_var_str
13046                    .into_iter()
13047                    .map(|p| ("protocol__isw".to_owned(), p.to_string()))
13048                    .collect::<Vec<(std::string::String, std::string::String)>>(),
13049            ),
13050            _ => local_var_req_builder.query(&[(
13051                "protocol__isw",
13052                &local_var_str
13053                    .into_iter()
13054                    .map(|p| p.to_string())
13055                    .collect::<Vec<String>>()
13056                    .join(",")
13057                    .to_string(),
13058            )]),
13059        };
13060    }
13061    if let Some(ref local_var_str) = protocol__n {
13062        local_var_req_builder = match "multi" {
13063            "multi" => local_var_req_builder.query(
13064                &local_var_str
13065                    .into_iter()
13066                    .map(|p| ("protocol__n".to_owned(), p.to_string()))
13067                    .collect::<Vec<(std::string::String, std::string::String)>>(),
13068            ),
13069            _ => local_var_req_builder.query(&[(
13070                "protocol__n",
13071                &local_var_str
13072                    .into_iter()
13073                    .map(|p| p.to_string())
13074                    .collect::<Vec<String>>()
13075                    .join(",")
13076                    .to_string(),
13077            )]),
13078        };
13079    }
13080    if let Some(ref local_var_str) = protocol__nic {
13081        local_var_req_builder = match "multi" {
13082            "multi" => local_var_req_builder.query(
13083                &local_var_str
13084                    .into_iter()
13085                    .map(|p| ("protocol__nic".to_owned(), p.to_string()))
13086                    .collect::<Vec<(std::string::String, std::string::String)>>(),
13087            ),
13088            _ => local_var_req_builder.query(&[(
13089                "protocol__nic",
13090                &local_var_str
13091                    .into_iter()
13092                    .map(|p| p.to_string())
13093                    .collect::<Vec<String>>()
13094                    .join(",")
13095                    .to_string(),
13096            )]),
13097        };
13098    }
13099    if let Some(ref local_var_str) = protocol__nie {
13100        local_var_req_builder = match "multi" {
13101            "multi" => local_var_req_builder.query(
13102                &local_var_str
13103                    .into_iter()
13104                    .map(|p| ("protocol__nie".to_owned(), p.to_string()))
13105                    .collect::<Vec<(std::string::String, std::string::String)>>(),
13106            ),
13107            _ => local_var_req_builder.query(&[(
13108                "protocol__nie",
13109                &local_var_str
13110                    .into_iter()
13111                    .map(|p| p.to_string())
13112                    .collect::<Vec<String>>()
13113                    .join(",")
13114                    .to_string(),
13115            )]),
13116        };
13117    }
13118    if let Some(ref local_var_str) = protocol__niew {
13119        local_var_req_builder = match "multi" {
13120            "multi" => local_var_req_builder.query(
13121                &local_var_str
13122                    .into_iter()
13123                    .map(|p| ("protocol__niew".to_owned(), p.to_string()))
13124                    .collect::<Vec<(std::string::String, std::string::String)>>(),
13125            ),
13126            _ => local_var_req_builder.query(&[(
13127                "protocol__niew",
13128                &local_var_str
13129                    .into_iter()
13130                    .map(|p| p.to_string())
13131                    .collect::<Vec<String>>()
13132                    .join(",")
13133                    .to_string(),
13134            )]),
13135        };
13136    }
13137    if let Some(ref local_var_str) = protocol__nire {
13138        local_var_req_builder = match "multi" {
13139            "multi" => local_var_req_builder.query(
13140                &local_var_str
13141                    .into_iter()
13142                    .map(|p| ("protocol__nire".to_owned(), p.to_string()))
13143                    .collect::<Vec<(std::string::String, std::string::String)>>(),
13144            ),
13145            _ => local_var_req_builder.query(&[(
13146                "protocol__nire",
13147                &local_var_str
13148                    .into_iter()
13149                    .map(|p| p.to_string())
13150                    .collect::<Vec<String>>()
13151                    .join(",")
13152                    .to_string(),
13153            )]),
13154        };
13155    }
13156    if let Some(ref local_var_str) = protocol__nisw {
13157        local_var_req_builder = match "multi" {
13158            "multi" => local_var_req_builder.query(
13159                &local_var_str
13160                    .into_iter()
13161                    .map(|p| ("protocol__nisw".to_owned(), p.to_string()))
13162                    .collect::<Vec<(std::string::String, std::string::String)>>(),
13163            ),
13164            _ => local_var_req_builder.query(&[(
13165                "protocol__nisw",
13166                &local_var_str
13167                    .into_iter()
13168                    .map(|p| p.to_string())
13169                    .collect::<Vec<String>>()
13170                    .join(",")
13171                    .to_string(),
13172            )]),
13173        };
13174    }
13175    if let Some(ref local_var_str) = protocol__nre {
13176        local_var_req_builder = match "multi" {
13177            "multi" => local_var_req_builder.query(
13178                &local_var_str
13179                    .into_iter()
13180                    .map(|p| ("protocol__nre".to_owned(), p.to_string()))
13181                    .collect::<Vec<(std::string::String, std::string::String)>>(),
13182            ),
13183            _ => local_var_req_builder.query(&[(
13184                "protocol__nre",
13185                &local_var_str
13186                    .into_iter()
13187                    .map(|p| p.to_string())
13188                    .collect::<Vec<String>>()
13189                    .join(",")
13190                    .to_string(),
13191            )]),
13192        };
13193    }
13194    if let Some(ref local_var_str) = protocol__re {
13195        local_var_req_builder = match "multi" {
13196            "multi" => local_var_req_builder.query(
13197                &local_var_str
13198                    .into_iter()
13199                    .map(|p| ("protocol__re".to_owned(), p.to_string()))
13200                    .collect::<Vec<(std::string::String, std::string::String)>>(),
13201            ),
13202            _ => local_var_req_builder.query(&[(
13203                "protocol__re",
13204                &local_var_str
13205                    .into_iter()
13206                    .map(|p| p.to_string())
13207                    .collect::<Vec<String>>()
13208                    .join(",")
13209                    .to_string(),
13210            )]),
13211        };
13212    }
13213    if let Some(ref local_var_str) = q {
13214        local_var_req_builder = local_var_req_builder.query(&[("q", &local_var_str.to_string())]);
13215    }
13216    if let Some(ref local_var_str) = sort {
13217        local_var_req_builder =
13218            local_var_req_builder.query(&[("sort", &local_var_str.to_string())]);
13219    }
13220    if let Some(ref local_var_str) = source_nat_pool {
13221        local_var_req_builder = match "multi" {
13222            "multi" => local_var_req_builder.query(
13223                &local_var_str
13224                    .into_iter()
13225                    .map(|p| ("source_nat_pool".to_owned(), p.to_string()))
13226                    .collect::<Vec<(std::string::String, std::string::String)>>(),
13227            ),
13228            _ => local_var_req_builder.query(&[(
13229                "source_nat_pool",
13230                &local_var_str
13231                    .into_iter()
13232                    .map(|p| p.to_string())
13233                    .collect::<Vec<String>>()
13234                    .join(",")
13235                    .to_string(),
13236            )]),
13237        };
13238    }
13239    if let Some(ref local_var_str) = source_nat_pool__isnull {
13240        local_var_req_builder =
13241            local_var_req_builder.query(&[("source_nat_pool__isnull", &local_var_str.to_string())]);
13242    }
13243    if let Some(ref local_var_str) = source_nat_pool__n {
13244        local_var_req_builder = match "multi" {
13245            "multi" => local_var_req_builder.query(
13246                &local_var_str
13247                    .into_iter()
13248                    .map(|p| ("source_nat_pool__n".to_owned(), p.to_string()))
13249                    .collect::<Vec<(std::string::String, std::string::String)>>(),
13250            ),
13251            _ => local_var_req_builder.query(&[(
13252                "source_nat_pool__n",
13253                &local_var_str
13254                    .into_iter()
13255                    .map(|p| p.to_string())
13256                    .collect::<Vec<String>>()
13257                    .join(",")
13258                    .to_string(),
13259            )]),
13260        };
13261    }
13262    if let Some(ref local_var_str) = source_nat_type {
13263        local_var_req_builder = match "multi" {
13264            "multi" => local_var_req_builder.query(
13265                &local_var_str
13266                    .into_iter()
13267                    .map(|p| ("source_nat_type".to_owned(), p.to_string()))
13268                    .collect::<Vec<(std::string::String, std::string::String)>>(),
13269            ),
13270            _ => local_var_req_builder.query(&[(
13271                "source_nat_type",
13272                &local_var_str
13273                    .into_iter()
13274                    .map(|p| p.to_string())
13275                    .collect::<Vec<String>>()
13276                    .join(",")
13277                    .to_string(),
13278            )]),
13279        };
13280    }
13281    if let Some(ref local_var_str) = source_nat_type__ic {
13282        local_var_req_builder = match "multi" {
13283            "multi" => local_var_req_builder.query(
13284                &local_var_str
13285                    .into_iter()
13286                    .map(|p| ("source_nat_type__ic".to_owned(), p.to_string()))
13287                    .collect::<Vec<(std::string::String, std::string::String)>>(),
13288            ),
13289            _ => local_var_req_builder.query(&[(
13290                "source_nat_type__ic",
13291                &local_var_str
13292                    .into_iter()
13293                    .map(|p| p.to_string())
13294                    .collect::<Vec<String>>()
13295                    .join(",")
13296                    .to_string(),
13297            )]),
13298        };
13299    }
13300    if let Some(ref local_var_str) = source_nat_type__ie {
13301        local_var_req_builder = match "multi" {
13302            "multi" => local_var_req_builder.query(
13303                &local_var_str
13304                    .into_iter()
13305                    .map(|p| ("source_nat_type__ie".to_owned(), p.to_string()))
13306                    .collect::<Vec<(std::string::String, std::string::String)>>(),
13307            ),
13308            _ => local_var_req_builder.query(&[(
13309                "source_nat_type__ie",
13310                &local_var_str
13311                    .into_iter()
13312                    .map(|p| p.to_string())
13313                    .collect::<Vec<String>>()
13314                    .join(",")
13315                    .to_string(),
13316            )]),
13317        };
13318    }
13319    if let Some(ref local_var_str) = source_nat_type__iew {
13320        local_var_req_builder = match "multi" {
13321            "multi" => local_var_req_builder.query(
13322                &local_var_str
13323                    .into_iter()
13324                    .map(|p| ("source_nat_type__iew".to_owned(), p.to_string()))
13325                    .collect::<Vec<(std::string::String, std::string::String)>>(),
13326            ),
13327            _ => local_var_req_builder.query(&[(
13328                "source_nat_type__iew",
13329                &local_var_str
13330                    .into_iter()
13331                    .map(|p| p.to_string())
13332                    .collect::<Vec<String>>()
13333                    .join(",")
13334                    .to_string(),
13335            )]),
13336        };
13337    }
13338    if let Some(ref local_var_str) = source_nat_type__ire {
13339        local_var_req_builder = match "multi" {
13340            "multi" => local_var_req_builder.query(
13341                &local_var_str
13342                    .into_iter()
13343                    .map(|p| ("source_nat_type__ire".to_owned(), p.to_string()))
13344                    .collect::<Vec<(std::string::String, std::string::String)>>(),
13345            ),
13346            _ => local_var_req_builder.query(&[(
13347                "source_nat_type__ire",
13348                &local_var_str
13349                    .into_iter()
13350                    .map(|p| p.to_string())
13351                    .collect::<Vec<String>>()
13352                    .join(",")
13353                    .to_string(),
13354            )]),
13355        };
13356    }
13357    if let Some(ref local_var_str) = source_nat_type__isw {
13358        local_var_req_builder = match "multi" {
13359            "multi" => local_var_req_builder.query(
13360                &local_var_str
13361                    .into_iter()
13362                    .map(|p| ("source_nat_type__isw".to_owned(), p.to_string()))
13363                    .collect::<Vec<(std::string::String, std::string::String)>>(),
13364            ),
13365            _ => local_var_req_builder.query(&[(
13366                "source_nat_type__isw",
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) = source_nat_type__n {
13377        local_var_req_builder = match "multi" {
13378            "multi" => local_var_req_builder.query(
13379                &local_var_str
13380                    .into_iter()
13381                    .map(|p| ("source_nat_type__n".to_owned(), p.to_string()))
13382                    .collect::<Vec<(std::string::String, std::string::String)>>(),
13383            ),
13384            _ => local_var_req_builder.query(&[(
13385                "source_nat_type__n",
13386                &local_var_str
13387                    .into_iter()
13388                    .map(|p| p.to_string())
13389                    .collect::<Vec<String>>()
13390                    .join(",")
13391                    .to_string(),
13392            )]),
13393        };
13394    }
13395    if let Some(ref local_var_str) = source_nat_type__nic {
13396        local_var_req_builder = match "multi" {
13397            "multi" => local_var_req_builder.query(
13398                &local_var_str
13399                    .into_iter()
13400                    .map(|p| ("source_nat_type__nic".to_owned(), p.to_string()))
13401                    .collect::<Vec<(std::string::String, std::string::String)>>(),
13402            ),
13403            _ => local_var_req_builder.query(&[(
13404                "source_nat_type__nic",
13405                &local_var_str
13406                    .into_iter()
13407                    .map(|p| p.to_string())
13408                    .collect::<Vec<String>>()
13409                    .join(",")
13410                    .to_string(),
13411            )]),
13412        };
13413    }
13414    if let Some(ref local_var_str) = source_nat_type__nie {
13415        local_var_req_builder = match "multi" {
13416            "multi" => local_var_req_builder.query(
13417                &local_var_str
13418                    .into_iter()
13419                    .map(|p| ("source_nat_type__nie".to_owned(), p.to_string()))
13420                    .collect::<Vec<(std::string::String, std::string::String)>>(),
13421            ),
13422            _ => local_var_req_builder.query(&[(
13423                "source_nat_type__nie",
13424                &local_var_str
13425                    .into_iter()
13426                    .map(|p| p.to_string())
13427                    .collect::<Vec<String>>()
13428                    .join(",")
13429                    .to_string(),
13430            )]),
13431        };
13432    }
13433    if let Some(ref local_var_str) = source_nat_type__niew {
13434        local_var_req_builder = match "multi" {
13435            "multi" => local_var_req_builder.query(
13436                &local_var_str
13437                    .into_iter()
13438                    .map(|p| ("source_nat_type__niew".to_owned(), p.to_string()))
13439                    .collect::<Vec<(std::string::String, std::string::String)>>(),
13440            ),
13441            _ => local_var_req_builder.query(&[(
13442                "source_nat_type__niew",
13443                &local_var_str
13444                    .into_iter()
13445                    .map(|p| p.to_string())
13446                    .collect::<Vec<String>>()
13447                    .join(",")
13448                    .to_string(),
13449            )]),
13450        };
13451    }
13452    if let Some(ref local_var_str) = source_nat_type__nire {
13453        local_var_req_builder = match "multi" {
13454            "multi" => local_var_req_builder.query(
13455                &local_var_str
13456                    .into_iter()
13457                    .map(|p| ("source_nat_type__nire".to_owned(), p.to_string()))
13458                    .collect::<Vec<(std::string::String, std::string::String)>>(),
13459            ),
13460            _ => local_var_req_builder.query(&[(
13461                "source_nat_type__nire",
13462                &local_var_str
13463                    .into_iter()
13464                    .map(|p| p.to_string())
13465                    .collect::<Vec<String>>()
13466                    .join(",")
13467                    .to_string(),
13468            )]),
13469        };
13470    }
13471    if let Some(ref local_var_str) = source_nat_type__nisw {
13472        local_var_req_builder = match "multi" {
13473            "multi" => local_var_req_builder.query(
13474                &local_var_str
13475                    .into_iter()
13476                    .map(|p| ("source_nat_type__nisw".to_owned(), p.to_string()))
13477                    .collect::<Vec<(std::string::String, std::string::String)>>(),
13478            ),
13479            _ => local_var_req_builder.query(&[(
13480                "source_nat_type__nisw",
13481                &local_var_str
13482                    .into_iter()
13483                    .map(|p| p.to_string())
13484                    .collect::<Vec<String>>()
13485                    .join(",")
13486                    .to_string(),
13487            )]),
13488        };
13489    }
13490    if let Some(ref local_var_str) = source_nat_type__nre {
13491        local_var_req_builder = match "multi" {
13492            "multi" => local_var_req_builder.query(
13493                &local_var_str
13494                    .into_iter()
13495                    .map(|p| ("source_nat_type__nre".to_owned(), p.to_string()))
13496                    .collect::<Vec<(std::string::String, std::string::String)>>(),
13497            ),
13498            _ => local_var_req_builder.query(&[(
13499                "source_nat_type__nre",
13500                &local_var_str
13501                    .into_iter()
13502                    .map(|p| p.to_string())
13503                    .collect::<Vec<String>>()
13504                    .join(",")
13505                    .to_string(),
13506            )]),
13507        };
13508    }
13509    if let Some(ref local_var_str) = source_nat_type__re {
13510        local_var_req_builder = match "multi" {
13511            "multi" => local_var_req_builder.query(
13512                &local_var_str
13513                    .into_iter()
13514                    .map(|p| ("source_nat_type__re".to_owned(), p.to_string()))
13515                    .collect::<Vec<(std::string::String, std::string::String)>>(),
13516            ),
13517            _ => local_var_req_builder.query(&[(
13518                "source_nat_type__re",
13519                &local_var_str
13520                    .into_iter()
13521                    .map(|p| p.to_string())
13522                    .collect::<Vec<String>>()
13523                    .join(",")
13524                    .to_string(),
13525            )]),
13526        };
13527    }
13528    if let Some(ref local_var_str) = ssl_offload {
13529        local_var_req_builder =
13530            local_var_req_builder.query(&[("ssl_offload", &local_var_str.to_string())]);
13531    }
13532    if let Some(ref local_var_str) = tags {
13533        local_var_req_builder = match "multi" {
13534            "multi" => local_var_req_builder.query(
13535                &local_var_str
13536                    .into_iter()
13537                    .map(|p| ("tags".to_owned(), p.to_string()))
13538                    .collect::<Vec<(std::string::String, std::string::String)>>(),
13539            ),
13540            _ => local_var_req_builder.query(&[(
13541                "tags",
13542                &local_var_str
13543                    .into_iter()
13544                    .map(|p| p.to_string())
13545                    .collect::<Vec<String>>()
13546                    .join(",")
13547                    .to_string(),
13548            )]),
13549        };
13550    }
13551    if let Some(ref local_var_str) = tags__isnull {
13552        local_var_req_builder =
13553            local_var_req_builder.query(&[("tags__isnull", &local_var_str.to_string())]);
13554    }
13555    if let Some(ref local_var_str) = tags__n {
13556        local_var_req_builder = match "multi" {
13557            "multi" => local_var_req_builder.query(
13558                &local_var_str
13559                    .into_iter()
13560                    .map(|p| ("tags__n".to_owned(), p.to_string()))
13561                    .collect::<Vec<(std::string::String, std::string::String)>>(),
13562            ),
13563            _ => local_var_req_builder.query(&[(
13564                "tags__n",
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) = teams {
13575        local_var_req_builder = match "multi" {
13576            "multi" => local_var_req_builder.query(
13577                &local_var_str
13578                    .into_iter()
13579                    .map(|p| ("teams".to_owned(), p.to_string()))
13580                    .collect::<Vec<(std::string::String, std::string::String)>>(),
13581            ),
13582            _ => local_var_req_builder.query(&[(
13583                "teams",
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) = teams__isnull {
13594        local_var_req_builder =
13595            local_var_req_builder.query(&[("teams__isnull", &local_var_str.to_string())]);
13596    }
13597    if let Some(ref local_var_str) = teams__n {
13598        local_var_req_builder = match "multi" {
13599            "multi" => local_var_req_builder.query(
13600                &local_var_str
13601                    .into_iter()
13602                    .map(|p| ("teams__n".to_owned(), p.to_string()))
13603                    .collect::<Vec<(std::string::String, std::string::String)>>(),
13604            ),
13605            _ => local_var_req_builder.query(&[(
13606                "teams__n",
13607                &local_var_str
13608                    .into_iter()
13609                    .map(|p| p.to_string())
13610                    .collect::<Vec<String>>()
13611                    .join(",")
13612                    .to_string(),
13613            )]),
13614        };
13615    }
13616    if let Some(ref local_var_str) = tenant {
13617        local_var_req_builder = match "multi" {
13618            "multi" => local_var_req_builder.query(
13619                &local_var_str
13620                    .into_iter()
13621                    .map(|p| ("tenant".to_owned(), p.to_string()))
13622                    .collect::<Vec<(std::string::String, std::string::String)>>(),
13623            ),
13624            _ => local_var_req_builder.query(&[(
13625                "tenant",
13626                &local_var_str
13627                    .into_iter()
13628                    .map(|p| p.to_string())
13629                    .collect::<Vec<String>>()
13630                    .join(",")
13631                    .to_string(),
13632            )]),
13633        };
13634    }
13635    if let Some(ref local_var_str) = tenant__isnull {
13636        local_var_req_builder =
13637            local_var_req_builder.query(&[("tenant__isnull", &local_var_str.to_string())]);
13638    }
13639    if let Some(ref local_var_str) = tenant__n {
13640        local_var_req_builder = match "multi" {
13641            "multi" => local_var_req_builder.query(
13642                &local_var_str
13643                    .into_iter()
13644                    .map(|p| ("tenant__n".to_owned(), p.to_string()))
13645                    .collect::<Vec<(std::string::String, std::string::String)>>(),
13646            ),
13647            _ => local_var_req_builder.query(&[(
13648                "tenant__n",
13649                &local_var_str
13650                    .into_iter()
13651                    .map(|p| p.to_string())
13652                    .collect::<Vec<String>>()
13653                    .join(",")
13654                    .to_string(),
13655            )]),
13656        };
13657    }
13658    if let Some(ref local_var_str) = tenant_group {
13659        local_var_req_builder = match "multi" {
13660            "multi" => local_var_req_builder.query(
13661                &local_var_str
13662                    .into_iter()
13663                    .map(|p| ("tenant_group".to_owned(), p.to_string()))
13664                    .collect::<Vec<(std::string::String, std::string::String)>>(),
13665            ),
13666            _ => local_var_req_builder.query(&[(
13667                "tenant_group",
13668                &local_var_str
13669                    .into_iter()
13670                    .map(|p| p.to_string())
13671                    .collect::<Vec<String>>()
13672                    .join(",")
13673                    .to_string(),
13674            )]),
13675        };
13676    }
13677    if let Some(ref local_var_str) = tenant_group__isnull {
13678        local_var_req_builder =
13679            local_var_req_builder.query(&[("tenant_group__isnull", &local_var_str.to_string())]);
13680    }
13681    if let Some(ref local_var_str) = tenant_group__n {
13682        local_var_req_builder = match "multi" {
13683            "multi" => local_var_req_builder.query(
13684                &local_var_str
13685                    .into_iter()
13686                    .map(|p| ("tenant_group__n".to_owned(), p.to_string()))
13687                    .collect::<Vec<(std::string::String, std::string::String)>>(),
13688            ),
13689            _ => local_var_req_builder.query(&[(
13690                "tenant_group__n",
13691                &local_var_str
13692                    .into_iter()
13693                    .map(|p| p.to_string())
13694                    .collect::<Vec<String>>()
13695                    .join(",")
13696                    .to_string(),
13697            )]),
13698        };
13699    }
13700    if let Some(ref local_var_str) = tenant_id {
13701        local_var_req_builder = match "multi" {
13702            "multi" => local_var_req_builder.query(
13703                &local_var_str
13704                    .into_iter()
13705                    .map(|p| ("tenant_id".to_owned(), p.to_string()))
13706                    .collect::<Vec<(std::string::String, std::string::String)>>(),
13707            ),
13708            _ => local_var_req_builder.query(&[(
13709                "tenant_id",
13710                &local_var_str
13711                    .into_iter()
13712                    .map(|p| p.to_string())
13713                    .collect::<Vec<String>>()
13714                    .join(",")
13715                    .to_string(),
13716            )]),
13717        };
13718    }
13719    if let Some(ref local_var_str) = tenant_id__isnull {
13720        local_var_req_builder =
13721            local_var_req_builder.query(&[("tenant_id__isnull", &local_var_str.to_string())]);
13722    }
13723    if let Some(ref local_var_str) = tenant_id__n {
13724        local_var_req_builder = match "multi" {
13725            "multi" => local_var_req_builder.query(
13726                &local_var_str
13727                    .into_iter()
13728                    .map(|p| ("tenant_id__n".to_owned(), p.to_string()))
13729                    .collect::<Vec<(std::string::String, std::string::String)>>(),
13730            ),
13731            _ => local_var_req_builder.query(&[(
13732                "tenant_id__n",
13733                &local_var_str
13734                    .into_iter()
13735                    .map(|p| p.to_string())
13736                    .collect::<Vec<String>>()
13737                    .join(",")
13738                    .to_string(),
13739            )]),
13740        };
13741    }
13742    if let Some(ref local_var_str) = vip {
13743        local_var_req_builder = match "multi" {
13744            "multi" => local_var_req_builder.query(
13745                &local_var_str
13746                    .into_iter()
13747                    .map(|p| ("vip".to_owned(), p.to_string()))
13748                    .collect::<Vec<(std::string::String, std::string::String)>>(),
13749            ),
13750            _ => local_var_req_builder.query(&[(
13751                "vip",
13752                &local_var_str
13753                    .into_iter()
13754                    .map(|p| p.to_string())
13755                    .collect::<Vec<String>>()
13756                    .join(",")
13757                    .to_string(),
13758            )]),
13759        };
13760    }
13761    if let Some(ref local_var_str) = vip__n {
13762        local_var_req_builder = match "multi" {
13763            "multi" => local_var_req_builder.query(
13764                &local_var_str
13765                    .into_iter()
13766                    .map(|p| ("vip__n".to_owned(), p.to_string()))
13767                    .collect::<Vec<(std::string::String, std::string::String)>>(),
13768            ),
13769            _ => local_var_req_builder.query(&[(
13770                "vip__n",
13771                &local_var_str
13772                    .into_iter()
13773                    .map(|p| p.to_string())
13774                    .collect::<Vec<String>>()
13775                    .join(",")
13776                    .to_string(),
13777            )]),
13778        };
13779    }
13780    if let Some(ref local_var_str) = virtual_chassis {
13781        local_var_req_builder = match "multi" {
13782            "multi" => local_var_req_builder.query(
13783                &local_var_str
13784                    .into_iter()
13785                    .map(|p| ("virtual_chassis".to_owned(), p.to_string()))
13786                    .collect::<Vec<(std::string::String, std::string::String)>>(),
13787            ),
13788            _ => local_var_req_builder.query(&[(
13789                "virtual_chassis",
13790                &local_var_str
13791                    .into_iter()
13792                    .map(|p| p.to_string())
13793                    .collect::<Vec<String>>()
13794                    .join(",")
13795                    .to_string(),
13796            )]),
13797        };
13798    }
13799    if let Some(ref local_var_str) = virtual_chassis__isnull {
13800        local_var_req_builder =
13801            local_var_req_builder.query(&[("virtual_chassis__isnull", &local_var_str.to_string())]);
13802    }
13803    if let Some(ref local_var_str) = virtual_chassis__n {
13804        local_var_req_builder = match "multi" {
13805            "multi" => local_var_req_builder.query(
13806                &local_var_str
13807                    .into_iter()
13808                    .map(|p| ("virtual_chassis__n".to_owned(), p.to_string()))
13809                    .collect::<Vec<(std::string::String, std::string::String)>>(),
13810            ),
13811            _ => local_var_req_builder.query(&[(
13812                "virtual_chassis__n",
13813                &local_var_str
13814                    .into_iter()
13815                    .map(|p| p.to_string())
13816                    .collect::<Vec<String>>()
13817                    .join(",")
13818                    .to_string(),
13819            )]),
13820        };
13821    }
13822    if let Some(ref local_var_str) = depth {
13823        local_var_req_builder =
13824            local_var_req_builder.query(&[("depth", &local_var_str.to_string())]);
13825    }
13826    if let Some(ref local_var_str) = exclude_m2m {
13827        local_var_req_builder =
13828            local_var_req_builder.query(&[("exclude_m2m", &local_var_str.to_string())]);
13829    }
13830    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
13831        local_var_req_builder =
13832            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
13833    }
13834    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
13835        let local_var_key = local_var_apikey.key.clone();
13836        let local_var_value = match local_var_apikey.prefix {
13837            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
13838            None => local_var_key,
13839        };
13840        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
13841    };
13842
13843    let local_var_req = local_var_req_builder.build()?;
13844    let local_var_resp = local_var_client.execute(local_var_req).await?;
13845
13846    let local_var_status = local_var_resp.status();
13847    let local_var_content = local_var_resp.text().await?;
13848
13849    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
13850        serde_json::from_str(&local_var_content).map_err(Error::from)
13851    } else {
13852        let local_var_entity: Option<LoadBalancersVirtualServersListError> =
13853            serde_json::from_str(&local_var_content).ok();
13854        let local_var_error = ResponseContent {
13855            status: local_var_status,
13856            content: local_var_content,
13857            entity: local_var_entity,
13858        };
13859        Err(Error::ResponseError(local_var_error))
13860    }
13861}
13862
13863/// API methods for returning or creating notes on an object.
13864pub async fn load_balancers_virtual_servers_notes_create(
13865    configuration: &configuration::Configuration,
13866    id: &str,
13867    note_input_request: crate::models::NoteInputRequest,
13868    format: Option<&str>,
13869) -> Result<crate::models::Note, Error<LoadBalancersVirtualServersNotesCreateError>> {
13870    let local_var_configuration = configuration;
13871
13872    let local_var_client = &local_var_configuration.client;
13873
13874    let local_var_uri_str = format!(
13875        "{}/load-balancers/virtual-servers/{id}/notes/",
13876        local_var_configuration.base_path,
13877        id = crate::apis::urlencode(id)
13878    );
13879    let mut local_var_req_builder =
13880        local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
13881
13882    if let Some(ref local_var_str) = format {
13883        local_var_req_builder =
13884            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
13885    }
13886    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
13887        local_var_req_builder =
13888            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
13889    }
13890    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
13891        let local_var_key = local_var_apikey.key.clone();
13892        let local_var_value = match local_var_apikey.prefix {
13893            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
13894            None => local_var_key,
13895        };
13896        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
13897    };
13898    local_var_req_builder = local_var_req_builder.json(&note_input_request);
13899
13900    let local_var_req = local_var_req_builder.build()?;
13901    let local_var_resp = local_var_client.execute(local_var_req).await?;
13902
13903    let local_var_status = local_var_resp.status();
13904    let local_var_content = local_var_resp.text().await?;
13905
13906    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
13907        serde_json::from_str(&local_var_content).map_err(Error::from)
13908    } else {
13909        let local_var_entity: Option<LoadBalancersVirtualServersNotesCreateError> =
13910            serde_json::from_str(&local_var_content).ok();
13911        let local_var_error = ResponseContent {
13912            status: local_var_status,
13913            content: local_var_content,
13914            entity: local_var_entity,
13915        };
13916        Err(Error::ResponseError(local_var_error))
13917    }
13918}
13919
13920/// API methods for returning or creating notes on an object.
13921pub async fn load_balancers_virtual_servers_notes_list(
13922    configuration: &configuration::Configuration,
13923    id: &str,
13924    format: Option<&str>,
13925    limit: Option<i32>,
13926    offset: Option<i32>,
13927    depth: Option<i32>,
13928    exclude_m2m: Option<bool>,
13929) -> Result<crate::models::PaginatedNoteList, Error<LoadBalancersVirtualServersNotesListError>> {
13930    let local_var_configuration = configuration;
13931
13932    let local_var_client = &local_var_configuration.client;
13933
13934    let local_var_uri_str = format!(
13935        "{}/load-balancers/virtual-servers/{id}/notes/",
13936        local_var_configuration.base_path,
13937        id = crate::apis::urlencode(id)
13938    );
13939    let mut local_var_req_builder =
13940        local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
13941
13942    if let Some(ref local_var_str) = format {
13943        local_var_req_builder =
13944            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
13945    }
13946    if let Some(ref local_var_str) = limit {
13947        local_var_req_builder =
13948            local_var_req_builder.query(&[("limit", &local_var_str.to_string())]);
13949    }
13950    if let Some(ref local_var_str) = offset {
13951        local_var_req_builder =
13952            local_var_req_builder.query(&[("offset", &local_var_str.to_string())]);
13953    }
13954    if let Some(ref local_var_str) = depth {
13955        local_var_req_builder =
13956            local_var_req_builder.query(&[("depth", &local_var_str.to_string())]);
13957    }
13958    if let Some(ref local_var_str) = exclude_m2m {
13959        local_var_req_builder =
13960            local_var_req_builder.query(&[("exclude_m2m", &local_var_str.to_string())]);
13961    }
13962    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
13963        local_var_req_builder =
13964            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
13965    }
13966    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
13967        let local_var_key = local_var_apikey.key.clone();
13968        let local_var_value = match local_var_apikey.prefix {
13969            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
13970            None => local_var_key,
13971        };
13972        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
13973    };
13974
13975    let local_var_req = local_var_req_builder.build()?;
13976    let local_var_resp = local_var_client.execute(local_var_req).await?;
13977
13978    let local_var_status = local_var_resp.status();
13979    let local_var_content = local_var_resp.text().await?;
13980
13981    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
13982        serde_json::from_str(&local_var_content).map_err(Error::from)
13983    } else {
13984        let local_var_entity: Option<LoadBalancersVirtualServersNotesListError> =
13985            serde_json::from_str(&local_var_content).ok();
13986        let local_var_error = ResponseContent {
13987            status: local_var_status,
13988            content: local_var_content,
13989            entity: local_var_entity,
13990        };
13991        Err(Error::ResponseError(local_var_error))
13992    }
13993}
13994
13995/// VirtualServer viewset.
13996pub async fn load_balancers_virtual_servers_partial_update(
13997    configuration: &configuration::Configuration,
13998    id: &str,
13999    format: Option<&str>,
14000    patched_virtual_server_request: Option<crate::models::PatchedVirtualServerRequest>,
14001) -> Result<crate::models::VirtualServer, Error<LoadBalancersVirtualServersPartialUpdateError>> {
14002    let local_var_configuration = configuration;
14003
14004    let local_var_client = &local_var_configuration.client;
14005
14006    let local_var_uri_str = format!(
14007        "{}/load-balancers/virtual-servers/{id}/",
14008        local_var_configuration.base_path,
14009        id = crate::apis::urlencode(id)
14010    );
14011    let mut local_var_req_builder =
14012        local_var_client.request(reqwest::Method::PATCH, local_var_uri_str.as_str());
14013
14014    if let Some(ref local_var_str) = format {
14015        local_var_req_builder =
14016            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
14017    }
14018    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
14019        local_var_req_builder =
14020            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
14021    }
14022    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
14023        let local_var_key = local_var_apikey.key.clone();
14024        let local_var_value = match local_var_apikey.prefix {
14025            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
14026            None => local_var_key,
14027        };
14028        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
14029    };
14030    local_var_req_builder = local_var_req_builder.json(&patched_virtual_server_request);
14031
14032    let local_var_req = local_var_req_builder.build()?;
14033    let local_var_resp = local_var_client.execute(local_var_req).await?;
14034
14035    let local_var_status = local_var_resp.status();
14036    let local_var_content = local_var_resp.text().await?;
14037
14038    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
14039        serde_json::from_str(&local_var_content).map_err(Error::from)
14040    } else {
14041        let local_var_entity: Option<LoadBalancersVirtualServersPartialUpdateError> =
14042            serde_json::from_str(&local_var_content).ok();
14043        let local_var_error = ResponseContent {
14044            status: local_var_status,
14045            content: local_var_content,
14046            entity: local_var_entity,
14047        };
14048        Err(Error::ResponseError(local_var_error))
14049    }
14050}
14051
14052/// VirtualServer viewset.
14053pub async fn load_balancers_virtual_servers_retrieve(
14054    configuration: &configuration::Configuration,
14055    id: &str,
14056    format: Option<&str>,
14057    depth: Option<i32>,
14058    exclude_m2m: Option<bool>,
14059) -> Result<crate::models::VirtualServer, Error<LoadBalancersVirtualServersRetrieveError>> {
14060    let local_var_configuration = configuration;
14061
14062    let local_var_client = &local_var_configuration.client;
14063
14064    let local_var_uri_str = format!(
14065        "{}/load-balancers/virtual-servers/{id}/",
14066        local_var_configuration.base_path,
14067        id = crate::apis::urlencode(id)
14068    );
14069    let mut local_var_req_builder =
14070        local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
14071
14072    if let Some(ref local_var_str) = format {
14073        local_var_req_builder =
14074            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
14075    }
14076    if let Some(ref local_var_str) = depth {
14077        local_var_req_builder =
14078            local_var_req_builder.query(&[("depth", &local_var_str.to_string())]);
14079    }
14080    if let Some(ref local_var_str) = exclude_m2m {
14081        local_var_req_builder =
14082            local_var_req_builder.query(&[("exclude_m2m", &local_var_str.to_string())]);
14083    }
14084    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
14085        local_var_req_builder =
14086            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
14087    }
14088    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
14089        let local_var_key = local_var_apikey.key.clone();
14090        let local_var_value = match local_var_apikey.prefix {
14091            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
14092            None => local_var_key,
14093        };
14094        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
14095    };
14096
14097    let local_var_req = local_var_req_builder.build()?;
14098    let local_var_resp = local_var_client.execute(local_var_req).await?;
14099
14100    let local_var_status = local_var_resp.status();
14101    let local_var_content = local_var_resp.text().await?;
14102
14103    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
14104        serde_json::from_str(&local_var_content).map_err(Error::from)
14105    } else {
14106        let local_var_entity: Option<LoadBalancersVirtualServersRetrieveError> =
14107            serde_json::from_str(&local_var_content).ok();
14108        let local_var_error = ResponseContent {
14109            status: local_var_status,
14110            content: local_var_content,
14111            entity: local_var_entity,
14112        };
14113        Err(Error::ResponseError(local_var_error))
14114    }
14115}
14116
14117/// VirtualServer viewset.
14118pub async fn load_balancers_virtual_servers_update(
14119    configuration: &configuration::Configuration,
14120    id: &str,
14121    virtual_server_request: crate::models::VirtualServerRequest,
14122    format: Option<&str>,
14123) -> Result<crate::models::VirtualServer, Error<LoadBalancersVirtualServersUpdateError>> {
14124    let local_var_configuration = configuration;
14125
14126    let local_var_client = &local_var_configuration.client;
14127
14128    let local_var_uri_str = format!(
14129        "{}/load-balancers/virtual-servers/{id}/",
14130        local_var_configuration.base_path,
14131        id = crate::apis::urlencode(id)
14132    );
14133    let mut local_var_req_builder =
14134        local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());
14135
14136    if let Some(ref local_var_str) = format {
14137        local_var_req_builder =
14138            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
14139    }
14140    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
14141        local_var_req_builder =
14142            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
14143    }
14144    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
14145        let local_var_key = local_var_apikey.key.clone();
14146        let local_var_value = match local_var_apikey.prefix {
14147            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
14148            None => local_var_key,
14149        };
14150        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
14151    };
14152    local_var_req_builder = local_var_req_builder.json(&virtual_server_request);
14153
14154    let local_var_req = local_var_req_builder.build()?;
14155    let local_var_resp = local_var_client.execute(local_var_req).await?;
14156
14157    let local_var_status = local_var_resp.status();
14158    let local_var_content = local_var_resp.text().await?;
14159
14160    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
14161        serde_json::from_str(&local_var_content).map_err(Error::from)
14162    } else {
14163        let local_var_entity: Option<LoadBalancersVirtualServersUpdateError> =
14164            serde_json::from_str(&local_var_content).ok();
14165        let local_var_error = ResponseContent {
14166            status: local_var_status,
14167            content: local_var_content,
14168            entity: local_var_entity,
14169        };
14170        Err(Error::ResponseError(local_var_error))
14171    }
14172}
nautobot_openapi/apis/load_balancers_api.rs

nautobot_openapi/apis/
load_balancers_api.rs
