netbox_openapi/apis/
virtualization_api.rs

1/*
2 * NetBox REST API
3 *
4 * No description provided (generated by Openapi Generator https://github.com/openapitools/openapi-generator)
5 *
6 * The version of the OpenAPI document: 4.6.0 (4.6)
7 *
8 * Generated by: https://openapi-generator.tech
9 */
10
11use reqwest;
12
13use super::{Error, configuration};
14use crate::apis::ResponseContent;
15
16/// struct for typed errors of method [`virtualization_cluster_groups_bulk_destroy`]
17#[derive(Debug, Clone, Serialize, Deserialize)]
18#[serde(untagged)]
19pub enum VirtualizationClusterGroupsBulkDestroyError {
20    UnknownValue(serde_json::Value),
21}
22
23/// struct for typed errors of method [`virtualization_cluster_groups_bulk_partial_update`]
24#[derive(Debug, Clone, Serialize, Deserialize)]
25#[serde(untagged)]
26pub enum VirtualizationClusterGroupsBulkPartialUpdateError {
27    UnknownValue(serde_json::Value),
28}
29
30/// struct for typed errors of method [`virtualization_cluster_groups_bulk_update`]
31#[derive(Debug, Clone, Serialize, Deserialize)]
32#[serde(untagged)]
33pub enum VirtualizationClusterGroupsBulkUpdateError {
34    UnknownValue(serde_json::Value),
35}
36
37/// struct for typed errors of method [`virtualization_cluster_groups_create`]
38#[derive(Debug, Clone, Serialize, Deserialize)]
39#[serde(untagged)]
40pub enum VirtualizationClusterGroupsCreateError {
41    UnknownValue(serde_json::Value),
42}
43
44/// struct for typed errors of method [`virtualization_cluster_groups_destroy`]
45#[derive(Debug, Clone, Serialize, Deserialize)]
46#[serde(untagged)]
47pub enum VirtualizationClusterGroupsDestroyError {
48    UnknownValue(serde_json::Value),
49}
50
51/// struct for typed errors of method [`virtualization_cluster_groups_list`]
52#[derive(Debug, Clone, Serialize, Deserialize)]
53#[serde(untagged)]
54pub enum VirtualizationClusterGroupsListError {
55    UnknownValue(serde_json::Value),
56}
57
58/// struct for typed errors of method [`virtualization_cluster_groups_partial_update`]
59#[derive(Debug, Clone, Serialize, Deserialize)]
60#[serde(untagged)]
61pub enum VirtualizationClusterGroupsPartialUpdateError {
62    UnknownValue(serde_json::Value),
63}
64
65/// struct for typed errors of method [`virtualization_cluster_groups_retrieve`]
66#[derive(Debug, Clone, Serialize, Deserialize)]
67#[serde(untagged)]
68pub enum VirtualizationClusterGroupsRetrieveError {
69    UnknownValue(serde_json::Value),
70}
71
72/// struct for typed errors of method [`virtualization_cluster_groups_update`]
73#[derive(Debug, Clone, Serialize, Deserialize)]
74#[serde(untagged)]
75pub enum VirtualizationClusterGroupsUpdateError {
76    UnknownValue(serde_json::Value),
77}
78
79/// struct for typed errors of method [`virtualization_cluster_types_bulk_destroy`]
80#[derive(Debug, Clone, Serialize, Deserialize)]
81#[serde(untagged)]
82pub enum VirtualizationClusterTypesBulkDestroyError {
83    UnknownValue(serde_json::Value),
84}
85
86/// struct for typed errors of method [`virtualization_cluster_types_bulk_partial_update`]
87#[derive(Debug, Clone, Serialize, Deserialize)]
88#[serde(untagged)]
89pub enum VirtualizationClusterTypesBulkPartialUpdateError {
90    UnknownValue(serde_json::Value),
91}
92
93/// struct for typed errors of method [`virtualization_cluster_types_bulk_update`]
94#[derive(Debug, Clone, Serialize, Deserialize)]
95#[serde(untagged)]
96pub enum VirtualizationClusterTypesBulkUpdateError {
97    UnknownValue(serde_json::Value),
98}
99
100/// struct for typed errors of method [`virtualization_cluster_types_create`]
101#[derive(Debug, Clone, Serialize, Deserialize)]
102#[serde(untagged)]
103pub enum VirtualizationClusterTypesCreateError {
104    UnknownValue(serde_json::Value),
105}
106
107/// struct for typed errors of method [`virtualization_cluster_types_destroy`]
108#[derive(Debug, Clone, Serialize, Deserialize)]
109#[serde(untagged)]
110pub enum VirtualizationClusterTypesDestroyError {
111    UnknownValue(serde_json::Value),
112}
113
114/// struct for typed errors of method [`virtualization_cluster_types_list`]
115#[derive(Debug, Clone, Serialize, Deserialize)]
116#[serde(untagged)]
117pub enum VirtualizationClusterTypesListError {
118    UnknownValue(serde_json::Value),
119}
120
121/// struct for typed errors of method [`virtualization_cluster_types_partial_update`]
122#[derive(Debug, Clone, Serialize, Deserialize)]
123#[serde(untagged)]
124pub enum VirtualizationClusterTypesPartialUpdateError {
125    UnknownValue(serde_json::Value),
126}
127
128/// struct for typed errors of method [`virtualization_cluster_types_retrieve`]
129#[derive(Debug, Clone, Serialize, Deserialize)]
130#[serde(untagged)]
131pub enum VirtualizationClusterTypesRetrieveError {
132    UnknownValue(serde_json::Value),
133}
134
135/// struct for typed errors of method [`virtualization_cluster_types_update`]
136#[derive(Debug, Clone, Serialize, Deserialize)]
137#[serde(untagged)]
138pub enum VirtualizationClusterTypesUpdateError {
139    UnknownValue(serde_json::Value),
140}
141
142/// struct for typed errors of method [`virtualization_clusters_bulk_destroy`]
143#[derive(Debug, Clone, Serialize, Deserialize)]
144#[serde(untagged)]
145pub enum VirtualizationClustersBulkDestroyError {
146    UnknownValue(serde_json::Value),
147}
148
149/// struct for typed errors of method [`virtualization_clusters_bulk_partial_update`]
150#[derive(Debug, Clone, Serialize, Deserialize)]
151#[serde(untagged)]
152pub enum VirtualizationClustersBulkPartialUpdateError {
153    UnknownValue(serde_json::Value),
154}
155
156/// struct for typed errors of method [`virtualization_clusters_bulk_update`]
157#[derive(Debug, Clone, Serialize, Deserialize)]
158#[serde(untagged)]
159pub enum VirtualizationClustersBulkUpdateError {
160    UnknownValue(serde_json::Value),
161}
162
163/// struct for typed errors of method [`virtualization_clusters_create`]
164#[derive(Debug, Clone, Serialize, Deserialize)]
165#[serde(untagged)]
166pub enum VirtualizationClustersCreateError {
167    UnknownValue(serde_json::Value),
168}
169
170/// struct for typed errors of method [`virtualization_clusters_destroy`]
171#[derive(Debug, Clone, Serialize, Deserialize)]
172#[serde(untagged)]
173pub enum VirtualizationClustersDestroyError {
174    UnknownValue(serde_json::Value),
175}
176
177/// struct for typed errors of method [`virtualization_clusters_list`]
178#[derive(Debug, Clone, Serialize, Deserialize)]
179#[serde(untagged)]
180pub enum VirtualizationClustersListError {
181    UnknownValue(serde_json::Value),
182}
183
184/// struct for typed errors of method [`virtualization_clusters_partial_update`]
185#[derive(Debug, Clone, Serialize, Deserialize)]
186#[serde(untagged)]
187pub enum VirtualizationClustersPartialUpdateError {
188    UnknownValue(serde_json::Value),
189}
190
191/// struct for typed errors of method [`virtualization_clusters_retrieve`]
192#[derive(Debug, Clone, Serialize, Deserialize)]
193#[serde(untagged)]
194pub enum VirtualizationClustersRetrieveError {
195    UnknownValue(serde_json::Value),
196}
197
198/// struct for typed errors of method [`virtualization_clusters_update`]
199#[derive(Debug, Clone, Serialize, Deserialize)]
200#[serde(untagged)]
201pub enum VirtualizationClustersUpdateError {
202    UnknownValue(serde_json::Value),
203}
204
205/// struct for typed errors of method [`virtualization_interfaces_bulk_destroy`]
206#[derive(Debug, Clone, Serialize, Deserialize)]
207#[serde(untagged)]
208pub enum VirtualizationInterfacesBulkDestroyError {
209    UnknownValue(serde_json::Value),
210}
211
212/// struct for typed errors of method [`virtualization_interfaces_bulk_partial_update`]
213#[derive(Debug, Clone, Serialize, Deserialize)]
214#[serde(untagged)]
215pub enum VirtualizationInterfacesBulkPartialUpdateError {
216    UnknownValue(serde_json::Value),
217}
218
219/// struct for typed errors of method [`virtualization_interfaces_bulk_update`]
220#[derive(Debug, Clone, Serialize, Deserialize)]
221#[serde(untagged)]
222pub enum VirtualizationInterfacesBulkUpdateError {
223    UnknownValue(serde_json::Value),
224}
225
226/// struct for typed errors of method [`virtualization_interfaces_create`]
227#[derive(Debug, Clone, Serialize, Deserialize)]
228#[serde(untagged)]
229pub enum VirtualizationInterfacesCreateError {
230    UnknownValue(serde_json::Value),
231}
232
233/// struct for typed errors of method [`virtualization_interfaces_destroy`]
234#[derive(Debug, Clone, Serialize, Deserialize)]
235#[serde(untagged)]
236pub enum VirtualizationInterfacesDestroyError {
237    UnknownValue(serde_json::Value),
238}
239
240/// struct for typed errors of method [`virtualization_interfaces_list`]
241#[derive(Debug, Clone, Serialize, Deserialize)]
242#[serde(untagged)]
243pub enum VirtualizationInterfacesListError {
244    UnknownValue(serde_json::Value),
245}
246
247/// struct for typed errors of method [`virtualization_interfaces_partial_update`]
248#[derive(Debug, Clone, Serialize, Deserialize)]
249#[serde(untagged)]
250pub enum VirtualizationInterfacesPartialUpdateError {
251    UnknownValue(serde_json::Value),
252}
253
254/// struct for typed errors of method [`virtualization_interfaces_retrieve`]
255#[derive(Debug, Clone, Serialize, Deserialize)]
256#[serde(untagged)]
257pub enum VirtualizationInterfacesRetrieveError {
258    UnknownValue(serde_json::Value),
259}
260
261/// struct for typed errors of method [`virtualization_interfaces_update`]
262#[derive(Debug, Clone, Serialize, Deserialize)]
263#[serde(untagged)]
264pub enum VirtualizationInterfacesUpdateError {
265    UnknownValue(serde_json::Value),
266}
267
268/// struct for typed errors of method [`virtualization_virtual_disks_bulk_destroy`]
269#[derive(Debug, Clone, Serialize, Deserialize)]
270#[serde(untagged)]
271pub enum VirtualizationVirtualDisksBulkDestroyError {
272    UnknownValue(serde_json::Value),
273}
274
275/// struct for typed errors of method [`virtualization_virtual_disks_bulk_partial_update`]
276#[derive(Debug, Clone, Serialize, Deserialize)]
277#[serde(untagged)]
278pub enum VirtualizationVirtualDisksBulkPartialUpdateError {
279    UnknownValue(serde_json::Value),
280}
281
282/// struct for typed errors of method [`virtualization_virtual_disks_bulk_update`]
283#[derive(Debug, Clone, Serialize, Deserialize)]
284#[serde(untagged)]
285pub enum VirtualizationVirtualDisksBulkUpdateError {
286    UnknownValue(serde_json::Value),
287}
288
289/// struct for typed errors of method [`virtualization_virtual_disks_create`]
290#[derive(Debug, Clone, Serialize, Deserialize)]
291#[serde(untagged)]
292pub enum VirtualizationVirtualDisksCreateError {
293    UnknownValue(serde_json::Value),
294}
295
296/// struct for typed errors of method [`virtualization_virtual_disks_destroy`]
297#[derive(Debug, Clone, Serialize, Deserialize)]
298#[serde(untagged)]
299pub enum VirtualizationVirtualDisksDestroyError {
300    UnknownValue(serde_json::Value),
301}
302
303/// struct for typed errors of method [`virtualization_virtual_disks_list`]
304#[derive(Debug, Clone, Serialize, Deserialize)]
305#[serde(untagged)]
306pub enum VirtualizationVirtualDisksListError {
307    UnknownValue(serde_json::Value),
308}
309
310/// struct for typed errors of method [`virtualization_virtual_disks_partial_update`]
311#[derive(Debug, Clone, Serialize, Deserialize)]
312#[serde(untagged)]
313pub enum VirtualizationVirtualDisksPartialUpdateError {
314    UnknownValue(serde_json::Value),
315}
316
317/// struct for typed errors of method [`virtualization_virtual_disks_retrieve`]
318#[derive(Debug, Clone, Serialize, Deserialize)]
319#[serde(untagged)]
320pub enum VirtualizationVirtualDisksRetrieveError {
321    UnknownValue(serde_json::Value),
322}
323
324/// struct for typed errors of method [`virtualization_virtual_disks_update`]
325#[derive(Debug, Clone, Serialize, Deserialize)]
326#[serde(untagged)]
327pub enum VirtualizationVirtualDisksUpdateError {
328    UnknownValue(serde_json::Value),
329}
330
331/// struct for typed errors of method [`virtualization_virtual_machine_types_bulk_destroy`]
332#[derive(Debug, Clone, Serialize, Deserialize)]
333#[serde(untagged)]
334pub enum VirtualizationVirtualMachineTypesBulkDestroyError {
335    UnknownValue(serde_json::Value),
336}
337
338/// struct for typed errors of method [`virtualization_virtual_machine_types_bulk_partial_update`]
339#[derive(Debug, Clone, Serialize, Deserialize)]
340#[serde(untagged)]
341pub enum VirtualizationVirtualMachineTypesBulkPartialUpdateError {
342    UnknownValue(serde_json::Value),
343}
344
345/// struct for typed errors of method [`virtualization_virtual_machine_types_bulk_update`]
346#[derive(Debug, Clone, Serialize, Deserialize)]
347#[serde(untagged)]
348pub enum VirtualizationVirtualMachineTypesBulkUpdateError {
349    UnknownValue(serde_json::Value),
350}
351
352/// struct for typed errors of method [`virtualization_virtual_machine_types_create`]
353#[derive(Debug, Clone, Serialize, Deserialize)]
354#[serde(untagged)]
355pub enum VirtualizationVirtualMachineTypesCreateError {
356    UnknownValue(serde_json::Value),
357}
358
359/// struct for typed errors of method [`virtualization_virtual_machine_types_destroy`]
360#[derive(Debug, Clone, Serialize, Deserialize)]
361#[serde(untagged)]
362pub enum VirtualizationVirtualMachineTypesDestroyError {
363    UnknownValue(serde_json::Value),
364}
365
366/// struct for typed errors of method [`virtualization_virtual_machine_types_list`]
367#[derive(Debug, Clone, Serialize, Deserialize)]
368#[serde(untagged)]
369pub enum VirtualizationVirtualMachineTypesListError {
370    UnknownValue(serde_json::Value),
371}
372
373/// struct for typed errors of method [`virtualization_virtual_machine_types_partial_update`]
374#[derive(Debug, Clone, Serialize, Deserialize)]
375#[serde(untagged)]
376pub enum VirtualizationVirtualMachineTypesPartialUpdateError {
377    UnknownValue(serde_json::Value),
378}
379
380/// struct for typed errors of method [`virtualization_virtual_machine_types_retrieve`]
381#[derive(Debug, Clone, Serialize, Deserialize)]
382#[serde(untagged)]
383pub enum VirtualizationVirtualMachineTypesRetrieveError {
384    UnknownValue(serde_json::Value),
385}
386
387/// struct for typed errors of method [`virtualization_virtual_machine_types_update`]
388#[derive(Debug, Clone, Serialize, Deserialize)]
389#[serde(untagged)]
390pub enum VirtualizationVirtualMachineTypesUpdateError {
391    UnknownValue(serde_json::Value),
392}
393
394/// struct for typed errors of method [`virtualization_virtual_machines_bulk_destroy`]
395#[derive(Debug, Clone, Serialize, Deserialize)]
396#[serde(untagged)]
397pub enum VirtualizationVirtualMachinesBulkDestroyError {
398    UnknownValue(serde_json::Value),
399}
400
401/// struct for typed errors of method [`virtualization_virtual_machines_bulk_partial_update`]
402#[derive(Debug, Clone, Serialize, Deserialize)]
403#[serde(untagged)]
404pub enum VirtualizationVirtualMachinesBulkPartialUpdateError {
405    UnknownValue(serde_json::Value),
406}
407
408/// struct for typed errors of method [`virtualization_virtual_machines_bulk_update`]
409#[derive(Debug, Clone, Serialize, Deserialize)]
410#[serde(untagged)]
411pub enum VirtualizationVirtualMachinesBulkUpdateError {
412    UnknownValue(serde_json::Value),
413}
414
415/// struct for typed errors of method [`virtualization_virtual_machines_create`]
416#[derive(Debug, Clone, Serialize, Deserialize)]
417#[serde(untagged)]
418pub enum VirtualizationVirtualMachinesCreateError {
419    UnknownValue(serde_json::Value),
420}
421
422/// struct for typed errors of method [`virtualization_virtual_machines_destroy`]
423#[derive(Debug, Clone, Serialize, Deserialize)]
424#[serde(untagged)]
425pub enum VirtualizationVirtualMachinesDestroyError {
426    UnknownValue(serde_json::Value),
427}
428
429/// struct for typed errors of method [`virtualization_virtual_machines_list`]
430#[derive(Debug, Clone, Serialize, Deserialize)]
431#[serde(untagged)]
432pub enum VirtualizationVirtualMachinesListError {
433    UnknownValue(serde_json::Value),
434}
435
436/// struct for typed errors of method [`virtualization_virtual_machines_partial_update`]
437#[derive(Debug, Clone, Serialize, Deserialize)]
438#[serde(untagged)]
439pub enum VirtualizationVirtualMachinesPartialUpdateError {
440    UnknownValue(serde_json::Value),
441}
442
443/// struct for typed errors of method [`virtualization_virtual_machines_render_config_create`]
444#[derive(Debug, Clone, Serialize, Deserialize)]
445#[serde(untagged)]
446pub enum VirtualizationVirtualMachinesRenderConfigCreateError {
447    UnknownValue(serde_json::Value),
448}
449
450/// struct for typed errors of method [`virtualization_virtual_machines_retrieve`]
451#[derive(Debug, Clone, Serialize, Deserialize)]
452#[serde(untagged)]
453pub enum VirtualizationVirtualMachinesRetrieveError {
454    UnknownValue(serde_json::Value),
455}
456
457/// struct for typed errors of method [`virtualization_virtual_machines_update`]
458#[derive(Debug, Clone, Serialize, Deserialize)]
459#[serde(untagged)]
460pub enum VirtualizationVirtualMachinesUpdateError {
461    UnknownValue(serde_json::Value),
462}
463
464/// Delete a list of cluster group objects.
465pub async fn virtualization_cluster_groups_bulk_destroy(
466    configuration: &configuration::Configuration,
467    cluster_group_request: Vec<crate::models::ClusterGroupRequest>,
468) -> Result<(), Error<VirtualizationClusterGroupsBulkDestroyError>> {
469    let local_var_configuration = configuration;
470
471    let local_var_client = &local_var_configuration.client;
472
473    let local_var_uri_str = format!(
474        "{}/api/virtualization/cluster-groups/",
475        local_var_configuration.base_path
476    );
477    let mut local_var_req_builder =
478        local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());
479
480    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
481        local_var_req_builder =
482            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
483    }
484    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
485        let local_var_key = local_var_apikey.key.clone();
486        let local_var_value = match local_var_apikey.prefix {
487            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
488            None => local_var_key,
489        };
490        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
491    };
492    local_var_req_builder = local_var_req_builder.json(&cluster_group_request);
493
494    let local_var_req = local_var_req_builder.build()?;
495    let local_var_resp = local_var_client.execute(local_var_req).await?;
496
497    let local_var_status = local_var_resp.status();
498    let local_var_content = local_var_resp.text().await?;
499
500    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
501        Ok(())
502    } else {
503        let local_var_entity: Option<VirtualizationClusterGroupsBulkDestroyError> =
504            serde_json::from_str(&local_var_content).ok();
505        let local_var_error = ResponseContent {
506            status: local_var_status,
507            content: local_var_content,
508            entity: local_var_entity,
509        };
510        Err(Error::ResponseError(local_var_error))
511    }
512}
513
514/// Patch a list of cluster group objects.
515pub async fn virtualization_cluster_groups_bulk_partial_update(
516    configuration: &configuration::Configuration,
517    cluster_group_request: Vec<crate::models::ClusterGroupRequest>,
518) -> Result<
519    Vec<crate::models::ClusterGroup>,
520    Error<VirtualizationClusterGroupsBulkPartialUpdateError>,
521> {
522    let local_var_configuration = configuration;
523
524    let local_var_client = &local_var_configuration.client;
525
526    let local_var_uri_str = format!(
527        "{}/api/virtualization/cluster-groups/",
528        local_var_configuration.base_path
529    );
530    let mut local_var_req_builder =
531        local_var_client.request(reqwest::Method::PATCH, local_var_uri_str.as_str());
532
533    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
534        local_var_req_builder =
535            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
536    }
537    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
538        let local_var_key = local_var_apikey.key.clone();
539        let local_var_value = match local_var_apikey.prefix {
540            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
541            None => local_var_key,
542        };
543        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
544    };
545    local_var_req_builder = local_var_req_builder.json(&cluster_group_request);
546
547    let local_var_req = local_var_req_builder.build()?;
548    let local_var_resp = local_var_client.execute(local_var_req).await?;
549
550    let local_var_status = local_var_resp.status();
551    let local_var_content = local_var_resp.text().await?;
552
553    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
554        serde_json::from_str(&local_var_content).map_err(Error::from)
555    } else {
556        let local_var_entity: Option<VirtualizationClusterGroupsBulkPartialUpdateError> =
557            serde_json::from_str(&local_var_content).ok();
558        let local_var_error = ResponseContent {
559            status: local_var_status,
560            content: local_var_content,
561            entity: local_var_entity,
562        };
563        Err(Error::ResponseError(local_var_error))
564    }
565}
566
567/// Put a list of cluster group objects.
568pub async fn virtualization_cluster_groups_bulk_update(
569    configuration: &configuration::Configuration,
570    cluster_group_request: Vec<crate::models::ClusterGroupRequest>,
571) -> Result<Vec<crate::models::ClusterGroup>, Error<VirtualizationClusterGroupsBulkUpdateError>> {
572    let local_var_configuration = configuration;
573
574    let local_var_client = &local_var_configuration.client;
575
576    let local_var_uri_str = format!(
577        "{}/api/virtualization/cluster-groups/",
578        local_var_configuration.base_path
579    );
580    let mut local_var_req_builder =
581        local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());
582
583    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
584        local_var_req_builder =
585            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
586    }
587    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
588        let local_var_key = local_var_apikey.key.clone();
589        let local_var_value = match local_var_apikey.prefix {
590            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
591            None => local_var_key,
592        };
593        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
594    };
595    local_var_req_builder = local_var_req_builder.json(&cluster_group_request);
596
597    let local_var_req = local_var_req_builder.build()?;
598    let local_var_resp = local_var_client.execute(local_var_req).await?;
599
600    let local_var_status = local_var_resp.status();
601    let local_var_content = local_var_resp.text().await?;
602
603    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
604        serde_json::from_str(&local_var_content).map_err(Error::from)
605    } else {
606        let local_var_entity: Option<VirtualizationClusterGroupsBulkUpdateError> =
607            serde_json::from_str(&local_var_content).ok();
608        let local_var_error = ResponseContent {
609            status: local_var_status,
610            content: local_var_content,
611            entity: local_var_entity,
612        };
613        Err(Error::ResponseError(local_var_error))
614    }
615}
616
617/// Post a list of cluster group objects.
618pub async fn virtualization_cluster_groups_create(
619    configuration: &configuration::Configuration,
620    virtualization_cluster_groups_create_request: crate::models::VirtualizationClusterGroupsCreateRequest,
621) -> Result<crate::models::ClusterGroup, Error<VirtualizationClusterGroupsCreateError>> {
622    let local_var_configuration = configuration;
623
624    let local_var_client = &local_var_configuration.client;
625
626    let local_var_uri_str = format!(
627        "{}/api/virtualization/cluster-groups/",
628        local_var_configuration.base_path
629    );
630    let mut local_var_req_builder =
631        local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
632
633    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
634        local_var_req_builder =
635            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
636    }
637    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
638        let local_var_key = local_var_apikey.key.clone();
639        let local_var_value = match local_var_apikey.prefix {
640            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
641            None => local_var_key,
642        };
643        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
644    };
645    local_var_req_builder =
646        local_var_req_builder.json(&virtualization_cluster_groups_create_request);
647
648    let local_var_req = local_var_req_builder.build()?;
649    let local_var_resp = local_var_client.execute(local_var_req).await?;
650
651    let local_var_status = local_var_resp.status();
652    let local_var_content = local_var_resp.text().await?;
653
654    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
655        serde_json::from_str(&local_var_content).map_err(Error::from)
656    } else {
657        let local_var_entity: Option<VirtualizationClusterGroupsCreateError> =
658            serde_json::from_str(&local_var_content).ok();
659        let local_var_error = ResponseContent {
660            status: local_var_status,
661            content: local_var_content,
662            entity: local_var_entity,
663        };
664        Err(Error::ResponseError(local_var_error))
665    }
666}
667
668/// Delete a cluster group object.
669pub async fn virtualization_cluster_groups_destroy(
670    configuration: &configuration::Configuration,
671    id: i32,
672) -> Result<(), Error<VirtualizationClusterGroupsDestroyError>> {
673    let local_var_configuration = configuration;
674
675    let local_var_client = &local_var_configuration.client;
676
677    let local_var_uri_str = format!(
678        "{}/api/virtualization/cluster-groups/{id}/",
679        local_var_configuration.base_path,
680        id = id
681    );
682    let mut local_var_req_builder =
683        local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());
684
685    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
686        local_var_req_builder =
687            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
688    }
689    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
690        let local_var_key = local_var_apikey.key.clone();
691        let local_var_value = match local_var_apikey.prefix {
692            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
693            None => local_var_key,
694        };
695        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
696    };
697
698    let local_var_req = local_var_req_builder.build()?;
699    let local_var_resp = local_var_client.execute(local_var_req).await?;
700
701    let local_var_status = local_var_resp.status();
702    let local_var_content = local_var_resp.text().await?;
703
704    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
705        Ok(())
706    } else {
707        let local_var_entity: Option<VirtualizationClusterGroupsDestroyError> =
708            serde_json::from_str(&local_var_content).ok();
709        let local_var_error = ResponseContent {
710            status: local_var_status,
711            content: local_var_content,
712            entity: local_var_entity,
713        };
714        Err(Error::ResponseError(local_var_error))
715    }
716}
717
718/// Get a list of cluster group objects.
719pub async fn virtualization_cluster_groups_list(
720    configuration: &configuration::Configuration,
721    contact: Option<Vec<i32>>,
722    contact__n: Option<Vec<i32>>,
723    contact_group: Option<Vec<String>>,
724    contact_group__n: Option<Vec<String>>,
725    contact_role: Option<Vec<i32>>,
726    contact_role__n: Option<Vec<i32>>,
727    created: Option<Vec<String>>,
728    created__empty: Option<Vec<String>>,
729    created__gt: Option<Vec<String>>,
730    created__gte: Option<Vec<String>>,
731    created__lt: Option<Vec<String>>,
732    created__lte: Option<Vec<String>>,
733    created__n: Option<Vec<String>>,
734    created_by_request: Option<&str>,
735    description: Option<Vec<String>>,
736    description__empty: Option<bool>,
737    description__ic: Option<Vec<String>>,
738    description__ie: Option<Vec<String>>,
739    description__iew: Option<Vec<String>>,
740    description__iregex: Option<Vec<String>>,
741    description__isw: Option<Vec<String>>,
742    description__n: Option<Vec<String>>,
743    description__nic: Option<Vec<String>>,
744    description__nie: Option<Vec<String>>,
745    description__niew: Option<Vec<String>>,
746    description__nisw: Option<Vec<String>>,
747    description__regex: Option<Vec<String>>,
748    id: Option<Vec<i32>>,
749    id__empty: Option<bool>,
750    id__gt: Option<Vec<i32>>,
751    id__gte: Option<Vec<i32>>,
752    id__lt: Option<Vec<i32>>,
753    id__lte: Option<Vec<i32>>,
754    id__n: Option<Vec<i32>>,
755    last_updated: Option<Vec<String>>,
756    last_updated__empty: Option<Vec<String>>,
757    last_updated__gt: Option<Vec<String>>,
758    last_updated__gte: Option<Vec<String>>,
759    last_updated__lt: Option<Vec<String>>,
760    last_updated__lte: Option<Vec<String>>,
761    last_updated__n: Option<Vec<String>>,
762    limit: Option<i32>,
763    modified_by_request: Option<&str>,
764    name: Option<Vec<String>>,
765    name__empty: Option<bool>,
766    name__ic: Option<Vec<String>>,
767    name__ie: Option<Vec<String>>,
768    name__iew: Option<Vec<String>>,
769    name__iregex: Option<Vec<String>>,
770    name__isw: Option<Vec<String>>,
771    name__n: Option<Vec<String>>,
772    name__nic: Option<Vec<String>>,
773    name__nie: Option<Vec<String>>,
774    name__niew: Option<Vec<String>>,
775    name__nisw: Option<Vec<String>>,
776    name__regex: Option<Vec<String>>,
777    offset: Option<i32>,
778    ordering: Option<&str>,
779    owner: Option<Vec<String>>,
780    owner__n: Option<Vec<String>>,
781    owner_group: Option<Vec<String>>,
782    owner_group__n: Option<Vec<String>>,
783    owner_group_id: Option<Vec<i32>>,
784    owner_group_id__n: Option<Vec<i32>>,
785    owner_id: Option<Vec<i32>>,
786    owner_id__n: Option<Vec<i32>>,
787    q: Option<&str>,
788    slug: Option<Vec<String>>,
789    slug__empty: Option<bool>,
790    slug__ic: Option<Vec<String>>,
791    slug__ie: Option<Vec<String>>,
792    slug__iew: Option<Vec<String>>,
793    slug__iregex: Option<Vec<String>>,
794    slug__isw: Option<Vec<String>>,
795    slug__n: Option<Vec<String>>,
796    slug__nic: Option<Vec<String>>,
797    slug__nie: Option<Vec<String>>,
798    slug__niew: Option<Vec<String>>,
799    slug__nisw: Option<Vec<String>>,
800    slug__regex: Option<Vec<String>>,
801    start: Option<i32>,
802    tag: Option<Vec<String>>,
803    tag__n: Option<Vec<String>>,
804    tag_id: Option<Vec<i32>>,
805    tag_id__n: Option<Vec<i32>>,
806    updated_by_request: Option<&str>,
807) -> Result<crate::models::PaginatedClusterGroupList, Error<VirtualizationClusterGroupsListError>> {
808    let local_var_configuration = configuration;
809
810    let local_var_client = &local_var_configuration.client;
811
812    let local_var_uri_str = format!(
813        "{}/api/virtualization/cluster-groups/",
814        local_var_configuration.base_path
815    );
816    let mut local_var_req_builder =
817        local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
818
819    if let Some(ref local_var_str) = contact {
820        local_var_req_builder = match "multi" {
821            "multi" => local_var_req_builder.query(
822                &local_var_str
823                    .into_iter()
824                    .map(|p| ("contact".to_owned(), p.to_string()))
825                    .collect::<Vec<(std::string::String, std::string::String)>>(),
826            ),
827            _ => local_var_req_builder.query(&[(
828                "contact",
829                &local_var_str
830                    .into_iter()
831                    .map(|p| p.to_string())
832                    .collect::<Vec<String>>()
833                    .join(",")
834                    .to_string(),
835            )]),
836        };
837    }
838    if let Some(ref local_var_str) = contact__n {
839        local_var_req_builder = match "multi" {
840            "multi" => local_var_req_builder.query(
841                &local_var_str
842                    .into_iter()
843                    .map(|p| ("contact__n".to_owned(), p.to_string()))
844                    .collect::<Vec<(std::string::String, std::string::String)>>(),
845            ),
846            _ => local_var_req_builder.query(&[(
847                "contact__n",
848                &local_var_str
849                    .into_iter()
850                    .map(|p| p.to_string())
851                    .collect::<Vec<String>>()
852                    .join(",")
853                    .to_string(),
854            )]),
855        };
856    }
857    if let Some(ref local_var_str) = contact_group {
858        local_var_req_builder = match "multi" {
859            "multi" => local_var_req_builder.query(
860                &local_var_str
861                    .into_iter()
862                    .map(|p| ("contact_group".to_owned(), p.to_string()))
863                    .collect::<Vec<(std::string::String, std::string::String)>>(),
864            ),
865            _ => local_var_req_builder.query(&[(
866                "contact_group",
867                &local_var_str
868                    .into_iter()
869                    .map(|p| p.to_string())
870                    .collect::<Vec<String>>()
871                    .join(",")
872                    .to_string(),
873            )]),
874        };
875    }
876    if let Some(ref local_var_str) = contact_group__n {
877        local_var_req_builder = match "multi" {
878            "multi" => local_var_req_builder.query(
879                &local_var_str
880                    .into_iter()
881                    .map(|p| ("contact_group__n".to_owned(), p.to_string()))
882                    .collect::<Vec<(std::string::String, std::string::String)>>(),
883            ),
884            _ => local_var_req_builder.query(&[(
885                "contact_group__n",
886                &local_var_str
887                    .into_iter()
888                    .map(|p| p.to_string())
889                    .collect::<Vec<String>>()
890                    .join(",")
891                    .to_string(),
892            )]),
893        };
894    }
895    if let Some(ref local_var_str) = contact_role {
896        local_var_req_builder = match "multi" {
897            "multi" => local_var_req_builder.query(
898                &local_var_str
899                    .into_iter()
900                    .map(|p| ("contact_role".to_owned(), p.to_string()))
901                    .collect::<Vec<(std::string::String, std::string::String)>>(),
902            ),
903            _ => local_var_req_builder.query(&[(
904                "contact_role",
905                &local_var_str
906                    .into_iter()
907                    .map(|p| p.to_string())
908                    .collect::<Vec<String>>()
909                    .join(",")
910                    .to_string(),
911            )]),
912        };
913    }
914    if let Some(ref local_var_str) = contact_role__n {
915        local_var_req_builder = match "multi" {
916            "multi" => local_var_req_builder.query(
917                &local_var_str
918                    .into_iter()
919                    .map(|p| ("contact_role__n".to_owned(), p.to_string()))
920                    .collect::<Vec<(std::string::String, std::string::String)>>(),
921            ),
922            _ => local_var_req_builder.query(&[(
923                "contact_role__n",
924                &local_var_str
925                    .into_iter()
926                    .map(|p| p.to_string())
927                    .collect::<Vec<String>>()
928                    .join(",")
929                    .to_string(),
930            )]),
931        };
932    }
933    if let Some(ref local_var_str) = created {
934        local_var_req_builder = match "multi" {
935            "multi" => local_var_req_builder.query(
936                &local_var_str
937                    .into_iter()
938                    .map(|p| ("created".to_owned(), p.to_string()))
939                    .collect::<Vec<(std::string::String, std::string::String)>>(),
940            ),
941            _ => local_var_req_builder.query(&[(
942                "created",
943                &local_var_str
944                    .into_iter()
945                    .map(|p| p.to_string())
946                    .collect::<Vec<String>>()
947                    .join(",")
948                    .to_string(),
949            )]),
950        };
951    }
952    if let Some(ref local_var_str) = created__empty {
953        local_var_req_builder = match "multi" {
954            "multi" => local_var_req_builder.query(
955                &local_var_str
956                    .into_iter()
957                    .map(|p| ("created__empty".to_owned(), p.to_string()))
958                    .collect::<Vec<(std::string::String, std::string::String)>>(),
959            ),
960            _ => local_var_req_builder.query(&[(
961                "created__empty",
962                &local_var_str
963                    .into_iter()
964                    .map(|p| p.to_string())
965                    .collect::<Vec<String>>()
966                    .join(",")
967                    .to_string(),
968            )]),
969        };
970    }
971    if let Some(ref local_var_str) = created__gt {
972        local_var_req_builder = match "multi" {
973            "multi" => local_var_req_builder.query(
974                &local_var_str
975                    .into_iter()
976                    .map(|p| ("created__gt".to_owned(), p.to_string()))
977                    .collect::<Vec<(std::string::String, std::string::String)>>(),
978            ),
979            _ => local_var_req_builder.query(&[(
980                "created__gt",
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) = created__gte {
991        local_var_req_builder = match "multi" {
992            "multi" => local_var_req_builder.query(
993                &local_var_str
994                    .into_iter()
995                    .map(|p| ("created__gte".to_owned(), p.to_string()))
996                    .collect::<Vec<(std::string::String, std::string::String)>>(),
997            ),
998            _ => local_var_req_builder.query(&[(
999                "created__gte",
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) = created__lt {
1010        local_var_req_builder = match "multi" {
1011            "multi" => local_var_req_builder.query(
1012                &local_var_str
1013                    .into_iter()
1014                    .map(|p| ("created__lt".to_owned(), p.to_string()))
1015                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1016            ),
1017            _ => local_var_req_builder.query(&[(
1018                "created__lt",
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) = created__lte {
1029        local_var_req_builder = match "multi" {
1030            "multi" => local_var_req_builder.query(
1031                &local_var_str
1032                    .into_iter()
1033                    .map(|p| ("created__lte".to_owned(), p.to_string()))
1034                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1035            ),
1036            _ => local_var_req_builder.query(&[(
1037                "created__lte",
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) = created__n {
1048        local_var_req_builder = match "multi" {
1049            "multi" => local_var_req_builder.query(
1050                &local_var_str
1051                    .into_iter()
1052                    .map(|p| ("created__n".to_owned(), p.to_string()))
1053                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1054            ),
1055            _ => local_var_req_builder.query(&[(
1056                "created__n",
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) = created_by_request {
1067        local_var_req_builder =
1068            local_var_req_builder.query(&[("created_by_request", &local_var_str.to_string())]);
1069    }
1070    if let Some(ref local_var_str) = description {
1071        local_var_req_builder = match "multi" {
1072            "multi" => local_var_req_builder.query(
1073                &local_var_str
1074                    .into_iter()
1075                    .map(|p| ("description".to_owned(), p.to_string()))
1076                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1077            ),
1078            _ => local_var_req_builder.query(&[(
1079                "description",
1080                &local_var_str
1081                    .into_iter()
1082                    .map(|p| p.to_string())
1083                    .collect::<Vec<String>>()
1084                    .join(",")
1085                    .to_string(),
1086            )]),
1087        };
1088    }
1089    if let Some(ref local_var_str) = description__empty {
1090        local_var_req_builder =
1091            local_var_req_builder.query(&[("description__empty", &local_var_str.to_string())]);
1092    }
1093    if let Some(ref local_var_str) = description__ic {
1094        local_var_req_builder = match "multi" {
1095            "multi" => local_var_req_builder.query(
1096                &local_var_str
1097                    .into_iter()
1098                    .map(|p| ("description__ic".to_owned(), p.to_string()))
1099                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1100            ),
1101            _ => local_var_req_builder.query(&[(
1102                "description__ic",
1103                &local_var_str
1104                    .into_iter()
1105                    .map(|p| p.to_string())
1106                    .collect::<Vec<String>>()
1107                    .join(",")
1108                    .to_string(),
1109            )]),
1110        };
1111    }
1112    if let Some(ref local_var_str) = description__ie {
1113        local_var_req_builder = match "multi" {
1114            "multi" => local_var_req_builder.query(
1115                &local_var_str
1116                    .into_iter()
1117                    .map(|p| ("description__ie".to_owned(), p.to_string()))
1118                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1119            ),
1120            _ => local_var_req_builder.query(&[(
1121                "description__ie",
1122                &local_var_str
1123                    .into_iter()
1124                    .map(|p| p.to_string())
1125                    .collect::<Vec<String>>()
1126                    .join(",")
1127                    .to_string(),
1128            )]),
1129        };
1130    }
1131    if let Some(ref local_var_str) = description__iew {
1132        local_var_req_builder = match "multi" {
1133            "multi" => local_var_req_builder.query(
1134                &local_var_str
1135                    .into_iter()
1136                    .map(|p| ("description__iew".to_owned(), p.to_string()))
1137                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1138            ),
1139            _ => local_var_req_builder.query(&[(
1140                "description__iew",
1141                &local_var_str
1142                    .into_iter()
1143                    .map(|p| p.to_string())
1144                    .collect::<Vec<String>>()
1145                    .join(",")
1146                    .to_string(),
1147            )]),
1148        };
1149    }
1150    if let Some(ref local_var_str) = description__iregex {
1151        local_var_req_builder = match "multi" {
1152            "multi" => local_var_req_builder.query(
1153                &local_var_str
1154                    .into_iter()
1155                    .map(|p| ("description__iregex".to_owned(), p.to_string()))
1156                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1157            ),
1158            _ => local_var_req_builder.query(&[(
1159                "description__iregex",
1160                &local_var_str
1161                    .into_iter()
1162                    .map(|p| p.to_string())
1163                    .collect::<Vec<String>>()
1164                    .join(",")
1165                    .to_string(),
1166            )]),
1167        };
1168    }
1169    if let Some(ref local_var_str) = description__isw {
1170        local_var_req_builder = match "multi" {
1171            "multi" => local_var_req_builder.query(
1172                &local_var_str
1173                    .into_iter()
1174                    .map(|p| ("description__isw".to_owned(), p.to_string()))
1175                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1176            ),
1177            _ => local_var_req_builder.query(&[(
1178                "description__isw",
1179                &local_var_str
1180                    .into_iter()
1181                    .map(|p| p.to_string())
1182                    .collect::<Vec<String>>()
1183                    .join(",")
1184                    .to_string(),
1185            )]),
1186        };
1187    }
1188    if let Some(ref local_var_str) = description__n {
1189        local_var_req_builder = match "multi" {
1190            "multi" => local_var_req_builder.query(
1191                &local_var_str
1192                    .into_iter()
1193                    .map(|p| ("description__n".to_owned(), p.to_string()))
1194                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1195            ),
1196            _ => local_var_req_builder.query(&[(
1197                "description__n",
1198                &local_var_str
1199                    .into_iter()
1200                    .map(|p| p.to_string())
1201                    .collect::<Vec<String>>()
1202                    .join(",")
1203                    .to_string(),
1204            )]),
1205        };
1206    }
1207    if let Some(ref local_var_str) = description__nic {
1208        local_var_req_builder = match "multi" {
1209            "multi" => local_var_req_builder.query(
1210                &local_var_str
1211                    .into_iter()
1212                    .map(|p| ("description__nic".to_owned(), p.to_string()))
1213                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1214            ),
1215            _ => local_var_req_builder.query(&[(
1216                "description__nic",
1217                &local_var_str
1218                    .into_iter()
1219                    .map(|p| p.to_string())
1220                    .collect::<Vec<String>>()
1221                    .join(",")
1222                    .to_string(),
1223            )]),
1224        };
1225    }
1226    if let Some(ref local_var_str) = description__nie {
1227        local_var_req_builder = match "multi" {
1228            "multi" => local_var_req_builder.query(
1229                &local_var_str
1230                    .into_iter()
1231                    .map(|p| ("description__nie".to_owned(), p.to_string()))
1232                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1233            ),
1234            _ => local_var_req_builder.query(&[(
1235                "description__nie",
1236                &local_var_str
1237                    .into_iter()
1238                    .map(|p| p.to_string())
1239                    .collect::<Vec<String>>()
1240                    .join(",")
1241                    .to_string(),
1242            )]),
1243        };
1244    }
1245    if let Some(ref local_var_str) = description__niew {
1246        local_var_req_builder = match "multi" {
1247            "multi" => local_var_req_builder.query(
1248                &local_var_str
1249                    .into_iter()
1250                    .map(|p| ("description__niew".to_owned(), p.to_string()))
1251                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1252            ),
1253            _ => local_var_req_builder.query(&[(
1254                "description__niew",
1255                &local_var_str
1256                    .into_iter()
1257                    .map(|p| p.to_string())
1258                    .collect::<Vec<String>>()
1259                    .join(",")
1260                    .to_string(),
1261            )]),
1262        };
1263    }
1264    if let Some(ref local_var_str) = description__nisw {
1265        local_var_req_builder = match "multi" {
1266            "multi" => local_var_req_builder.query(
1267                &local_var_str
1268                    .into_iter()
1269                    .map(|p| ("description__nisw".to_owned(), p.to_string()))
1270                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1271            ),
1272            _ => local_var_req_builder.query(&[(
1273                "description__nisw",
1274                &local_var_str
1275                    .into_iter()
1276                    .map(|p| p.to_string())
1277                    .collect::<Vec<String>>()
1278                    .join(",")
1279                    .to_string(),
1280            )]),
1281        };
1282    }
1283    if let Some(ref local_var_str) = description__regex {
1284        local_var_req_builder = match "multi" {
1285            "multi" => local_var_req_builder.query(
1286                &local_var_str
1287                    .into_iter()
1288                    .map(|p| ("description__regex".to_owned(), p.to_string()))
1289                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1290            ),
1291            _ => local_var_req_builder.query(&[(
1292                "description__regex",
1293                &local_var_str
1294                    .into_iter()
1295                    .map(|p| p.to_string())
1296                    .collect::<Vec<String>>()
1297                    .join(",")
1298                    .to_string(),
1299            )]),
1300        };
1301    }
1302    if let Some(ref local_var_str) = id {
1303        local_var_req_builder = match "multi" {
1304            "multi" => local_var_req_builder.query(
1305                &local_var_str
1306                    .into_iter()
1307                    .map(|p| ("id".to_owned(), p.to_string()))
1308                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1309            ),
1310            _ => local_var_req_builder.query(&[(
1311                "id",
1312                &local_var_str
1313                    .into_iter()
1314                    .map(|p| p.to_string())
1315                    .collect::<Vec<String>>()
1316                    .join(",")
1317                    .to_string(),
1318            )]),
1319        };
1320    }
1321    if let Some(ref local_var_str) = id__empty {
1322        local_var_req_builder =
1323            local_var_req_builder.query(&[("id__empty", &local_var_str.to_string())]);
1324    }
1325    if let Some(ref local_var_str) = id__gt {
1326        local_var_req_builder = match "multi" {
1327            "multi" => local_var_req_builder.query(
1328                &local_var_str
1329                    .into_iter()
1330                    .map(|p| ("id__gt".to_owned(), p.to_string()))
1331                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1332            ),
1333            _ => local_var_req_builder.query(&[(
1334                "id__gt",
1335                &local_var_str
1336                    .into_iter()
1337                    .map(|p| p.to_string())
1338                    .collect::<Vec<String>>()
1339                    .join(",")
1340                    .to_string(),
1341            )]),
1342        };
1343    }
1344    if let Some(ref local_var_str) = id__gte {
1345        local_var_req_builder = match "multi" {
1346            "multi" => local_var_req_builder.query(
1347                &local_var_str
1348                    .into_iter()
1349                    .map(|p| ("id__gte".to_owned(), p.to_string()))
1350                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1351            ),
1352            _ => local_var_req_builder.query(&[(
1353                "id__gte",
1354                &local_var_str
1355                    .into_iter()
1356                    .map(|p| p.to_string())
1357                    .collect::<Vec<String>>()
1358                    .join(",")
1359                    .to_string(),
1360            )]),
1361        };
1362    }
1363    if let Some(ref local_var_str) = id__lt {
1364        local_var_req_builder = match "multi" {
1365            "multi" => local_var_req_builder.query(
1366                &local_var_str
1367                    .into_iter()
1368                    .map(|p| ("id__lt".to_owned(), p.to_string()))
1369                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1370            ),
1371            _ => local_var_req_builder.query(&[(
1372                "id__lt",
1373                &local_var_str
1374                    .into_iter()
1375                    .map(|p| p.to_string())
1376                    .collect::<Vec<String>>()
1377                    .join(",")
1378                    .to_string(),
1379            )]),
1380        };
1381    }
1382    if let Some(ref local_var_str) = id__lte {
1383        local_var_req_builder = match "multi" {
1384            "multi" => local_var_req_builder.query(
1385                &local_var_str
1386                    .into_iter()
1387                    .map(|p| ("id__lte".to_owned(), p.to_string()))
1388                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1389            ),
1390            _ => local_var_req_builder.query(&[(
1391                "id__lte",
1392                &local_var_str
1393                    .into_iter()
1394                    .map(|p| p.to_string())
1395                    .collect::<Vec<String>>()
1396                    .join(",")
1397                    .to_string(),
1398            )]),
1399        };
1400    }
1401    if let Some(ref local_var_str) = id__n {
1402        local_var_req_builder = match "multi" {
1403            "multi" => local_var_req_builder.query(
1404                &local_var_str
1405                    .into_iter()
1406                    .map(|p| ("id__n".to_owned(), p.to_string()))
1407                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1408            ),
1409            _ => local_var_req_builder.query(&[(
1410                "id__n",
1411                &local_var_str
1412                    .into_iter()
1413                    .map(|p| p.to_string())
1414                    .collect::<Vec<String>>()
1415                    .join(",")
1416                    .to_string(),
1417            )]),
1418        };
1419    }
1420    if let Some(ref local_var_str) = last_updated {
1421        local_var_req_builder = match "multi" {
1422            "multi" => local_var_req_builder.query(
1423                &local_var_str
1424                    .into_iter()
1425                    .map(|p| ("last_updated".to_owned(), p.to_string()))
1426                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1427            ),
1428            _ => local_var_req_builder.query(&[(
1429                "last_updated",
1430                &local_var_str
1431                    .into_iter()
1432                    .map(|p| p.to_string())
1433                    .collect::<Vec<String>>()
1434                    .join(",")
1435                    .to_string(),
1436            )]),
1437        };
1438    }
1439    if let Some(ref local_var_str) = last_updated__empty {
1440        local_var_req_builder = match "multi" {
1441            "multi" => local_var_req_builder.query(
1442                &local_var_str
1443                    .into_iter()
1444                    .map(|p| ("last_updated__empty".to_owned(), p.to_string()))
1445                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1446            ),
1447            _ => local_var_req_builder.query(&[(
1448                "last_updated__empty",
1449                &local_var_str
1450                    .into_iter()
1451                    .map(|p| p.to_string())
1452                    .collect::<Vec<String>>()
1453                    .join(",")
1454                    .to_string(),
1455            )]),
1456        };
1457    }
1458    if let Some(ref local_var_str) = last_updated__gt {
1459        local_var_req_builder = match "multi" {
1460            "multi" => local_var_req_builder.query(
1461                &local_var_str
1462                    .into_iter()
1463                    .map(|p| ("last_updated__gt".to_owned(), p.to_string()))
1464                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1465            ),
1466            _ => local_var_req_builder.query(&[(
1467                "last_updated__gt",
1468                &local_var_str
1469                    .into_iter()
1470                    .map(|p| p.to_string())
1471                    .collect::<Vec<String>>()
1472                    .join(",")
1473                    .to_string(),
1474            )]),
1475        };
1476    }
1477    if let Some(ref local_var_str) = last_updated__gte {
1478        local_var_req_builder = match "multi" {
1479            "multi" => local_var_req_builder.query(
1480                &local_var_str
1481                    .into_iter()
1482                    .map(|p| ("last_updated__gte".to_owned(), p.to_string()))
1483                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1484            ),
1485            _ => local_var_req_builder.query(&[(
1486                "last_updated__gte",
1487                &local_var_str
1488                    .into_iter()
1489                    .map(|p| p.to_string())
1490                    .collect::<Vec<String>>()
1491                    .join(",")
1492                    .to_string(),
1493            )]),
1494        };
1495    }
1496    if let Some(ref local_var_str) = last_updated__lt {
1497        local_var_req_builder = match "multi" {
1498            "multi" => local_var_req_builder.query(
1499                &local_var_str
1500                    .into_iter()
1501                    .map(|p| ("last_updated__lt".to_owned(), p.to_string()))
1502                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1503            ),
1504            _ => local_var_req_builder.query(&[(
1505                "last_updated__lt",
1506                &local_var_str
1507                    .into_iter()
1508                    .map(|p| p.to_string())
1509                    .collect::<Vec<String>>()
1510                    .join(",")
1511                    .to_string(),
1512            )]),
1513        };
1514    }
1515    if let Some(ref local_var_str) = last_updated__lte {
1516        local_var_req_builder = match "multi" {
1517            "multi" => local_var_req_builder.query(
1518                &local_var_str
1519                    .into_iter()
1520                    .map(|p| ("last_updated__lte".to_owned(), p.to_string()))
1521                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1522            ),
1523            _ => local_var_req_builder.query(&[(
1524                "last_updated__lte",
1525                &local_var_str
1526                    .into_iter()
1527                    .map(|p| p.to_string())
1528                    .collect::<Vec<String>>()
1529                    .join(",")
1530                    .to_string(),
1531            )]),
1532        };
1533    }
1534    if let Some(ref local_var_str) = last_updated__n {
1535        local_var_req_builder = match "multi" {
1536            "multi" => local_var_req_builder.query(
1537                &local_var_str
1538                    .into_iter()
1539                    .map(|p| ("last_updated__n".to_owned(), p.to_string()))
1540                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1541            ),
1542            _ => local_var_req_builder.query(&[(
1543                "last_updated__n",
1544                &local_var_str
1545                    .into_iter()
1546                    .map(|p| p.to_string())
1547                    .collect::<Vec<String>>()
1548                    .join(",")
1549                    .to_string(),
1550            )]),
1551        };
1552    }
1553    if let Some(ref local_var_str) = limit {
1554        local_var_req_builder =
1555            local_var_req_builder.query(&[("limit", &local_var_str.to_string())]);
1556    }
1557    if let Some(ref local_var_str) = modified_by_request {
1558        local_var_req_builder =
1559            local_var_req_builder.query(&[("modified_by_request", &local_var_str.to_string())]);
1560    }
1561    if let Some(ref local_var_str) = name {
1562        local_var_req_builder = match "multi" {
1563            "multi" => local_var_req_builder.query(
1564                &local_var_str
1565                    .into_iter()
1566                    .map(|p| ("name".to_owned(), p.to_string()))
1567                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1568            ),
1569            _ => local_var_req_builder.query(&[(
1570                "name",
1571                &local_var_str
1572                    .into_iter()
1573                    .map(|p| p.to_string())
1574                    .collect::<Vec<String>>()
1575                    .join(",")
1576                    .to_string(),
1577            )]),
1578        };
1579    }
1580    if let Some(ref local_var_str) = name__empty {
1581        local_var_req_builder =
1582            local_var_req_builder.query(&[("name__empty", &local_var_str.to_string())]);
1583    }
1584    if let Some(ref local_var_str) = name__ic {
1585        local_var_req_builder = match "multi" {
1586            "multi" => local_var_req_builder.query(
1587                &local_var_str
1588                    .into_iter()
1589                    .map(|p| ("name__ic".to_owned(), p.to_string()))
1590                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1591            ),
1592            _ => local_var_req_builder.query(&[(
1593                "name__ic",
1594                &local_var_str
1595                    .into_iter()
1596                    .map(|p| p.to_string())
1597                    .collect::<Vec<String>>()
1598                    .join(",")
1599                    .to_string(),
1600            )]),
1601        };
1602    }
1603    if let Some(ref local_var_str) = name__ie {
1604        local_var_req_builder = match "multi" {
1605            "multi" => local_var_req_builder.query(
1606                &local_var_str
1607                    .into_iter()
1608                    .map(|p| ("name__ie".to_owned(), p.to_string()))
1609                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1610            ),
1611            _ => local_var_req_builder.query(&[(
1612                "name__ie",
1613                &local_var_str
1614                    .into_iter()
1615                    .map(|p| p.to_string())
1616                    .collect::<Vec<String>>()
1617                    .join(",")
1618                    .to_string(),
1619            )]),
1620        };
1621    }
1622    if let Some(ref local_var_str) = name__iew {
1623        local_var_req_builder = match "multi" {
1624            "multi" => local_var_req_builder.query(
1625                &local_var_str
1626                    .into_iter()
1627                    .map(|p| ("name__iew".to_owned(), p.to_string()))
1628                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1629            ),
1630            _ => local_var_req_builder.query(&[(
1631                "name__iew",
1632                &local_var_str
1633                    .into_iter()
1634                    .map(|p| p.to_string())
1635                    .collect::<Vec<String>>()
1636                    .join(",")
1637                    .to_string(),
1638            )]),
1639        };
1640    }
1641    if let Some(ref local_var_str) = name__iregex {
1642        local_var_req_builder = match "multi" {
1643            "multi" => local_var_req_builder.query(
1644                &local_var_str
1645                    .into_iter()
1646                    .map(|p| ("name__iregex".to_owned(), p.to_string()))
1647                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1648            ),
1649            _ => local_var_req_builder.query(&[(
1650                "name__iregex",
1651                &local_var_str
1652                    .into_iter()
1653                    .map(|p| p.to_string())
1654                    .collect::<Vec<String>>()
1655                    .join(",")
1656                    .to_string(),
1657            )]),
1658        };
1659    }
1660    if let Some(ref local_var_str) = name__isw {
1661        local_var_req_builder = match "multi" {
1662            "multi" => local_var_req_builder.query(
1663                &local_var_str
1664                    .into_iter()
1665                    .map(|p| ("name__isw".to_owned(), p.to_string()))
1666                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1667            ),
1668            _ => local_var_req_builder.query(&[(
1669                "name__isw",
1670                &local_var_str
1671                    .into_iter()
1672                    .map(|p| p.to_string())
1673                    .collect::<Vec<String>>()
1674                    .join(",")
1675                    .to_string(),
1676            )]),
1677        };
1678    }
1679    if let Some(ref local_var_str) = name__n {
1680        local_var_req_builder = match "multi" {
1681            "multi" => local_var_req_builder.query(
1682                &local_var_str
1683                    .into_iter()
1684                    .map(|p| ("name__n".to_owned(), p.to_string()))
1685                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1686            ),
1687            _ => local_var_req_builder.query(&[(
1688                "name__n",
1689                &local_var_str
1690                    .into_iter()
1691                    .map(|p| p.to_string())
1692                    .collect::<Vec<String>>()
1693                    .join(",")
1694                    .to_string(),
1695            )]),
1696        };
1697    }
1698    if let Some(ref local_var_str) = name__nic {
1699        local_var_req_builder = match "multi" {
1700            "multi" => local_var_req_builder.query(
1701                &local_var_str
1702                    .into_iter()
1703                    .map(|p| ("name__nic".to_owned(), p.to_string()))
1704                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1705            ),
1706            _ => local_var_req_builder.query(&[(
1707                "name__nic",
1708                &local_var_str
1709                    .into_iter()
1710                    .map(|p| p.to_string())
1711                    .collect::<Vec<String>>()
1712                    .join(",")
1713                    .to_string(),
1714            )]),
1715        };
1716    }
1717    if let Some(ref local_var_str) = name__nie {
1718        local_var_req_builder = match "multi" {
1719            "multi" => local_var_req_builder.query(
1720                &local_var_str
1721                    .into_iter()
1722                    .map(|p| ("name__nie".to_owned(), p.to_string()))
1723                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1724            ),
1725            _ => local_var_req_builder.query(&[(
1726                "name__nie",
1727                &local_var_str
1728                    .into_iter()
1729                    .map(|p| p.to_string())
1730                    .collect::<Vec<String>>()
1731                    .join(",")
1732                    .to_string(),
1733            )]),
1734        };
1735    }
1736    if let Some(ref local_var_str) = name__niew {
1737        local_var_req_builder = match "multi" {
1738            "multi" => local_var_req_builder.query(
1739                &local_var_str
1740                    .into_iter()
1741                    .map(|p| ("name__niew".to_owned(), p.to_string()))
1742                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1743            ),
1744            _ => local_var_req_builder.query(&[(
1745                "name__niew",
1746                &local_var_str
1747                    .into_iter()
1748                    .map(|p| p.to_string())
1749                    .collect::<Vec<String>>()
1750                    .join(",")
1751                    .to_string(),
1752            )]),
1753        };
1754    }
1755    if let Some(ref local_var_str) = name__nisw {
1756        local_var_req_builder = match "multi" {
1757            "multi" => local_var_req_builder.query(
1758                &local_var_str
1759                    .into_iter()
1760                    .map(|p| ("name__nisw".to_owned(), p.to_string()))
1761                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1762            ),
1763            _ => local_var_req_builder.query(&[(
1764                "name__nisw",
1765                &local_var_str
1766                    .into_iter()
1767                    .map(|p| p.to_string())
1768                    .collect::<Vec<String>>()
1769                    .join(",")
1770                    .to_string(),
1771            )]),
1772        };
1773    }
1774    if let Some(ref local_var_str) = name__regex {
1775        local_var_req_builder = match "multi" {
1776            "multi" => local_var_req_builder.query(
1777                &local_var_str
1778                    .into_iter()
1779                    .map(|p| ("name__regex".to_owned(), p.to_string()))
1780                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1781            ),
1782            _ => local_var_req_builder.query(&[(
1783                "name__regex",
1784                &local_var_str
1785                    .into_iter()
1786                    .map(|p| p.to_string())
1787                    .collect::<Vec<String>>()
1788                    .join(",")
1789                    .to_string(),
1790            )]),
1791        };
1792    }
1793    if let Some(ref local_var_str) = offset {
1794        local_var_req_builder =
1795            local_var_req_builder.query(&[("offset", &local_var_str.to_string())]);
1796    }
1797    if let Some(ref local_var_str) = ordering {
1798        local_var_req_builder =
1799            local_var_req_builder.query(&[("ordering", &local_var_str.to_string())]);
1800    }
1801    if let Some(ref local_var_str) = owner {
1802        local_var_req_builder = match "multi" {
1803            "multi" => local_var_req_builder.query(
1804                &local_var_str
1805                    .into_iter()
1806                    .map(|p| ("owner".to_owned(), p.to_string()))
1807                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1808            ),
1809            _ => local_var_req_builder.query(&[(
1810                "owner",
1811                &local_var_str
1812                    .into_iter()
1813                    .map(|p| p.to_string())
1814                    .collect::<Vec<String>>()
1815                    .join(",")
1816                    .to_string(),
1817            )]),
1818        };
1819    }
1820    if let Some(ref local_var_str) = owner__n {
1821        local_var_req_builder = match "multi" {
1822            "multi" => local_var_req_builder.query(
1823                &local_var_str
1824                    .into_iter()
1825                    .map(|p| ("owner__n".to_owned(), p.to_string()))
1826                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1827            ),
1828            _ => local_var_req_builder.query(&[(
1829                "owner__n",
1830                &local_var_str
1831                    .into_iter()
1832                    .map(|p| p.to_string())
1833                    .collect::<Vec<String>>()
1834                    .join(",")
1835                    .to_string(),
1836            )]),
1837        };
1838    }
1839    if let Some(ref local_var_str) = owner_group {
1840        local_var_req_builder = match "multi" {
1841            "multi" => local_var_req_builder.query(
1842                &local_var_str
1843                    .into_iter()
1844                    .map(|p| ("owner_group".to_owned(), p.to_string()))
1845                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1846            ),
1847            _ => local_var_req_builder.query(&[(
1848                "owner_group",
1849                &local_var_str
1850                    .into_iter()
1851                    .map(|p| p.to_string())
1852                    .collect::<Vec<String>>()
1853                    .join(",")
1854                    .to_string(),
1855            )]),
1856        };
1857    }
1858    if let Some(ref local_var_str) = owner_group__n {
1859        local_var_req_builder = match "multi" {
1860            "multi" => local_var_req_builder.query(
1861                &local_var_str
1862                    .into_iter()
1863                    .map(|p| ("owner_group__n".to_owned(), p.to_string()))
1864                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1865            ),
1866            _ => local_var_req_builder.query(&[(
1867                "owner_group__n",
1868                &local_var_str
1869                    .into_iter()
1870                    .map(|p| p.to_string())
1871                    .collect::<Vec<String>>()
1872                    .join(",")
1873                    .to_string(),
1874            )]),
1875        };
1876    }
1877    if let Some(ref local_var_str) = owner_group_id {
1878        local_var_req_builder = match "multi" {
1879            "multi" => local_var_req_builder.query(
1880                &local_var_str
1881                    .into_iter()
1882                    .map(|p| ("owner_group_id".to_owned(), p.to_string()))
1883                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1884            ),
1885            _ => local_var_req_builder.query(&[(
1886                "owner_group_id",
1887                &local_var_str
1888                    .into_iter()
1889                    .map(|p| p.to_string())
1890                    .collect::<Vec<String>>()
1891                    .join(",")
1892                    .to_string(),
1893            )]),
1894        };
1895    }
1896    if let Some(ref local_var_str) = owner_group_id__n {
1897        local_var_req_builder = match "multi" {
1898            "multi" => local_var_req_builder.query(
1899                &local_var_str
1900                    .into_iter()
1901                    .map(|p| ("owner_group_id__n".to_owned(), p.to_string()))
1902                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1903            ),
1904            _ => local_var_req_builder.query(&[(
1905                "owner_group_id__n",
1906                &local_var_str
1907                    .into_iter()
1908                    .map(|p| p.to_string())
1909                    .collect::<Vec<String>>()
1910                    .join(",")
1911                    .to_string(),
1912            )]),
1913        };
1914    }
1915    if let Some(ref local_var_str) = owner_id {
1916        local_var_req_builder = match "multi" {
1917            "multi" => local_var_req_builder.query(
1918                &local_var_str
1919                    .into_iter()
1920                    .map(|p| ("owner_id".to_owned(), p.to_string()))
1921                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1922            ),
1923            _ => local_var_req_builder.query(&[(
1924                "owner_id",
1925                &local_var_str
1926                    .into_iter()
1927                    .map(|p| p.to_string())
1928                    .collect::<Vec<String>>()
1929                    .join(",")
1930                    .to_string(),
1931            )]),
1932        };
1933    }
1934    if let Some(ref local_var_str) = owner_id__n {
1935        local_var_req_builder = match "multi" {
1936            "multi" => local_var_req_builder.query(
1937                &local_var_str
1938                    .into_iter()
1939                    .map(|p| ("owner_id__n".to_owned(), p.to_string()))
1940                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1941            ),
1942            _ => local_var_req_builder.query(&[(
1943                "owner_id__n",
1944                &local_var_str
1945                    .into_iter()
1946                    .map(|p| p.to_string())
1947                    .collect::<Vec<String>>()
1948                    .join(",")
1949                    .to_string(),
1950            )]),
1951        };
1952    }
1953    if let Some(ref local_var_str) = q {
1954        local_var_req_builder = local_var_req_builder.query(&[("q", &local_var_str.to_string())]);
1955    }
1956    if let Some(ref local_var_str) = slug {
1957        local_var_req_builder = match "multi" {
1958            "multi" => local_var_req_builder.query(
1959                &local_var_str
1960                    .into_iter()
1961                    .map(|p| ("slug".to_owned(), p.to_string()))
1962                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1963            ),
1964            _ => local_var_req_builder.query(&[(
1965                "slug",
1966                &local_var_str
1967                    .into_iter()
1968                    .map(|p| p.to_string())
1969                    .collect::<Vec<String>>()
1970                    .join(",")
1971                    .to_string(),
1972            )]),
1973        };
1974    }
1975    if let Some(ref local_var_str) = slug__empty {
1976        local_var_req_builder =
1977            local_var_req_builder.query(&[("slug__empty", &local_var_str.to_string())]);
1978    }
1979    if let Some(ref local_var_str) = slug__ic {
1980        local_var_req_builder = match "multi" {
1981            "multi" => local_var_req_builder.query(
1982                &local_var_str
1983                    .into_iter()
1984                    .map(|p| ("slug__ic".to_owned(), p.to_string()))
1985                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1986            ),
1987            _ => local_var_req_builder.query(&[(
1988                "slug__ic",
1989                &local_var_str
1990                    .into_iter()
1991                    .map(|p| p.to_string())
1992                    .collect::<Vec<String>>()
1993                    .join(",")
1994                    .to_string(),
1995            )]),
1996        };
1997    }
1998    if let Some(ref local_var_str) = slug__ie {
1999        local_var_req_builder = match "multi" {
2000            "multi" => local_var_req_builder.query(
2001                &local_var_str
2002                    .into_iter()
2003                    .map(|p| ("slug__ie".to_owned(), p.to_string()))
2004                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2005            ),
2006            _ => local_var_req_builder.query(&[(
2007                "slug__ie",
2008                &local_var_str
2009                    .into_iter()
2010                    .map(|p| p.to_string())
2011                    .collect::<Vec<String>>()
2012                    .join(",")
2013                    .to_string(),
2014            )]),
2015        };
2016    }
2017    if let Some(ref local_var_str) = slug__iew {
2018        local_var_req_builder = match "multi" {
2019            "multi" => local_var_req_builder.query(
2020                &local_var_str
2021                    .into_iter()
2022                    .map(|p| ("slug__iew".to_owned(), p.to_string()))
2023                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2024            ),
2025            _ => local_var_req_builder.query(&[(
2026                "slug__iew",
2027                &local_var_str
2028                    .into_iter()
2029                    .map(|p| p.to_string())
2030                    .collect::<Vec<String>>()
2031                    .join(",")
2032                    .to_string(),
2033            )]),
2034        };
2035    }
2036    if let Some(ref local_var_str) = slug__iregex {
2037        local_var_req_builder = match "multi" {
2038            "multi" => local_var_req_builder.query(
2039                &local_var_str
2040                    .into_iter()
2041                    .map(|p| ("slug__iregex".to_owned(), p.to_string()))
2042                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2043            ),
2044            _ => local_var_req_builder.query(&[(
2045                "slug__iregex",
2046                &local_var_str
2047                    .into_iter()
2048                    .map(|p| p.to_string())
2049                    .collect::<Vec<String>>()
2050                    .join(",")
2051                    .to_string(),
2052            )]),
2053        };
2054    }
2055    if let Some(ref local_var_str) = slug__isw {
2056        local_var_req_builder = match "multi" {
2057            "multi" => local_var_req_builder.query(
2058                &local_var_str
2059                    .into_iter()
2060                    .map(|p| ("slug__isw".to_owned(), p.to_string()))
2061                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2062            ),
2063            _ => local_var_req_builder.query(&[(
2064                "slug__isw",
2065                &local_var_str
2066                    .into_iter()
2067                    .map(|p| p.to_string())
2068                    .collect::<Vec<String>>()
2069                    .join(",")
2070                    .to_string(),
2071            )]),
2072        };
2073    }
2074    if let Some(ref local_var_str) = slug__n {
2075        local_var_req_builder = match "multi" {
2076            "multi" => local_var_req_builder.query(
2077                &local_var_str
2078                    .into_iter()
2079                    .map(|p| ("slug__n".to_owned(), p.to_string()))
2080                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2081            ),
2082            _ => local_var_req_builder.query(&[(
2083                "slug__n",
2084                &local_var_str
2085                    .into_iter()
2086                    .map(|p| p.to_string())
2087                    .collect::<Vec<String>>()
2088                    .join(",")
2089                    .to_string(),
2090            )]),
2091        };
2092    }
2093    if let Some(ref local_var_str) = slug__nic {
2094        local_var_req_builder = match "multi" {
2095            "multi" => local_var_req_builder.query(
2096                &local_var_str
2097                    .into_iter()
2098                    .map(|p| ("slug__nic".to_owned(), p.to_string()))
2099                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2100            ),
2101            _ => local_var_req_builder.query(&[(
2102                "slug__nic",
2103                &local_var_str
2104                    .into_iter()
2105                    .map(|p| p.to_string())
2106                    .collect::<Vec<String>>()
2107                    .join(",")
2108                    .to_string(),
2109            )]),
2110        };
2111    }
2112    if let Some(ref local_var_str) = slug__nie {
2113        local_var_req_builder = match "multi" {
2114            "multi" => local_var_req_builder.query(
2115                &local_var_str
2116                    .into_iter()
2117                    .map(|p| ("slug__nie".to_owned(), p.to_string()))
2118                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2119            ),
2120            _ => local_var_req_builder.query(&[(
2121                "slug__nie",
2122                &local_var_str
2123                    .into_iter()
2124                    .map(|p| p.to_string())
2125                    .collect::<Vec<String>>()
2126                    .join(",")
2127                    .to_string(),
2128            )]),
2129        };
2130    }
2131    if let Some(ref local_var_str) = slug__niew {
2132        local_var_req_builder = match "multi" {
2133            "multi" => local_var_req_builder.query(
2134                &local_var_str
2135                    .into_iter()
2136                    .map(|p| ("slug__niew".to_owned(), p.to_string()))
2137                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2138            ),
2139            _ => local_var_req_builder.query(&[(
2140                "slug__niew",
2141                &local_var_str
2142                    .into_iter()
2143                    .map(|p| p.to_string())
2144                    .collect::<Vec<String>>()
2145                    .join(",")
2146                    .to_string(),
2147            )]),
2148        };
2149    }
2150    if let Some(ref local_var_str) = slug__nisw {
2151        local_var_req_builder = match "multi" {
2152            "multi" => local_var_req_builder.query(
2153                &local_var_str
2154                    .into_iter()
2155                    .map(|p| ("slug__nisw".to_owned(), p.to_string()))
2156                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2157            ),
2158            _ => local_var_req_builder.query(&[(
2159                "slug__nisw",
2160                &local_var_str
2161                    .into_iter()
2162                    .map(|p| p.to_string())
2163                    .collect::<Vec<String>>()
2164                    .join(",")
2165                    .to_string(),
2166            )]),
2167        };
2168    }
2169    if let Some(ref local_var_str) = slug__regex {
2170        local_var_req_builder = match "multi" {
2171            "multi" => local_var_req_builder.query(
2172                &local_var_str
2173                    .into_iter()
2174                    .map(|p| ("slug__regex".to_owned(), p.to_string()))
2175                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2176            ),
2177            _ => local_var_req_builder.query(&[(
2178                "slug__regex",
2179                &local_var_str
2180                    .into_iter()
2181                    .map(|p| p.to_string())
2182                    .collect::<Vec<String>>()
2183                    .join(",")
2184                    .to_string(),
2185            )]),
2186        };
2187    }
2188    if let Some(ref local_var_str) = start {
2189        local_var_req_builder =
2190            local_var_req_builder.query(&[("start", &local_var_str.to_string())]);
2191    }
2192    if let Some(ref local_var_str) = tag {
2193        local_var_req_builder = match "multi" {
2194            "multi" => local_var_req_builder.query(
2195                &local_var_str
2196                    .into_iter()
2197                    .map(|p| ("tag".to_owned(), p.to_string()))
2198                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2199            ),
2200            _ => local_var_req_builder.query(&[(
2201                "tag",
2202                &local_var_str
2203                    .into_iter()
2204                    .map(|p| p.to_string())
2205                    .collect::<Vec<String>>()
2206                    .join(",")
2207                    .to_string(),
2208            )]),
2209        };
2210    }
2211    if let Some(ref local_var_str) = tag__n {
2212        local_var_req_builder = match "multi" {
2213            "multi" => local_var_req_builder.query(
2214                &local_var_str
2215                    .into_iter()
2216                    .map(|p| ("tag__n".to_owned(), p.to_string()))
2217                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2218            ),
2219            _ => local_var_req_builder.query(&[(
2220                "tag__n",
2221                &local_var_str
2222                    .into_iter()
2223                    .map(|p| p.to_string())
2224                    .collect::<Vec<String>>()
2225                    .join(",")
2226                    .to_string(),
2227            )]),
2228        };
2229    }
2230    if let Some(ref local_var_str) = tag_id {
2231        local_var_req_builder = match "multi" {
2232            "multi" => local_var_req_builder.query(
2233                &local_var_str
2234                    .into_iter()
2235                    .map(|p| ("tag_id".to_owned(), p.to_string()))
2236                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2237            ),
2238            _ => local_var_req_builder.query(&[(
2239                "tag_id",
2240                &local_var_str
2241                    .into_iter()
2242                    .map(|p| p.to_string())
2243                    .collect::<Vec<String>>()
2244                    .join(",")
2245                    .to_string(),
2246            )]),
2247        };
2248    }
2249    if let Some(ref local_var_str) = tag_id__n {
2250        local_var_req_builder = match "multi" {
2251            "multi" => local_var_req_builder.query(
2252                &local_var_str
2253                    .into_iter()
2254                    .map(|p| ("tag_id__n".to_owned(), p.to_string()))
2255                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2256            ),
2257            _ => local_var_req_builder.query(&[(
2258                "tag_id__n",
2259                &local_var_str
2260                    .into_iter()
2261                    .map(|p| p.to_string())
2262                    .collect::<Vec<String>>()
2263                    .join(",")
2264                    .to_string(),
2265            )]),
2266        };
2267    }
2268    if let Some(ref local_var_str) = updated_by_request {
2269        local_var_req_builder =
2270            local_var_req_builder.query(&[("updated_by_request", &local_var_str.to_string())]);
2271    }
2272    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
2273        local_var_req_builder =
2274            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
2275    }
2276    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
2277        let local_var_key = local_var_apikey.key.clone();
2278        let local_var_value = match local_var_apikey.prefix {
2279            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
2280            None => local_var_key,
2281        };
2282        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
2283    };
2284
2285    let local_var_req = local_var_req_builder.build()?;
2286    let local_var_resp = local_var_client.execute(local_var_req).await?;
2287
2288    let local_var_status = local_var_resp.status();
2289    let local_var_content = local_var_resp.text().await?;
2290
2291    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
2292        serde_json::from_str(&local_var_content).map_err(Error::from)
2293    } else {
2294        let local_var_entity: Option<VirtualizationClusterGroupsListError> =
2295            serde_json::from_str(&local_var_content).ok();
2296        let local_var_error = ResponseContent {
2297            status: local_var_status,
2298            content: local_var_content,
2299            entity: local_var_entity,
2300        };
2301        Err(Error::ResponseError(local_var_error))
2302    }
2303}
2304
2305/// Patch a cluster group object.
2306pub async fn virtualization_cluster_groups_partial_update(
2307    configuration: &configuration::Configuration,
2308    id: i32,
2309    patched_cluster_group_request: Option<crate::models::PatchedClusterGroupRequest>,
2310) -> Result<crate::models::ClusterGroup, Error<VirtualizationClusterGroupsPartialUpdateError>> {
2311    let local_var_configuration = configuration;
2312
2313    let local_var_client = &local_var_configuration.client;
2314
2315    let local_var_uri_str = format!(
2316        "{}/api/virtualization/cluster-groups/{id}/",
2317        local_var_configuration.base_path,
2318        id = id
2319    );
2320    let mut local_var_req_builder =
2321        local_var_client.request(reqwest::Method::PATCH, local_var_uri_str.as_str());
2322
2323    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
2324        local_var_req_builder =
2325            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
2326    }
2327    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
2328        let local_var_key = local_var_apikey.key.clone();
2329        let local_var_value = match local_var_apikey.prefix {
2330            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
2331            None => local_var_key,
2332        };
2333        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
2334    };
2335    local_var_req_builder = local_var_req_builder.json(&patched_cluster_group_request);
2336
2337    let local_var_req = local_var_req_builder.build()?;
2338    let local_var_resp = local_var_client.execute(local_var_req).await?;
2339
2340    let local_var_status = local_var_resp.status();
2341    let local_var_content = local_var_resp.text().await?;
2342
2343    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
2344        serde_json::from_str(&local_var_content).map_err(Error::from)
2345    } else {
2346        let local_var_entity: Option<VirtualizationClusterGroupsPartialUpdateError> =
2347            serde_json::from_str(&local_var_content).ok();
2348        let local_var_error = ResponseContent {
2349            status: local_var_status,
2350            content: local_var_content,
2351            entity: local_var_entity,
2352        };
2353        Err(Error::ResponseError(local_var_error))
2354    }
2355}
2356
2357/// Get a cluster group object.
2358pub async fn virtualization_cluster_groups_retrieve(
2359    configuration: &configuration::Configuration,
2360    id: i32,
2361) -> Result<crate::models::ClusterGroup, Error<VirtualizationClusterGroupsRetrieveError>> {
2362    let local_var_configuration = configuration;
2363
2364    let local_var_client = &local_var_configuration.client;
2365
2366    let local_var_uri_str = format!(
2367        "{}/api/virtualization/cluster-groups/{id}/",
2368        local_var_configuration.base_path,
2369        id = id
2370    );
2371    let mut local_var_req_builder =
2372        local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
2373
2374    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
2375        local_var_req_builder =
2376            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
2377    }
2378    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
2379        let local_var_key = local_var_apikey.key.clone();
2380        let local_var_value = match local_var_apikey.prefix {
2381            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
2382            None => local_var_key,
2383        };
2384        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
2385    };
2386
2387    let local_var_req = local_var_req_builder.build()?;
2388    let local_var_resp = local_var_client.execute(local_var_req).await?;
2389
2390    let local_var_status = local_var_resp.status();
2391    let local_var_content = local_var_resp.text().await?;
2392
2393    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
2394        serde_json::from_str(&local_var_content).map_err(Error::from)
2395    } else {
2396        let local_var_entity: Option<VirtualizationClusterGroupsRetrieveError> =
2397            serde_json::from_str(&local_var_content).ok();
2398        let local_var_error = ResponseContent {
2399            status: local_var_status,
2400            content: local_var_content,
2401            entity: local_var_entity,
2402        };
2403        Err(Error::ResponseError(local_var_error))
2404    }
2405}
2406
2407/// Put a cluster group object.
2408pub async fn virtualization_cluster_groups_update(
2409    configuration: &configuration::Configuration,
2410    id: i32,
2411    cluster_group_request: crate::models::ClusterGroupRequest,
2412) -> Result<crate::models::ClusterGroup, Error<VirtualizationClusterGroupsUpdateError>> {
2413    let local_var_configuration = configuration;
2414
2415    let local_var_client = &local_var_configuration.client;
2416
2417    let local_var_uri_str = format!(
2418        "{}/api/virtualization/cluster-groups/{id}/",
2419        local_var_configuration.base_path,
2420        id = id
2421    );
2422    let mut local_var_req_builder =
2423        local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());
2424
2425    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
2426        local_var_req_builder =
2427            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
2428    }
2429    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
2430        let local_var_key = local_var_apikey.key.clone();
2431        let local_var_value = match local_var_apikey.prefix {
2432            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
2433            None => local_var_key,
2434        };
2435        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
2436    };
2437    local_var_req_builder = local_var_req_builder.json(&cluster_group_request);
2438
2439    let local_var_req = local_var_req_builder.build()?;
2440    let local_var_resp = local_var_client.execute(local_var_req).await?;
2441
2442    let local_var_status = local_var_resp.status();
2443    let local_var_content = local_var_resp.text().await?;
2444
2445    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
2446        serde_json::from_str(&local_var_content).map_err(Error::from)
2447    } else {
2448        let local_var_entity: Option<VirtualizationClusterGroupsUpdateError> =
2449            serde_json::from_str(&local_var_content).ok();
2450        let local_var_error = ResponseContent {
2451            status: local_var_status,
2452            content: local_var_content,
2453            entity: local_var_entity,
2454        };
2455        Err(Error::ResponseError(local_var_error))
2456    }
2457}
2458
2459/// Delete a list of cluster type objects.
2460pub async fn virtualization_cluster_types_bulk_destroy(
2461    configuration: &configuration::Configuration,
2462    cluster_type_request: Vec<crate::models::ClusterTypeRequest>,
2463) -> Result<(), Error<VirtualizationClusterTypesBulkDestroyError>> {
2464    let local_var_configuration = configuration;
2465
2466    let local_var_client = &local_var_configuration.client;
2467
2468    let local_var_uri_str = format!(
2469        "{}/api/virtualization/cluster-types/",
2470        local_var_configuration.base_path
2471    );
2472    let mut local_var_req_builder =
2473        local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());
2474
2475    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
2476        local_var_req_builder =
2477            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
2478    }
2479    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
2480        let local_var_key = local_var_apikey.key.clone();
2481        let local_var_value = match local_var_apikey.prefix {
2482            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
2483            None => local_var_key,
2484        };
2485        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
2486    };
2487    local_var_req_builder = local_var_req_builder.json(&cluster_type_request);
2488
2489    let local_var_req = local_var_req_builder.build()?;
2490    let local_var_resp = local_var_client.execute(local_var_req).await?;
2491
2492    let local_var_status = local_var_resp.status();
2493    let local_var_content = local_var_resp.text().await?;
2494
2495    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
2496        Ok(())
2497    } else {
2498        let local_var_entity: Option<VirtualizationClusterTypesBulkDestroyError> =
2499            serde_json::from_str(&local_var_content).ok();
2500        let local_var_error = ResponseContent {
2501            status: local_var_status,
2502            content: local_var_content,
2503            entity: local_var_entity,
2504        };
2505        Err(Error::ResponseError(local_var_error))
2506    }
2507}
2508
2509/// Patch a list of cluster type objects.
2510pub async fn virtualization_cluster_types_bulk_partial_update(
2511    configuration: &configuration::Configuration,
2512    cluster_type_request: Vec<crate::models::ClusterTypeRequest>,
2513) -> Result<Vec<crate::models::ClusterType>, Error<VirtualizationClusterTypesBulkPartialUpdateError>>
2514{
2515    let local_var_configuration = configuration;
2516
2517    let local_var_client = &local_var_configuration.client;
2518
2519    let local_var_uri_str = format!(
2520        "{}/api/virtualization/cluster-types/",
2521        local_var_configuration.base_path
2522    );
2523    let mut local_var_req_builder =
2524        local_var_client.request(reqwest::Method::PATCH, local_var_uri_str.as_str());
2525
2526    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
2527        local_var_req_builder =
2528            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
2529    }
2530    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
2531        let local_var_key = local_var_apikey.key.clone();
2532        let local_var_value = match local_var_apikey.prefix {
2533            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
2534            None => local_var_key,
2535        };
2536        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
2537    };
2538    local_var_req_builder = local_var_req_builder.json(&cluster_type_request);
2539
2540    let local_var_req = local_var_req_builder.build()?;
2541    let local_var_resp = local_var_client.execute(local_var_req).await?;
2542
2543    let local_var_status = local_var_resp.status();
2544    let local_var_content = local_var_resp.text().await?;
2545
2546    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
2547        serde_json::from_str(&local_var_content).map_err(Error::from)
2548    } else {
2549        let local_var_entity: Option<VirtualizationClusterTypesBulkPartialUpdateError> =
2550            serde_json::from_str(&local_var_content).ok();
2551        let local_var_error = ResponseContent {
2552            status: local_var_status,
2553            content: local_var_content,
2554            entity: local_var_entity,
2555        };
2556        Err(Error::ResponseError(local_var_error))
2557    }
2558}
2559
2560/// Put a list of cluster type objects.
2561pub async fn virtualization_cluster_types_bulk_update(
2562    configuration: &configuration::Configuration,
2563    cluster_type_request: Vec<crate::models::ClusterTypeRequest>,
2564) -> Result<Vec<crate::models::ClusterType>, Error<VirtualizationClusterTypesBulkUpdateError>> {
2565    let local_var_configuration = configuration;
2566
2567    let local_var_client = &local_var_configuration.client;
2568
2569    let local_var_uri_str = format!(
2570        "{}/api/virtualization/cluster-types/",
2571        local_var_configuration.base_path
2572    );
2573    let mut local_var_req_builder =
2574        local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());
2575
2576    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
2577        local_var_req_builder =
2578            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
2579    }
2580    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
2581        let local_var_key = local_var_apikey.key.clone();
2582        let local_var_value = match local_var_apikey.prefix {
2583            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
2584            None => local_var_key,
2585        };
2586        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
2587    };
2588    local_var_req_builder = local_var_req_builder.json(&cluster_type_request);
2589
2590    let local_var_req = local_var_req_builder.build()?;
2591    let local_var_resp = local_var_client.execute(local_var_req).await?;
2592
2593    let local_var_status = local_var_resp.status();
2594    let local_var_content = local_var_resp.text().await?;
2595
2596    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
2597        serde_json::from_str(&local_var_content).map_err(Error::from)
2598    } else {
2599        let local_var_entity: Option<VirtualizationClusterTypesBulkUpdateError> =
2600            serde_json::from_str(&local_var_content).ok();
2601        let local_var_error = ResponseContent {
2602            status: local_var_status,
2603            content: local_var_content,
2604            entity: local_var_entity,
2605        };
2606        Err(Error::ResponseError(local_var_error))
2607    }
2608}
2609
2610/// Post a list of cluster type objects.
2611pub async fn virtualization_cluster_types_create(
2612    configuration: &configuration::Configuration,
2613    virtualization_cluster_types_create_request: crate::models::VirtualizationClusterTypesCreateRequest,
2614) -> Result<crate::models::ClusterType, Error<VirtualizationClusterTypesCreateError>> {
2615    let local_var_configuration = configuration;
2616
2617    let local_var_client = &local_var_configuration.client;
2618
2619    let local_var_uri_str = format!(
2620        "{}/api/virtualization/cluster-types/",
2621        local_var_configuration.base_path
2622    );
2623    let mut local_var_req_builder =
2624        local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
2625
2626    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
2627        local_var_req_builder =
2628            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
2629    }
2630    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
2631        let local_var_key = local_var_apikey.key.clone();
2632        let local_var_value = match local_var_apikey.prefix {
2633            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
2634            None => local_var_key,
2635        };
2636        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
2637    };
2638    local_var_req_builder =
2639        local_var_req_builder.json(&virtualization_cluster_types_create_request);
2640
2641    let local_var_req = local_var_req_builder.build()?;
2642    let local_var_resp = local_var_client.execute(local_var_req).await?;
2643
2644    let local_var_status = local_var_resp.status();
2645    let local_var_content = local_var_resp.text().await?;
2646
2647    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
2648        serde_json::from_str(&local_var_content).map_err(Error::from)
2649    } else {
2650        let local_var_entity: Option<VirtualizationClusterTypesCreateError> =
2651            serde_json::from_str(&local_var_content).ok();
2652        let local_var_error = ResponseContent {
2653            status: local_var_status,
2654            content: local_var_content,
2655            entity: local_var_entity,
2656        };
2657        Err(Error::ResponseError(local_var_error))
2658    }
2659}
2660
2661/// Delete a cluster type object.
2662pub async fn virtualization_cluster_types_destroy(
2663    configuration: &configuration::Configuration,
2664    id: i32,
2665) -> Result<(), Error<VirtualizationClusterTypesDestroyError>> {
2666    let local_var_configuration = configuration;
2667
2668    let local_var_client = &local_var_configuration.client;
2669
2670    let local_var_uri_str = format!(
2671        "{}/api/virtualization/cluster-types/{id}/",
2672        local_var_configuration.base_path,
2673        id = id
2674    );
2675    let mut local_var_req_builder =
2676        local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());
2677
2678    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
2679        local_var_req_builder =
2680            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
2681    }
2682    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
2683        let local_var_key = local_var_apikey.key.clone();
2684        let local_var_value = match local_var_apikey.prefix {
2685            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
2686            None => local_var_key,
2687        };
2688        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
2689    };
2690
2691    let local_var_req = local_var_req_builder.build()?;
2692    let local_var_resp = local_var_client.execute(local_var_req).await?;
2693
2694    let local_var_status = local_var_resp.status();
2695    let local_var_content = local_var_resp.text().await?;
2696
2697    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
2698        Ok(())
2699    } else {
2700        let local_var_entity: Option<VirtualizationClusterTypesDestroyError> =
2701            serde_json::from_str(&local_var_content).ok();
2702        let local_var_error = ResponseContent {
2703            status: local_var_status,
2704            content: local_var_content,
2705            entity: local_var_entity,
2706        };
2707        Err(Error::ResponseError(local_var_error))
2708    }
2709}
2710
2711/// Get a list of cluster type objects.
2712pub async fn virtualization_cluster_types_list(
2713    configuration: &configuration::Configuration,
2714    created: Option<Vec<String>>,
2715    created__empty: Option<Vec<String>>,
2716    created__gt: Option<Vec<String>>,
2717    created__gte: Option<Vec<String>>,
2718    created__lt: Option<Vec<String>>,
2719    created__lte: Option<Vec<String>>,
2720    created__n: Option<Vec<String>>,
2721    created_by_request: Option<&str>,
2722    description: Option<Vec<String>>,
2723    description__empty: Option<bool>,
2724    description__ic: Option<Vec<String>>,
2725    description__ie: Option<Vec<String>>,
2726    description__iew: Option<Vec<String>>,
2727    description__iregex: Option<Vec<String>>,
2728    description__isw: Option<Vec<String>>,
2729    description__n: Option<Vec<String>>,
2730    description__nic: Option<Vec<String>>,
2731    description__nie: Option<Vec<String>>,
2732    description__niew: Option<Vec<String>>,
2733    description__nisw: Option<Vec<String>>,
2734    description__regex: Option<Vec<String>>,
2735    id: Option<Vec<i32>>,
2736    id__empty: Option<bool>,
2737    id__gt: Option<Vec<i32>>,
2738    id__gte: Option<Vec<i32>>,
2739    id__lt: Option<Vec<i32>>,
2740    id__lte: Option<Vec<i32>>,
2741    id__n: Option<Vec<i32>>,
2742    last_updated: Option<Vec<String>>,
2743    last_updated__empty: Option<Vec<String>>,
2744    last_updated__gt: Option<Vec<String>>,
2745    last_updated__gte: Option<Vec<String>>,
2746    last_updated__lt: Option<Vec<String>>,
2747    last_updated__lte: Option<Vec<String>>,
2748    last_updated__n: Option<Vec<String>>,
2749    limit: Option<i32>,
2750    modified_by_request: Option<&str>,
2751    name: Option<Vec<String>>,
2752    name__empty: Option<bool>,
2753    name__ic: Option<Vec<String>>,
2754    name__ie: Option<Vec<String>>,
2755    name__iew: Option<Vec<String>>,
2756    name__iregex: Option<Vec<String>>,
2757    name__isw: Option<Vec<String>>,
2758    name__n: Option<Vec<String>>,
2759    name__nic: Option<Vec<String>>,
2760    name__nie: Option<Vec<String>>,
2761    name__niew: Option<Vec<String>>,
2762    name__nisw: Option<Vec<String>>,
2763    name__regex: Option<Vec<String>>,
2764    offset: Option<i32>,
2765    ordering: Option<&str>,
2766    owner: Option<Vec<String>>,
2767    owner__n: Option<Vec<String>>,
2768    owner_group: Option<Vec<String>>,
2769    owner_group__n: Option<Vec<String>>,
2770    owner_group_id: Option<Vec<i32>>,
2771    owner_group_id__n: Option<Vec<i32>>,
2772    owner_id: Option<Vec<i32>>,
2773    owner_id__n: Option<Vec<i32>>,
2774    q: Option<&str>,
2775    slug: Option<Vec<String>>,
2776    slug__empty: Option<bool>,
2777    slug__ic: Option<Vec<String>>,
2778    slug__ie: Option<Vec<String>>,
2779    slug__iew: Option<Vec<String>>,
2780    slug__iregex: Option<Vec<String>>,
2781    slug__isw: Option<Vec<String>>,
2782    slug__n: Option<Vec<String>>,
2783    slug__nic: Option<Vec<String>>,
2784    slug__nie: Option<Vec<String>>,
2785    slug__niew: Option<Vec<String>>,
2786    slug__nisw: Option<Vec<String>>,
2787    slug__regex: Option<Vec<String>>,
2788    start: Option<i32>,
2789    tag: Option<Vec<String>>,
2790    tag__n: Option<Vec<String>>,
2791    tag_id: Option<Vec<i32>>,
2792    tag_id__n: Option<Vec<i32>>,
2793    updated_by_request: Option<&str>,
2794) -> Result<crate::models::PaginatedClusterTypeList, Error<VirtualizationClusterTypesListError>> {
2795    let local_var_configuration = configuration;
2796
2797    let local_var_client = &local_var_configuration.client;
2798
2799    let local_var_uri_str = format!(
2800        "{}/api/virtualization/cluster-types/",
2801        local_var_configuration.base_path
2802    );
2803    let mut local_var_req_builder =
2804        local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
2805
2806    if let Some(ref local_var_str) = created {
2807        local_var_req_builder = match "multi" {
2808            "multi" => local_var_req_builder.query(
2809                &local_var_str
2810                    .into_iter()
2811                    .map(|p| ("created".to_owned(), p.to_string()))
2812                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2813            ),
2814            _ => local_var_req_builder.query(&[(
2815                "created",
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) = created__empty {
2826        local_var_req_builder = match "multi" {
2827            "multi" => local_var_req_builder.query(
2828                &local_var_str
2829                    .into_iter()
2830                    .map(|p| ("created__empty".to_owned(), p.to_string()))
2831                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2832            ),
2833            _ => local_var_req_builder.query(&[(
2834                "created__empty",
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) = created__gt {
2845        local_var_req_builder = match "multi" {
2846            "multi" => local_var_req_builder.query(
2847                &local_var_str
2848                    .into_iter()
2849                    .map(|p| ("created__gt".to_owned(), p.to_string()))
2850                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2851            ),
2852            _ => local_var_req_builder.query(&[(
2853                "created__gt",
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) = created__gte {
2864        local_var_req_builder = match "multi" {
2865            "multi" => local_var_req_builder.query(
2866                &local_var_str
2867                    .into_iter()
2868                    .map(|p| ("created__gte".to_owned(), p.to_string()))
2869                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2870            ),
2871            _ => local_var_req_builder.query(&[(
2872                "created__gte",
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) = created__lt {
2883        local_var_req_builder = match "multi" {
2884            "multi" => local_var_req_builder.query(
2885                &local_var_str
2886                    .into_iter()
2887                    .map(|p| ("created__lt".to_owned(), p.to_string()))
2888                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2889            ),
2890            _ => local_var_req_builder.query(&[(
2891                "created__lt",
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) = created__lte {
2902        local_var_req_builder = match "multi" {
2903            "multi" => local_var_req_builder.query(
2904                &local_var_str
2905                    .into_iter()
2906                    .map(|p| ("created__lte".to_owned(), p.to_string()))
2907                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2908            ),
2909            _ => local_var_req_builder.query(&[(
2910                "created__lte",
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) = created__n {
2921        local_var_req_builder = match "multi" {
2922            "multi" => local_var_req_builder.query(
2923                &local_var_str
2924                    .into_iter()
2925                    .map(|p| ("created__n".to_owned(), p.to_string()))
2926                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2927            ),
2928            _ => local_var_req_builder.query(&[(
2929                "created__n",
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) = created_by_request {
2940        local_var_req_builder =
2941            local_var_req_builder.query(&[("created_by_request", &local_var_str.to_string())]);
2942    }
2943    if let Some(ref local_var_str) = description {
2944        local_var_req_builder = match "multi" {
2945            "multi" => local_var_req_builder.query(
2946                &local_var_str
2947                    .into_iter()
2948                    .map(|p| ("description".to_owned(), p.to_string()))
2949                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2950            ),
2951            _ => local_var_req_builder.query(&[(
2952                "description",
2953                &local_var_str
2954                    .into_iter()
2955                    .map(|p| p.to_string())
2956                    .collect::<Vec<String>>()
2957                    .join(",")
2958                    .to_string(),
2959            )]),
2960        };
2961    }
2962    if let Some(ref local_var_str) = description__empty {
2963        local_var_req_builder =
2964            local_var_req_builder.query(&[("description__empty", &local_var_str.to_string())]);
2965    }
2966    if let Some(ref local_var_str) = description__ic {
2967        local_var_req_builder = match "multi" {
2968            "multi" => local_var_req_builder.query(
2969                &local_var_str
2970                    .into_iter()
2971                    .map(|p| ("description__ic".to_owned(), p.to_string()))
2972                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2973            ),
2974            _ => local_var_req_builder.query(&[(
2975                "description__ic",
2976                &local_var_str
2977                    .into_iter()
2978                    .map(|p| p.to_string())
2979                    .collect::<Vec<String>>()
2980                    .join(",")
2981                    .to_string(),
2982            )]),
2983        };
2984    }
2985    if let Some(ref local_var_str) = description__ie {
2986        local_var_req_builder = match "multi" {
2987            "multi" => local_var_req_builder.query(
2988                &local_var_str
2989                    .into_iter()
2990                    .map(|p| ("description__ie".to_owned(), p.to_string()))
2991                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2992            ),
2993            _ => local_var_req_builder.query(&[(
2994                "description__ie",
2995                &local_var_str
2996                    .into_iter()
2997                    .map(|p| p.to_string())
2998                    .collect::<Vec<String>>()
2999                    .join(",")
3000                    .to_string(),
3001            )]),
3002        };
3003    }
3004    if let Some(ref local_var_str) = description__iew {
3005        local_var_req_builder = match "multi" {
3006            "multi" => local_var_req_builder.query(
3007                &local_var_str
3008                    .into_iter()
3009                    .map(|p| ("description__iew".to_owned(), p.to_string()))
3010                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3011            ),
3012            _ => local_var_req_builder.query(&[(
3013                "description__iew",
3014                &local_var_str
3015                    .into_iter()
3016                    .map(|p| p.to_string())
3017                    .collect::<Vec<String>>()
3018                    .join(",")
3019                    .to_string(),
3020            )]),
3021        };
3022    }
3023    if let Some(ref local_var_str) = description__iregex {
3024        local_var_req_builder = match "multi" {
3025            "multi" => local_var_req_builder.query(
3026                &local_var_str
3027                    .into_iter()
3028                    .map(|p| ("description__iregex".to_owned(), p.to_string()))
3029                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3030            ),
3031            _ => local_var_req_builder.query(&[(
3032                "description__iregex",
3033                &local_var_str
3034                    .into_iter()
3035                    .map(|p| p.to_string())
3036                    .collect::<Vec<String>>()
3037                    .join(",")
3038                    .to_string(),
3039            )]),
3040        };
3041    }
3042    if let Some(ref local_var_str) = description__isw {
3043        local_var_req_builder = match "multi" {
3044            "multi" => local_var_req_builder.query(
3045                &local_var_str
3046                    .into_iter()
3047                    .map(|p| ("description__isw".to_owned(), p.to_string()))
3048                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3049            ),
3050            _ => local_var_req_builder.query(&[(
3051                "description__isw",
3052                &local_var_str
3053                    .into_iter()
3054                    .map(|p| p.to_string())
3055                    .collect::<Vec<String>>()
3056                    .join(",")
3057                    .to_string(),
3058            )]),
3059        };
3060    }
3061    if let Some(ref local_var_str) = description__n {
3062        local_var_req_builder = match "multi" {
3063            "multi" => local_var_req_builder.query(
3064                &local_var_str
3065                    .into_iter()
3066                    .map(|p| ("description__n".to_owned(), p.to_string()))
3067                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3068            ),
3069            _ => local_var_req_builder.query(&[(
3070                "description__n",
3071                &local_var_str
3072                    .into_iter()
3073                    .map(|p| p.to_string())
3074                    .collect::<Vec<String>>()
3075                    .join(",")
3076                    .to_string(),
3077            )]),
3078        };
3079    }
3080    if let Some(ref local_var_str) = description__nic {
3081        local_var_req_builder = match "multi" {
3082            "multi" => local_var_req_builder.query(
3083                &local_var_str
3084                    .into_iter()
3085                    .map(|p| ("description__nic".to_owned(), p.to_string()))
3086                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3087            ),
3088            _ => local_var_req_builder.query(&[(
3089                "description__nic",
3090                &local_var_str
3091                    .into_iter()
3092                    .map(|p| p.to_string())
3093                    .collect::<Vec<String>>()
3094                    .join(",")
3095                    .to_string(),
3096            )]),
3097        };
3098    }
3099    if let Some(ref local_var_str) = description__nie {
3100        local_var_req_builder = match "multi" {
3101            "multi" => local_var_req_builder.query(
3102                &local_var_str
3103                    .into_iter()
3104                    .map(|p| ("description__nie".to_owned(), p.to_string()))
3105                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3106            ),
3107            _ => local_var_req_builder.query(&[(
3108                "description__nie",
3109                &local_var_str
3110                    .into_iter()
3111                    .map(|p| p.to_string())
3112                    .collect::<Vec<String>>()
3113                    .join(",")
3114                    .to_string(),
3115            )]),
3116        };
3117    }
3118    if let Some(ref local_var_str) = description__niew {
3119        local_var_req_builder = match "multi" {
3120            "multi" => local_var_req_builder.query(
3121                &local_var_str
3122                    .into_iter()
3123                    .map(|p| ("description__niew".to_owned(), p.to_string()))
3124                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3125            ),
3126            _ => local_var_req_builder.query(&[(
3127                "description__niew",
3128                &local_var_str
3129                    .into_iter()
3130                    .map(|p| p.to_string())
3131                    .collect::<Vec<String>>()
3132                    .join(",")
3133                    .to_string(),
3134            )]),
3135        };
3136    }
3137    if let Some(ref local_var_str) = description__nisw {
3138        local_var_req_builder = match "multi" {
3139            "multi" => local_var_req_builder.query(
3140                &local_var_str
3141                    .into_iter()
3142                    .map(|p| ("description__nisw".to_owned(), p.to_string()))
3143                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3144            ),
3145            _ => local_var_req_builder.query(&[(
3146                "description__nisw",
3147                &local_var_str
3148                    .into_iter()
3149                    .map(|p| p.to_string())
3150                    .collect::<Vec<String>>()
3151                    .join(",")
3152                    .to_string(),
3153            )]),
3154        };
3155    }
3156    if let Some(ref local_var_str) = description__regex {
3157        local_var_req_builder = match "multi" {
3158            "multi" => local_var_req_builder.query(
3159                &local_var_str
3160                    .into_iter()
3161                    .map(|p| ("description__regex".to_owned(), p.to_string()))
3162                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3163            ),
3164            _ => local_var_req_builder.query(&[(
3165                "description__regex",
3166                &local_var_str
3167                    .into_iter()
3168                    .map(|p| p.to_string())
3169                    .collect::<Vec<String>>()
3170                    .join(",")
3171                    .to_string(),
3172            )]),
3173        };
3174    }
3175    if let Some(ref local_var_str) = id {
3176        local_var_req_builder = match "multi" {
3177            "multi" => local_var_req_builder.query(
3178                &local_var_str
3179                    .into_iter()
3180                    .map(|p| ("id".to_owned(), p.to_string()))
3181                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3182            ),
3183            _ => local_var_req_builder.query(&[(
3184                "id",
3185                &local_var_str
3186                    .into_iter()
3187                    .map(|p| p.to_string())
3188                    .collect::<Vec<String>>()
3189                    .join(",")
3190                    .to_string(),
3191            )]),
3192        };
3193    }
3194    if let Some(ref local_var_str) = id__empty {
3195        local_var_req_builder =
3196            local_var_req_builder.query(&[("id__empty", &local_var_str.to_string())]);
3197    }
3198    if let Some(ref local_var_str) = id__gt {
3199        local_var_req_builder = match "multi" {
3200            "multi" => local_var_req_builder.query(
3201                &local_var_str
3202                    .into_iter()
3203                    .map(|p| ("id__gt".to_owned(), p.to_string()))
3204                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3205            ),
3206            _ => local_var_req_builder.query(&[(
3207                "id__gt",
3208                &local_var_str
3209                    .into_iter()
3210                    .map(|p| p.to_string())
3211                    .collect::<Vec<String>>()
3212                    .join(",")
3213                    .to_string(),
3214            )]),
3215        };
3216    }
3217    if let Some(ref local_var_str) = id__gte {
3218        local_var_req_builder = match "multi" {
3219            "multi" => local_var_req_builder.query(
3220                &local_var_str
3221                    .into_iter()
3222                    .map(|p| ("id__gte".to_owned(), p.to_string()))
3223                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3224            ),
3225            _ => local_var_req_builder.query(&[(
3226                "id__gte",
3227                &local_var_str
3228                    .into_iter()
3229                    .map(|p| p.to_string())
3230                    .collect::<Vec<String>>()
3231                    .join(",")
3232                    .to_string(),
3233            )]),
3234        };
3235    }
3236    if let Some(ref local_var_str) = id__lt {
3237        local_var_req_builder = match "multi" {
3238            "multi" => local_var_req_builder.query(
3239                &local_var_str
3240                    .into_iter()
3241                    .map(|p| ("id__lt".to_owned(), p.to_string()))
3242                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3243            ),
3244            _ => local_var_req_builder.query(&[(
3245                "id__lt",
3246                &local_var_str
3247                    .into_iter()
3248                    .map(|p| p.to_string())
3249                    .collect::<Vec<String>>()
3250                    .join(",")
3251                    .to_string(),
3252            )]),
3253        };
3254    }
3255    if let Some(ref local_var_str) = id__lte {
3256        local_var_req_builder = match "multi" {
3257            "multi" => local_var_req_builder.query(
3258                &local_var_str
3259                    .into_iter()
3260                    .map(|p| ("id__lte".to_owned(), p.to_string()))
3261                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3262            ),
3263            _ => local_var_req_builder.query(&[(
3264                "id__lte",
3265                &local_var_str
3266                    .into_iter()
3267                    .map(|p| p.to_string())
3268                    .collect::<Vec<String>>()
3269                    .join(",")
3270                    .to_string(),
3271            )]),
3272        };
3273    }
3274    if let Some(ref local_var_str) = id__n {
3275        local_var_req_builder = match "multi" {
3276            "multi" => local_var_req_builder.query(
3277                &local_var_str
3278                    .into_iter()
3279                    .map(|p| ("id__n".to_owned(), p.to_string()))
3280                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3281            ),
3282            _ => local_var_req_builder.query(&[(
3283                "id__n",
3284                &local_var_str
3285                    .into_iter()
3286                    .map(|p| p.to_string())
3287                    .collect::<Vec<String>>()
3288                    .join(",")
3289                    .to_string(),
3290            )]),
3291        };
3292    }
3293    if let Some(ref local_var_str) = last_updated {
3294        local_var_req_builder = match "multi" {
3295            "multi" => local_var_req_builder.query(
3296                &local_var_str
3297                    .into_iter()
3298                    .map(|p| ("last_updated".to_owned(), p.to_string()))
3299                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3300            ),
3301            _ => local_var_req_builder.query(&[(
3302                "last_updated",
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) = last_updated__empty {
3313        local_var_req_builder = match "multi" {
3314            "multi" => local_var_req_builder.query(
3315                &local_var_str
3316                    .into_iter()
3317                    .map(|p| ("last_updated__empty".to_owned(), p.to_string()))
3318                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3319            ),
3320            _ => local_var_req_builder.query(&[(
3321                "last_updated__empty",
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) = last_updated__gt {
3332        local_var_req_builder = match "multi" {
3333            "multi" => local_var_req_builder.query(
3334                &local_var_str
3335                    .into_iter()
3336                    .map(|p| ("last_updated__gt".to_owned(), p.to_string()))
3337                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3338            ),
3339            _ => local_var_req_builder.query(&[(
3340                "last_updated__gt",
3341                &local_var_str
3342                    .into_iter()
3343                    .map(|p| p.to_string())
3344                    .collect::<Vec<String>>()
3345                    .join(",")
3346                    .to_string(),
3347            )]),
3348        };
3349    }
3350    if let Some(ref local_var_str) = last_updated__gte {
3351        local_var_req_builder = match "multi" {
3352            "multi" => local_var_req_builder.query(
3353                &local_var_str
3354                    .into_iter()
3355                    .map(|p| ("last_updated__gte".to_owned(), p.to_string()))
3356                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3357            ),
3358            _ => local_var_req_builder.query(&[(
3359                "last_updated__gte",
3360                &local_var_str
3361                    .into_iter()
3362                    .map(|p| p.to_string())
3363                    .collect::<Vec<String>>()
3364                    .join(",")
3365                    .to_string(),
3366            )]),
3367        };
3368    }
3369    if let Some(ref local_var_str) = last_updated__lt {
3370        local_var_req_builder = match "multi" {
3371            "multi" => local_var_req_builder.query(
3372                &local_var_str
3373                    .into_iter()
3374                    .map(|p| ("last_updated__lt".to_owned(), p.to_string()))
3375                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3376            ),
3377            _ => local_var_req_builder.query(&[(
3378                "last_updated__lt",
3379                &local_var_str
3380                    .into_iter()
3381                    .map(|p| p.to_string())
3382                    .collect::<Vec<String>>()
3383                    .join(",")
3384                    .to_string(),
3385            )]),
3386        };
3387    }
3388    if let Some(ref local_var_str) = last_updated__lte {
3389        local_var_req_builder = match "multi" {
3390            "multi" => local_var_req_builder.query(
3391                &local_var_str
3392                    .into_iter()
3393                    .map(|p| ("last_updated__lte".to_owned(), p.to_string()))
3394                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3395            ),
3396            _ => local_var_req_builder.query(&[(
3397                "last_updated__lte",
3398                &local_var_str
3399                    .into_iter()
3400                    .map(|p| p.to_string())
3401                    .collect::<Vec<String>>()
3402                    .join(",")
3403                    .to_string(),
3404            )]),
3405        };
3406    }
3407    if let Some(ref local_var_str) = last_updated__n {
3408        local_var_req_builder = match "multi" {
3409            "multi" => local_var_req_builder.query(
3410                &local_var_str
3411                    .into_iter()
3412                    .map(|p| ("last_updated__n".to_owned(), p.to_string()))
3413                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3414            ),
3415            _ => local_var_req_builder.query(&[(
3416                "last_updated__n",
3417                &local_var_str
3418                    .into_iter()
3419                    .map(|p| p.to_string())
3420                    .collect::<Vec<String>>()
3421                    .join(",")
3422                    .to_string(),
3423            )]),
3424        };
3425    }
3426    if let Some(ref local_var_str) = limit {
3427        local_var_req_builder =
3428            local_var_req_builder.query(&[("limit", &local_var_str.to_string())]);
3429    }
3430    if let Some(ref local_var_str) = modified_by_request {
3431        local_var_req_builder =
3432            local_var_req_builder.query(&[("modified_by_request", &local_var_str.to_string())]);
3433    }
3434    if let Some(ref local_var_str) = name {
3435        local_var_req_builder = match "multi" {
3436            "multi" => local_var_req_builder.query(
3437                &local_var_str
3438                    .into_iter()
3439                    .map(|p| ("name".to_owned(), p.to_string()))
3440                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3441            ),
3442            _ => local_var_req_builder.query(&[(
3443                "name",
3444                &local_var_str
3445                    .into_iter()
3446                    .map(|p| p.to_string())
3447                    .collect::<Vec<String>>()
3448                    .join(",")
3449                    .to_string(),
3450            )]),
3451        };
3452    }
3453    if let Some(ref local_var_str) = name__empty {
3454        local_var_req_builder =
3455            local_var_req_builder.query(&[("name__empty", &local_var_str.to_string())]);
3456    }
3457    if let Some(ref local_var_str) = name__ic {
3458        local_var_req_builder = match "multi" {
3459            "multi" => local_var_req_builder.query(
3460                &local_var_str
3461                    .into_iter()
3462                    .map(|p| ("name__ic".to_owned(), p.to_string()))
3463                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3464            ),
3465            _ => local_var_req_builder.query(&[(
3466                "name__ic",
3467                &local_var_str
3468                    .into_iter()
3469                    .map(|p| p.to_string())
3470                    .collect::<Vec<String>>()
3471                    .join(",")
3472                    .to_string(),
3473            )]),
3474        };
3475    }
3476    if let Some(ref local_var_str) = name__ie {
3477        local_var_req_builder = match "multi" {
3478            "multi" => local_var_req_builder.query(
3479                &local_var_str
3480                    .into_iter()
3481                    .map(|p| ("name__ie".to_owned(), p.to_string()))
3482                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3483            ),
3484            _ => local_var_req_builder.query(&[(
3485                "name__ie",
3486                &local_var_str
3487                    .into_iter()
3488                    .map(|p| p.to_string())
3489                    .collect::<Vec<String>>()
3490                    .join(",")
3491                    .to_string(),
3492            )]),
3493        };
3494    }
3495    if let Some(ref local_var_str) = name__iew {
3496        local_var_req_builder = match "multi" {
3497            "multi" => local_var_req_builder.query(
3498                &local_var_str
3499                    .into_iter()
3500                    .map(|p| ("name__iew".to_owned(), p.to_string()))
3501                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3502            ),
3503            _ => local_var_req_builder.query(&[(
3504                "name__iew",
3505                &local_var_str
3506                    .into_iter()
3507                    .map(|p| p.to_string())
3508                    .collect::<Vec<String>>()
3509                    .join(",")
3510                    .to_string(),
3511            )]),
3512        };
3513    }
3514    if let Some(ref local_var_str) = name__iregex {
3515        local_var_req_builder = match "multi" {
3516            "multi" => local_var_req_builder.query(
3517                &local_var_str
3518                    .into_iter()
3519                    .map(|p| ("name__iregex".to_owned(), p.to_string()))
3520                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3521            ),
3522            _ => local_var_req_builder.query(&[(
3523                "name__iregex",
3524                &local_var_str
3525                    .into_iter()
3526                    .map(|p| p.to_string())
3527                    .collect::<Vec<String>>()
3528                    .join(",")
3529                    .to_string(),
3530            )]),
3531        };
3532    }
3533    if let Some(ref local_var_str) = name__isw {
3534        local_var_req_builder = match "multi" {
3535            "multi" => local_var_req_builder.query(
3536                &local_var_str
3537                    .into_iter()
3538                    .map(|p| ("name__isw".to_owned(), p.to_string()))
3539                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3540            ),
3541            _ => local_var_req_builder.query(&[(
3542                "name__isw",
3543                &local_var_str
3544                    .into_iter()
3545                    .map(|p| p.to_string())
3546                    .collect::<Vec<String>>()
3547                    .join(",")
3548                    .to_string(),
3549            )]),
3550        };
3551    }
3552    if let Some(ref local_var_str) = name__n {
3553        local_var_req_builder = match "multi" {
3554            "multi" => local_var_req_builder.query(
3555                &local_var_str
3556                    .into_iter()
3557                    .map(|p| ("name__n".to_owned(), p.to_string()))
3558                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3559            ),
3560            _ => local_var_req_builder.query(&[(
3561                "name__n",
3562                &local_var_str
3563                    .into_iter()
3564                    .map(|p| p.to_string())
3565                    .collect::<Vec<String>>()
3566                    .join(",")
3567                    .to_string(),
3568            )]),
3569        };
3570    }
3571    if let Some(ref local_var_str) = name__nic {
3572        local_var_req_builder = match "multi" {
3573            "multi" => local_var_req_builder.query(
3574                &local_var_str
3575                    .into_iter()
3576                    .map(|p| ("name__nic".to_owned(), p.to_string()))
3577                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3578            ),
3579            _ => local_var_req_builder.query(&[(
3580                "name__nic",
3581                &local_var_str
3582                    .into_iter()
3583                    .map(|p| p.to_string())
3584                    .collect::<Vec<String>>()
3585                    .join(",")
3586                    .to_string(),
3587            )]),
3588        };
3589    }
3590    if let Some(ref local_var_str) = name__nie {
3591        local_var_req_builder = match "multi" {
3592            "multi" => local_var_req_builder.query(
3593                &local_var_str
3594                    .into_iter()
3595                    .map(|p| ("name__nie".to_owned(), p.to_string()))
3596                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3597            ),
3598            _ => local_var_req_builder.query(&[(
3599                "name__nie",
3600                &local_var_str
3601                    .into_iter()
3602                    .map(|p| p.to_string())
3603                    .collect::<Vec<String>>()
3604                    .join(",")
3605                    .to_string(),
3606            )]),
3607        };
3608    }
3609    if let Some(ref local_var_str) = name__niew {
3610        local_var_req_builder = match "multi" {
3611            "multi" => local_var_req_builder.query(
3612                &local_var_str
3613                    .into_iter()
3614                    .map(|p| ("name__niew".to_owned(), p.to_string()))
3615                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3616            ),
3617            _ => local_var_req_builder.query(&[(
3618                "name__niew",
3619                &local_var_str
3620                    .into_iter()
3621                    .map(|p| p.to_string())
3622                    .collect::<Vec<String>>()
3623                    .join(",")
3624                    .to_string(),
3625            )]),
3626        };
3627    }
3628    if let Some(ref local_var_str) = name__nisw {
3629        local_var_req_builder = match "multi" {
3630            "multi" => local_var_req_builder.query(
3631                &local_var_str
3632                    .into_iter()
3633                    .map(|p| ("name__nisw".to_owned(), p.to_string()))
3634                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3635            ),
3636            _ => local_var_req_builder.query(&[(
3637                "name__nisw",
3638                &local_var_str
3639                    .into_iter()
3640                    .map(|p| p.to_string())
3641                    .collect::<Vec<String>>()
3642                    .join(",")
3643                    .to_string(),
3644            )]),
3645        };
3646    }
3647    if let Some(ref local_var_str) = name__regex {
3648        local_var_req_builder = match "multi" {
3649            "multi" => local_var_req_builder.query(
3650                &local_var_str
3651                    .into_iter()
3652                    .map(|p| ("name__regex".to_owned(), p.to_string()))
3653                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3654            ),
3655            _ => local_var_req_builder.query(&[(
3656                "name__regex",
3657                &local_var_str
3658                    .into_iter()
3659                    .map(|p| p.to_string())
3660                    .collect::<Vec<String>>()
3661                    .join(",")
3662                    .to_string(),
3663            )]),
3664        };
3665    }
3666    if let Some(ref local_var_str) = offset {
3667        local_var_req_builder =
3668            local_var_req_builder.query(&[("offset", &local_var_str.to_string())]);
3669    }
3670    if let Some(ref local_var_str) = ordering {
3671        local_var_req_builder =
3672            local_var_req_builder.query(&[("ordering", &local_var_str.to_string())]);
3673    }
3674    if let Some(ref local_var_str) = owner {
3675        local_var_req_builder = match "multi" {
3676            "multi" => local_var_req_builder.query(
3677                &local_var_str
3678                    .into_iter()
3679                    .map(|p| ("owner".to_owned(), p.to_string()))
3680                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3681            ),
3682            _ => local_var_req_builder.query(&[(
3683                "owner",
3684                &local_var_str
3685                    .into_iter()
3686                    .map(|p| p.to_string())
3687                    .collect::<Vec<String>>()
3688                    .join(",")
3689                    .to_string(),
3690            )]),
3691        };
3692    }
3693    if let Some(ref local_var_str) = owner__n {
3694        local_var_req_builder = match "multi" {
3695            "multi" => local_var_req_builder.query(
3696                &local_var_str
3697                    .into_iter()
3698                    .map(|p| ("owner__n".to_owned(), p.to_string()))
3699                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3700            ),
3701            _ => local_var_req_builder.query(&[(
3702                "owner__n",
3703                &local_var_str
3704                    .into_iter()
3705                    .map(|p| p.to_string())
3706                    .collect::<Vec<String>>()
3707                    .join(",")
3708                    .to_string(),
3709            )]),
3710        };
3711    }
3712    if let Some(ref local_var_str) = owner_group {
3713        local_var_req_builder = match "multi" {
3714            "multi" => local_var_req_builder.query(
3715                &local_var_str
3716                    .into_iter()
3717                    .map(|p| ("owner_group".to_owned(), p.to_string()))
3718                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3719            ),
3720            _ => local_var_req_builder.query(&[(
3721                "owner_group",
3722                &local_var_str
3723                    .into_iter()
3724                    .map(|p| p.to_string())
3725                    .collect::<Vec<String>>()
3726                    .join(",")
3727                    .to_string(),
3728            )]),
3729        };
3730    }
3731    if let Some(ref local_var_str) = owner_group__n {
3732        local_var_req_builder = match "multi" {
3733            "multi" => local_var_req_builder.query(
3734                &local_var_str
3735                    .into_iter()
3736                    .map(|p| ("owner_group__n".to_owned(), p.to_string()))
3737                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3738            ),
3739            _ => local_var_req_builder.query(&[(
3740                "owner_group__n",
3741                &local_var_str
3742                    .into_iter()
3743                    .map(|p| p.to_string())
3744                    .collect::<Vec<String>>()
3745                    .join(",")
3746                    .to_string(),
3747            )]),
3748        };
3749    }
3750    if let Some(ref local_var_str) = owner_group_id {
3751        local_var_req_builder = match "multi" {
3752            "multi" => local_var_req_builder.query(
3753                &local_var_str
3754                    .into_iter()
3755                    .map(|p| ("owner_group_id".to_owned(), p.to_string()))
3756                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3757            ),
3758            _ => local_var_req_builder.query(&[(
3759                "owner_group_id",
3760                &local_var_str
3761                    .into_iter()
3762                    .map(|p| p.to_string())
3763                    .collect::<Vec<String>>()
3764                    .join(",")
3765                    .to_string(),
3766            )]),
3767        };
3768    }
3769    if let Some(ref local_var_str) = owner_group_id__n {
3770        local_var_req_builder = match "multi" {
3771            "multi" => local_var_req_builder.query(
3772                &local_var_str
3773                    .into_iter()
3774                    .map(|p| ("owner_group_id__n".to_owned(), p.to_string()))
3775                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3776            ),
3777            _ => local_var_req_builder.query(&[(
3778                "owner_group_id__n",
3779                &local_var_str
3780                    .into_iter()
3781                    .map(|p| p.to_string())
3782                    .collect::<Vec<String>>()
3783                    .join(",")
3784                    .to_string(),
3785            )]),
3786        };
3787    }
3788    if let Some(ref local_var_str) = owner_id {
3789        local_var_req_builder = match "multi" {
3790            "multi" => local_var_req_builder.query(
3791                &local_var_str
3792                    .into_iter()
3793                    .map(|p| ("owner_id".to_owned(), p.to_string()))
3794                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3795            ),
3796            _ => local_var_req_builder.query(&[(
3797                "owner_id",
3798                &local_var_str
3799                    .into_iter()
3800                    .map(|p| p.to_string())
3801                    .collect::<Vec<String>>()
3802                    .join(",")
3803                    .to_string(),
3804            )]),
3805        };
3806    }
3807    if let Some(ref local_var_str) = owner_id__n {
3808        local_var_req_builder = match "multi" {
3809            "multi" => local_var_req_builder.query(
3810                &local_var_str
3811                    .into_iter()
3812                    .map(|p| ("owner_id__n".to_owned(), p.to_string()))
3813                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3814            ),
3815            _ => local_var_req_builder.query(&[(
3816                "owner_id__n",
3817                &local_var_str
3818                    .into_iter()
3819                    .map(|p| p.to_string())
3820                    .collect::<Vec<String>>()
3821                    .join(",")
3822                    .to_string(),
3823            )]),
3824        };
3825    }
3826    if let Some(ref local_var_str) = q {
3827        local_var_req_builder = local_var_req_builder.query(&[("q", &local_var_str.to_string())]);
3828    }
3829    if let Some(ref local_var_str) = slug {
3830        local_var_req_builder = match "multi" {
3831            "multi" => local_var_req_builder.query(
3832                &local_var_str
3833                    .into_iter()
3834                    .map(|p| ("slug".to_owned(), p.to_string()))
3835                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3836            ),
3837            _ => local_var_req_builder.query(&[(
3838                "slug",
3839                &local_var_str
3840                    .into_iter()
3841                    .map(|p| p.to_string())
3842                    .collect::<Vec<String>>()
3843                    .join(",")
3844                    .to_string(),
3845            )]),
3846        };
3847    }
3848    if let Some(ref local_var_str) = slug__empty {
3849        local_var_req_builder =
3850            local_var_req_builder.query(&[("slug__empty", &local_var_str.to_string())]);
3851    }
3852    if let Some(ref local_var_str) = slug__ic {
3853        local_var_req_builder = match "multi" {
3854            "multi" => local_var_req_builder.query(
3855                &local_var_str
3856                    .into_iter()
3857                    .map(|p| ("slug__ic".to_owned(), p.to_string()))
3858                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3859            ),
3860            _ => local_var_req_builder.query(&[(
3861                "slug__ic",
3862                &local_var_str
3863                    .into_iter()
3864                    .map(|p| p.to_string())
3865                    .collect::<Vec<String>>()
3866                    .join(",")
3867                    .to_string(),
3868            )]),
3869        };
3870    }
3871    if let Some(ref local_var_str) = slug__ie {
3872        local_var_req_builder = match "multi" {
3873            "multi" => local_var_req_builder.query(
3874                &local_var_str
3875                    .into_iter()
3876                    .map(|p| ("slug__ie".to_owned(), p.to_string()))
3877                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3878            ),
3879            _ => local_var_req_builder.query(&[(
3880                "slug__ie",
3881                &local_var_str
3882                    .into_iter()
3883                    .map(|p| p.to_string())
3884                    .collect::<Vec<String>>()
3885                    .join(",")
3886                    .to_string(),
3887            )]),
3888        };
3889    }
3890    if let Some(ref local_var_str) = slug__iew {
3891        local_var_req_builder = match "multi" {
3892            "multi" => local_var_req_builder.query(
3893                &local_var_str
3894                    .into_iter()
3895                    .map(|p| ("slug__iew".to_owned(), p.to_string()))
3896                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3897            ),
3898            _ => local_var_req_builder.query(&[(
3899                "slug__iew",
3900                &local_var_str
3901                    .into_iter()
3902                    .map(|p| p.to_string())
3903                    .collect::<Vec<String>>()
3904                    .join(",")
3905                    .to_string(),
3906            )]),
3907        };
3908    }
3909    if let Some(ref local_var_str) = slug__iregex {
3910        local_var_req_builder = match "multi" {
3911            "multi" => local_var_req_builder.query(
3912                &local_var_str
3913                    .into_iter()
3914                    .map(|p| ("slug__iregex".to_owned(), p.to_string()))
3915                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3916            ),
3917            _ => local_var_req_builder.query(&[(
3918                "slug__iregex",
3919                &local_var_str
3920                    .into_iter()
3921                    .map(|p| p.to_string())
3922                    .collect::<Vec<String>>()
3923                    .join(",")
3924                    .to_string(),
3925            )]),
3926        };
3927    }
3928    if let Some(ref local_var_str) = slug__isw {
3929        local_var_req_builder = match "multi" {
3930            "multi" => local_var_req_builder.query(
3931                &local_var_str
3932                    .into_iter()
3933                    .map(|p| ("slug__isw".to_owned(), p.to_string()))
3934                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3935            ),
3936            _ => local_var_req_builder.query(&[(
3937                "slug__isw",
3938                &local_var_str
3939                    .into_iter()
3940                    .map(|p| p.to_string())
3941                    .collect::<Vec<String>>()
3942                    .join(",")
3943                    .to_string(),
3944            )]),
3945        };
3946    }
3947    if let Some(ref local_var_str) = slug__n {
3948        local_var_req_builder = match "multi" {
3949            "multi" => local_var_req_builder.query(
3950                &local_var_str
3951                    .into_iter()
3952                    .map(|p| ("slug__n".to_owned(), p.to_string()))
3953                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3954            ),
3955            _ => local_var_req_builder.query(&[(
3956                "slug__n",
3957                &local_var_str
3958                    .into_iter()
3959                    .map(|p| p.to_string())
3960                    .collect::<Vec<String>>()
3961                    .join(",")
3962                    .to_string(),
3963            )]),
3964        };
3965    }
3966    if let Some(ref local_var_str) = slug__nic {
3967        local_var_req_builder = match "multi" {
3968            "multi" => local_var_req_builder.query(
3969                &local_var_str
3970                    .into_iter()
3971                    .map(|p| ("slug__nic".to_owned(), p.to_string()))
3972                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3973            ),
3974            _ => local_var_req_builder.query(&[(
3975                "slug__nic",
3976                &local_var_str
3977                    .into_iter()
3978                    .map(|p| p.to_string())
3979                    .collect::<Vec<String>>()
3980                    .join(",")
3981                    .to_string(),
3982            )]),
3983        };
3984    }
3985    if let Some(ref local_var_str) = slug__nie {
3986        local_var_req_builder = match "multi" {
3987            "multi" => local_var_req_builder.query(
3988                &local_var_str
3989                    .into_iter()
3990                    .map(|p| ("slug__nie".to_owned(), p.to_string()))
3991                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3992            ),
3993            _ => local_var_req_builder.query(&[(
3994                "slug__nie",
3995                &local_var_str
3996                    .into_iter()
3997                    .map(|p| p.to_string())
3998                    .collect::<Vec<String>>()
3999                    .join(",")
4000                    .to_string(),
4001            )]),
4002        };
4003    }
4004    if let Some(ref local_var_str) = slug__niew {
4005        local_var_req_builder = match "multi" {
4006            "multi" => local_var_req_builder.query(
4007                &local_var_str
4008                    .into_iter()
4009                    .map(|p| ("slug__niew".to_owned(), p.to_string()))
4010                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4011            ),
4012            _ => local_var_req_builder.query(&[(
4013                "slug__niew",
4014                &local_var_str
4015                    .into_iter()
4016                    .map(|p| p.to_string())
4017                    .collect::<Vec<String>>()
4018                    .join(",")
4019                    .to_string(),
4020            )]),
4021        };
4022    }
4023    if let Some(ref local_var_str) = slug__nisw {
4024        local_var_req_builder = match "multi" {
4025            "multi" => local_var_req_builder.query(
4026                &local_var_str
4027                    .into_iter()
4028                    .map(|p| ("slug__nisw".to_owned(), p.to_string()))
4029                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4030            ),
4031            _ => local_var_req_builder.query(&[(
4032                "slug__nisw",
4033                &local_var_str
4034                    .into_iter()
4035                    .map(|p| p.to_string())
4036                    .collect::<Vec<String>>()
4037                    .join(",")
4038                    .to_string(),
4039            )]),
4040        };
4041    }
4042    if let Some(ref local_var_str) = slug__regex {
4043        local_var_req_builder = match "multi" {
4044            "multi" => local_var_req_builder.query(
4045                &local_var_str
4046                    .into_iter()
4047                    .map(|p| ("slug__regex".to_owned(), p.to_string()))
4048                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4049            ),
4050            _ => local_var_req_builder.query(&[(
4051                "slug__regex",
4052                &local_var_str
4053                    .into_iter()
4054                    .map(|p| p.to_string())
4055                    .collect::<Vec<String>>()
4056                    .join(",")
4057                    .to_string(),
4058            )]),
4059        };
4060    }
4061    if let Some(ref local_var_str) = start {
4062        local_var_req_builder =
4063            local_var_req_builder.query(&[("start", &local_var_str.to_string())]);
4064    }
4065    if let Some(ref local_var_str) = tag {
4066        local_var_req_builder = match "multi" {
4067            "multi" => local_var_req_builder.query(
4068                &local_var_str
4069                    .into_iter()
4070                    .map(|p| ("tag".to_owned(), p.to_string()))
4071                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4072            ),
4073            _ => local_var_req_builder.query(&[(
4074                "tag",
4075                &local_var_str
4076                    .into_iter()
4077                    .map(|p| p.to_string())
4078                    .collect::<Vec<String>>()
4079                    .join(",")
4080                    .to_string(),
4081            )]),
4082        };
4083    }
4084    if let Some(ref local_var_str) = tag__n {
4085        local_var_req_builder = match "multi" {
4086            "multi" => local_var_req_builder.query(
4087                &local_var_str
4088                    .into_iter()
4089                    .map(|p| ("tag__n".to_owned(), p.to_string()))
4090                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4091            ),
4092            _ => local_var_req_builder.query(&[(
4093                "tag__n",
4094                &local_var_str
4095                    .into_iter()
4096                    .map(|p| p.to_string())
4097                    .collect::<Vec<String>>()
4098                    .join(",")
4099                    .to_string(),
4100            )]),
4101        };
4102    }
4103    if let Some(ref local_var_str) = tag_id {
4104        local_var_req_builder = match "multi" {
4105            "multi" => local_var_req_builder.query(
4106                &local_var_str
4107                    .into_iter()
4108                    .map(|p| ("tag_id".to_owned(), p.to_string()))
4109                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4110            ),
4111            _ => local_var_req_builder.query(&[(
4112                "tag_id",
4113                &local_var_str
4114                    .into_iter()
4115                    .map(|p| p.to_string())
4116                    .collect::<Vec<String>>()
4117                    .join(",")
4118                    .to_string(),
4119            )]),
4120        };
4121    }
4122    if let Some(ref local_var_str) = tag_id__n {
4123        local_var_req_builder = match "multi" {
4124            "multi" => local_var_req_builder.query(
4125                &local_var_str
4126                    .into_iter()
4127                    .map(|p| ("tag_id__n".to_owned(), p.to_string()))
4128                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4129            ),
4130            _ => local_var_req_builder.query(&[(
4131                "tag_id__n",
4132                &local_var_str
4133                    .into_iter()
4134                    .map(|p| p.to_string())
4135                    .collect::<Vec<String>>()
4136                    .join(",")
4137                    .to_string(),
4138            )]),
4139        };
4140    }
4141    if let Some(ref local_var_str) = updated_by_request {
4142        local_var_req_builder =
4143            local_var_req_builder.query(&[("updated_by_request", &local_var_str.to_string())]);
4144    }
4145    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
4146        local_var_req_builder =
4147            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
4148    }
4149    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
4150        let local_var_key = local_var_apikey.key.clone();
4151        let local_var_value = match local_var_apikey.prefix {
4152            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
4153            None => local_var_key,
4154        };
4155        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
4156    };
4157
4158    let local_var_req = local_var_req_builder.build()?;
4159    let local_var_resp = local_var_client.execute(local_var_req).await?;
4160
4161    let local_var_status = local_var_resp.status();
4162    let local_var_content = local_var_resp.text().await?;
4163
4164    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
4165        serde_json::from_str(&local_var_content).map_err(Error::from)
4166    } else {
4167        let local_var_entity: Option<VirtualizationClusterTypesListError> =
4168            serde_json::from_str(&local_var_content).ok();
4169        let local_var_error = ResponseContent {
4170            status: local_var_status,
4171            content: local_var_content,
4172            entity: local_var_entity,
4173        };
4174        Err(Error::ResponseError(local_var_error))
4175    }
4176}
4177
4178/// Patch a cluster type object.
4179pub async fn virtualization_cluster_types_partial_update(
4180    configuration: &configuration::Configuration,
4181    id: i32,
4182    patched_cluster_type_request: Option<crate::models::PatchedClusterTypeRequest>,
4183) -> Result<crate::models::ClusterType, Error<VirtualizationClusterTypesPartialUpdateError>> {
4184    let local_var_configuration = configuration;
4185
4186    let local_var_client = &local_var_configuration.client;
4187
4188    let local_var_uri_str = format!(
4189        "{}/api/virtualization/cluster-types/{id}/",
4190        local_var_configuration.base_path,
4191        id = id
4192    );
4193    let mut local_var_req_builder =
4194        local_var_client.request(reqwest::Method::PATCH, local_var_uri_str.as_str());
4195
4196    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
4197        local_var_req_builder =
4198            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
4199    }
4200    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
4201        let local_var_key = local_var_apikey.key.clone();
4202        let local_var_value = match local_var_apikey.prefix {
4203            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
4204            None => local_var_key,
4205        };
4206        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
4207    };
4208    local_var_req_builder = local_var_req_builder.json(&patched_cluster_type_request);
4209
4210    let local_var_req = local_var_req_builder.build()?;
4211    let local_var_resp = local_var_client.execute(local_var_req).await?;
4212
4213    let local_var_status = local_var_resp.status();
4214    let local_var_content = local_var_resp.text().await?;
4215
4216    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
4217        serde_json::from_str(&local_var_content).map_err(Error::from)
4218    } else {
4219        let local_var_entity: Option<VirtualizationClusterTypesPartialUpdateError> =
4220            serde_json::from_str(&local_var_content).ok();
4221        let local_var_error = ResponseContent {
4222            status: local_var_status,
4223            content: local_var_content,
4224            entity: local_var_entity,
4225        };
4226        Err(Error::ResponseError(local_var_error))
4227    }
4228}
4229
4230/// Get a cluster type object.
4231pub async fn virtualization_cluster_types_retrieve(
4232    configuration: &configuration::Configuration,
4233    id: i32,
4234) -> Result<crate::models::ClusterType, Error<VirtualizationClusterTypesRetrieveError>> {
4235    let local_var_configuration = configuration;
4236
4237    let local_var_client = &local_var_configuration.client;
4238
4239    let local_var_uri_str = format!(
4240        "{}/api/virtualization/cluster-types/{id}/",
4241        local_var_configuration.base_path,
4242        id = id
4243    );
4244    let mut local_var_req_builder =
4245        local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
4246
4247    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
4248        local_var_req_builder =
4249            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
4250    }
4251    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
4252        let local_var_key = local_var_apikey.key.clone();
4253        let local_var_value = match local_var_apikey.prefix {
4254            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
4255            None => local_var_key,
4256        };
4257        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
4258    };
4259
4260    let local_var_req = local_var_req_builder.build()?;
4261    let local_var_resp = local_var_client.execute(local_var_req).await?;
4262
4263    let local_var_status = local_var_resp.status();
4264    let local_var_content = local_var_resp.text().await?;
4265
4266    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
4267        serde_json::from_str(&local_var_content).map_err(Error::from)
4268    } else {
4269        let local_var_entity: Option<VirtualizationClusterTypesRetrieveError> =
4270            serde_json::from_str(&local_var_content).ok();
4271        let local_var_error = ResponseContent {
4272            status: local_var_status,
4273            content: local_var_content,
4274            entity: local_var_entity,
4275        };
4276        Err(Error::ResponseError(local_var_error))
4277    }
4278}
4279
4280/// Put a cluster type object.
4281pub async fn virtualization_cluster_types_update(
4282    configuration: &configuration::Configuration,
4283    id: i32,
4284    cluster_type_request: crate::models::ClusterTypeRequest,
4285) -> Result<crate::models::ClusterType, Error<VirtualizationClusterTypesUpdateError>> {
4286    let local_var_configuration = configuration;
4287
4288    let local_var_client = &local_var_configuration.client;
4289
4290    let local_var_uri_str = format!(
4291        "{}/api/virtualization/cluster-types/{id}/",
4292        local_var_configuration.base_path,
4293        id = id
4294    );
4295    let mut local_var_req_builder =
4296        local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());
4297
4298    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
4299        local_var_req_builder =
4300            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
4301    }
4302    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
4303        let local_var_key = local_var_apikey.key.clone();
4304        let local_var_value = match local_var_apikey.prefix {
4305            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
4306            None => local_var_key,
4307        };
4308        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
4309    };
4310    local_var_req_builder = local_var_req_builder.json(&cluster_type_request);
4311
4312    let local_var_req = local_var_req_builder.build()?;
4313    let local_var_resp = local_var_client.execute(local_var_req).await?;
4314
4315    let local_var_status = local_var_resp.status();
4316    let local_var_content = local_var_resp.text().await?;
4317
4318    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
4319        serde_json::from_str(&local_var_content).map_err(Error::from)
4320    } else {
4321        let local_var_entity: Option<VirtualizationClusterTypesUpdateError> =
4322            serde_json::from_str(&local_var_content).ok();
4323        let local_var_error = ResponseContent {
4324            status: local_var_status,
4325            content: local_var_content,
4326            entity: local_var_entity,
4327        };
4328        Err(Error::ResponseError(local_var_error))
4329    }
4330}
4331
4332/// Delete a list of cluster objects.
4333pub async fn virtualization_clusters_bulk_destroy(
4334    configuration: &configuration::Configuration,
4335    cluster_request: Vec<crate::models::ClusterRequest>,
4336) -> Result<(), Error<VirtualizationClustersBulkDestroyError>> {
4337    let local_var_configuration = configuration;
4338
4339    let local_var_client = &local_var_configuration.client;
4340
4341    let local_var_uri_str = format!(
4342        "{}/api/virtualization/clusters/",
4343        local_var_configuration.base_path
4344    );
4345    let mut local_var_req_builder =
4346        local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());
4347
4348    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
4349        local_var_req_builder =
4350            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
4351    }
4352    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
4353        let local_var_key = local_var_apikey.key.clone();
4354        let local_var_value = match local_var_apikey.prefix {
4355            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
4356            None => local_var_key,
4357        };
4358        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
4359    };
4360    local_var_req_builder = local_var_req_builder.json(&cluster_request);
4361
4362    let local_var_req = local_var_req_builder.build()?;
4363    let local_var_resp = local_var_client.execute(local_var_req).await?;
4364
4365    let local_var_status = local_var_resp.status();
4366    let local_var_content = local_var_resp.text().await?;
4367
4368    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
4369        Ok(())
4370    } else {
4371        let local_var_entity: Option<VirtualizationClustersBulkDestroyError> =
4372            serde_json::from_str(&local_var_content).ok();
4373        let local_var_error = ResponseContent {
4374            status: local_var_status,
4375            content: local_var_content,
4376            entity: local_var_entity,
4377        };
4378        Err(Error::ResponseError(local_var_error))
4379    }
4380}
4381
4382/// Patch a list of cluster objects.
4383pub async fn virtualization_clusters_bulk_partial_update(
4384    configuration: &configuration::Configuration,
4385    cluster_request: Vec<crate::models::ClusterRequest>,
4386) -> Result<Vec<crate::models::Cluster>, Error<VirtualizationClustersBulkPartialUpdateError>> {
4387    let local_var_configuration = configuration;
4388
4389    let local_var_client = &local_var_configuration.client;
4390
4391    let local_var_uri_str = format!(
4392        "{}/api/virtualization/clusters/",
4393        local_var_configuration.base_path
4394    );
4395    let mut local_var_req_builder =
4396        local_var_client.request(reqwest::Method::PATCH, local_var_uri_str.as_str());
4397
4398    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
4399        local_var_req_builder =
4400            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
4401    }
4402    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
4403        let local_var_key = local_var_apikey.key.clone();
4404        let local_var_value = match local_var_apikey.prefix {
4405            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
4406            None => local_var_key,
4407        };
4408        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
4409    };
4410    local_var_req_builder = local_var_req_builder.json(&cluster_request);
4411
4412    let local_var_req = local_var_req_builder.build()?;
4413    let local_var_resp = local_var_client.execute(local_var_req).await?;
4414
4415    let local_var_status = local_var_resp.status();
4416    let local_var_content = local_var_resp.text().await?;
4417
4418    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
4419        serde_json::from_str(&local_var_content).map_err(Error::from)
4420    } else {
4421        let local_var_entity: Option<VirtualizationClustersBulkPartialUpdateError> =
4422            serde_json::from_str(&local_var_content).ok();
4423        let local_var_error = ResponseContent {
4424            status: local_var_status,
4425            content: local_var_content,
4426            entity: local_var_entity,
4427        };
4428        Err(Error::ResponseError(local_var_error))
4429    }
4430}
4431
4432/// Put a list of cluster objects.
4433pub async fn virtualization_clusters_bulk_update(
4434    configuration: &configuration::Configuration,
4435    cluster_request: Vec<crate::models::ClusterRequest>,
4436) -> Result<Vec<crate::models::Cluster>, Error<VirtualizationClustersBulkUpdateError>> {
4437    let local_var_configuration = configuration;
4438
4439    let local_var_client = &local_var_configuration.client;
4440
4441    let local_var_uri_str = format!(
4442        "{}/api/virtualization/clusters/",
4443        local_var_configuration.base_path
4444    );
4445    let mut local_var_req_builder =
4446        local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());
4447
4448    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
4449        local_var_req_builder =
4450            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
4451    }
4452    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
4453        let local_var_key = local_var_apikey.key.clone();
4454        let local_var_value = match local_var_apikey.prefix {
4455            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
4456            None => local_var_key,
4457        };
4458        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
4459    };
4460    local_var_req_builder = local_var_req_builder.json(&cluster_request);
4461
4462    let local_var_req = local_var_req_builder.build()?;
4463    let local_var_resp = local_var_client.execute(local_var_req).await?;
4464
4465    let local_var_status = local_var_resp.status();
4466    let local_var_content = local_var_resp.text().await?;
4467
4468    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
4469        serde_json::from_str(&local_var_content).map_err(Error::from)
4470    } else {
4471        let local_var_entity: Option<VirtualizationClustersBulkUpdateError> =
4472            serde_json::from_str(&local_var_content).ok();
4473        let local_var_error = ResponseContent {
4474            status: local_var_status,
4475            content: local_var_content,
4476            entity: local_var_entity,
4477        };
4478        Err(Error::ResponseError(local_var_error))
4479    }
4480}
4481
4482/// Post a list of cluster objects.
4483pub async fn virtualization_clusters_create(
4484    configuration: &configuration::Configuration,
4485    virtualization_clusters_create_request: crate::models::VirtualizationClustersCreateRequest,
4486) -> Result<crate::models::Cluster, Error<VirtualizationClustersCreateError>> {
4487    let local_var_configuration = configuration;
4488
4489    let local_var_client = &local_var_configuration.client;
4490
4491    let local_var_uri_str = format!(
4492        "{}/api/virtualization/clusters/",
4493        local_var_configuration.base_path
4494    );
4495    let mut local_var_req_builder =
4496        local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
4497
4498    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
4499        local_var_req_builder =
4500            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
4501    }
4502    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
4503        let local_var_key = local_var_apikey.key.clone();
4504        let local_var_value = match local_var_apikey.prefix {
4505            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
4506            None => local_var_key,
4507        };
4508        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
4509    };
4510    local_var_req_builder = local_var_req_builder.json(&virtualization_clusters_create_request);
4511
4512    let local_var_req = local_var_req_builder.build()?;
4513    let local_var_resp = local_var_client.execute(local_var_req).await?;
4514
4515    let local_var_status = local_var_resp.status();
4516    let local_var_content = local_var_resp.text().await?;
4517
4518    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
4519        serde_json::from_str(&local_var_content).map_err(Error::from)
4520    } else {
4521        let local_var_entity: Option<VirtualizationClustersCreateError> =
4522            serde_json::from_str(&local_var_content).ok();
4523        let local_var_error = ResponseContent {
4524            status: local_var_status,
4525            content: local_var_content,
4526            entity: local_var_entity,
4527        };
4528        Err(Error::ResponseError(local_var_error))
4529    }
4530}
4531
4532/// Delete a cluster object.
4533pub async fn virtualization_clusters_destroy(
4534    configuration: &configuration::Configuration,
4535    id: i32,
4536) -> Result<(), Error<VirtualizationClustersDestroyError>> {
4537    let local_var_configuration = configuration;
4538
4539    let local_var_client = &local_var_configuration.client;
4540
4541    let local_var_uri_str = format!(
4542        "{}/api/virtualization/clusters/{id}/",
4543        local_var_configuration.base_path,
4544        id = id
4545    );
4546    let mut local_var_req_builder =
4547        local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());
4548
4549    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
4550        local_var_req_builder =
4551            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
4552    }
4553    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
4554        let local_var_key = local_var_apikey.key.clone();
4555        let local_var_value = match local_var_apikey.prefix {
4556            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
4557            None => local_var_key,
4558        };
4559        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
4560    };
4561
4562    let local_var_req = local_var_req_builder.build()?;
4563    let local_var_resp = local_var_client.execute(local_var_req).await?;
4564
4565    let local_var_status = local_var_resp.status();
4566    let local_var_content = local_var_resp.text().await?;
4567
4568    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
4569        Ok(())
4570    } else {
4571        let local_var_entity: Option<VirtualizationClustersDestroyError> =
4572            serde_json::from_str(&local_var_content).ok();
4573        let local_var_error = ResponseContent {
4574            status: local_var_status,
4575            content: local_var_content,
4576            entity: local_var_entity,
4577        };
4578        Err(Error::ResponseError(local_var_error))
4579    }
4580}
4581
4582/// Get a list of cluster objects.
4583pub async fn virtualization_clusters_list(
4584    configuration: &configuration::Configuration,
4585    contact: Option<Vec<i32>>,
4586    contact__n: Option<Vec<i32>>,
4587    contact_group: Option<Vec<String>>,
4588    contact_group__n: Option<Vec<String>>,
4589    contact_role: Option<Vec<i32>>,
4590    contact_role__n: Option<Vec<i32>>,
4591    created: Option<Vec<String>>,
4592    created__empty: Option<Vec<String>>,
4593    created__gt: Option<Vec<String>>,
4594    created__gte: Option<Vec<String>>,
4595    created__lt: Option<Vec<String>>,
4596    created__lte: Option<Vec<String>>,
4597    created__n: Option<Vec<String>>,
4598    created_by_request: Option<&str>,
4599    description: Option<Vec<String>>,
4600    description__empty: Option<bool>,
4601    description__ic: Option<Vec<String>>,
4602    description__ie: Option<Vec<String>>,
4603    description__iew: Option<Vec<String>>,
4604    description__iregex: Option<Vec<String>>,
4605    description__isw: Option<Vec<String>>,
4606    description__n: Option<Vec<String>>,
4607    description__nic: Option<Vec<String>>,
4608    description__nie: Option<Vec<String>>,
4609    description__niew: Option<Vec<String>>,
4610    description__nisw: Option<Vec<String>>,
4611    description__regex: Option<Vec<String>>,
4612    group: Option<Vec<String>>,
4613    group__n: Option<Vec<String>>,
4614    group_id: Option<Vec<i32>>,
4615    group_id__n: Option<Vec<i32>>,
4616    id: Option<Vec<i32>>,
4617    id__empty: Option<bool>,
4618    id__gt: Option<Vec<i32>>,
4619    id__gte: Option<Vec<i32>>,
4620    id__lt: Option<Vec<i32>>,
4621    id__lte: Option<Vec<i32>>,
4622    id__n: Option<Vec<i32>>,
4623    last_updated: Option<Vec<String>>,
4624    last_updated__empty: Option<Vec<String>>,
4625    last_updated__gt: Option<Vec<String>>,
4626    last_updated__gte: Option<Vec<String>>,
4627    last_updated__lt: Option<Vec<String>>,
4628    last_updated__lte: Option<Vec<String>>,
4629    last_updated__n: Option<Vec<String>>,
4630    limit: Option<i32>,
4631    location: Option<Vec<String>>,
4632    location__n: Option<Vec<String>>,
4633    location_id: Option<Vec<String>>,
4634    location_id__n: Option<Vec<String>>,
4635    modified_by_request: Option<&str>,
4636    name: Option<Vec<String>>,
4637    name__empty: Option<bool>,
4638    name__ic: Option<Vec<String>>,
4639    name__ie: Option<Vec<String>>,
4640    name__iew: Option<Vec<String>>,
4641    name__iregex: Option<Vec<String>>,
4642    name__isw: Option<Vec<String>>,
4643    name__n: Option<Vec<String>>,
4644    name__nic: Option<Vec<String>>,
4645    name__nie: Option<Vec<String>>,
4646    name__niew: Option<Vec<String>>,
4647    name__nisw: Option<Vec<String>>,
4648    name__regex: Option<Vec<String>>,
4649    offset: Option<i32>,
4650    ordering: Option<&str>,
4651    owner: Option<Vec<String>>,
4652    owner__n: Option<Vec<String>>,
4653    owner_group: Option<Vec<String>>,
4654    owner_group__n: Option<Vec<String>>,
4655    owner_group_id: Option<Vec<i32>>,
4656    owner_group_id__n: Option<Vec<i32>>,
4657    owner_id: Option<Vec<i32>>,
4658    owner_id__n: Option<Vec<i32>>,
4659    q: Option<&str>,
4660    region: Option<Vec<String>>,
4661    region__n: Option<Vec<String>>,
4662    region_id: Option<Vec<String>>,
4663    region_id__n: Option<Vec<String>>,
4664    scope_id: Option<Vec<i32>>,
4665    scope_id__empty: Option<bool>,
4666    scope_id__gt: Option<Vec<i32>>,
4667    scope_id__gte: Option<Vec<i32>>,
4668    scope_id__lt: Option<Vec<i32>>,
4669    scope_id__lte: Option<Vec<i32>>,
4670    scope_id__n: Option<Vec<i32>>,
4671    scope_type: Option<Vec<String>>,
4672    scope_type__n: Option<Vec<String>>,
4673    site: Option<Vec<String>>,
4674    site__n: Option<Vec<String>>,
4675    site_group: Option<Vec<String>>,
4676    site_group__n: Option<Vec<String>>,
4677    site_group_id: Option<Vec<String>>,
4678    site_group_id__n: Option<Vec<String>>,
4679    site_id: Option<Vec<i32>>,
4680    site_id__n: Option<Vec<i32>>,
4681    start: Option<i32>,
4682    status: Option<Vec<String>>,
4683    status__empty: Option<bool>,
4684    status__ic: Option<Vec<String>>,
4685    status__ie: Option<Vec<String>>,
4686    status__iew: Option<Vec<String>>,
4687    status__iregex: Option<Vec<String>>,
4688    status__isw: Option<Vec<String>>,
4689    status__n: Option<Vec<String>>,
4690    status__nic: Option<Vec<String>>,
4691    status__nie: Option<Vec<String>>,
4692    status__niew: Option<Vec<String>>,
4693    status__nisw: Option<Vec<String>>,
4694    status__regex: Option<Vec<String>>,
4695    tag: Option<Vec<String>>,
4696    tag__n: Option<Vec<String>>,
4697    tag_id: Option<Vec<i32>>,
4698    tag_id__n: Option<Vec<i32>>,
4699    tenant: Option<Vec<String>>,
4700    tenant__n: Option<Vec<String>>,
4701    tenant_group: Option<Vec<String>>,
4702    tenant_group__n: Option<Vec<String>>,
4703    tenant_group_id: Option<Vec<String>>,
4704    tenant_group_id__n: Option<Vec<String>>,
4705    tenant_id: Option<Vec<i32>>,
4706    tenant_id__n: Option<Vec<i32>>,
4707    r#type: Option<Vec<String>>,
4708    type__n: Option<Vec<String>>,
4709    type_id: Option<Vec<i32>>,
4710    type_id__n: Option<Vec<i32>>,
4711    updated_by_request: Option<&str>,
4712) -> Result<crate::models::PaginatedClusterList, Error<VirtualizationClustersListError>> {
4713    let local_var_configuration = configuration;
4714
4715    let local_var_client = &local_var_configuration.client;
4716
4717    let local_var_uri_str = format!(
4718        "{}/api/virtualization/clusters/",
4719        local_var_configuration.base_path
4720    );
4721    let mut local_var_req_builder =
4722        local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
4723
4724    if let Some(ref local_var_str) = contact {
4725        local_var_req_builder = match "multi" {
4726            "multi" => local_var_req_builder.query(
4727                &local_var_str
4728                    .into_iter()
4729                    .map(|p| ("contact".to_owned(), p.to_string()))
4730                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4731            ),
4732            _ => local_var_req_builder.query(&[(
4733                "contact",
4734                &local_var_str
4735                    .into_iter()
4736                    .map(|p| p.to_string())
4737                    .collect::<Vec<String>>()
4738                    .join(",")
4739                    .to_string(),
4740            )]),
4741        };
4742    }
4743    if let Some(ref local_var_str) = contact__n {
4744        local_var_req_builder = match "multi" {
4745            "multi" => local_var_req_builder.query(
4746                &local_var_str
4747                    .into_iter()
4748                    .map(|p| ("contact__n".to_owned(), p.to_string()))
4749                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4750            ),
4751            _ => local_var_req_builder.query(&[(
4752                "contact__n",
4753                &local_var_str
4754                    .into_iter()
4755                    .map(|p| p.to_string())
4756                    .collect::<Vec<String>>()
4757                    .join(",")
4758                    .to_string(),
4759            )]),
4760        };
4761    }
4762    if let Some(ref local_var_str) = contact_group {
4763        local_var_req_builder = match "multi" {
4764            "multi" => local_var_req_builder.query(
4765                &local_var_str
4766                    .into_iter()
4767                    .map(|p| ("contact_group".to_owned(), p.to_string()))
4768                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4769            ),
4770            _ => local_var_req_builder.query(&[(
4771                "contact_group",
4772                &local_var_str
4773                    .into_iter()
4774                    .map(|p| p.to_string())
4775                    .collect::<Vec<String>>()
4776                    .join(",")
4777                    .to_string(),
4778            )]),
4779        };
4780    }
4781    if let Some(ref local_var_str) = contact_group__n {
4782        local_var_req_builder = match "multi" {
4783            "multi" => local_var_req_builder.query(
4784                &local_var_str
4785                    .into_iter()
4786                    .map(|p| ("contact_group__n".to_owned(), p.to_string()))
4787                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4788            ),
4789            _ => local_var_req_builder.query(&[(
4790                "contact_group__n",
4791                &local_var_str
4792                    .into_iter()
4793                    .map(|p| p.to_string())
4794                    .collect::<Vec<String>>()
4795                    .join(",")
4796                    .to_string(),
4797            )]),
4798        };
4799    }
4800    if let Some(ref local_var_str) = contact_role {
4801        local_var_req_builder = match "multi" {
4802            "multi" => local_var_req_builder.query(
4803                &local_var_str
4804                    .into_iter()
4805                    .map(|p| ("contact_role".to_owned(), p.to_string()))
4806                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4807            ),
4808            _ => local_var_req_builder.query(&[(
4809                "contact_role",
4810                &local_var_str
4811                    .into_iter()
4812                    .map(|p| p.to_string())
4813                    .collect::<Vec<String>>()
4814                    .join(",")
4815                    .to_string(),
4816            )]),
4817        };
4818    }
4819    if let Some(ref local_var_str) = contact_role__n {
4820        local_var_req_builder = match "multi" {
4821            "multi" => local_var_req_builder.query(
4822                &local_var_str
4823                    .into_iter()
4824                    .map(|p| ("contact_role__n".to_owned(), p.to_string()))
4825                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4826            ),
4827            _ => local_var_req_builder.query(&[(
4828                "contact_role__n",
4829                &local_var_str
4830                    .into_iter()
4831                    .map(|p| p.to_string())
4832                    .collect::<Vec<String>>()
4833                    .join(",")
4834                    .to_string(),
4835            )]),
4836        };
4837    }
4838    if let Some(ref local_var_str) = created {
4839        local_var_req_builder = match "multi" {
4840            "multi" => local_var_req_builder.query(
4841                &local_var_str
4842                    .into_iter()
4843                    .map(|p| ("created".to_owned(), p.to_string()))
4844                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4845            ),
4846            _ => local_var_req_builder.query(&[(
4847                "created",
4848                &local_var_str
4849                    .into_iter()
4850                    .map(|p| p.to_string())
4851                    .collect::<Vec<String>>()
4852                    .join(",")
4853                    .to_string(),
4854            )]),
4855        };
4856    }
4857    if let Some(ref local_var_str) = created__empty {
4858        local_var_req_builder = match "multi" {
4859            "multi" => local_var_req_builder.query(
4860                &local_var_str
4861                    .into_iter()
4862                    .map(|p| ("created__empty".to_owned(), p.to_string()))
4863                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4864            ),
4865            _ => local_var_req_builder.query(&[(
4866                "created__empty",
4867                &local_var_str
4868                    .into_iter()
4869                    .map(|p| p.to_string())
4870                    .collect::<Vec<String>>()
4871                    .join(",")
4872                    .to_string(),
4873            )]),
4874        };
4875    }
4876    if let Some(ref local_var_str) = created__gt {
4877        local_var_req_builder = match "multi" {
4878            "multi" => local_var_req_builder.query(
4879                &local_var_str
4880                    .into_iter()
4881                    .map(|p| ("created__gt".to_owned(), p.to_string()))
4882                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4883            ),
4884            _ => local_var_req_builder.query(&[(
4885                "created__gt",
4886                &local_var_str
4887                    .into_iter()
4888                    .map(|p| p.to_string())
4889                    .collect::<Vec<String>>()
4890                    .join(",")
4891                    .to_string(),
4892            )]),
4893        };
4894    }
4895    if let Some(ref local_var_str) = created__gte {
4896        local_var_req_builder = match "multi" {
4897            "multi" => local_var_req_builder.query(
4898                &local_var_str
4899                    .into_iter()
4900                    .map(|p| ("created__gte".to_owned(), p.to_string()))
4901                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4902            ),
4903            _ => local_var_req_builder.query(&[(
4904                "created__gte",
4905                &local_var_str
4906                    .into_iter()
4907                    .map(|p| p.to_string())
4908                    .collect::<Vec<String>>()
4909                    .join(",")
4910                    .to_string(),
4911            )]),
4912        };
4913    }
4914    if let Some(ref local_var_str) = created__lt {
4915        local_var_req_builder = match "multi" {
4916            "multi" => local_var_req_builder.query(
4917                &local_var_str
4918                    .into_iter()
4919                    .map(|p| ("created__lt".to_owned(), p.to_string()))
4920                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4921            ),
4922            _ => local_var_req_builder.query(&[(
4923                "created__lt",
4924                &local_var_str
4925                    .into_iter()
4926                    .map(|p| p.to_string())
4927                    .collect::<Vec<String>>()
4928                    .join(",")
4929                    .to_string(),
4930            )]),
4931        };
4932    }
4933    if let Some(ref local_var_str) = created__lte {
4934        local_var_req_builder = match "multi" {
4935            "multi" => local_var_req_builder.query(
4936                &local_var_str
4937                    .into_iter()
4938                    .map(|p| ("created__lte".to_owned(), p.to_string()))
4939                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4940            ),
4941            _ => local_var_req_builder.query(&[(
4942                "created__lte",
4943                &local_var_str
4944                    .into_iter()
4945                    .map(|p| p.to_string())
4946                    .collect::<Vec<String>>()
4947                    .join(",")
4948                    .to_string(),
4949            )]),
4950        };
4951    }
4952    if let Some(ref local_var_str) = created__n {
4953        local_var_req_builder = match "multi" {
4954            "multi" => local_var_req_builder.query(
4955                &local_var_str
4956                    .into_iter()
4957                    .map(|p| ("created__n".to_owned(), p.to_string()))
4958                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4959            ),
4960            _ => local_var_req_builder.query(&[(
4961                "created__n",
4962                &local_var_str
4963                    .into_iter()
4964                    .map(|p| p.to_string())
4965                    .collect::<Vec<String>>()
4966                    .join(",")
4967                    .to_string(),
4968            )]),
4969        };
4970    }
4971    if let Some(ref local_var_str) = created_by_request {
4972        local_var_req_builder =
4973            local_var_req_builder.query(&[("created_by_request", &local_var_str.to_string())]);
4974    }
4975    if let Some(ref local_var_str) = description {
4976        local_var_req_builder = match "multi" {
4977            "multi" => local_var_req_builder.query(
4978                &local_var_str
4979                    .into_iter()
4980                    .map(|p| ("description".to_owned(), p.to_string()))
4981                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4982            ),
4983            _ => local_var_req_builder.query(&[(
4984                "description",
4985                &local_var_str
4986                    .into_iter()
4987                    .map(|p| p.to_string())
4988                    .collect::<Vec<String>>()
4989                    .join(",")
4990                    .to_string(),
4991            )]),
4992        };
4993    }
4994    if let Some(ref local_var_str) = description__empty {
4995        local_var_req_builder =
4996            local_var_req_builder.query(&[("description__empty", &local_var_str.to_string())]);
4997    }
4998    if let Some(ref local_var_str) = description__ic {
4999        local_var_req_builder = match "multi" {
5000            "multi" => local_var_req_builder.query(
5001                &local_var_str
5002                    .into_iter()
5003                    .map(|p| ("description__ic".to_owned(), p.to_string()))
5004                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5005            ),
5006            _ => local_var_req_builder.query(&[(
5007                "description__ic",
5008                &local_var_str
5009                    .into_iter()
5010                    .map(|p| p.to_string())
5011                    .collect::<Vec<String>>()
5012                    .join(",")
5013                    .to_string(),
5014            )]),
5015        };
5016    }
5017    if let Some(ref local_var_str) = description__ie {
5018        local_var_req_builder = match "multi" {
5019            "multi" => local_var_req_builder.query(
5020                &local_var_str
5021                    .into_iter()
5022                    .map(|p| ("description__ie".to_owned(), p.to_string()))
5023                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5024            ),
5025            _ => local_var_req_builder.query(&[(
5026                "description__ie",
5027                &local_var_str
5028                    .into_iter()
5029                    .map(|p| p.to_string())
5030                    .collect::<Vec<String>>()
5031                    .join(",")
5032                    .to_string(),
5033            )]),
5034        };
5035    }
5036    if let Some(ref local_var_str) = description__iew {
5037        local_var_req_builder = match "multi" {
5038            "multi" => local_var_req_builder.query(
5039                &local_var_str
5040                    .into_iter()
5041                    .map(|p| ("description__iew".to_owned(), p.to_string()))
5042                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5043            ),
5044            _ => local_var_req_builder.query(&[(
5045                "description__iew",
5046                &local_var_str
5047                    .into_iter()
5048                    .map(|p| p.to_string())
5049                    .collect::<Vec<String>>()
5050                    .join(",")
5051                    .to_string(),
5052            )]),
5053        };
5054    }
5055    if let Some(ref local_var_str) = description__iregex {
5056        local_var_req_builder = match "multi" {
5057            "multi" => local_var_req_builder.query(
5058                &local_var_str
5059                    .into_iter()
5060                    .map(|p| ("description__iregex".to_owned(), p.to_string()))
5061                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5062            ),
5063            _ => local_var_req_builder.query(&[(
5064                "description__iregex",
5065                &local_var_str
5066                    .into_iter()
5067                    .map(|p| p.to_string())
5068                    .collect::<Vec<String>>()
5069                    .join(",")
5070                    .to_string(),
5071            )]),
5072        };
5073    }
5074    if let Some(ref local_var_str) = description__isw {
5075        local_var_req_builder = match "multi" {
5076            "multi" => local_var_req_builder.query(
5077                &local_var_str
5078                    .into_iter()
5079                    .map(|p| ("description__isw".to_owned(), p.to_string()))
5080                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5081            ),
5082            _ => local_var_req_builder.query(&[(
5083                "description__isw",
5084                &local_var_str
5085                    .into_iter()
5086                    .map(|p| p.to_string())
5087                    .collect::<Vec<String>>()
5088                    .join(",")
5089                    .to_string(),
5090            )]),
5091        };
5092    }
5093    if let Some(ref local_var_str) = description__n {
5094        local_var_req_builder = match "multi" {
5095            "multi" => local_var_req_builder.query(
5096                &local_var_str
5097                    .into_iter()
5098                    .map(|p| ("description__n".to_owned(), p.to_string()))
5099                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5100            ),
5101            _ => local_var_req_builder.query(&[(
5102                "description__n",
5103                &local_var_str
5104                    .into_iter()
5105                    .map(|p| p.to_string())
5106                    .collect::<Vec<String>>()
5107                    .join(",")
5108                    .to_string(),
5109            )]),
5110        };
5111    }
5112    if let Some(ref local_var_str) = description__nic {
5113        local_var_req_builder = match "multi" {
5114            "multi" => local_var_req_builder.query(
5115                &local_var_str
5116                    .into_iter()
5117                    .map(|p| ("description__nic".to_owned(), p.to_string()))
5118                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5119            ),
5120            _ => local_var_req_builder.query(&[(
5121                "description__nic",
5122                &local_var_str
5123                    .into_iter()
5124                    .map(|p| p.to_string())
5125                    .collect::<Vec<String>>()
5126                    .join(",")
5127                    .to_string(),
5128            )]),
5129        };
5130    }
5131    if let Some(ref local_var_str) = description__nie {
5132        local_var_req_builder = match "multi" {
5133            "multi" => local_var_req_builder.query(
5134                &local_var_str
5135                    .into_iter()
5136                    .map(|p| ("description__nie".to_owned(), p.to_string()))
5137                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5138            ),
5139            _ => local_var_req_builder.query(&[(
5140                "description__nie",
5141                &local_var_str
5142                    .into_iter()
5143                    .map(|p| p.to_string())
5144                    .collect::<Vec<String>>()
5145                    .join(",")
5146                    .to_string(),
5147            )]),
5148        };
5149    }
5150    if let Some(ref local_var_str) = description__niew {
5151        local_var_req_builder = match "multi" {
5152            "multi" => local_var_req_builder.query(
5153                &local_var_str
5154                    .into_iter()
5155                    .map(|p| ("description__niew".to_owned(), p.to_string()))
5156                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5157            ),
5158            _ => local_var_req_builder.query(&[(
5159                "description__niew",
5160                &local_var_str
5161                    .into_iter()
5162                    .map(|p| p.to_string())
5163                    .collect::<Vec<String>>()
5164                    .join(",")
5165                    .to_string(),
5166            )]),
5167        };
5168    }
5169    if let Some(ref local_var_str) = description__nisw {
5170        local_var_req_builder = match "multi" {
5171            "multi" => local_var_req_builder.query(
5172                &local_var_str
5173                    .into_iter()
5174                    .map(|p| ("description__nisw".to_owned(), p.to_string()))
5175                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5176            ),
5177            _ => local_var_req_builder.query(&[(
5178                "description__nisw",
5179                &local_var_str
5180                    .into_iter()
5181                    .map(|p| p.to_string())
5182                    .collect::<Vec<String>>()
5183                    .join(",")
5184                    .to_string(),
5185            )]),
5186        };
5187    }
5188    if let Some(ref local_var_str) = description__regex {
5189        local_var_req_builder = match "multi" {
5190            "multi" => local_var_req_builder.query(
5191                &local_var_str
5192                    .into_iter()
5193                    .map(|p| ("description__regex".to_owned(), p.to_string()))
5194                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5195            ),
5196            _ => local_var_req_builder.query(&[(
5197                "description__regex",
5198                &local_var_str
5199                    .into_iter()
5200                    .map(|p| p.to_string())
5201                    .collect::<Vec<String>>()
5202                    .join(",")
5203                    .to_string(),
5204            )]),
5205        };
5206    }
5207    if let Some(ref local_var_str) = group {
5208        local_var_req_builder = match "multi" {
5209            "multi" => local_var_req_builder.query(
5210                &local_var_str
5211                    .into_iter()
5212                    .map(|p| ("group".to_owned(), p.to_string()))
5213                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5214            ),
5215            _ => local_var_req_builder.query(&[(
5216                "group",
5217                &local_var_str
5218                    .into_iter()
5219                    .map(|p| p.to_string())
5220                    .collect::<Vec<String>>()
5221                    .join(",")
5222                    .to_string(),
5223            )]),
5224        };
5225    }
5226    if let Some(ref local_var_str) = group__n {
5227        local_var_req_builder = match "multi" {
5228            "multi" => local_var_req_builder.query(
5229                &local_var_str
5230                    .into_iter()
5231                    .map(|p| ("group__n".to_owned(), p.to_string()))
5232                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5233            ),
5234            _ => local_var_req_builder.query(&[(
5235                "group__n",
5236                &local_var_str
5237                    .into_iter()
5238                    .map(|p| p.to_string())
5239                    .collect::<Vec<String>>()
5240                    .join(",")
5241                    .to_string(),
5242            )]),
5243        };
5244    }
5245    if let Some(ref local_var_str) = group_id {
5246        local_var_req_builder = match "multi" {
5247            "multi" => local_var_req_builder.query(
5248                &local_var_str
5249                    .into_iter()
5250                    .map(|p| ("group_id".to_owned(), p.to_string()))
5251                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5252            ),
5253            _ => local_var_req_builder.query(&[(
5254                "group_id",
5255                &local_var_str
5256                    .into_iter()
5257                    .map(|p| p.to_string())
5258                    .collect::<Vec<String>>()
5259                    .join(",")
5260                    .to_string(),
5261            )]),
5262        };
5263    }
5264    if let Some(ref local_var_str) = group_id__n {
5265        local_var_req_builder = match "multi" {
5266            "multi" => local_var_req_builder.query(
5267                &local_var_str
5268                    .into_iter()
5269                    .map(|p| ("group_id__n".to_owned(), p.to_string()))
5270                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5271            ),
5272            _ => local_var_req_builder.query(&[(
5273                "group_id__n",
5274                &local_var_str
5275                    .into_iter()
5276                    .map(|p| p.to_string())
5277                    .collect::<Vec<String>>()
5278                    .join(",")
5279                    .to_string(),
5280            )]),
5281        };
5282    }
5283    if let Some(ref local_var_str) = id {
5284        local_var_req_builder = match "multi" {
5285            "multi" => local_var_req_builder.query(
5286                &local_var_str
5287                    .into_iter()
5288                    .map(|p| ("id".to_owned(), p.to_string()))
5289                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5290            ),
5291            _ => local_var_req_builder.query(&[(
5292                "id",
5293                &local_var_str
5294                    .into_iter()
5295                    .map(|p| p.to_string())
5296                    .collect::<Vec<String>>()
5297                    .join(",")
5298                    .to_string(),
5299            )]),
5300        };
5301    }
5302    if let Some(ref local_var_str) = id__empty {
5303        local_var_req_builder =
5304            local_var_req_builder.query(&[("id__empty", &local_var_str.to_string())]);
5305    }
5306    if let Some(ref local_var_str) = id__gt {
5307        local_var_req_builder = match "multi" {
5308            "multi" => local_var_req_builder.query(
5309                &local_var_str
5310                    .into_iter()
5311                    .map(|p| ("id__gt".to_owned(), p.to_string()))
5312                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5313            ),
5314            _ => local_var_req_builder.query(&[(
5315                "id__gt",
5316                &local_var_str
5317                    .into_iter()
5318                    .map(|p| p.to_string())
5319                    .collect::<Vec<String>>()
5320                    .join(",")
5321                    .to_string(),
5322            )]),
5323        };
5324    }
5325    if let Some(ref local_var_str) = id__gte {
5326        local_var_req_builder = match "multi" {
5327            "multi" => local_var_req_builder.query(
5328                &local_var_str
5329                    .into_iter()
5330                    .map(|p| ("id__gte".to_owned(), p.to_string()))
5331                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5332            ),
5333            _ => local_var_req_builder.query(&[(
5334                "id__gte",
5335                &local_var_str
5336                    .into_iter()
5337                    .map(|p| p.to_string())
5338                    .collect::<Vec<String>>()
5339                    .join(",")
5340                    .to_string(),
5341            )]),
5342        };
5343    }
5344    if let Some(ref local_var_str) = id__lt {
5345        local_var_req_builder = match "multi" {
5346            "multi" => local_var_req_builder.query(
5347                &local_var_str
5348                    .into_iter()
5349                    .map(|p| ("id__lt".to_owned(), p.to_string()))
5350                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5351            ),
5352            _ => local_var_req_builder.query(&[(
5353                "id__lt",
5354                &local_var_str
5355                    .into_iter()
5356                    .map(|p| p.to_string())
5357                    .collect::<Vec<String>>()
5358                    .join(",")
5359                    .to_string(),
5360            )]),
5361        };
5362    }
5363    if let Some(ref local_var_str) = id__lte {
5364        local_var_req_builder = match "multi" {
5365            "multi" => local_var_req_builder.query(
5366                &local_var_str
5367                    .into_iter()
5368                    .map(|p| ("id__lte".to_owned(), p.to_string()))
5369                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5370            ),
5371            _ => local_var_req_builder.query(&[(
5372                "id__lte",
5373                &local_var_str
5374                    .into_iter()
5375                    .map(|p| p.to_string())
5376                    .collect::<Vec<String>>()
5377                    .join(",")
5378                    .to_string(),
5379            )]),
5380        };
5381    }
5382    if let Some(ref local_var_str) = id__n {
5383        local_var_req_builder = match "multi" {
5384            "multi" => local_var_req_builder.query(
5385                &local_var_str
5386                    .into_iter()
5387                    .map(|p| ("id__n".to_owned(), p.to_string()))
5388                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5389            ),
5390            _ => local_var_req_builder.query(&[(
5391                "id__n",
5392                &local_var_str
5393                    .into_iter()
5394                    .map(|p| p.to_string())
5395                    .collect::<Vec<String>>()
5396                    .join(",")
5397                    .to_string(),
5398            )]),
5399        };
5400    }
5401    if let Some(ref local_var_str) = last_updated {
5402        local_var_req_builder = match "multi" {
5403            "multi" => local_var_req_builder.query(
5404                &local_var_str
5405                    .into_iter()
5406                    .map(|p| ("last_updated".to_owned(), p.to_string()))
5407                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5408            ),
5409            _ => local_var_req_builder.query(&[(
5410                "last_updated",
5411                &local_var_str
5412                    .into_iter()
5413                    .map(|p| p.to_string())
5414                    .collect::<Vec<String>>()
5415                    .join(",")
5416                    .to_string(),
5417            )]),
5418        };
5419    }
5420    if let Some(ref local_var_str) = last_updated__empty {
5421        local_var_req_builder = match "multi" {
5422            "multi" => local_var_req_builder.query(
5423                &local_var_str
5424                    .into_iter()
5425                    .map(|p| ("last_updated__empty".to_owned(), p.to_string()))
5426                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5427            ),
5428            _ => local_var_req_builder.query(&[(
5429                "last_updated__empty",
5430                &local_var_str
5431                    .into_iter()
5432                    .map(|p| p.to_string())
5433                    .collect::<Vec<String>>()
5434                    .join(",")
5435                    .to_string(),
5436            )]),
5437        };
5438    }
5439    if let Some(ref local_var_str) = last_updated__gt {
5440        local_var_req_builder = match "multi" {
5441            "multi" => local_var_req_builder.query(
5442                &local_var_str
5443                    .into_iter()
5444                    .map(|p| ("last_updated__gt".to_owned(), p.to_string()))
5445                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5446            ),
5447            _ => local_var_req_builder.query(&[(
5448                "last_updated__gt",
5449                &local_var_str
5450                    .into_iter()
5451                    .map(|p| p.to_string())
5452                    .collect::<Vec<String>>()
5453                    .join(",")
5454                    .to_string(),
5455            )]),
5456        };
5457    }
5458    if let Some(ref local_var_str) = last_updated__gte {
5459        local_var_req_builder = match "multi" {
5460            "multi" => local_var_req_builder.query(
5461                &local_var_str
5462                    .into_iter()
5463                    .map(|p| ("last_updated__gte".to_owned(), p.to_string()))
5464                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5465            ),
5466            _ => local_var_req_builder.query(&[(
5467                "last_updated__gte",
5468                &local_var_str
5469                    .into_iter()
5470                    .map(|p| p.to_string())
5471                    .collect::<Vec<String>>()
5472                    .join(",")
5473                    .to_string(),
5474            )]),
5475        };
5476    }
5477    if let Some(ref local_var_str) = last_updated__lt {
5478        local_var_req_builder = match "multi" {
5479            "multi" => local_var_req_builder.query(
5480                &local_var_str
5481                    .into_iter()
5482                    .map(|p| ("last_updated__lt".to_owned(), p.to_string()))
5483                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5484            ),
5485            _ => local_var_req_builder.query(&[(
5486                "last_updated__lt",
5487                &local_var_str
5488                    .into_iter()
5489                    .map(|p| p.to_string())
5490                    .collect::<Vec<String>>()
5491                    .join(",")
5492                    .to_string(),
5493            )]),
5494        };
5495    }
5496    if let Some(ref local_var_str) = last_updated__lte {
5497        local_var_req_builder = match "multi" {
5498            "multi" => local_var_req_builder.query(
5499                &local_var_str
5500                    .into_iter()
5501                    .map(|p| ("last_updated__lte".to_owned(), p.to_string()))
5502                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5503            ),
5504            _ => local_var_req_builder.query(&[(
5505                "last_updated__lte",
5506                &local_var_str
5507                    .into_iter()
5508                    .map(|p| p.to_string())
5509                    .collect::<Vec<String>>()
5510                    .join(",")
5511                    .to_string(),
5512            )]),
5513        };
5514    }
5515    if let Some(ref local_var_str) = last_updated__n {
5516        local_var_req_builder = match "multi" {
5517            "multi" => local_var_req_builder.query(
5518                &local_var_str
5519                    .into_iter()
5520                    .map(|p| ("last_updated__n".to_owned(), p.to_string()))
5521                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5522            ),
5523            _ => local_var_req_builder.query(&[(
5524                "last_updated__n",
5525                &local_var_str
5526                    .into_iter()
5527                    .map(|p| p.to_string())
5528                    .collect::<Vec<String>>()
5529                    .join(",")
5530                    .to_string(),
5531            )]),
5532        };
5533    }
5534    if let Some(ref local_var_str) = limit {
5535        local_var_req_builder =
5536            local_var_req_builder.query(&[("limit", &local_var_str.to_string())]);
5537    }
5538    if let Some(ref local_var_str) = location {
5539        local_var_req_builder = match "multi" {
5540            "multi" => local_var_req_builder.query(
5541                &local_var_str
5542                    .into_iter()
5543                    .map(|p| ("location".to_owned(), p.to_string()))
5544                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5545            ),
5546            _ => local_var_req_builder.query(&[(
5547                "location",
5548                &local_var_str
5549                    .into_iter()
5550                    .map(|p| p.to_string())
5551                    .collect::<Vec<String>>()
5552                    .join(",")
5553                    .to_string(),
5554            )]),
5555        };
5556    }
5557    if let Some(ref local_var_str) = location__n {
5558        local_var_req_builder = match "multi" {
5559            "multi" => local_var_req_builder.query(
5560                &local_var_str
5561                    .into_iter()
5562                    .map(|p| ("location__n".to_owned(), p.to_string()))
5563                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5564            ),
5565            _ => local_var_req_builder.query(&[(
5566                "location__n",
5567                &local_var_str
5568                    .into_iter()
5569                    .map(|p| p.to_string())
5570                    .collect::<Vec<String>>()
5571                    .join(",")
5572                    .to_string(),
5573            )]),
5574        };
5575    }
5576    if let Some(ref local_var_str) = location_id {
5577        local_var_req_builder = match "multi" {
5578            "multi" => local_var_req_builder.query(
5579                &local_var_str
5580                    .into_iter()
5581                    .map(|p| ("location_id".to_owned(), p.to_string()))
5582                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5583            ),
5584            _ => local_var_req_builder.query(&[(
5585                "location_id",
5586                &local_var_str
5587                    .into_iter()
5588                    .map(|p| p.to_string())
5589                    .collect::<Vec<String>>()
5590                    .join(",")
5591                    .to_string(),
5592            )]),
5593        };
5594    }
5595    if let Some(ref local_var_str) = location_id__n {
5596        local_var_req_builder = match "multi" {
5597            "multi" => local_var_req_builder.query(
5598                &local_var_str
5599                    .into_iter()
5600                    .map(|p| ("location_id__n".to_owned(), p.to_string()))
5601                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5602            ),
5603            _ => local_var_req_builder.query(&[(
5604                "location_id__n",
5605                &local_var_str
5606                    .into_iter()
5607                    .map(|p| p.to_string())
5608                    .collect::<Vec<String>>()
5609                    .join(",")
5610                    .to_string(),
5611            )]),
5612        };
5613    }
5614    if let Some(ref local_var_str) = modified_by_request {
5615        local_var_req_builder =
5616            local_var_req_builder.query(&[("modified_by_request", &local_var_str.to_string())]);
5617    }
5618    if let Some(ref local_var_str) = name {
5619        local_var_req_builder = match "multi" {
5620            "multi" => local_var_req_builder.query(
5621                &local_var_str
5622                    .into_iter()
5623                    .map(|p| ("name".to_owned(), p.to_string()))
5624                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5625            ),
5626            _ => local_var_req_builder.query(&[(
5627                "name",
5628                &local_var_str
5629                    .into_iter()
5630                    .map(|p| p.to_string())
5631                    .collect::<Vec<String>>()
5632                    .join(",")
5633                    .to_string(),
5634            )]),
5635        };
5636    }
5637    if let Some(ref local_var_str) = name__empty {
5638        local_var_req_builder =
5639            local_var_req_builder.query(&[("name__empty", &local_var_str.to_string())]);
5640    }
5641    if let Some(ref local_var_str) = name__ic {
5642        local_var_req_builder = match "multi" {
5643            "multi" => local_var_req_builder.query(
5644                &local_var_str
5645                    .into_iter()
5646                    .map(|p| ("name__ic".to_owned(), p.to_string()))
5647                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5648            ),
5649            _ => local_var_req_builder.query(&[(
5650                "name__ic",
5651                &local_var_str
5652                    .into_iter()
5653                    .map(|p| p.to_string())
5654                    .collect::<Vec<String>>()
5655                    .join(",")
5656                    .to_string(),
5657            )]),
5658        };
5659    }
5660    if let Some(ref local_var_str) = name__ie {
5661        local_var_req_builder = match "multi" {
5662            "multi" => local_var_req_builder.query(
5663                &local_var_str
5664                    .into_iter()
5665                    .map(|p| ("name__ie".to_owned(), p.to_string()))
5666                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5667            ),
5668            _ => local_var_req_builder.query(&[(
5669                "name__ie",
5670                &local_var_str
5671                    .into_iter()
5672                    .map(|p| p.to_string())
5673                    .collect::<Vec<String>>()
5674                    .join(",")
5675                    .to_string(),
5676            )]),
5677        };
5678    }
5679    if let Some(ref local_var_str) = name__iew {
5680        local_var_req_builder = match "multi" {
5681            "multi" => local_var_req_builder.query(
5682                &local_var_str
5683                    .into_iter()
5684                    .map(|p| ("name__iew".to_owned(), p.to_string()))
5685                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5686            ),
5687            _ => local_var_req_builder.query(&[(
5688                "name__iew",
5689                &local_var_str
5690                    .into_iter()
5691                    .map(|p| p.to_string())
5692                    .collect::<Vec<String>>()
5693                    .join(",")
5694                    .to_string(),
5695            )]),
5696        };
5697    }
5698    if let Some(ref local_var_str) = name__iregex {
5699        local_var_req_builder = match "multi" {
5700            "multi" => local_var_req_builder.query(
5701                &local_var_str
5702                    .into_iter()
5703                    .map(|p| ("name__iregex".to_owned(), p.to_string()))
5704                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5705            ),
5706            _ => local_var_req_builder.query(&[(
5707                "name__iregex",
5708                &local_var_str
5709                    .into_iter()
5710                    .map(|p| p.to_string())
5711                    .collect::<Vec<String>>()
5712                    .join(",")
5713                    .to_string(),
5714            )]),
5715        };
5716    }
5717    if let Some(ref local_var_str) = name__isw {
5718        local_var_req_builder = match "multi" {
5719            "multi" => local_var_req_builder.query(
5720                &local_var_str
5721                    .into_iter()
5722                    .map(|p| ("name__isw".to_owned(), p.to_string()))
5723                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5724            ),
5725            _ => local_var_req_builder.query(&[(
5726                "name__isw",
5727                &local_var_str
5728                    .into_iter()
5729                    .map(|p| p.to_string())
5730                    .collect::<Vec<String>>()
5731                    .join(",")
5732                    .to_string(),
5733            )]),
5734        };
5735    }
5736    if let Some(ref local_var_str) = name__n {
5737        local_var_req_builder = match "multi" {
5738            "multi" => local_var_req_builder.query(
5739                &local_var_str
5740                    .into_iter()
5741                    .map(|p| ("name__n".to_owned(), p.to_string()))
5742                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5743            ),
5744            _ => local_var_req_builder.query(&[(
5745                "name__n",
5746                &local_var_str
5747                    .into_iter()
5748                    .map(|p| p.to_string())
5749                    .collect::<Vec<String>>()
5750                    .join(",")
5751                    .to_string(),
5752            )]),
5753        };
5754    }
5755    if let Some(ref local_var_str) = name__nic {
5756        local_var_req_builder = match "multi" {
5757            "multi" => local_var_req_builder.query(
5758                &local_var_str
5759                    .into_iter()
5760                    .map(|p| ("name__nic".to_owned(), p.to_string()))
5761                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5762            ),
5763            _ => local_var_req_builder.query(&[(
5764                "name__nic",
5765                &local_var_str
5766                    .into_iter()
5767                    .map(|p| p.to_string())
5768                    .collect::<Vec<String>>()
5769                    .join(",")
5770                    .to_string(),
5771            )]),
5772        };
5773    }
5774    if let Some(ref local_var_str) = name__nie {
5775        local_var_req_builder = match "multi" {
5776            "multi" => local_var_req_builder.query(
5777                &local_var_str
5778                    .into_iter()
5779                    .map(|p| ("name__nie".to_owned(), p.to_string()))
5780                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5781            ),
5782            _ => local_var_req_builder.query(&[(
5783                "name__nie",
5784                &local_var_str
5785                    .into_iter()
5786                    .map(|p| p.to_string())
5787                    .collect::<Vec<String>>()
5788                    .join(",")
5789                    .to_string(),
5790            )]),
5791        };
5792    }
5793    if let Some(ref local_var_str) = name__niew {
5794        local_var_req_builder = match "multi" {
5795            "multi" => local_var_req_builder.query(
5796                &local_var_str
5797                    .into_iter()
5798                    .map(|p| ("name__niew".to_owned(), p.to_string()))
5799                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5800            ),
5801            _ => local_var_req_builder.query(&[(
5802                "name__niew",
5803                &local_var_str
5804                    .into_iter()
5805                    .map(|p| p.to_string())
5806                    .collect::<Vec<String>>()
5807                    .join(",")
5808                    .to_string(),
5809            )]),
5810        };
5811    }
5812    if let Some(ref local_var_str) = name__nisw {
5813        local_var_req_builder = match "multi" {
5814            "multi" => local_var_req_builder.query(
5815                &local_var_str
5816                    .into_iter()
5817                    .map(|p| ("name__nisw".to_owned(), p.to_string()))
5818                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5819            ),
5820            _ => local_var_req_builder.query(&[(
5821                "name__nisw",
5822                &local_var_str
5823                    .into_iter()
5824                    .map(|p| p.to_string())
5825                    .collect::<Vec<String>>()
5826                    .join(",")
5827                    .to_string(),
5828            )]),
5829        };
5830    }
5831    if let Some(ref local_var_str) = name__regex {
5832        local_var_req_builder = match "multi" {
5833            "multi" => local_var_req_builder.query(
5834                &local_var_str
5835                    .into_iter()
5836                    .map(|p| ("name__regex".to_owned(), p.to_string()))
5837                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5838            ),
5839            _ => local_var_req_builder.query(&[(
5840                "name__regex",
5841                &local_var_str
5842                    .into_iter()
5843                    .map(|p| p.to_string())
5844                    .collect::<Vec<String>>()
5845                    .join(",")
5846                    .to_string(),
5847            )]),
5848        };
5849    }
5850    if let Some(ref local_var_str) = offset {
5851        local_var_req_builder =
5852            local_var_req_builder.query(&[("offset", &local_var_str.to_string())]);
5853    }
5854    if let Some(ref local_var_str) = ordering {
5855        local_var_req_builder =
5856            local_var_req_builder.query(&[("ordering", &local_var_str.to_string())]);
5857    }
5858    if let Some(ref local_var_str) = owner {
5859        local_var_req_builder = match "multi" {
5860            "multi" => local_var_req_builder.query(
5861                &local_var_str
5862                    .into_iter()
5863                    .map(|p| ("owner".to_owned(), p.to_string()))
5864                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5865            ),
5866            _ => local_var_req_builder.query(&[(
5867                "owner",
5868                &local_var_str
5869                    .into_iter()
5870                    .map(|p| p.to_string())
5871                    .collect::<Vec<String>>()
5872                    .join(",")
5873                    .to_string(),
5874            )]),
5875        };
5876    }
5877    if let Some(ref local_var_str) = owner__n {
5878        local_var_req_builder = match "multi" {
5879            "multi" => local_var_req_builder.query(
5880                &local_var_str
5881                    .into_iter()
5882                    .map(|p| ("owner__n".to_owned(), p.to_string()))
5883                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5884            ),
5885            _ => local_var_req_builder.query(&[(
5886                "owner__n",
5887                &local_var_str
5888                    .into_iter()
5889                    .map(|p| p.to_string())
5890                    .collect::<Vec<String>>()
5891                    .join(",")
5892                    .to_string(),
5893            )]),
5894        };
5895    }
5896    if let Some(ref local_var_str) = owner_group {
5897        local_var_req_builder = match "multi" {
5898            "multi" => local_var_req_builder.query(
5899                &local_var_str
5900                    .into_iter()
5901                    .map(|p| ("owner_group".to_owned(), p.to_string()))
5902                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5903            ),
5904            _ => local_var_req_builder.query(&[(
5905                "owner_group",
5906                &local_var_str
5907                    .into_iter()
5908                    .map(|p| p.to_string())
5909                    .collect::<Vec<String>>()
5910                    .join(",")
5911                    .to_string(),
5912            )]),
5913        };
5914    }
5915    if let Some(ref local_var_str) = owner_group__n {
5916        local_var_req_builder = match "multi" {
5917            "multi" => local_var_req_builder.query(
5918                &local_var_str
5919                    .into_iter()
5920                    .map(|p| ("owner_group__n".to_owned(), p.to_string()))
5921                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5922            ),
5923            _ => local_var_req_builder.query(&[(
5924                "owner_group__n",
5925                &local_var_str
5926                    .into_iter()
5927                    .map(|p| p.to_string())
5928                    .collect::<Vec<String>>()
5929                    .join(",")
5930                    .to_string(),
5931            )]),
5932        };
5933    }
5934    if let Some(ref local_var_str) = owner_group_id {
5935        local_var_req_builder = match "multi" {
5936            "multi" => local_var_req_builder.query(
5937                &local_var_str
5938                    .into_iter()
5939                    .map(|p| ("owner_group_id".to_owned(), p.to_string()))
5940                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5941            ),
5942            _ => local_var_req_builder.query(&[(
5943                "owner_group_id",
5944                &local_var_str
5945                    .into_iter()
5946                    .map(|p| p.to_string())
5947                    .collect::<Vec<String>>()
5948                    .join(",")
5949                    .to_string(),
5950            )]),
5951        };
5952    }
5953    if let Some(ref local_var_str) = owner_group_id__n {
5954        local_var_req_builder = match "multi" {
5955            "multi" => local_var_req_builder.query(
5956                &local_var_str
5957                    .into_iter()
5958                    .map(|p| ("owner_group_id__n".to_owned(), p.to_string()))
5959                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5960            ),
5961            _ => local_var_req_builder.query(&[(
5962                "owner_group_id__n",
5963                &local_var_str
5964                    .into_iter()
5965                    .map(|p| p.to_string())
5966                    .collect::<Vec<String>>()
5967                    .join(",")
5968                    .to_string(),
5969            )]),
5970        };
5971    }
5972    if let Some(ref local_var_str) = owner_id {
5973        local_var_req_builder = match "multi" {
5974            "multi" => local_var_req_builder.query(
5975                &local_var_str
5976                    .into_iter()
5977                    .map(|p| ("owner_id".to_owned(), p.to_string()))
5978                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5979            ),
5980            _ => local_var_req_builder.query(&[(
5981                "owner_id",
5982                &local_var_str
5983                    .into_iter()
5984                    .map(|p| p.to_string())
5985                    .collect::<Vec<String>>()
5986                    .join(",")
5987                    .to_string(),
5988            )]),
5989        };
5990    }
5991    if let Some(ref local_var_str) = owner_id__n {
5992        local_var_req_builder = match "multi" {
5993            "multi" => local_var_req_builder.query(
5994                &local_var_str
5995                    .into_iter()
5996                    .map(|p| ("owner_id__n".to_owned(), p.to_string()))
5997                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5998            ),
5999            _ => local_var_req_builder.query(&[(
6000                "owner_id__n",
6001                &local_var_str
6002                    .into_iter()
6003                    .map(|p| p.to_string())
6004                    .collect::<Vec<String>>()
6005                    .join(",")
6006                    .to_string(),
6007            )]),
6008        };
6009    }
6010    if let Some(ref local_var_str) = q {
6011        local_var_req_builder = local_var_req_builder.query(&[("q", &local_var_str.to_string())]);
6012    }
6013    if let Some(ref local_var_str) = region {
6014        local_var_req_builder = match "multi" {
6015            "multi" => local_var_req_builder.query(
6016                &local_var_str
6017                    .into_iter()
6018                    .map(|p| ("region".to_owned(), p.to_string()))
6019                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6020            ),
6021            _ => local_var_req_builder.query(&[(
6022                "region",
6023                &local_var_str
6024                    .into_iter()
6025                    .map(|p| p.to_string())
6026                    .collect::<Vec<String>>()
6027                    .join(",")
6028                    .to_string(),
6029            )]),
6030        };
6031    }
6032    if let Some(ref local_var_str) = region__n {
6033        local_var_req_builder = match "multi" {
6034            "multi" => local_var_req_builder.query(
6035                &local_var_str
6036                    .into_iter()
6037                    .map(|p| ("region__n".to_owned(), p.to_string()))
6038                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6039            ),
6040            _ => local_var_req_builder.query(&[(
6041                "region__n",
6042                &local_var_str
6043                    .into_iter()
6044                    .map(|p| p.to_string())
6045                    .collect::<Vec<String>>()
6046                    .join(",")
6047                    .to_string(),
6048            )]),
6049        };
6050    }
6051    if let Some(ref local_var_str) = region_id {
6052        local_var_req_builder = match "multi" {
6053            "multi" => local_var_req_builder.query(
6054                &local_var_str
6055                    .into_iter()
6056                    .map(|p| ("region_id".to_owned(), p.to_string()))
6057                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6058            ),
6059            _ => local_var_req_builder.query(&[(
6060                "region_id",
6061                &local_var_str
6062                    .into_iter()
6063                    .map(|p| p.to_string())
6064                    .collect::<Vec<String>>()
6065                    .join(",")
6066                    .to_string(),
6067            )]),
6068        };
6069    }
6070    if let Some(ref local_var_str) = region_id__n {
6071        local_var_req_builder = match "multi" {
6072            "multi" => local_var_req_builder.query(
6073                &local_var_str
6074                    .into_iter()
6075                    .map(|p| ("region_id__n".to_owned(), p.to_string()))
6076                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6077            ),
6078            _ => local_var_req_builder.query(&[(
6079                "region_id__n",
6080                &local_var_str
6081                    .into_iter()
6082                    .map(|p| p.to_string())
6083                    .collect::<Vec<String>>()
6084                    .join(",")
6085                    .to_string(),
6086            )]),
6087        };
6088    }
6089    if let Some(ref local_var_str) = scope_id {
6090        local_var_req_builder = match "multi" {
6091            "multi" => local_var_req_builder.query(
6092                &local_var_str
6093                    .into_iter()
6094                    .map(|p| ("scope_id".to_owned(), p.to_string()))
6095                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6096            ),
6097            _ => local_var_req_builder.query(&[(
6098                "scope_id",
6099                &local_var_str
6100                    .into_iter()
6101                    .map(|p| p.to_string())
6102                    .collect::<Vec<String>>()
6103                    .join(",")
6104                    .to_string(),
6105            )]),
6106        };
6107    }
6108    if let Some(ref local_var_str) = scope_id__empty {
6109        local_var_req_builder =
6110            local_var_req_builder.query(&[("scope_id__empty", &local_var_str.to_string())]);
6111    }
6112    if let Some(ref local_var_str) = scope_id__gt {
6113        local_var_req_builder = match "multi" {
6114            "multi" => local_var_req_builder.query(
6115                &local_var_str
6116                    .into_iter()
6117                    .map(|p| ("scope_id__gt".to_owned(), p.to_string()))
6118                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6119            ),
6120            _ => local_var_req_builder.query(&[(
6121                "scope_id__gt",
6122                &local_var_str
6123                    .into_iter()
6124                    .map(|p| p.to_string())
6125                    .collect::<Vec<String>>()
6126                    .join(",")
6127                    .to_string(),
6128            )]),
6129        };
6130    }
6131    if let Some(ref local_var_str) = scope_id__gte {
6132        local_var_req_builder = match "multi" {
6133            "multi" => local_var_req_builder.query(
6134                &local_var_str
6135                    .into_iter()
6136                    .map(|p| ("scope_id__gte".to_owned(), p.to_string()))
6137                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6138            ),
6139            _ => local_var_req_builder.query(&[(
6140                "scope_id__gte",
6141                &local_var_str
6142                    .into_iter()
6143                    .map(|p| p.to_string())
6144                    .collect::<Vec<String>>()
6145                    .join(",")
6146                    .to_string(),
6147            )]),
6148        };
6149    }
6150    if let Some(ref local_var_str) = scope_id__lt {
6151        local_var_req_builder = match "multi" {
6152            "multi" => local_var_req_builder.query(
6153                &local_var_str
6154                    .into_iter()
6155                    .map(|p| ("scope_id__lt".to_owned(), p.to_string()))
6156                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6157            ),
6158            _ => local_var_req_builder.query(&[(
6159                "scope_id__lt",
6160                &local_var_str
6161                    .into_iter()
6162                    .map(|p| p.to_string())
6163                    .collect::<Vec<String>>()
6164                    .join(",")
6165                    .to_string(),
6166            )]),
6167        };
6168    }
6169    if let Some(ref local_var_str) = scope_id__lte {
6170        local_var_req_builder = match "multi" {
6171            "multi" => local_var_req_builder.query(
6172                &local_var_str
6173                    .into_iter()
6174                    .map(|p| ("scope_id__lte".to_owned(), p.to_string()))
6175                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6176            ),
6177            _ => local_var_req_builder.query(&[(
6178                "scope_id__lte",
6179                &local_var_str
6180                    .into_iter()
6181                    .map(|p| p.to_string())
6182                    .collect::<Vec<String>>()
6183                    .join(",")
6184                    .to_string(),
6185            )]),
6186        };
6187    }
6188    if let Some(ref local_var_str) = scope_id__n {
6189        local_var_req_builder = match "multi" {
6190            "multi" => local_var_req_builder.query(
6191                &local_var_str
6192                    .into_iter()
6193                    .map(|p| ("scope_id__n".to_owned(), p.to_string()))
6194                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6195            ),
6196            _ => local_var_req_builder.query(&[(
6197                "scope_id__n",
6198                &local_var_str
6199                    .into_iter()
6200                    .map(|p| p.to_string())
6201                    .collect::<Vec<String>>()
6202                    .join(",")
6203                    .to_string(),
6204            )]),
6205        };
6206    }
6207    if let Some(ref local_var_str) = scope_type {
6208        local_var_req_builder = match "multi" {
6209            "multi" => local_var_req_builder.query(
6210                &local_var_str
6211                    .into_iter()
6212                    .map(|p| ("scope_type".to_owned(), p.to_string()))
6213                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6214            ),
6215            _ => local_var_req_builder.query(&[(
6216                "scope_type",
6217                &local_var_str
6218                    .into_iter()
6219                    .map(|p| p.to_string())
6220                    .collect::<Vec<String>>()
6221                    .join(",")
6222                    .to_string(),
6223            )]),
6224        };
6225    }
6226    if let Some(ref local_var_str) = scope_type__n {
6227        local_var_req_builder = match "multi" {
6228            "multi" => local_var_req_builder.query(
6229                &local_var_str
6230                    .into_iter()
6231                    .map(|p| ("scope_type__n".to_owned(), p.to_string()))
6232                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6233            ),
6234            _ => local_var_req_builder.query(&[(
6235                "scope_type__n",
6236                &local_var_str
6237                    .into_iter()
6238                    .map(|p| p.to_string())
6239                    .collect::<Vec<String>>()
6240                    .join(",")
6241                    .to_string(),
6242            )]),
6243        };
6244    }
6245    if let Some(ref local_var_str) = site {
6246        local_var_req_builder = match "multi" {
6247            "multi" => local_var_req_builder.query(
6248                &local_var_str
6249                    .into_iter()
6250                    .map(|p| ("site".to_owned(), p.to_string()))
6251                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6252            ),
6253            _ => local_var_req_builder.query(&[(
6254                "site",
6255                &local_var_str
6256                    .into_iter()
6257                    .map(|p| p.to_string())
6258                    .collect::<Vec<String>>()
6259                    .join(",")
6260                    .to_string(),
6261            )]),
6262        };
6263    }
6264    if let Some(ref local_var_str) = site__n {
6265        local_var_req_builder = match "multi" {
6266            "multi" => local_var_req_builder.query(
6267                &local_var_str
6268                    .into_iter()
6269                    .map(|p| ("site__n".to_owned(), p.to_string()))
6270                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6271            ),
6272            _ => local_var_req_builder.query(&[(
6273                "site__n",
6274                &local_var_str
6275                    .into_iter()
6276                    .map(|p| p.to_string())
6277                    .collect::<Vec<String>>()
6278                    .join(",")
6279                    .to_string(),
6280            )]),
6281        };
6282    }
6283    if let Some(ref local_var_str) = site_group {
6284        local_var_req_builder = match "multi" {
6285            "multi" => local_var_req_builder.query(
6286                &local_var_str
6287                    .into_iter()
6288                    .map(|p| ("site_group".to_owned(), p.to_string()))
6289                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6290            ),
6291            _ => local_var_req_builder.query(&[(
6292                "site_group",
6293                &local_var_str
6294                    .into_iter()
6295                    .map(|p| p.to_string())
6296                    .collect::<Vec<String>>()
6297                    .join(",")
6298                    .to_string(),
6299            )]),
6300        };
6301    }
6302    if let Some(ref local_var_str) = site_group__n {
6303        local_var_req_builder = match "multi" {
6304            "multi" => local_var_req_builder.query(
6305                &local_var_str
6306                    .into_iter()
6307                    .map(|p| ("site_group__n".to_owned(), p.to_string()))
6308                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6309            ),
6310            _ => local_var_req_builder.query(&[(
6311                "site_group__n",
6312                &local_var_str
6313                    .into_iter()
6314                    .map(|p| p.to_string())
6315                    .collect::<Vec<String>>()
6316                    .join(",")
6317                    .to_string(),
6318            )]),
6319        };
6320    }
6321    if let Some(ref local_var_str) = site_group_id {
6322        local_var_req_builder = match "multi" {
6323            "multi" => local_var_req_builder.query(
6324                &local_var_str
6325                    .into_iter()
6326                    .map(|p| ("site_group_id".to_owned(), p.to_string()))
6327                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6328            ),
6329            _ => local_var_req_builder.query(&[(
6330                "site_group_id",
6331                &local_var_str
6332                    .into_iter()
6333                    .map(|p| p.to_string())
6334                    .collect::<Vec<String>>()
6335                    .join(",")
6336                    .to_string(),
6337            )]),
6338        };
6339    }
6340    if let Some(ref local_var_str) = site_group_id__n {
6341        local_var_req_builder = match "multi" {
6342            "multi" => local_var_req_builder.query(
6343                &local_var_str
6344                    .into_iter()
6345                    .map(|p| ("site_group_id__n".to_owned(), p.to_string()))
6346                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6347            ),
6348            _ => local_var_req_builder.query(&[(
6349                "site_group_id__n",
6350                &local_var_str
6351                    .into_iter()
6352                    .map(|p| p.to_string())
6353                    .collect::<Vec<String>>()
6354                    .join(",")
6355                    .to_string(),
6356            )]),
6357        };
6358    }
6359    if let Some(ref local_var_str) = site_id {
6360        local_var_req_builder = match "multi" {
6361            "multi" => local_var_req_builder.query(
6362                &local_var_str
6363                    .into_iter()
6364                    .map(|p| ("site_id".to_owned(), p.to_string()))
6365                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6366            ),
6367            _ => local_var_req_builder.query(&[(
6368                "site_id",
6369                &local_var_str
6370                    .into_iter()
6371                    .map(|p| p.to_string())
6372                    .collect::<Vec<String>>()
6373                    .join(",")
6374                    .to_string(),
6375            )]),
6376        };
6377    }
6378    if let Some(ref local_var_str) = site_id__n {
6379        local_var_req_builder = match "multi" {
6380            "multi" => local_var_req_builder.query(
6381                &local_var_str
6382                    .into_iter()
6383                    .map(|p| ("site_id__n".to_owned(), p.to_string()))
6384                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6385            ),
6386            _ => local_var_req_builder.query(&[(
6387                "site_id__n",
6388                &local_var_str
6389                    .into_iter()
6390                    .map(|p| p.to_string())
6391                    .collect::<Vec<String>>()
6392                    .join(",")
6393                    .to_string(),
6394            )]),
6395        };
6396    }
6397    if let Some(ref local_var_str) = start {
6398        local_var_req_builder =
6399            local_var_req_builder.query(&[("start", &local_var_str.to_string())]);
6400    }
6401    if let Some(ref local_var_str) = status {
6402        local_var_req_builder = match "multi" {
6403            "multi" => local_var_req_builder.query(
6404                &local_var_str
6405                    .into_iter()
6406                    .map(|p| ("status".to_owned(), p.to_string()))
6407                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6408            ),
6409            _ => local_var_req_builder.query(&[(
6410                "status",
6411                &local_var_str
6412                    .into_iter()
6413                    .map(|p| p.to_string())
6414                    .collect::<Vec<String>>()
6415                    .join(",")
6416                    .to_string(),
6417            )]),
6418        };
6419    }
6420    if let Some(ref local_var_str) = status__empty {
6421        local_var_req_builder =
6422            local_var_req_builder.query(&[("status__empty", &local_var_str.to_string())]);
6423    }
6424    if let Some(ref local_var_str) = status__ic {
6425        local_var_req_builder = match "multi" {
6426            "multi" => local_var_req_builder.query(
6427                &local_var_str
6428                    .into_iter()
6429                    .map(|p| ("status__ic".to_owned(), p.to_string()))
6430                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6431            ),
6432            _ => local_var_req_builder.query(&[(
6433                "status__ic",
6434                &local_var_str
6435                    .into_iter()
6436                    .map(|p| p.to_string())
6437                    .collect::<Vec<String>>()
6438                    .join(",")
6439                    .to_string(),
6440            )]),
6441        };
6442    }
6443    if let Some(ref local_var_str) = status__ie {
6444        local_var_req_builder = match "multi" {
6445            "multi" => local_var_req_builder.query(
6446                &local_var_str
6447                    .into_iter()
6448                    .map(|p| ("status__ie".to_owned(), p.to_string()))
6449                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6450            ),
6451            _ => local_var_req_builder.query(&[(
6452                "status__ie",
6453                &local_var_str
6454                    .into_iter()
6455                    .map(|p| p.to_string())
6456                    .collect::<Vec<String>>()
6457                    .join(",")
6458                    .to_string(),
6459            )]),
6460        };
6461    }
6462    if let Some(ref local_var_str) = status__iew {
6463        local_var_req_builder = match "multi" {
6464            "multi" => local_var_req_builder.query(
6465                &local_var_str
6466                    .into_iter()
6467                    .map(|p| ("status__iew".to_owned(), p.to_string()))
6468                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6469            ),
6470            _ => local_var_req_builder.query(&[(
6471                "status__iew",
6472                &local_var_str
6473                    .into_iter()
6474                    .map(|p| p.to_string())
6475                    .collect::<Vec<String>>()
6476                    .join(",")
6477                    .to_string(),
6478            )]),
6479        };
6480    }
6481    if let Some(ref local_var_str) = status__iregex {
6482        local_var_req_builder = match "multi" {
6483            "multi" => local_var_req_builder.query(
6484                &local_var_str
6485                    .into_iter()
6486                    .map(|p| ("status__iregex".to_owned(), p.to_string()))
6487                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6488            ),
6489            _ => local_var_req_builder.query(&[(
6490                "status__iregex",
6491                &local_var_str
6492                    .into_iter()
6493                    .map(|p| p.to_string())
6494                    .collect::<Vec<String>>()
6495                    .join(",")
6496                    .to_string(),
6497            )]),
6498        };
6499    }
6500    if let Some(ref local_var_str) = status__isw {
6501        local_var_req_builder = match "multi" {
6502            "multi" => local_var_req_builder.query(
6503                &local_var_str
6504                    .into_iter()
6505                    .map(|p| ("status__isw".to_owned(), p.to_string()))
6506                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6507            ),
6508            _ => local_var_req_builder.query(&[(
6509                "status__isw",
6510                &local_var_str
6511                    .into_iter()
6512                    .map(|p| p.to_string())
6513                    .collect::<Vec<String>>()
6514                    .join(",")
6515                    .to_string(),
6516            )]),
6517        };
6518    }
6519    if let Some(ref local_var_str) = status__n {
6520        local_var_req_builder = match "multi" {
6521            "multi" => local_var_req_builder.query(
6522                &local_var_str
6523                    .into_iter()
6524                    .map(|p| ("status__n".to_owned(), p.to_string()))
6525                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6526            ),
6527            _ => local_var_req_builder.query(&[(
6528                "status__n",
6529                &local_var_str
6530                    .into_iter()
6531                    .map(|p| p.to_string())
6532                    .collect::<Vec<String>>()
6533                    .join(",")
6534                    .to_string(),
6535            )]),
6536        };
6537    }
6538    if let Some(ref local_var_str) = status__nic {
6539        local_var_req_builder = match "multi" {
6540            "multi" => local_var_req_builder.query(
6541                &local_var_str
6542                    .into_iter()
6543                    .map(|p| ("status__nic".to_owned(), p.to_string()))
6544                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6545            ),
6546            _ => local_var_req_builder.query(&[(
6547                "status__nic",
6548                &local_var_str
6549                    .into_iter()
6550                    .map(|p| p.to_string())
6551                    .collect::<Vec<String>>()
6552                    .join(",")
6553                    .to_string(),
6554            )]),
6555        };
6556    }
6557    if let Some(ref local_var_str) = status__nie {
6558        local_var_req_builder = match "multi" {
6559            "multi" => local_var_req_builder.query(
6560                &local_var_str
6561                    .into_iter()
6562                    .map(|p| ("status__nie".to_owned(), p.to_string()))
6563                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6564            ),
6565            _ => local_var_req_builder.query(&[(
6566                "status__nie",
6567                &local_var_str
6568                    .into_iter()
6569                    .map(|p| p.to_string())
6570                    .collect::<Vec<String>>()
6571                    .join(",")
6572                    .to_string(),
6573            )]),
6574        };
6575    }
6576    if let Some(ref local_var_str) = status__niew {
6577        local_var_req_builder = match "multi" {
6578            "multi" => local_var_req_builder.query(
6579                &local_var_str
6580                    .into_iter()
6581                    .map(|p| ("status__niew".to_owned(), p.to_string()))
6582                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6583            ),
6584            _ => local_var_req_builder.query(&[(
6585                "status__niew",
6586                &local_var_str
6587                    .into_iter()
6588                    .map(|p| p.to_string())
6589                    .collect::<Vec<String>>()
6590                    .join(",")
6591                    .to_string(),
6592            )]),
6593        };
6594    }
6595    if let Some(ref local_var_str) = status__nisw {
6596        local_var_req_builder = match "multi" {
6597            "multi" => local_var_req_builder.query(
6598                &local_var_str
6599                    .into_iter()
6600                    .map(|p| ("status__nisw".to_owned(), p.to_string()))
6601                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6602            ),
6603            _ => local_var_req_builder.query(&[(
6604                "status__nisw",
6605                &local_var_str
6606                    .into_iter()
6607                    .map(|p| p.to_string())
6608                    .collect::<Vec<String>>()
6609                    .join(",")
6610                    .to_string(),
6611            )]),
6612        };
6613    }
6614    if let Some(ref local_var_str) = status__regex {
6615        local_var_req_builder = match "multi" {
6616            "multi" => local_var_req_builder.query(
6617                &local_var_str
6618                    .into_iter()
6619                    .map(|p| ("status__regex".to_owned(), p.to_string()))
6620                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6621            ),
6622            _ => local_var_req_builder.query(&[(
6623                "status__regex",
6624                &local_var_str
6625                    .into_iter()
6626                    .map(|p| p.to_string())
6627                    .collect::<Vec<String>>()
6628                    .join(",")
6629                    .to_string(),
6630            )]),
6631        };
6632    }
6633    if let Some(ref local_var_str) = tag {
6634        local_var_req_builder = match "multi" {
6635            "multi" => local_var_req_builder.query(
6636                &local_var_str
6637                    .into_iter()
6638                    .map(|p| ("tag".to_owned(), p.to_string()))
6639                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6640            ),
6641            _ => local_var_req_builder.query(&[(
6642                "tag",
6643                &local_var_str
6644                    .into_iter()
6645                    .map(|p| p.to_string())
6646                    .collect::<Vec<String>>()
6647                    .join(",")
6648                    .to_string(),
6649            )]),
6650        };
6651    }
6652    if let Some(ref local_var_str) = tag__n {
6653        local_var_req_builder = match "multi" {
6654            "multi" => local_var_req_builder.query(
6655                &local_var_str
6656                    .into_iter()
6657                    .map(|p| ("tag__n".to_owned(), p.to_string()))
6658                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6659            ),
6660            _ => local_var_req_builder.query(&[(
6661                "tag__n",
6662                &local_var_str
6663                    .into_iter()
6664                    .map(|p| p.to_string())
6665                    .collect::<Vec<String>>()
6666                    .join(",")
6667                    .to_string(),
6668            )]),
6669        };
6670    }
6671    if let Some(ref local_var_str) = tag_id {
6672        local_var_req_builder = match "multi" {
6673            "multi" => local_var_req_builder.query(
6674                &local_var_str
6675                    .into_iter()
6676                    .map(|p| ("tag_id".to_owned(), p.to_string()))
6677                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6678            ),
6679            _ => local_var_req_builder.query(&[(
6680                "tag_id",
6681                &local_var_str
6682                    .into_iter()
6683                    .map(|p| p.to_string())
6684                    .collect::<Vec<String>>()
6685                    .join(",")
6686                    .to_string(),
6687            )]),
6688        };
6689    }
6690    if let Some(ref local_var_str) = tag_id__n {
6691        local_var_req_builder = match "multi" {
6692            "multi" => local_var_req_builder.query(
6693                &local_var_str
6694                    .into_iter()
6695                    .map(|p| ("tag_id__n".to_owned(), p.to_string()))
6696                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6697            ),
6698            _ => local_var_req_builder.query(&[(
6699                "tag_id__n",
6700                &local_var_str
6701                    .into_iter()
6702                    .map(|p| p.to_string())
6703                    .collect::<Vec<String>>()
6704                    .join(",")
6705                    .to_string(),
6706            )]),
6707        };
6708    }
6709    if let Some(ref local_var_str) = tenant {
6710        local_var_req_builder = match "multi" {
6711            "multi" => local_var_req_builder.query(
6712                &local_var_str
6713                    .into_iter()
6714                    .map(|p| ("tenant".to_owned(), p.to_string()))
6715                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6716            ),
6717            _ => local_var_req_builder.query(&[(
6718                "tenant",
6719                &local_var_str
6720                    .into_iter()
6721                    .map(|p| p.to_string())
6722                    .collect::<Vec<String>>()
6723                    .join(",")
6724                    .to_string(),
6725            )]),
6726        };
6727    }
6728    if let Some(ref local_var_str) = tenant__n {
6729        local_var_req_builder = match "multi" {
6730            "multi" => local_var_req_builder.query(
6731                &local_var_str
6732                    .into_iter()
6733                    .map(|p| ("tenant__n".to_owned(), p.to_string()))
6734                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6735            ),
6736            _ => local_var_req_builder.query(&[(
6737                "tenant__n",
6738                &local_var_str
6739                    .into_iter()
6740                    .map(|p| p.to_string())
6741                    .collect::<Vec<String>>()
6742                    .join(",")
6743                    .to_string(),
6744            )]),
6745        };
6746    }
6747    if let Some(ref local_var_str) = tenant_group {
6748        local_var_req_builder = match "multi" {
6749            "multi" => local_var_req_builder.query(
6750                &local_var_str
6751                    .into_iter()
6752                    .map(|p| ("tenant_group".to_owned(), p.to_string()))
6753                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6754            ),
6755            _ => local_var_req_builder.query(&[(
6756                "tenant_group",
6757                &local_var_str
6758                    .into_iter()
6759                    .map(|p| p.to_string())
6760                    .collect::<Vec<String>>()
6761                    .join(",")
6762                    .to_string(),
6763            )]),
6764        };
6765    }
6766    if let Some(ref local_var_str) = tenant_group__n {
6767        local_var_req_builder = match "multi" {
6768            "multi" => local_var_req_builder.query(
6769                &local_var_str
6770                    .into_iter()
6771                    .map(|p| ("tenant_group__n".to_owned(), p.to_string()))
6772                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6773            ),
6774            _ => local_var_req_builder.query(&[(
6775                "tenant_group__n",
6776                &local_var_str
6777                    .into_iter()
6778                    .map(|p| p.to_string())
6779                    .collect::<Vec<String>>()
6780                    .join(",")
6781                    .to_string(),
6782            )]),
6783        };
6784    }
6785    if let Some(ref local_var_str) = tenant_group_id {
6786        local_var_req_builder = match "multi" {
6787            "multi" => local_var_req_builder.query(
6788                &local_var_str
6789                    .into_iter()
6790                    .map(|p| ("tenant_group_id".to_owned(), p.to_string()))
6791                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6792            ),
6793            _ => local_var_req_builder.query(&[(
6794                "tenant_group_id",
6795                &local_var_str
6796                    .into_iter()
6797                    .map(|p| p.to_string())
6798                    .collect::<Vec<String>>()
6799                    .join(",")
6800                    .to_string(),
6801            )]),
6802        };
6803    }
6804    if let Some(ref local_var_str) = tenant_group_id__n {
6805        local_var_req_builder = match "multi" {
6806            "multi" => local_var_req_builder.query(
6807                &local_var_str
6808                    .into_iter()
6809                    .map(|p| ("tenant_group_id__n".to_owned(), p.to_string()))
6810                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6811            ),
6812            _ => local_var_req_builder.query(&[(
6813                "tenant_group_id__n",
6814                &local_var_str
6815                    .into_iter()
6816                    .map(|p| p.to_string())
6817                    .collect::<Vec<String>>()
6818                    .join(",")
6819                    .to_string(),
6820            )]),
6821        };
6822    }
6823    if let Some(ref local_var_str) = tenant_id {
6824        local_var_req_builder = match "multi" {
6825            "multi" => local_var_req_builder.query(
6826                &local_var_str
6827                    .into_iter()
6828                    .map(|p| ("tenant_id".to_owned(), p.to_string()))
6829                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6830            ),
6831            _ => local_var_req_builder.query(&[(
6832                "tenant_id",
6833                &local_var_str
6834                    .into_iter()
6835                    .map(|p| p.to_string())
6836                    .collect::<Vec<String>>()
6837                    .join(",")
6838                    .to_string(),
6839            )]),
6840        };
6841    }
6842    if let Some(ref local_var_str) = tenant_id__n {
6843        local_var_req_builder = match "multi" {
6844            "multi" => local_var_req_builder.query(
6845                &local_var_str
6846                    .into_iter()
6847                    .map(|p| ("tenant_id__n".to_owned(), p.to_string()))
6848                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6849            ),
6850            _ => local_var_req_builder.query(&[(
6851                "tenant_id__n",
6852                &local_var_str
6853                    .into_iter()
6854                    .map(|p| p.to_string())
6855                    .collect::<Vec<String>>()
6856                    .join(",")
6857                    .to_string(),
6858            )]),
6859        };
6860    }
6861    if let Some(ref local_var_str) = r#type {
6862        local_var_req_builder = match "multi" {
6863            "multi" => local_var_req_builder.query(
6864                &local_var_str
6865                    .into_iter()
6866                    .map(|p| ("type".to_owned(), p.to_string()))
6867                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6868            ),
6869            _ => local_var_req_builder.query(&[(
6870                "type",
6871                &local_var_str
6872                    .into_iter()
6873                    .map(|p| p.to_string())
6874                    .collect::<Vec<String>>()
6875                    .join(",")
6876                    .to_string(),
6877            )]),
6878        };
6879    }
6880    if let Some(ref local_var_str) = type__n {
6881        local_var_req_builder = match "multi" {
6882            "multi" => local_var_req_builder.query(
6883                &local_var_str
6884                    .into_iter()
6885                    .map(|p| ("type__n".to_owned(), p.to_string()))
6886                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6887            ),
6888            _ => local_var_req_builder.query(&[(
6889                "type__n",
6890                &local_var_str
6891                    .into_iter()
6892                    .map(|p| p.to_string())
6893                    .collect::<Vec<String>>()
6894                    .join(",")
6895                    .to_string(),
6896            )]),
6897        };
6898    }
6899    if let Some(ref local_var_str) = type_id {
6900        local_var_req_builder = match "multi" {
6901            "multi" => local_var_req_builder.query(
6902                &local_var_str
6903                    .into_iter()
6904                    .map(|p| ("type_id".to_owned(), p.to_string()))
6905                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6906            ),
6907            _ => local_var_req_builder.query(&[(
6908                "type_id",
6909                &local_var_str
6910                    .into_iter()
6911                    .map(|p| p.to_string())
6912                    .collect::<Vec<String>>()
6913                    .join(",")
6914                    .to_string(),
6915            )]),
6916        };
6917    }
6918    if let Some(ref local_var_str) = type_id__n {
6919        local_var_req_builder = match "multi" {
6920            "multi" => local_var_req_builder.query(
6921                &local_var_str
6922                    .into_iter()
6923                    .map(|p| ("type_id__n".to_owned(), p.to_string()))
6924                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6925            ),
6926            _ => local_var_req_builder.query(&[(
6927                "type_id__n",
6928                &local_var_str
6929                    .into_iter()
6930                    .map(|p| p.to_string())
6931                    .collect::<Vec<String>>()
6932                    .join(",")
6933                    .to_string(),
6934            )]),
6935        };
6936    }
6937    if let Some(ref local_var_str) = updated_by_request {
6938        local_var_req_builder =
6939            local_var_req_builder.query(&[("updated_by_request", &local_var_str.to_string())]);
6940    }
6941    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
6942        local_var_req_builder =
6943            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
6944    }
6945    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
6946        let local_var_key = local_var_apikey.key.clone();
6947        let local_var_value = match local_var_apikey.prefix {
6948            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
6949            None => local_var_key,
6950        };
6951        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
6952    };
6953
6954    let local_var_req = local_var_req_builder.build()?;
6955    let local_var_resp = local_var_client.execute(local_var_req).await?;
6956
6957    let local_var_status = local_var_resp.status();
6958    let local_var_content = local_var_resp.text().await?;
6959
6960    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
6961        serde_json::from_str(&local_var_content).map_err(Error::from)
6962    } else {
6963        let local_var_entity: Option<VirtualizationClustersListError> =
6964            serde_json::from_str(&local_var_content).ok();
6965        let local_var_error = ResponseContent {
6966            status: local_var_status,
6967            content: local_var_content,
6968            entity: local_var_entity,
6969        };
6970        Err(Error::ResponseError(local_var_error))
6971    }
6972}
6973
6974/// Patch a cluster object.
6975pub async fn virtualization_clusters_partial_update(
6976    configuration: &configuration::Configuration,
6977    id: i32,
6978    patched_writable_cluster_request: Option<crate::models::PatchedWritableClusterRequest>,
6979) -> Result<crate::models::Cluster, Error<VirtualizationClustersPartialUpdateError>> {
6980    let local_var_configuration = configuration;
6981
6982    let local_var_client = &local_var_configuration.client;
6983
6984    let local_var_uri_str = format!(
6985        "{}/api/virtualization/clusters/{id}/",
6986        local_var_configuration.base_path,
6987        id = id
6988    );
6989    let mut local_var_req_builder =
6990        local_var_client.request(reqwest::Method::PATCH, local_var_uri_str.as_str());
6991
6992    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
6993        local_var_req_builder =
6994            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
6995    }
6996    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
6997        let local_var_key = local_var_apikey.key.clone();
6998        let local_var_value = match local_var_apikey.prefix {
6999            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
7000            None => local_var_key,
7001        };
7002        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
7003    };
7004    local_var_req_builder = local_var_req_builder.json(&patched_writable_cluster_request);
7005
7006    let local_var_req = local_var_req_builder.build()?;
7007    let local_var_resp = local_var_client.execute(local_var_req).await?;
7008
7009    let local_var_status = local_var_resp.status();
7010    let local_var_content = local_var_resp.text().await?;
7011
7012    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
7013        serde_json::from_str(&local_var_content).map_err(Error::from)
7014    } else {
7015        let local_var_entity: Option<VirtualizationClustersPartialUpdateError> =
7016            serde_json::from_str(&local_var_content).ok();
7017        let local_var_error = ResponseContent {
7018            status: local_var_status,
7019            content: local_var_content,
7020            entity: local_var_entity,
7021        };
7022        Err(Error::ResponseError(local_var_error))
7023    }
7024}
7025
7026/// Get a cluster object.
7027pub async fn virtualization_clusters_retrieve(
7028    configuration: &configuration::Configuration,
7029    id: i32,
7030) -> Result<crate::models::Cluster, Error<VirtualizationClustersRetrieveError>> {
7031    let local_var_configuration = configuration;
7032
7033    let local_var_client = &local_var_configuration.client;
7034
7035    let local_var_uri_str = format!(
7036        "{}/api/virtualization/clusters/{id}/",
7037        local_var_configuration.base_path,
7038        id = id
7039    );
7040    let mut local_var_req_builder =
7041        local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
7042
7043    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
7044        local_var_req_builder =
7045            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
7046    }
7047    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
7048        let local_var_key = local_var_apikey.key.clone();
7049        let local_var_value = match local_var_apikey.prefix {
7050            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
7051            None => local_var_key,
7052        };
7053        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
7054    };
7055
7056    let local_var_req = local_var_req_builder.build()?;
7057    let local_var_resp = local_var_client.execute(local_var_req).await?;
7058
7059    let local_var_status = local_var_resp.status();
7060    let local_var_content = local_var_resp.text().await?;
7061
7062    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
7063        serde_json::from_str(&local_var_content).map_err(Error::from)
7064    } else {
7065        let local_var_entity: Option<VirtualizationClustersRetrieveError> =
7066            serde_json::from_str(&local_var_content).ok();
7067        let local_var_error = ResponseContent {
7068            status: local_var_status,
7069            content: local_var_content,
7070            entity: local_var_entity,
7071        };
7072        Err(Error::ResponseError(local_var_error))
7073    }
7074}
7075
7076/// Put a cluster object.
7077pub async fn virtualization_clusters_update(
7078    configuration: &configuration::Configuration,
7079    id: i32,
7080    writable_cluster_request: crate::models::WritableClusterRequest,
7081) -> Result<crate::models::Cluster, Error<VirtualizationClustersUpdateError>> {
7082    let local_var_configuration = configuration;
7083
7084    let local_var_client = &local_var_configuration.client;
7085
7086    let local_var_uri_str = format!(
7087        "{}/api/virtualization/clusters/{id}/",
7088        local_var_configuration.base_path,
7089        id = id
7090    );
7091    let mut local_var_req_builder =
7092        local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());
7093
7094    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
7095        local_var_req_builder =
7096            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
7097    }
7098    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
7099        let local_var_key = local_var_apikey.key.clone();
7100        let local_var_value = match local_var_apikey.prefix {
7101            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
7102            None => local_var_key,
7103        };
7104        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
7105    };
7106    local_var_req_builder = local_var_req_builder.json(&writable_cluster_request);
7107
7108    let local_var_req = local_var_req_builder.build()?;
7109    let local_var_resp = local_var_client.execute(local_var_req).await?;
7110
7111    let local_var_status = local_var_resp.status();
7112    let local_var_content = local_var_resp.text().await?;
7113
7114    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
7115        serde_json::from_str(&local_var_content).map_err(Error::from)
7116    } else {
7117        let local_var_entity: Option<VirtualizationClustersUpdateError> =
7118            serde_json::from_str(&local_var_content).ok();
7119        let local_var_error = ResponseContent {
7120            status: local_var_status,
7121            content: local_var_content,
7122            entity: local_var_entity,
7123        };
7124        Err(Error::ResponseError(local_var_error))
7125    }
7126}
7127
7128/// Delete a list of interface objects.
7129pub async fn virtualization_interfaces_bulk_destroy(
7130    configuration: &configuration::Configuration,
7131    vm_interface_request: Vec<crate::models::VmInterfaceRequest>,
7132) -> Result<(), Error<VirtualizationInterfacesBulkDestroyError>> {
7133    let local_var_configuration = configuration;
7134
7135    let local_var_client = &local_var_configuration.client;
7136
7137    let local_var_uri_str = format!(
7138        "{}/api/virtualization/interfaces/",
7139        local_var_configuration.base_path
7140    );
7141    let mut local_var_req_builder =
7142        local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());
7143
7144    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
7145        local_var_req_builder =
7146            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
7147    }
7148    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
7149        let local_var_key = local_var_apikey.key.clone();
7150        let local_var_value = match local_var_apikey.prefix {
7151            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
7152            None => local_var_key,
7153        };
7154        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
7155    };
7156    local_var_req_builder = local_var_req_builder.json(&vm_interface_request);
7157
7158    let local_var_req = local_var_req_builder.build()?;
7159    let local_var_resp = local_var_client.execute(local_var_req).await?;
7160
7161    let local_var_status = local_var_resp.status();
7162    let local_var_content = local_var_resp.text().await?;
7163
7164    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
7165        Ok(())
7166    } else {
7167        let local_var_entity: Option<VirtualizationInterfacesBulkDestroyError> =
7168            serde_json::from_str(&local_var_content).ok();
7169        let local_var_error = ResponseContent {
7170            status: local_var_status,
7171            content: local_var_content,
7172            entity: local_var_entity,
7173        };
7174        Err(Error::ResponseError(local_var_error))
7175    }
7176}
7177
7178/// Patch a list of interface objects.
7179pub async fn virtualization_interfaces_bulk_partial_update(
7180    configuration: &configuration::Configuration,
7181    vm_interface_request: Vec<crate::models::VmInterfaceRequest>,
7182) -> Result<Vec<crate::models::VmInterface>, Error<VirtualizationInterfacesBulkPartialUpdateError>>
7183{
7184    let local_var_configuration = configuration;
7185
7186    let local_var_client = &local_var_configuration.client;
7187
7188    let local_var_uri_str = format!(
7189        "{}/api/virtualization/interfaces/",
7190        local_var_configuration.base_path
7191    );
7192    let mut local_var_req_builder =
7193        local_var_client.request(reqwest::Method::PATCH, local_var_uri_str.as_str());
7194
7195    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
7196        local_var_req_builder =
7197            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
7198    }
7199    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
7200        let local_var_key = local_var_apikey.key.clone();
7201        let local_var_value = match local_var_apikey.prefix {
7202            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
7203            None => local_var_key,
7204        };
7205        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
7206    };
7207    local_var_req_builder = local_var_req_builder.json(&vm_interface_request);
7208
7209    let local_var_req = local_var_req_builder.build()?;
7210    let local_var_resp = local_var_client.execute(local_var_req).await?;
7211
7212    let local_var_status = local_var_resp.status();
7213    let local_var_content = local_var_resp.text().await?;
7214
7215    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
7216        serde_json::from_str(&local_var_content).map_err(Error::from)
7217    } else {
7218        let local_var_entity: Option<VirtualizationInterfacesBulkPartialUpdateError> =
7219            serde_json::from_str(&local_var_content).ok();
7220        let local_var_error = ResponseContent {
7221            status: local_var_status,
7222            content: local_var_content,
7223            entity: local_var_entity,
7224        };
7225        Err(Error::ResponseError(local_var_error))
7226    }
7227}
7228
7229/// Put a list of interface objects.
7230pub async fn virtualization_interfaces_bulk_update(
7231    configuration: &configuration::Configuration,
7232    vm_interface_request: Vec<crate::models::VmInterfaceRequest>,
7233) -> Result<Vec<crate::models::VmInterface>, Error<VirtualizationInterfacesBulkUpdateError>> {
7234    let local_var_configuration = configuration;
7235
7236    let local_var_client = &local_var_configuration.client;
7237
7238    let local_var_uri_str = format!(
7239        "{}/api/virtualization/interfaces/",
7240        local_var_configuration.base_path
7241    );
7242    let mut local_var_req_builder =
7243        local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());
7244
7245    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
7246        local_var_req_builder =
7247            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
7248    }
7249    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
7250        let local_var_key = local_var_apikey.key.clone();
7251        let local_var_value = match local_var_apikey.prefix {
7252            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
7253            None => local_var_key,
7254        };
7255        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
7256    };
7257    local_var_req_builder = local_var_req_builder.json(&vm_interface_request);
7258
7259    let local_var_req = local_var_req_builder.build()?;
7260    let local_var_resp = local_var_client.execute(local_var_req).await?;
7261
7262    let local_var_status = local_var_resp.status();
7263    let local_var_content = local_var_resp.text().await?;
7264
7265    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
7266        serde_json::from_str(&local_var_content).map_err(Error::from)
7267    } else {
7268        let local_var_entity: Option<VirtualizationInterfacesBulkUpdateError> =
7269            serde_json::from_str(&local_var_content).ok();
7270        let local_var_error = ResponseContent {
7271            status: local_var_status,
7272            content: local_var_content,
7273            entity: local_var_entity,
7274        };
7275        Err(Error::ResponseError(local_var_error))
7276    }
7277}
7278
7279/// Post a list of interface objects.
7280pub async fn virtualization_interfaces_create(
7281    configuration: &configuration::Configuration,
7282    virtualization_interfaces_create_request: crate::models::VirtualizationInterfacesCreateRequest,
7283) -> Result<crate::models::VmInterface, Error<VirtualizationInterfacesCreateError>> {
7284    let local_var_configuration = configuration;
7285
7286    let local_var_client = &local_var_configuration.client;
7287
7288    let local_var_uri_str = format!(
7289        "{}/api/virtualization/interfaces/",
7290        local_var_configuration.base_path
7291    );
7292    let mut local_var_req_builder =
7293        local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
7294
7295    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
7296        local_var_req_builder =
7297            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
7298    }
7299    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
7300        let local_var_key = local_var_apikey.key.clone();
7301        let local_var_value = match local_var_apikey.prefix {
7302            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
7303            None => local_var_key,
7304        };
7305        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
7306    };
7307    local_var_req_builder = local_var_req_builder.json(&virtualization_interfaces_create_request);
7308
7309    let local_var_req = local_var_req_builder.build()?;
7310    let local_var_resp = local_var_client.execute(local_var_req).await?;
7311
7312    let local_var_status = local_var_resp.status();
7313    let local_var_content = local_var_resp.text().await?;
7314
7315    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
7316        serde_json::from_str(&local_var_content).map_err(Error::from)
7317    } else {
7318        let local_var_entity: Option<VirtualizationInterfacesCreateError> =
7319            serde_json::from_str(&local_var_content).ok();
7320        let local_var_error = ResponseContent {
7321            status: local_var_status,
7322            content: local_var_content,
7323            entity: local_var_entity,
7324        };
7325        Err(Error::ResponseError(local_var_error))
7326    }
7327}
7328
7329/// Delete a interface object.
7330pub async fn virtualization_interfaces_destroy(
7331    configuration: &configuration::Configuration,
7332    id: i32,
7333) -> Result<(), Error<VirtualizationInterfacesDestroyError>> {
7334    let local_var_configuration = configuration;
7335
7336    let local_var_client = &local_var_configuration.client;
7337
7338    let local_var_uri_str = format!(
7339        "{}/api/virtualization/interfaces/{id}/",
7340        local_var_configuration.base_path,
7341        id = id
7342    );
7343    let mut local_var_req_builder =
7344        local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());
7345
7346    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
7347        local_var_req_builder =
7348            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
7349    }
7350    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
7351        let local_var_key = local_var_apikey.key.clone();
7352        let local_var_value = match local_var_apikey.prefix {
7353            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
7354            None => local_var_key,
7355        };
7356        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
7357    };
7358
7359    let local_var_req = local_var_req_builder.build()?;
7360    let local_var_resp = local_var_client.execute(local_var_req).await?;
7361
7362    let local_var_status = local_var_resp.status();
7363    let local_var_content = local_var_resp.text().await?;
7364
7365    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
7366        Ok(())
7367    } else {
7368        let local_var_entity: Option<VirtualizationInterfacesDestroyError> =
7369            serde_json::from_str(&local_var_content).ok();
7370        let local_var_error = ResponseContent {
7371            status: local_var_status,
7372            content: local_var_content,
7373            entity: local_var_entity,
7374        };
7375        Err(Error::ResponseError(local_var_error))
7376    }
7377}
7378
7379/// Get a list of interface objects.
7380pub async fn virtualization_interfaces_list(
7381    configuration: &configuration::Configuration,
7382    bridge_id: Option<Vec<i32>>,
7383    bridge_id__n: Option<Vec<i32>>,
7384    cluster: Option<Vec<String>>,
7385    cluster__n: Option<Vec<String>>,
7386    cluster_id: Option<Vec<i32>>,
7387    cluster_id__n: Option<Vec<i32>>,
7388    created: Option<Vec<String>>,
7389    created__empty: Option<Vec<String>>,
7390    created__gt: Option<Vec<String>>,
7391    created__gte: Option<Vec<String>>,
7392    created__lt: Option<Vec<String>>,
7393    created__lte: Option<Vec<String>>,
7394    created__n: Option<Vec<String>>,
7395    created_by_request: Option<&str>,
7396    description: Option<Vec<String>>,
7397    description__empty: Option<bool>,
7398    description__ic: Option<Vec<String>>,
7399    description__ie: Option<Vec<String>>,
7400    description__iew: Option<Vec<String>>,
7401    description__iregex: Option<Vec<String>>,
7402    description__isw: Option<Vec<String>>,
7403    description__n: Option<Vec<String>>,
7404    description__nic: Option<Vec<String>>,
7405    description__nie: Option<Vec<String>>,
7406    description__niew: Option<Vec<String>>,
7407    description__nisw: Option<Vec<String>>,
7408    description__regex: Option<Vec<String>>,
7409    enabled: Option<bool>,
7410    id: Option<Vec<i32>>,
7411    id__empty: Option<bool>,
7412    id__gt: Option<Vec<i32>>,
7413    id__gte: Option<Vec<i32>>,
7414    id__lt: Option<Vec<i32>>,
7415    id__lte: Option<Vec<i32>>,
7416    id__n: Option<Vec<i32>>,
7417    l2vpn: Option<Vec<i64>>,
7418    l2vpn__n: Option<Vec<i64>>,
7419    l2vpn_id: Option<Vec<i32>>,
7420    l2vpn_id__n: Option<Vec<i32>>,
7421    last_updated: Option<Vec<String>>,
7422    last_updated__empty: Option<Vec<String>>,
7423    last_updated__gt: Option<Vec<String>>,
7424    last_updated__gte: Option<Vec<String>>,
7425    last_updated__lt: Option<Vec<String>>,
7426    last_updated__lte: Option<Vec<String>>,
7427    last_updated__n: Option<Vec<String>>,
7428    limit: Option<i32>,
7429    mac_address: Option<Vec<String>>,
7430    mac_address__ic: Option<Vec<String>>,
7431    mac_address__ie: Option<Vec<String>>,
7432    mac_address__iew: Option<Vec<String>>,
7433    mac_address__iregex: Option<Vec<String>>,
7434    mac_address__isw: Option<Vec<String>>,
7435    mac_address__n: Option<Vec<String>>,
7436    mac_address__nic: Option<Vec<String>>,
7437    mac_address__nie: Option<Vec<String>>,
7438    mac_address__niew: Option<Vec<String>>,
7439    mac_address__nisw: Option<Vec<String>>,
7440    mac_address__regex: Option<Vec<String>>,
7441    mode: Option<Vec<String>>,
7442    mode__empty: Option<bool>,
7443    mode__ic: Option<Vec<String>>,
7444    mode__ie: Option<Vec<String>>,
7445    mode__iew: Option<Vec<String>>,
7446    mode__iregex: Option<Vec<String>>,
7447    mode__isw: Option<Vec<String>>,
7448    mode__n: Option<Vec<String>>,
7449    mode__nic: Option<Vec<String>>,
7450    mode__nie: Option<Vec<String>>,
7451    mode__niew: Option<Vec<String>>,
7452    mode__nisw: Option<Vec<String>>,
7453    mode__regex: Option<Vec<String>>,
7454    modified_by_request: Option<&str>,
7455    mtu: Option<Vec<i32>>,
7456    mtu__empty: Option<bool>,
7457    mtu__gt: Option<Vec<i32>>,
7458    mtu__gte: Option<Vec<i32>>,
7459    mtu__lt: Option<Vec<i32>>,
7460    mtu__lte: Option<Vec<i32>>,
7461    mtu__n: Option<Vec<i32>>,
7462    name: Option<Vec<String>>,
7463    name__empty: Option<bool>,
7464    name__ic: Option<Vec<String>>,
7465    name__ie: Option<Vec<String>>,
7466    name__iew: Option<Vec<String>>,
7467    name__iregex: Option<Vec<String>>,
7468    name__isw: Option<Vec<String>>,
7469    name__n: Option<Vec<String>>,
7470    name__nic: Option<Vec<String>>,
7471    name__nie: Option<Vec<String>>,
7472    name__niew: Option<Vec<String>>,
7473    name__nisw: Option<Vec<String>>,
7474    name__regex: Option<Vec<String>>,
7475    offset: Option<i32>,
7476    ordering: Option<&str>,
7477    owner: Option<Vec<String>>,
7478    owner__n: Option<Vec<String>>,
7479    owner_group: Option<Vec<String>>,
7480    owner_group__n: Option<Vec<String>>,
7481    owner_group_id: Option<Vec<i32>>,
7482    owner_group_id__n: Option<Vec<i32>>,
7483    owner_id: Option<Vec<i32>>,
7484    owner_id__n: Option<Vec<i32>>,
7485    parent_id: Option<Vec<i32>>,
7486    parent_id__n: Option<Vec<i32>>,
7487    primary_mac_address: Option<Vec<String>>,
7488    primary_mac_address__n: Option<Vec<String>>,
7489    primary_mac_address_id: Option<Vec<i32>>,
7490    primary_mac_address_id__n: Option<Vec<i32>>,
7491    q: Option<&str>,
7492    start: Option<i32>,
7493    tag: Option<Vec<String>>,
7494    tag__n: Option<Vec<String>>,
7495    tag_id: Option<Vec<i32>>,
7496    tag_id__n: Option<Vec<i32>>,
7497    updated_by_request: Option<&str>,
7498    virtual_machine: Option<Vec<String>>,
7499    virtual_machine__n: Option<Vec<String>>,
7500    virtual_machine_id: Option<Vec<i32>>,
7501    virtual_machine_id__n: Option<Vec<i32>>,
7502    vlan: Option<&str>,
7503    vlan_id: Option<&str>,
7504    vlan_translation_policy: Option<Vec<String>>,
7505    vlan_translation_policy__n: Option<Vec<String>>,
7506    vlan_translation_policy_id: Option<Vec<i32>>,
7507    vlan_translation_policy_id__n: Option<Vec<i32>>,
7508    vrf: Option<Vec<String>>,
7509    vrf__n: Option<Vec<String>>,
7510    vrf_id: Option<Vec<i32>>,
7511    vrf_id__n: Option<Vec<i32>>,
7512) -> Result<crate::models::PaginatedVmInterfaceList, Error<VirtualizationInterfacesListError>> {
7513    let local_var_configuration = configuration;
7514
7515    let local_var_client = &local_var_configuration.client;
7516
7517    let local_var_uri_str = format!(
7518        "{}/api/virtualization/interfaces/",
7519        local_var_configuration.base_path
7520    );
7521    let mut local_var_req_builder =
7522        local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
7523
7524    if let Some(ref local_var_str) = bridge_id {
7525        local_var_req_builder = match "multi" {
7526            "multi" => local_var_req_builder.query(
7527                &local_var_str
7528                    .into_iter()
7529                    .map(|p| ("bridge_id".to_owned(), p.to_string()))
7530                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7531            ),
7532            _ => local_var_req_builder.query(&[(
7533                "bridge_id",
7534                &local_var_str
7535                    .into_iter()
7536                    .map(|p| p.to_string())
7537                    .collect::<Vec<String>>()
7538                    .join(",")
7539                    .to_string(),
7540            )]),
7541        };
7542    }
7543    if let Some(ref local_var_str) = bridge_id__n {
7544        local_var_req_builder = match "multi" {
7545            "multi" => local_var_req_builder.query(
7546                &local_var_str
7547                    .into_iter()
7548                    .map(|p| ("bridge_id__n".to_owned(), p.to_string()))
7549                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7550            ),
7551            _ => local_var_req_builder.query(&[(
7552                "bridge_id__n",
7553                &local_var_str
7554                    .into_iter()
7555                    .map(|p| p.to_string())
7556                    .collect::<Vec<String>>()
7557                    .join(",")
7558                    .to_string(),
7559            )]),
7560        };
7561    }
7562    if let Some(ref local_var_str) = cluster {
7563        local_var_req_builder = match "multi" {
7564            "multi" => local_var_req_builder.query(
7565                &local_var_str
7566                    .into_iter()
7567                    .map(|p| ("cluster".to_owned(), p.to_string()))
7568                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7569            ),
7570            _ => local_var_req_builder.query(&[(
7571                "cluster",
7572                &local_var_str
7573                    .into_iter()
7574                    .map(|p| p.to_string())
7575                    .collect::<Vec<String>>()
7576                    .join(",")
7577                    .to_string(),
7578            )]),
7579        };
7580    }
7581    if let Some(ref local_var_str) = cluster__n {
7582        local_var_req_builder = match "multi" {
7583            "multi" => local_var_req_builder.query(
7584                &local_var_str
7585                    .into_iter()
7586                    .map(|p| ("cluster__n".to_owned(), p.to_string()))
7587                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7588            ),
7589            _ => local_var_req_builder.query(&[(
7590                "cluster__n",
7591                &local_var_str
7592                    .into_iter()
7593                    .map(|p| p.to_string())
7594                    .collect::<Vec<String>>()
7595                    .join(",")
7596                    .to_string(),
7597            )]),
7598        };
7599    }
7600    if let Some(ref local_var_str) = cluster_id {
7601        local_var_req_builder = match "multi" {
7602            "multi" => local_var_req_builder.query(
7603                &local_var_str
7604                    .into_iter()
7605                    .map(|p| ("cluster_id".to_owned(), p.to_string()))
7606                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7607            ),
7608            _ => local_var_req_builder.query(&[(
7609                "cluster_id",
7610                &local_var_str
7611                    .into_iter()
7612                    .map(|p| p.to_string())
7613                    .collect::<Vec<String>>()
7614                    .join(",")
7615                    .to_string(),
7616            )]),
7617        };
7618    }
7619    if let Some(ref local_var_str) = cluster_id__n {
7620        local_var_req_builder = match "multi" {
7621            "multi" => local_var_req_builder.query(
7622                &local_var_str
7623                    .into_iter()
7624                    .map(|p| ("cluster_id__n".to_owned(), p.to_string()))
7625                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7626            ),
7627            _ => local_var_req_builder.query(&[(
7628                "cluster_id__n",
7629                &local_var_str
7630                    .into_iter()
7631                    .map(|p| p.to_string())
7632                    .collect::<Vec<String>>()
7633                    .join(",")
7634                    .to_string(),
7635            )]),
7636        };
7637    }
7638    if let Some(ref local_var_str) = created {
7639        local_var_req_builder = match "multi" {
7640            "multi" => local_var_req_builder.query(
7641                &local_var_str
7642                    .into_iter()
7643                    .map(|p| ("created".to_owned(), p.to_string()))
7644                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7645            ),
7646            _ => local_var_req_builder.query(&[(
7647                "created",
7648                &local_var_str
7649                    .into_iter()
7650                    .map(|p| p.to_string())
7651                    .collect::<Vec<String>>()
7652                    .join(",")
7653                    .to_string(),
7654            )]),
7655        };
7656    }
7657    if let Some(ref local_var_str) = created__empty {
7658        local_var_req_builder = match "multi" {
7659            "multi" => local_var_req_builder.query(
7660                &local_var_str
7661                    .into_iter()
7662                    .map(|p| ("created__empty".to_owned(), p.to_string()))
7663                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7664            ),
7665            _ => local_var_req_builder.query(&[(
7666                "created__empty",
7667                &local_var_str
7668                    .into_iter()
7669                    .map(|p| p.to_string())
7670                    .collect::<Vec<String>>()
7671                    .join(",")
7672                    .to_string(),
7673            )]),
7674        };
7675    }
7676    if let Some(ref local_var_str) = created__gt {
7677        local_var_req_builder = match "multi" {
7678            "multi" => local_var_req_builder.query(
7679                &local_var_str
7680                    .into_iter()
7681                    .map(|p| ("created__gt".to_owned(), p.to_string()))
7682                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7683            ),
7684            _ => local_var_req_builder.query(&[(
7685                "created__gt",
7686                &local_var_str
7687                    .into_iter()
7688                    .map(|p| p.to_string())
7689                    .collect::<Vec<String>>()
7690                    .join(",")
7691                    .to_string(),
7692            )]),
7693        };
7694    }
7695    if let Some(ref local_var_str) = created__gte {
7696        local_var_req_builder = match "multi" {
7697            "multi" => local_var_req_builder.query(
7698                &local_var_str
7699                    .into_iter()
7700                    .map(|p| ("created__gte".to_owned(), p.to_string()))
7701                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7702            ),
7703            _ => local_var_req_builder.query(&[(
7704                "created__gte",
7705                &local_var_str
7706                    .into_iter()
7707                    .map(|p| p.to_string())
7708                    .collect::<Vec<String>>()
7709                    .join(",")
7710                    .to_string(),
7711            )]),
7712        };
7713    }
7714    if let Some(ref local_var_str) = created__lt {
7715        local_var_req_builder = match "multi" {
7716            "multi" => local_var_req_builder.query(
7717                &local_var_str
7718                    .into_iter()
7719                    .map(|p| ("created__lt".to_owned(), p.to_string()))
7720                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7721            ),
7722            _ => local_var_req_builder.query(&[(
7723                "created__lt",
7724                &local_var_str
7725                    .into_iter()
7726                    .map(|p| p.to_string())
7727                    .collect::<Vec<String>>()
7728                    .join(",")
7729                    .to_string(),
7730            )]),
7731        };
7732    }
7733    if let Some(ref local_var_str) = created__lte {
7734        local_var_req_builder = match "multi" {
7735            "multi" => local_var_req_builder.query(
7736                &local_var_str
7737                    .into_iter()
7738                    .map(|p| ("created__lte".to_owned(), p.to_string()))
7739                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7740            ),
7741            _ => local_var_req_builder.query(&[(
7742                "created__lte",
7743                &local_var_str
7744                    .into_iter()
7745                    .map(|p| p.to_string())
7746                    .collect::<Vec<String>>()
7747                    .join(",")
7748                    .to_string(),
7749            )]),
7750        };
7751    }
7752    if let Some(ref local_var_str) = created__n {
7753        local_var_req_builder = match "multi" {
7754            "multi" => local_var_req_builder.query(
7755                &local_var_str
7756                    .into_iter()
7757                    .map(|p| ("created__n".to_owned(), p.to_string()))
7758                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7759            ),
7760            _ => local_var_req_builder.query(&[(
7761                "created__n",
7762                &local_var_str
7763                    .into_iter()
7764                    .map(|p| p.to_string())
7765                    .collect::<Vec<String>>()
7766                    .join(",")
7767                    .to_string(),
7768            )]),
7769        };
7770    }
7771    if let Some(ref local_var_str) = created_by_request {
7772        local_var_req_builder =
7773            local_var_req_builder.query(&[("created_by_request", &local_var_str.to_string())]);
7774    }
7775    if let Some(ref local_var_str) = description {
7776        local_var_req_builder = match "multi" {
7777            "multi" => local_var_req_builder.query(
7778                &local_var_str
7779                    .into_iter()
7780                    .map(|p| ("description".to_owned(), p.to_string()))
7781                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7782            ),
7783            _ => local_var_req_builder.query(&[(
7784                "description",
7785                &local_var_str
7786                    .into_iter()
7787                    .map(|p| p.to_string())
7788                    .collect::<Vec<String>>()
7789                    .join(",")
7790                    .to_string(),
7791            )]),
7792        };
7793    }
7794    if let Some(ref local_var_str) = description__empty {
7795        local_var_req_builder =
7796            local_var_req_builder.query(&[("description__empty", &local_var_str.to_string())]);
7797    }
7798    if let Some(ref local_var_str) = description__ic {
7799        local_var_req_builder = match "multi" {
7800            "multi" => local_var_req_builder.query(
7801                &local_var_str
7802                    .into_iter()
7803                    .map(|p| ("description__ic".to_owned(), p.to_string()))
7804                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7805            ),
7806            _ => local_var_req_builder.query(&[(
7807                "description__ic",
7808                &local_var_str
7809                    .into_iter()
7810                    .map(|p| p.to_string())
7811                    .collect::<Vec<String>>()
7812                    .join(",")
7813                    .to_string(),
7814            )]),
7815        };
7816    }
7817    if let Some(ref local_var_str) = description__ie {
7818        local_var_req_builder = match "multi" {
7819            "multi" => local_var_req_builder.query(
7820                &local_var_str
7821                    .into_iter()
7822                    .map(|p| ("description__ie".to_owned(), p.to_string()))
7823                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7824            ),
7825            _ => local_var_req_builder.query(&[(
7826                "description__ie",
7827                &local_var_str
7828                    .into_iter()
7829                    .map(|p| p.to_string())
7830                    .collect::<Vec<String>>()
7831                    .join(",")
7832                    .to_string(),
7833            )]),
7834        };
7835    }
7836    if let Some(ref local_var_str) = description__iew {
7837        local_var_req_builder = match "multi" {
7838            "multi" => local_var_req_builder.query(
7839                &local_var_str
7840                    .into_iter()
7841                    .map(|p| ("description__iew".to_owned(), p.to_string()))
7842                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7843            ),
7844            _ => local_var_req_builder.query(&[(
7845                "description__iew",
7846                &local_var_str
7847                    .into_iter()
7848                    .map(|p| p.to_string())
7849                    .collect::<Vec<String>>()
7850                    .join(",")
7851                    .to_string(),
7852            )]),
7853        };
7854    }
7855    if let Some(ref local_var_str) = description__iregex {
7856        local_var_req_builder = match "multi" {
7857            "multi" => local_var_req_builder.query(
7858                &local_var_str
7859                    .into_iter()
7860                    .map(|p| ("description__iregex".to_owned(), p.to_string()))
7861                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7862            ),
7863            _ => local_var_req_builder.query(&[(
7864                "description__iregex",
7865                &local_var_str
7866                    .into_iter()
7867                    .map(|p| p.to_string())
7868                    .collect::<Vec<String>>()
7869                    .join(",")
7870                    .to_string(),
7871            )]),
7872        };
7873    }
7874    if let Some(ref local_var_str) = description__isw {
7875        local_var_req_builder = match "multi" {
7876            "multi" => local_var_req_builder.query(
7877                &local_var_str
7878                    .into_iter()
7879                    .map(|p| ("description__isw".to_owned(), p.to_string()))
7880                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7881            ),
7882            _ => local_var_req_builder.query(&[(
7883                "description__isw",
7884                &local_var_str
7885                    .into_iter()
7886                    .map(|p| p.to_string())
7887                    .collect::<Vec<String>>()
7888                    .join(",")
7889                    .to_string(),
7890            )]),
7891        };
7892    }
7893    if let Some(ref local_var_str) = description__n {
7894        local_var_req_builder = match "multi" {
7895            "multi" => local_var_req_builder.query(
7896                &local_var_str
7897                    .into_iter()
7898                    .map(|p| ("description__n".to_owned(), p.to_string()))
7899                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7900            ),
7901            _ => local_var_req_builder.query(&[(
7902                "description__n",
7903                &local_var_str
7904                    .into_iter()
7905                    .map(|p| p.to_string())
7906                    .collect::<Vec<String>>()
7907                    .join(",")
7908                    .to_string(),
7909            )]),
7910        };
7911    }
7912    if let Some(ref local_var_str) = description__nic {
7913        local_var_req_builder = match "multi" {
7914            "multi" => local_var_req_builder.query(
7915                &local_var_str
7916                    .into_iter()
7917                    .map(|p| ("description__nic".to_owned(), p.to_string()))
7918                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7919            ),
7920            _ => local_var_req_builder.query(&[(
7921                "description__nic",
7922                &local_var_str
7923                    .into_iter()
7924                    .map(|p| p.to_string())
7925                    .collect::<Vec<String>>()
7926                    .join(",")
7927                    .to_string(),
7928            )]),
7929        };
7930    }
7931    if let Some(ref local_var_str) = description__nie {
7932        local_var_req_builder = match "multi" {
7933            "multi" => local_var_req_builder.query(
7934                &local_var_str
7935                    .into_iter()
7936                    .map(|p| ("description__nie".to_owned(), p.to_string()))
7937                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7938            ),
7939            _ => local_var_req_builder.query(&[(
7940                "description__nie",
7941                &local_var_str
7942                    .into_iter()
7943                    .map(|p| p.to_string())
7944                    .collect::<Vec<String>>()
7945                    .join(",")
7946                    .to_string(),
7947            )]),
7948        };
7949    }
7950    if let Some(ref local_var_str) = description__niew {
7951        local_var_req_builder = match "multi" {
7952            "multi" => local_var_req_builder.query(
7953                &local_var_str
7954                    .into_iter()
7955                    .map(|p| ("description__niew".to_owned(), p.to_string()))
7956                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7957            ),
7958            _ => local_var_req_builder.query(&[(
7959                "description__niew",
7960                &local_var_str
7961                    .into_iter()
7962                    .map(|p| p.to_string())
7963                    .collect::<Vec<String>>()
7964                    .join(",")
7965                    .to_string(),
7966            )]),
7967        };
7968    }
7969    if let Some(ref local_var_str) = description__nisw {
7970        local_var_req_builder = match "multi" {
7971            "multi" => local_var_req_builder.query(
7972                &local_var_str
7973                    .into_iter()
7974                    .map(|p| ("description__nisw".to_owned(), p.to_string()))
7975                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7976            ),
7977            _ => local_var_req_builder.query(&[(
7978                "description__nisw",
7979                &local_var_str
7980                    .into_iter()
7981                    .map(|p| p.to_string())
7982                    .collect::<Vec<String>>()
7983                    .join(",")
7984                    .to_string(),
7985            )]),
7986        };
7987    }
7988    if let Some(ref local_var_str) = description__regex {
7989        local_var_req_builder = match "multi" {
7990            "multi" => local_var_req_builder.query(
7991                &local_var_str
7992                    .into_iter()
7993                    .map(|p| ("description__regex".to_owned(), p.to_string()))
7994                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7995            ),
7996            _ => local_var_req_builder.query(&[(
7997                "description__regex",
7998                &local_var_str
7999                    .into_iter()
8000                    .map(|p| p.to_string())
8001                    .collect::<Vec<String>>()
8002                    .join(",")
8003                    .to_string(),
8004            )]),
8005        };
8006    }
8007    if let Some(ref local_var_str) = enabled {
8008        local_var_req_builder =
8009            local_var_req_builder.query(&[("enabled", &local_var_str.to_string())]);
8010    }
8011    if let Some(ref local_var_str) = id {
8012        local_var_req_builder = match "multi" {
8013            "multi" => local_var_req_builder.query(
8014                &local_var_str
8015                    .into_iter()
8016                    .map(|p| ("id".to_owned(), p.to_string()))
8017                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8018            ),
8019            _ => local_var_req_builder.query(&[(
8020                "id",
8021                &local_var_str
8022                    .into_iter()
8023                    .map(|p| p.to_string())
8024                    .collect::<Vec<String>>()
8025                    .join(",")
8026                    .to_string(),
8027            )]),
8028        };
8029    }
8030    if let Some(ref local_var_str) = id__empty {
8031        local_var_req_builder =
8032            local_var_req_builder.query(&[("id__empty", &local_var_str.to_string())]);
8033    }
8034    if let Some(ref local_var_str) = id__gt {
8035        local_var_req_builder = match "multi" {
8036            "multi" => local_var_req_builder.query(
8037                &local_var_str
8038                    .into_iter()
8039                    .map(|p| ("id__gt".to_owned(), p.to_string()))
8040                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8041            ),
8042            _ => local_var_req_builder.query(&[(
8043                "id__gt",
8044                &local_var_str
8045                    .into_iter()
8046                    .map(|p| p.to_string())
8047                    .collect::<Vec<String>>()
8048                    .join(",")
8049                    .to_string(),
8050            )]),
8051        };
8052    }
8053    if let Some(ref local_var_str) = id__gte {
8054        local_var_req_builder = match "multi" {
8055            "multi" => local_var_req_builder.query(
8056                &local_var_str
8057                    .into_iter()
8058                    .map(|p| ("id__gte".to_owned(), p.to_string()))
8059                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8060            ),
8061            _ => local_var_req_builder.query(&[(
8062                "id__gte",
8063                &local_var_str
8064                    .into_iter()
8065                    .map(|p| p.to_string())
8066                    .collect::<Vec<String>>()
8067                    .join(",")
8068                    .to_string(),
8069            )]),
8070        };
8071    }
8072    if let Some(ref local_var_str) = id__lt {
8073        local_var_req_builder = match "multi" {
8074            "multi" => local_var_req_builder.query(
8075                &local_var_str
8076                    .into_iter()
8077                    .map(|p| ("id__lt".to_owned(), p.to_string()))
8078                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8079            ),
8080            _ => local_var_req_builder.query(&[(
8081                "id__lt",
8082                &local_var_str
8083                    .into_iter()
8084                    .map(|p| p.to_string())
8085                    .collect::<Vec<String>>()
8086                    .join(",")
8087                    .to_string(),
8088            )]),
8089        };
8090    }
8091    if let Some(ref local_var_str) = id__lte {
8092        local_var_req_builder = match "multi" {
8093            "multi" => local_var_req_builder.query(
8094                &local_var_str
8095                    .into_iter()
8096                    .map(|p| ("id__lte".to_owned(), p.to_string()))
8097                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8098            ),
8099            _ => local_var_req_builder.query(&[(
8100                "id__lte",
8101                &local_var_str
8102                    .into_iter()
8103                    .map(|p| p.to_string())
8104                    .collect::<Vec<String>>()
8105                    .join(",")
8106                    .to_string(),
8107            )]),
8108        };
8109    }
8110    if let Some(ref local_var_str) = id__n {
8111        local_var_req_builder = match "multi" {
8112            "multi" => local_var_req_builder.query(
8113                &local_var_str
8114                    .into_iter()
8115                    .map(|p| ("id__n".to_owned(), p.to_string()))
8116                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8117            ),
8118            _ => local_var_req_builder.query(&[(
8119                "id__n",
8120                &local_var_str
8121                    .into_iter()
8122                    .map(|p| p.to_string())
8123                    .collect::<Vec<String>>()
8124                    .join(",")
8125                    .to_string(),
8126            )]),
8127        };
8128    }
8129    if let Some(ref local_var_str) = l2vpn {
8130        local_var_req_builder = match "multi" {
8131            "multi" => local_var_req_builder.query(
8132                &local_var_str
8133                    .into_iter()
8134                    .map(|p| ("l2vpn".to_owned(), p.to_string()))
8135                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8136            ),
8137            _ => local_var_req_builder.query(&[(
8138                "l2vpn",
8139                &local_var_str
8140                    .into_iter()
8141                    .map(|p| p.to_string())
8142                    .collect::<Vec<String>>()
8143                    .join(",")
8144                    .to_string(),
8145            )]),
8146        };
8147    }
8148    if let Some(ref local_var_str) = l2vpn__n {
8149        local_var_req_builder = match "multi" {
8150            "multi" => local_var_req_builder.query(
8151                &local_var_str
8152                    .into_iter()
8153                    .map(|p| ("l2vpn__n".to_owned(), p.to_string()))
8154                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8155            ),
8156            _ => local_var_req_builder.query(&[(
8157                "l2vpn__n",
8158                &local_var_str
8159                    .into_iter()
8160                    .map(|p| p.to_string())
8161                    .collect::<Vec<String>>()
8162                    .join(",")
8163                    .to_string(),
8164            )]),
8165        };
8166    }
8167    if let Some(ref local_var_str) = l2vpn_id {
8168        local_var_req_builder = match "multi" {
8169            "multi" => local_var_req_builder.query(
8170                &local_var_str
8171                    .into_iter()
8172                    .map(|p| ("l2vpn_id".to_owned(), p.to_string()))
8173                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8174            ),
8175            _ => local_var_req_builder.query(&[(
8176                "l2vpn_id",
8177                &local_var_str
8178                    .into_iter()
8179                    .map(|p| p.to_string())
8180                    .collect::<Vec<String>>()
8181                    .join(",")
8182                    .to_string(),
8183            )]),
8184        };
8185    }
8186    if let Some(ref local_var_str) = l2vpn_id__n {
8187        local_var_req_builder = match "multi" {
8188            "multi" => local_var_req_builder.query(
8189                &local_var_str
8190                    .into_iter()
8191                    .map(|p| ("l2vpn_id__n".to_owned(), p.to_string()))
8192                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8193            ),
8194            _ => local_var_req_builder.query(&[(
8195                "l2vpn_id__n",
8196                &local_var_str
8197                    .into_iter()
8198                    .map(|p| p.to_string())
8199                    .collect::<Vec<String>>()
8200                    .join(",")
8201                    .to_string(),
8202            )]),
8203        };
8204    }
8205    if let Some(ref local_var_str) = last_updated {
8206        local_var_req_builder = match "multi" {
8207            "multi" => local_var_req_builder.query(
8208                &local_var_str
8209                    .into_iter()
8210                    .map(|p| ("last_updated".to_owned(), p.to_string()))
8211                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8212            ),
8213            _ => local_var_req_builder.query(&[(
8214                "last_updated",
8215                &local_var_str
8216                    .into_iter()
8217                    .map(|p| p.to_string())
8218                    .collect::<Vec<String>>()
8219                    .join(",")
8220                    .to_string(),
8221            )]),
8222        };
8223    }
8224    if let Some(ref local_var_str) = last_updated__empty {
8225        local_var_req_builder = match "multi" {
8226            "multi" => local_var_req_builder.query(
8227                &local_var_str
8228                    .into_iter()
8229                    .map(|p| ("last_updated__empty".to_owned(), p.to_string()))
8230                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8231            ),
8232            _ => local_var_req_builder.query(&[(
8233                "last_updated__empty",
8234                &local_var_str
8235                    .into_iter()
8236                    .map(|p| p.to_string())
8237                    .collect::<Vec<String>>()
8238                    .join(",")
8239                    .to_string(),
8240            )]),
8241        };
8242    }
8243    if let Some(ref local_var_str) = last_updated__gt {
8244        local_var_req_builder = match "multi" {
8245            "multi" => local_var_req_builder.query(
8246                &local_var_str
8247                    .into_iter()
8248                    .map(|p| ("last_updated__gt".to_owned(), p.to_string()))
8249                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8250            ),
8251            _ => local_var_req_builder.query(&[(
8252                "last_updated__gt",
8253                &local_var_str
8254                    .into_iter()
8255                    .map(|p| p.to_string())
8256                    .collect::<Vec<String>>()
8257                    .join(",")
8258                    .to_string(),
8259            )]),
8260        };
8261    }
8262    if let Some(ref local_var_str) = last_updated__gte {
8263        local_var_req_builder = match "multi" {
8264            "multi" => local_var_req_builder.query(
8265                &local_var_str
8266                    .into_iter()
8267                    .map(|p| ("last_updated__gte".to_owned(), p.to_string()))
8268                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8269            ),
8270            _ => local_var_req_builder.query(&[(
8271                "last_updated__gte",
8272                &local_var_str
8273                    .into_iter()
8274                    .map(|p| p.to_string())
8275                    .collect::<Vec<String>>()
8276                    .join(",")
8277                    .to_string(),
8278            )]),
8279        };
8280    }
8281    if let Some(ref local_var_str) = last_updated__lt {
8282        local_var_req_builder = match "multi" {
8283            "multi" => local_var_req_builder.query(
8284                &local_var_str
8285                    .into_iter()
8286                    .map(|p| ("last_updated__lt".to_owned(), p.to_string()))
8287                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8288            ),
8289            _ => local_var_req_builder.query(&[(
8290                "last_updated__lt",
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) = last_updated__lte {
8301        local_var_req_builder = match "multi" {
8302            "multi" => local_var_req_builder.query(
8303                &local_var_str
8304                    .into_iter()
8305                    .map(|p| ("last_updated__lte".to_owned(), p.to_string()))
8306                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8307            ),
8308            _ => local_var_req_builder.query(&[(
8309                "last_updated__lte",
8310                &local_var_str
8311                    .into_iter()
8312                    .map(|p| p.to_string())
8313                    .collect::<Vec<String>>()
8314                    .join(",")
8315                    .to_string(),
8316            )]),
8317        };
8318    }
8319    if let Some(ref local_var_str) = last_updated__n {
8320        local_var_req_builder = match "multi" {
8321            "multi" => local_var_req_builder.query(
8322                &local_var_str
8323                    .into_iter()
8324                    .map(|p| ("last_updated__n".to_owned(), p.to_string()))
8325                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8326            ),
8327            _ => local_var_req_builder.query(&[(
8328                "last_updated__n",
8329                &local_var_str
8330                    .into_iter()
8331                    .map(|p| p.to_string())
8332                    .collect::<Vec<String>>()
8333                    .join(",")
8334                    .to_string(),
8335            )]),
8336        };
8337    }
8338    if let Some(ref local_var_str) = limit {
8339        local_var_req_builder =
8340            local_var_req_builder.query(&[("limit", &local_var_str.to_string())]);
8341    }
8342    if let Some(ref local_var_str) = mac_address {
8343        local_var_req_builder = match "multi" {
8344            "multi" => local_var_req_builder.query(
8345                &local_var_str
8346                    .into_iter()
8347                    .map(|p| ("mac_address".to_owned(), p.to_string()))
8348                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8349            ),
8350            _ => local_var_req_builder.query(&[(
8351                "mac_address",
8352                &local_var_str
8353                    .into_iter()
8354                    .map(|p| p.to_string())
8355                    .collect::<Vec<String>>()
8356                    .join(",")
8357                    .to_string(),
8358            )]),
8359        };
8360    }
8361    if let Some(ref local_var_str) = mac_address__ic {
8362        local_var_req_builder = match "multi" {
8363            "multi" => local_var_req_builder.query(
8364                &local_var_str
8365                    .into_iter()
8366                    .map(|p| ("mac_address__ic".to_owned(), p.to_string()))
8367                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8368            ),
8369            _ => local_var_req_builder.query(&[(
8370                "mac_address__ic",
8371                &local_var_str
8372                    .into_iter()
8373                    .map(|p| p.to_string())
8374                    .collect::<Vec<String>>()
8375                    .join(",")
8376                    .to_string(),
8377            )]),
8378        };
8379    }
8380    if let Some(ref local_var_str) = mac_address__ie {
8381        local_var_req_builder = match "multi" {
8382            "multi" => local_var_req_builder.query(
8383                &local_var_str
8384                    .into_iter()
8385                    .map(|p| ("mac_address__ie".to_owned(), p.to_string()))
8386                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8387            ),
8388            _ => local_var_req_builder.query(&[(
8389                "mac_address__ie",
8390                &local_var_str
8391                    .into_iter()
8392                    .map(|p| p.to_string())
8393                    .collect::<Vec<String>>()
8394                    .join(",")
8395                    .to_string(),
8396            )]),
8397        };
8398    }
8399    if let Some(ref local_var_str) = mac_address__iew {
8400        local_var_req_builder = match "multi" {
8401            "multi" => local_var_req_builder.query(
8402                &local_var_str
8403                    .into_iter()
8404                    .map(|p| ("mac_address__iew".to_owned(), p.to_string()))
8405                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8406            ),
8407            _ => local_var_req_builder.query(&[(
8408                "mac_address__iew",
8409                &local_var_str
8410                    .into_iter()
8411                    .map(|p| p.to_string())
8412                    .collect::<Vec<String>>()
8413                    .join(",")
8414                    .to_string(),
8415            )]),
8416        };
8417    }
8418    if let Some(ref local_var_str) = mac_address__iregex {
8419        local_var_req_builder = match "multi" {
8420            "multi" => local_var_req_builder.query(
8421                &local_var_str
8422                    .into_iter()
8423                    .map(|p| ("mac_address__iregex".to_owned(), p.to_string()))
8424                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8425            ),
8426            _ => local_var_req_builder.query(&[(
8427                "mac_address__iregex",
8428                &local_var_str
8429                    .into_iter()
8430                    .map(|p| p.to_string())
8431                    .collect::<Vec<String>>()
8432                    .join(",")
8433                    .to_string(),
8434            )]),
8435        };
8436    }
8437    if let Some(ref local_var_str) = mac_address__isw {
8438        local_var_req_builder = match "multi" {
8439            "multi" => local_var_req_builder.query(
8440                &local_var_str
8441                    .into_iter()
8442                    .map(|p| ("mac_address__isw".to_owned(), p.to_string()))
8443                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8444            ),
8445            _ => local_var_req_builder.query(&[(
8446                "mac_address__isw",
8447                &local_var_str
8448                    .into_iter()
8449                    .map(|p| p.to_string())
8450                    .collect::<Vec<String>>()
8451                    .join(",")
8452                    .to_string(),
8453            )]),
8454        };
8455    }
8456    if let Some(ref local_var_str) = mac_address__n {
8457        local_var_req_builder = match "multi" {
8458            "multi" => local_var_req_builder.query(
8459                &local_var_str
8460                    .into_iter()
8461                    .map(|p| ("mac_address__n".to_owned(), p.to_string()))
8462                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8463            ),
8464            _ => local_var_req_builder.query(&[(
8465                "mac_address__n",
8466                &local_var_str
8467                    .into_iter()
8468                    .map(|p| p.to_string())
8469                    .collect::<Vec<String>>()
8470                    .join(",")
8471                    .to_string(),
8472            )]),
8473        };
8474    }
8475    if let Some(ref local_var_str) = mac_address__nic {
8476        local_var_req_builder = match "multi" {
8477            "multi" => local_var_req_builder.query(
8478                &local_var_str
8479                    .into_iter()
8480                    .map(|p| ("mac_address__nic".to_owned(), p.to_string()))
8481                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8482            ),
8483            _ => local_var_req_builder.query(&[(
8484                "mac_address__nic",
8485                &local_var_str
8486                    .into_iter()
8487                    .map(|p| p.to_string())
8488                    .collect::<Vec<String>>()
8489                    .join(",")
8490                    .to_string(),
8491            )]),
8492        };
8493    }
8494    if let Some(ref local_var_str) = mac_address__nie {
8495        local_var_req_builder = match "multi" {
8496            "multi" => local_var_req_builder.query(
8497                &local_var_str
8498                    .into_iter()
8499                    .map(|p| ("mac_address__nie".to_owned(), p.to_string()))
8500                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8501            ),
8502            _ => local_var_req_builder.query(&[(
8503                "mac_address__nie",
8504                &local_var_str
8505                    .into_iter()
8506                    .map(|p| p.to_string())
8507                    .collect::<Vec<String>>()
8508                    .join(",")
8509                    .to_string(),
8510            )]),
8511        };
8512    }
8513    if let Some(ref local_var_str) = mac_address__niew {
8514        local_var_req_builder = match "multi" {
8515            "multi" => local_var_req_builder.query(
8516                &local_var_str
8517                    .into_iter()
8518                    .map(|p| ("mac_address__niew".to_owned(), p.to_string()))
8519                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8520            ),
8521            _ => local_var_req_builder.query(&[(
8522                "mac_address__niew",
8523                &local_var_str
8524                    .into_iter()
8525                    .map(|p| p.to_string())
8526                    .collect::<Vec<String>>()
8527                    .join(",")
8528                    .to_string(),
8529            )]),
8530        };
8531    }
8532    if let Some(ref local_var_str) = mac_address__nisw {
8533        local_var_req_builder = match "multi" {
8534            "multi" => local_var_req_builder.query(
8535                &local_var_str
8536                    .into_iter()
8537                    .map(|p| ("mac_address__nisw".to_owned(), p.to_string()))
8538                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8539            ),
8540            _ => local_var_req_builder.query(&[(
8541                "mac_address__nisw",
8542                &local_var_str
8543                    .into_iter()
8544                    .map(|p| p.to_string())
8545                    .collect::<Vec<String>>()
8546                    .join(",")
8547                    .to_string(),
8548            )]),
8549        };
8550    }
8551    if let Some(ref local_var_str) = mac_address__regex {
8552        local_var_req_builder = match "multi" {
8553            "multi" => local_var_req_builder.query(
8554                &local_var_str
8555                    .into_iter()
8556                    .map(|p| ("mac_address__regex".to_owned(), p.to_string()))
8557                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8558            ),
8559            _ => local_var_req_builder.query(&[(
8560                "mac_address__regex",
8561                &local_var_str
8562                    .into_iter()
8563                    .map(|p| p.to_string())
8564                    .collect::<Vec<String>>()
8565                    .join(",")
8566                    .to_string(),
8567            )]),
8568        };
8569    }
8570    if let Some(ref local_var_str) = mode {
8571        local_var_req_builder = match "multi" {
8572            "multi" => local_var_req_builder.query(
8573                &local_var_str
8574                    .into_iter()
8575                    .map(|p| ("mode".to_owned(), p.to_string()))
8576                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8577            ),
8578            _ => local_var_req_builder.query(&[(
8579                "mode",
8580                &local_var_str
8581                    .into_iter()
8582                    .map(|p| p.to_string())
8583                    .collect::<Vec<String>>()
8584                    .join(",")
8585                    .to_string(),
8586            )]),
8587        };
8588    }
8589    if let Some(ref local_var_str) = mode__empty {
8590        local_var_req_builder =
8591            local_var_req_builder.query(&[("mode__empty", &local_var_str.to_string())]);
8592    }
8593    if let Some(ref local_var_str) = mode__ic {
8594        local_var_req_builder = match "multi" {
8595            "multi" => local_var_req_builder.query(
8596                &local_var_str
8597                    .into_iter()
8598                    .map(|p| ("mode__ic".to_owned(), p.to_string()))
8599                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8600            ),
8601            _ => local_var_req_builder.query(&[(
8602                "mode__ic",
8603                &local_var_str
8604                    .into_iter()
8605                    .map(|p| p.to_string())
8606                    .collect::<Vec<String>>()
8607                    .join(",")
8608                    .to_string(),
8609            )]),
8610        };
8611    }
8612    if let Some(ref local_var_str) = mode__ie {
8613        local_var_req_builder = match "multi" {
8614            "multi" => local_var_req_builder.query(
8615                &local_var_str
8616                    .into_iter()
8617                    .map(|p| ("mode__ie".to_owned(), p.to_string()))
8618                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8619            ),
8620            _ => local_var_req_builder.query(&[(
8621                "mode__ie",
8622                &local_var_str
8623                    .into_iter()
8624                    .map(|p| p.to_string())
8625                    .collect::<Vec<String>>()
8626                    .join(",")
8627                    .to_string(),
8628            )]),
8629        };
8630    }
8631    if let Some(ref local_var_str) = mode__iew {
8632        local_var_req_builder = match "multi" {
8633            "multi" => local_var_req_builder.query(
8634                &local_var_str
8635                    .into_iter()
8636                    .map(|p| ("mode__iew".to_owned(), p.to_string()))
8637                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8638            ),
8639            _ => local_var_req_builder.query(&[(
8640                "mode__iew",
8641                &local_var_str
8642                    .into_iter()
8643                    .map(|p| p.to_string())
8644                    .collect::<Vec<String>>()
8645                    .join(",")
8646                    .to_string(),
8647            )]),
8648        };
8649    }
8650    if let Some(ref local_var_str) = mode__iregex {
8651        local_var_req_builder = match "multi" {
8652            "multi" => local_var_req_builder.query(
8653                &local_var_str
8654                    .into_iter()
8655                    .map(|p| ("mode__iregex".to_owned(), p.to_string()))
8656                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8657            ),
8658            _ => local_var_req_builder.query(&[(
8659                "mode__iregex",
8660                &local_var_str
8661                    .into_iter()
8662                    .map(|p| p.to_string())
8663                    .collect::<Vec<String>>()
8664                    .join(",")
8665                    .to_string(),
8666            )]),
8667        };
8668    }
8669    if let Some(ref local_var_str) = mode__isw {
8670        local_var_req_builder = match "multi" {
8671            "multi" => local_var_req_builder.query(
8672                &local_var_str
8673                    .into_iter()
8674                    .map(|p| ("mode__isw".to_owned(), p.to_string()))
8675                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8676            ),
8677            _ => local_var_req_builder.query(&[(
8678                "mode__isw",
8679                &local_var_str
8680                    .into_iter()
8681                    .map(|p| p.to_string())
8682                    .collect::<Vec<String>>()
8683                    .join(",")
8684                    .to_string(),
8685            )]),
8686        };
8687    }
8688    if let Some(ref local_var_str) = mode__n {
8689        local_var_req_builder = match "multi" {
8690            "multi" => local_var_req_builder.query(
8691                &local_var_str
8692                    .into_iter()
8693                    .map(|p| ("mode__n".to_owned(), p.to_string()))
8694                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8695            ),
8696            _ => local_var_req_builder.query(&[(
8697                "mode__n",
8698                &local_var_str
8699                    .into_iter()
8700                    .map(|p| p.to_string())
8701                    .collect::<Vec<String>>()
8702                    .join(",")
8703                    .to_string(),
8704            )]),
8705        };
8706    }
8707    if let Some(ref local_var_str) = mode__nic {
8708        local_var_req_builder = match "multi" {
8709            "multi" => local_var_req_builder.query(
8710                &local_var_str
8711                    .into_iter()
8712                    .map(|p| ("mode__nic".to_owned(), p.to_string()))
8713                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8714            ),
8715            _ => local_var_req_builder.query(&[(
8716                "mode__nic",
8717                &local_var_str
8718                    .into_iter()
8719                    .map(|p| p.to_string())
8720                    .collect::<Vec<String>>()
8721                    .join(",")
8722                    .to_string(),
8723            )]),
8724        };
8725    }
8726    if let Some(ref local_var_str) = mode__nie {
8727        local_var_req_builder = match "multi" {
8728            "multi" => local_var_req_builder.query(
8729                &local_var_str
8730                    .into_iter()
8731                    .map(|p| ("mode__nie".to_owned(), p.to_string()))
8732                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8733            ),
8734            _ => local_var_req_builder.query(&[(
8735                "mode__nie",
8736                &local_var_str
8737                    .into_iter()
8738                    .map(|p| p.to_string())
8739                    .collect::<Vec<String>>()
8740                    .join(",")
8741                    .to_string(),
8742            )]),
8743        };
8744    }
8745    if let Some(ref local_var_str) = mode__niew {
8746        local_var_req_builder = match "multi" {
8747            "multi" => local_var_req_builder.query(
8748                &local_var_str
8749                    .into_iter()
8750                    .map(|p| ("mode__niew".to_owned(), p.to_string()))
8751                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8752            ),
8753            _ => local_var_req_builder.query(&[(
8754                "mode__niew",
8755                &local_var_str
8756                    .into_iter()
8757                    .map(|p| p.to_string())
8758                    .collect::<Vec<String>>()
8759                    .join(",")
8760                    .to_string(),
8761            )]),
8762        };
8763    }
8764    if let Some(ref local_var_str) = mode__nisw {
8765        local_var_req_builder = match "multi" {
8766            "multi" => local_var_req_builder.query(
8767                &local_var_str
8768                    .into_iter()
8769                    .map(|p| ("mode__nisw".to_owned(), p.to_string()))
8770                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8771            ),
8772            _ => local_var_req_builder.query(&[(
8773                "mode__nisw",
8774                &local_var_str
8775                    .into_iter()
8776                    .map(|p| p.to_string())
8777                    .collect::<Vec<String>>()
8778                    .join(",")
8779                    .to_string(),
8780            )]),
8781        };
8782    }
8783    if let Some(ref local_var_str) = mode__regex {
8784        local_var_req_builder = match "multi" {
8785            "multi" => local_var_req_builder.query(
8786                &local_var_str
8787                    .into_iter()
8788                    .map(|p| ("mode__regex".to_owned(), p.to_string()))
8789                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8790            ),
8791            _ => local_var_req_builder.query(&[(
8792                "mode__regex",
8793                &local_var_str
8794                    .into_iter()
8795                    .map(|p| p.to_string())
8796                    .collect::<Vec<String>>()
8797                    .join(",")
8798                    .to_string(),
8799            )]),
8800        };
8801    }
8802    if let Some(ref local_var_str) = modified_by_request {
8803        local_var_req_builder =
8804            local_var_req_builder.query(&[("modified_by_request", &local_var_str.to_string())]);
8805    }
8806    if let Some(ref local_var_str) = mtu {
8807        local_var_req_builder = match "multi" {
8808            "multi" => local_var_req_builder.query(
8809                &local_var_str
8810                    .into_iter()
8811                    .map(|p| ("mtu".to_owned(), p.to_string()))
8812                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8813            ),
8814            _ => local_var_req_builder.query(&[(
8815                "mtu",
8816                &local_var_str
8817                    .into_iter()
8818                    .map(|p| p.to_string())
8819                    .collect::<Vec<String>>()
8820                    .join(",")
8821                    .to_string(),
8822            )]),
8823        };
8824    }
8825    if let Some(ref local_var_str) = mtu__empty {
8826        local_var_req_builder =
8827            local_var_req_builder.query(&[("mtu__empty", &local_var_str.to_string())]);
8828    }
8829    if let Some(ref local_var_str) = mtu__gt {
8830        local_var_req_builder = match "multi" {
8831            "multi" => local_var_req_builder.query(
8832                &local_var_str
8833                    .into_iter()
8834                    .map(|p| ("mtu__gt".to_owned(), p.to_string()))
8835                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8836            ),
8837            _ => local_var_req_builder.query(&[(
8838                "mtu__gt",
8839                &local_var_str
8840                    .into_iter()
8841                    .map(|p| p.to_string())
8842                    .collect::<Vec<String>>()
8843                    .join(",")
8844                    .to_string(),
8845            )]),
8846        };
8847    }
8848    if let Some(ref local_var_str) = mtu__gte {
8849        local_var_req_builder = match "multi" {
8850            "multi" => local_var_req_builder.query(
8851                &local_var_str
8852                    .into_iter()
8853                    .map(|p| ("mtu__gte".to_owned(), p.to_string()))
8854                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8855            ),
8856            _ => local_var_req_builder.query(&[(
8857                "mtu__gte",
8858                &local_var_str
8859                    .into_iter()
8860                    .map(|p| p.to_string())
8861                    .collect::<Vec<String>>()
8862                    .join(",")
8863                    .to_string(),
8864            )]),
8865        };
8866    }
8867    if let Some(ref local_var_str) = mtu__lt {
8868        local_var_req_builder = match "multi" {
8869            "multi" => local_var_req_builder.query(
8870                &local_var_str
8871                    .into_iter()
8872                    .map(|p| ("mtu__lt".to_owned(), p.to_string()))
8873                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8874            ),
8875            _ => local_var_req_builder.query(&[(
8876                "mtu__lt",
8877                &local_var_str
8878                    .into_iter()
8879                    .map(|p| p.to_string())
8880                    .collect::<Vec<String>>()
8881                    .join(",")
8882                    .to_string(),
8883            )]),
8884        };
8885    }
8886    if let Some(ref local_var_str) = mtu__lte {
8887        local_var_req_builder = match "multi" {
8888            "multi" => local_var_req_builder.query(
8889                &local_var_str
8890                    .into_iter()
8891                    .map(|p| ("mtu__lte".to_owned(), p.to_string()))
8892                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8893            ),
8894            _ => local_var_req_builder.query(&[(
8895                "mtu__lte",
8896                &local_var_str
8897                    .into_iter()
8898                    .map(|p| p.to_string())
8899                    .collect::<Vec<String>>()
8900                    .join(",")
8901                    .to_string(),
8902            )]),
8903        };
8904    }
8905    if let Some(ref local_var_str) = mtu__n {
8906        local_var_req_builder = match "multi" {
8907            "multi" => local_var_req_builder.query(
8908                &local_var_str
8909                    .into_iter()
8910                    .map(|p| ("mtu__n".to_owned(), p.to_string()))
8911                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8912            ),
8913            _ => local_var_req_builder.query(&[(
8914                "mtu__n",
8915                &local_var_str
8916                    .into_iter()
8917                    .map(|p| p.to_string())
8918                    .collect::<Vec<String>>()
8919                    .join(",")
8920                    .to_string(),
8921            )]),
8922        };
8923    }
8924    if let Some(ref local_var_str) = name {
8925        local_var_req_builder = match "multi" {
8926            "multi" => local_var_req_builder.query(
8927                &local_var_str
8928                    .into_iter()
8929                    .map(|p| ("name".to_owned(), p.to_string()))
8930                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8931            ),
8932            _ => local_var_req_builder.query(&[(
8933                "name",
8934                &local_var_str
8935                    .into_iter()
8936                    .map(|p| p.to_string())
8937                    .collect::<Vec<String>>()
8938                    .join(",")
8939                    .to_string(),
8940            )]),
8941        };
8942    }
8943    if let Some(ref local_var_str) = name__empty {
8944        local_var_req_builder =
8945            local_var_req_builder.query(&[("name__empty", &local_var_str.to_string())]);
8946    }
8947    if let Some(ref local_var_str) = name__ic {
8948        local_var_req_builder = match "multi" {
8949            "multi" => local_var_req_builder.query(
8950                &local_var_str
8951                    .into_iter()
8952                    .map(|p| ("name__ic".to_owned(), p.to_string()))
8953                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8954            ),
8955            _ => local_var_req_builder.query(&[(
8956                "name__ic",
8957                &local_var_str
8958                    .into_iter()
8959                    .map(|p| p.to_string())
8960                    .collect::<Vec<String>>()
8961                    .join(",")
8962                    .to_string(),
8963            )]),
8964        };
8965    }
8966    if let Some(ref local_var_str) = name__ie {
8967        local_var_req_builder = match "multi" {
8968            "multi" => local_var_req_builder.query(
8969                &local_var_str
8970                    .into_iter()
8971                    .map(|p| ("name__ie".to_owned(), p.to_string()))
8972                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8973            ),
8974            _ => local_var_req_builder.query(&[(
8975                "name__ie",
8976                &local_var_str
8977                    .into_iter()
8978                    .map(|p| p.to_string())
8979                    .collect::<Vec<String>>()
8980                    .join(",")
8981                    .to_string(),
8982            )]),
8983        };
8984    }
8985    if let Some(ref local_var_str) = name__iew {
8986        local_var_req_builder = match "multi" {
8987            "multi" => local_var_req_builder.query(
8988                &local_var_str
8989                    .into_iter()
8990                    .map(|p| ("name__iew".to_owned(), p.to_string()))
8991                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8992            ),
8993            _ => local_var_req_builder.query(&[(
8994                "name__iew",
8995                &local_var_str
8996                    .into_iter()
8997                    .map(|p| p.to_string())
8998                    .collect::<Vec<String>>()
8999                    .join(",")
9000                    .to_string(),
9001            )]),
9002        };
9003    }
9004    if let Some(ref local_var_str) = name__iregex {
9005        local_var_req_builder = match "multi" {
9006            "multi" => local_var_req_builder.query(
9007                &local_var_str
9008                    .into_iter()
9009                    .map(|p| ("name__iregex".to_owned(), p.to_string()))
9010                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9011            ),
9012            _ => local_var_req_builder.query(&[(
9013                "name__iregex",
9014                &local_var_str
9015                    .into_iter()
9016                    .map(|p| p.to_string())
9017                    .collect::<Vec<String>>()
9018                    .join(",")
9019                    .to_string(),
9020            )]),
9021        };
9022    }
9023    if let Some(ref local_var_str) = name__isw {
9024        local_var_req_builder = match "multi" {
9025            "multi" => local_var_req_builder.query(
9026                &local_var_str
9027                    .into_iter()
9028                    .map(|p| ("name__isw".to_owned(), p.to_string()))
9029                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9030            ),
9031            _ => local_var_req_builder.query(&[(
9032                "name__isw",
9033                &local_var_str
9034                    .into_iter()
9035                    .map(|p| p.to_string())
9036                    .collect::<Vec<String>>()
9037                    .join(",")
9038                    .to_string(),
9039            )]),
9040        };
9041    }
9042    if let Some(ref local_var_str) = name__n {
9043        local_var_req_builder = match "multi" {
9044            "multi" => local_var_req_builder.query(
9045                &local_var_str
9046                    .into_iter()
9047                    .map(|p| ("name__n".to_owned(), p.to_string()))
9048                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9049            ),
9050            _ => local_var_req_builder.query(&[(
9051                "name__n",
9052                &local_var_str
9053                    .into_iter()
9054                    .map(|p| p.to_string())
9055                    .collect::<Vec<String>>()
9056                    .join(",")
9057                    .to_string(),
9058            )]),
9059        };
9060    }
9061    if let Some(ref local_var_str) = name__nic {
9062        local_var_req_builder = match "multi" {
9063            "multi" => local_var_req_builder.query(
9064                &local_var_str
9065                    .into_iter()
9066                    .map(|p| ("name__nic".to_owned(), p.to_string()))
9067                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9068            ),
9069            _ => local_var_req_builder.query(&[(
9070                "name__nic",
9071                &local_var_str
9072                    .into_iter()
9073                    .map(|p| p.to_string())
9074                    .collect::<Vec<String>>()
9075                    .join(",")
9076                    .to_string(),
9077            )]),
9078        };
9079    }
9080    if let Some(ref local_var_str) = name__nie {
9081        local_var_req_builder = match "multi" {
9082            "multi" => local_var_req_builder.query(
9083                &local_var_str
9084                    .into_iter()
9085                    .map(|p| ("name__nie".to_owned(), p.to_string()))
9086                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9087            ),
9088            _ => local_var_req_builder.query(&[(
9089                "name__nie",
9090                &local_var_str
9091                    .into_iter()
9092                    .map(|p| p.to_string())
9093                    .collect::<Vec<String>>()
9094                    .join(",")
9095                    .to_string(),
9096            )]),
9097        };
9098    }
9099    if let Some(ref local_var_str) = name__niew {
9100        local_var_req_builder = match "multi" {
9101            "multi" => local_var_req_builder.query(
9102                &local_var_str
9103                    .into_iter()
9104                    .map(|p| ("name__niew".to_owned(), p.to_string()))
9105                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9106            ),
9107            _ => local_var_req_builder.query(&[(
9108                "name__niew",
9109                &local_var_str
9110                    .into_iter()
9111                    .map(|p| p.to_string())
9112                    .collect::<Vec<String>>()
9113                    .join(",")
9114                    .to_string(),
9115            )]),
9116        };
9117    }
9118    if let Some(ref local_var_str) = name__nisw {
9119        local_var_req_builder = match "multi" {
9120            "multi" => local_var_req_builder.query(
9121                &local_var_str
9122                    .into_iter()
9123                    .map(|p| ("name__nisw".to_owned(), p.to_string()))
9124                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9125            ),
9126            _ => local_var_req_builder.query(&[(
9127                "name__nisw",
9128                &local_var_str
9129                    .into_iter()
9130                    .map(|p| p.to_string())
9131                    .collect::<Vec<String>>()
9132                    .join(",")
9133                    .to_string(),
9134            )]),
9135        };
9136    }
9137    if let Some(ref local_var_str) = name__regex {
9138        local_var_req_builder = match "multi" {
9139            "multi" => local_var_req_builder.query(
9140                &local_var_str
9141                    .into_iter()
9142                    .map(|p| ("name__regex".to_owned(), p.to_string()))
9143                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9144            ),
9145            _ => local_var_req_builder.query(&[(
9146                "name__regex",
9147                &local_var_str
9148                    .into_iter()
9149                    .map(|p| p.to_string())
9150                    .collect::<Vec<String>>()
9151                    .join(",")
9152                    .to_string(),
9153            )]),
9154        };
9155    }
9156    if let Some(ref local_var_str) = offset {
9157        local_var_req_builder =
9158            local_var_req_builder.query(&[("offset", &local_var_str.to_string())]);
9159    }
9160    if let Some(ref local_var_str) = ordering {
9161        local_var_req_builder =
9162            local_var_req_builder.query(&[("ordering", &local_var_str.to_string())]);
9163    }
9164    if let Some(ref local_var_str) = owner {
9165        local_var_req_builder = match "multi" {
9166            "multi" => local_var_req_builder.query(
9167                &local_var_str
9168                    .into_iter()
9169                    .map(|p| ("owner".to_owned(), p.to_string()))
9170                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9171            ),
9172            _ => local_var_req_builder.query(&[(
9173                "owner",
9174                &local_var_str
9175                    .into_iter()
9176                    .map(|p| p.to_string())
9177                    .collect::<Vec<String>>()
9178                    .join(",")
9179                    .to_string(),
9180            )]),
9181        };
9182    }
9183    if let Some(ref local_var_str) = owner__n {
9184        local_var_req_builder = match "multi" {
9185            "multi" => local_var_req_builder.query(
9186                &local_var_str
9187                    .into_iter()
9188                    .map(|p| ("owner__n".to_owned(), p.to_string()))
9189                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9190            ),
9191            _ => local_var_req_builder.query(&[(
9192                "owner__n",
9193                &local_var_str
9194                    .into_iter()
9195                    .map(|p| p.to_string())
9196                    .collect::<Vec<String>>()
9197                    .join(",")
9198                    .to_string(),
9199            )]),
9200        };
9201    }
9202    if let Some(ref local_var_str) = owner_group {
9203        local_var_req_builder = match "multi" {
9204            "multi" => local_var_req_builder.query(
9205                &local_var_str
9206                    .into_iter()
9207                    .map(|p| ("owner_group".to_owned(), p.to_string()))
9208                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9209            ),
9210            _ => local_var_req_builder.query(&[(
9211                "owner_group",
9212                &local_var_str
9213                    .into_iter()
9214                    .map(|p| p.to_string())
9215                    .collect::<Vec<String>>()
9216                    .join(",")
9217                    .to_string(),
9218            )]),
9219        };
9220    }
9221    if let Some(ref local_var_str) = owner_group__n {
9222        local_var_req_builder = match "multi" {
9223            "multi" => local_var_req_builder.query(
9224                &local_var_str
9225                    .into_iter()
9226                    .map(|p| ("owner_group__n".to_owned(), p.to_string()))
9227                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9228            ),
9229            _ => local_var_req_builder.query(&[(
9230                "owner_group__n",
9231                &local_var_str
9232                    .into_iter()
9233                    .map(|p| p.to_string())
9234                    .collect::<Vec<String>>()
9235                    .join(",")
9236                    .to_string(),
9237            )]),
9238        };
9239    }
9240    if let Some(ref local_var_str) = owner_group_id {
9241        local_var_req_builder = match "multi" {
9242            "multi" => local_var_req_builder.query(
9243                &local_var_str
9244                    .into_iter()
9245                    .map(|p| ("owner_group_id".to_owned(), p.to_string()))
9246                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9247            ),
9248            _ => local_var_req_builder.query(&[(
9249                "owner_group_id",
9250                &local_var_str
9251                    .into_iter()
9252                    .map(|p| p.to_string())
9253                    .collect::<Vec<String>>()
9254                    .join(",")
9255                    .to_string(),
9256            )]),
9257        };
9258    }
9259    if let Some(ref local_var_str) = owner_group_id__n {
9260        local_var_req_builder = match "multi" {
9261            "multi" => local_var_req_builder.query(
9262                &local_var_str
9263                    .into_iter()
9264                    .map(|p| ("owner_group_id__n".to_owned(), p.to_string()))
9265                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9266            ),
9267            _ => local_var_req_builder.query(&[(
9268                "owner_group_id__n",
9269                &local_var_str
9270                    .into_iter()
9271                    .map(|p| p.to_string())
9272                    .collect::<Vec<String>>()
9273                    .join(",")
9274                    .to_string(),
9275            )]),
9276        };
9277    }
9278    if let Some(ref local_var_str) = owner_id {
9279        local_var_req_builder = match "multi" {
9280            "multi" => local_var_req_builder.query(
9281                &local_var_str
9282                    .into_iter()
9283                    .map(|p| ("owner_id".to_owned(), p.to_string()))
9284                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9285            ),
9286            _ => local_var_req_builder.query(&[(
9287                "owner_id",
9288                &local_var_str
9289                    .into_iter()
9290                    .map(|p| p.to_string())
9291                    .collect::<Vec<String>>()
9292                    .join(",")
9293                    .to_string(),
9294            )]),
9295        };
9296    }
9297    if let Some(ref local_var_str) = owner_id__n {
9298        local_var_req_builder = match "multi" {
9299            "multi" => local_var_req_builder.query(
9300                &local_var_str
9301                    .into_iter()
9302                    .map(|p| ("owner_id__n".to_owned(), p.to_string()))
9303                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9304            ),
9305            _ => local_var_req_builder.query(&[(
9306                "owner_id__n",
9307                &local_var_str
9308                    .into_iter()
9309                    .map(|p| p.to_string())
9310                    .collect::<Vec<String>>()
9311                    .join(",")
9312                    .to_string(),
9313            )]),
9314        };
9315    }
9316    if let Some(ref local_var_str) = parent_id {
9317        local_var_req_builder = match "multi" {
9318            "multi" => local_var_req_builder.query(
9319                &local_var_str
9320                    .into_iter()
9321                    .map(|p| ("parent_id".to_owned(), p.to_string()))
9322                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9323            ),
9324            _ => local_var_req_builder.query(&[(
9325                "parent_id",
9326                &local_var_str
9327                    .into_iter()
9328                    .map(|p| p.to_string())
9329                    .collect::<Vec<String>>()
9330                    .join(",")
9331                    .to_string(),
9332            )]),
9333        };
9334    }
9335    if let Some(ref local_var_str) = parent_id__n {
9336        local_var_req_builder = match "multi" {
9337            "multi" => local_var_req_builder.query(
9338                &local_var_str
9339                    .into_iter()
9340                    .map(|p| ("parent_id__n".to_owned(), p.to_string()))
9341                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9342            ),
9343            _ => local_var_req_builder.query(&[(
9344                "parent_id__n",
9345                &local_var_str
9346                    .into_iter()
9347                    .map(|p| p.to_string())
9348                    .collect::<Vec<String>>()
9349                    .join(",")
9350                    .to_string(),
9351            )]),
9352        };
9353    }
9354    if let Some(ref local_var_str) = primary_mac_address {
9355        local_var_req_builder = match "multi" {
9356            "multi" => local_var_req_builder.query(
9357                &local_var_str
9358                    .into_iter()
9359                    .map(|p| ("primary_mac_address".to_owned(), p.to_string()))
9360                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9361            ),
9362            _ => local_var_req_builder.query(&[(
9363                "primary_mac_address",
9364                &local_var_str
9365                    .into_iter()
9366                    .map(|p| p.to_string())
9367                    .collect::<Vec<String>>()
9368                    .join(",")
9369                    .to_string(),
9370            )]),
9371        };
9372    }
9373    if let Some(ref local_var_str) = primary_mac_address__n {
9374        local_var_req_builder = match "multi" {
9375            "multi" => local_var_req_builder.query(
9376                &local_var_str
9377                    .into_iter()
9378                    .map(|p| ("primary_mac_address__n".to_owned(), p.to_string()))
9379                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9380            ),
9381            _ => local_var_req_builder.query(&[(
9382                "primary_mac_address__n",
9383                &local_var_str
9384                    .into_iter()
9385                    .map(|p| p.to_string())
9386                    .collect::<Vec<String>>()
9387                    .join(",")
9388                    .to_string(),
9389            )]),
9390        };
9391    }
9392    if let Some(ref local_var_str) = primary_mac_address_id {
9393        local_var_req_builder = match "multi" {
9394            "multi" => local_var_req_builder.query(
9395                &local_var_str
9396                    .into_iter()
9397                    .map(|p| ("primary_mac_address_id".to_owned(), p.to_string()))
9398                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9399            ),
9400            _ => local_var_req_builder.query(&[(
9401                "primary_mac_address_id",
9402                &local_var_str
9403                    .into_iter()
9404                    .map(|p| p.to_string())
9405                    .collect::<Vec<String>>()
9406                    .join(",")
9407                    .to_string(),
9408            )]),
9409        };
9410    }
9411    if let Some(ref local_var_str) = primary_mac_address_id__n {
9412        local_var_req_builder = match "multi" {
9413            "multi" => local_var_req_builder.query(
9414                &local_var_str
9415                    .into_iter()
9416                    .map(|p| ("primary_mac_address_id__n".to_owned(), p.to_string()))
9417                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9418            ),
9419            _ => local_var_req_builder.query(&[(
9420                "primary_mac_address_id__n",
9421                &local_var_str
9422                    .into_iter()
9423                    .map(|p| p.to_string())
9424                    .collect::<Vec<String>>()
9425                    .join(",")
9426                    .to_string(),
9427            )]),
9428        };
9429    }
9430    if let Some(ref local_var_str) = q {
9431        local_var_req_builder = local_var_req_builder.query(&[("q", &local_var_str.to_string())]);
9432    }
9433    if let Some(ref local_var_str) = start {
9434        local_var_req_builder =
9435            local_var_req_builder.query(&[("start", &local_var_str.to_string())]);
9436    }
9437    if let Some(ref local_var_str) = tag {
9438        local_var_req_builder = match "multi" {
9439            "multi" => local_var_req_builder.query(
9440                &local_var_str
9441                    .into_iter()
9442                    .map(|p| ("tag".to_owned(), p.to_string()))
9443                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9444            ),
9445            _ => local_var_req_builder.query(&[(
9446                "tag",
9447                &local_var_str
9448                    .into_iter()
9449                    .map(|p| p.to_string())
9450                    .collect::<Vec<String>>()
9451                    .join(",")
9452                    .to_string(),
9453            )]),
9454        };
9455    }
9456    if let Some(ref local_var_str) = tag__n {
9457        local_var_req_builder = match "multi" {
9458            "multi" => local_var_req_builder.query(
9459                &local_var_str
9460                    .into_iter()
9461                    .map(|p| ("tag__n".to_owned(), p.to_string()))
9462                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9463            ),
9464            _ => local_var_req_builder.query(&[(
9465                "tag__n",
9466                &local_var_str
9467                    .into_iter()
9468                    .map(|p| p.to_string())
9469                    .collect::<Vec<String>>()
9470                    .join(",")
9471                    .to_string(),
9472            )]),
9473        };
9474    }
9475    if let Some(ref local_var_str) = tag_id {
9476        local_var_req_builder = match "multi" {
9477            "multi" => local_var_req_builder.query(
9478                &local_var_str
9479                    .into_iter()
9480                    .map(|p| ("tag_id".to_owned(), p.to_string()))
9481                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9482            ),
9483            _ => local_var_req_builder.query(&[(
9484                "tag_id",
9485                &local_var_str
9486                    .into_iter()
9487                    .map(|p| p.to_string())
9488                    .collect::<Vec<String>>()
9489                    .join(",")
9490                    .to_string(),
9491            )]),
9492        };
9493    }
9494    if let Some(ref local_var_str) = tag_id__n {
9495        local_var_req_builder = match "multi" {
9496            "multi" => local_var_req_builder.query(
9497                &local_var_str
9498                    .into_iter()
9499                    .map(|p| ("tag_id__n".to_owned(), p.to_string()))
9500                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9501            ),
9502            _ => local_var_req_builder.query(&[(
9503                "tag_id__n",
9504                &local_var_str
9505                    .into_iter()
9506                    .map(|p| p.to_string())
9507                    .collect::<Vec<String>>()
9508                    .join(",")
9509                    .to_string(),
9510            )]),
9511        };
9512    }
9513    if let Some(ref local_var_str) = updated_by_request {
9514        local_var_req_builder =
9515            local_var_req_builder.query(&[("updated_by_request", &local_var_str.to_string())]);
9516    }
9517    if let Some(ref local_var_str) = virtual_machine {
9518        local_var_req_builder = match "multi" {
9519            "multi" => local_var_req_builder.query(
9520                &local_var_str
9521                    .into_iter()
9522                    .map(|p| ("virtual_machine".to_owned(), p.to_string()))
9523                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9524            ),
9525            _ => local_var_req_builder.query(&[(
9526                "virtual_machine",
9527                &local_var_str
9528                    .into_iter()
9529                    .map(|p| p.to_string())
9530                    .collect::<Vec<String>>()
9531                    .join(",")
9532                    .to_string(),
9533            )]),
9534        };
9535    }
9536    if let Some(ref local_var_str) = virtual_machine__n {
9537        local_var_req_builder = match "multi" {
9538            "multi" => local_var_req_builder.query(
9539                &local_var_str
9540                    .into_iter()
9541                    .map(|p| ("virtual_machine__n".to_owned(), p.to_string()))
9542                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9543            ),
9544            _ => local_var_req_builder.query(&[(
9545                "virtual_machine__n",
9546                &local_var_str
9547                    .into_iter()
9548                    .map(|p| p.to_string())
9549                    .collect::<Vec<String>>()
9550                    .join(",")
9551                    .to_string(),
9552            )]),
9553        };
9554    }
9555    if let Some(ref local_var_str) = virtual_machine_id {
9556        local_var_req_builder = match "multi" {
9557            "multi" => local_var_req_builder.query(
9558                &local_var_str
9559                    .into_iter()
9560                    .map(|p| ("virtual_machine_id".to_owned(), p.to_string()))
9561                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9562            ),
9563            _ => local_var_req_builder.query(&[(
9564                "virtual_machine_id",
9565                &local_var_str
9566                    .into_iter()
9567                    .map(|p| p.to_string())
9568                    .collect::<Vec<String>>()
9569                    .join(",")
9570                    .to_string(),
9571            )]),
9572        };
9573    }
9574    if let Some(ref local_var_str) = virtual_machine_id__n {
9575        local_var_req_builder = match "multi" {
9576            "multi" => local_var_req_builder.query(
9577                &local_var_str
9578                    .into_iter()
9579                    .map(|p| ("virtual_machine_id__n".to_owned(), p.to_string()))
9580                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9581            ),
9582            _ => local_var_req_builder.query(&[(
9583                "virtual_machine_id__n",
9584                &local_var_str
9585                    .into_iter()
9586                    .map(|p| p.to_string())
9587                    .collect::<Vec<String>>()
9588                    .join(",")
9589                    .to_string(),
9590            )]),
9591        };
9592    }
9593    if let Some(ref local_var_str) = vlan {
9594        local_var_req_builder =
9595            local_var_req_builder.query(&[("vlan", &local_var_str.to_string())]);
9596    }
9597    if let Some(ref local_var_str) = vlan_id {
9598        local_var_req_builder =
9599            local_var_req_builder.query(&[("vlan_id", &local_var_str.to_string())]);
9600    }
9601    if let Some(ref local_var_str) = vlan_translation_policy {
9602        local_var_req_builder = match "multi" {
9603            "multi" => local_var_req_builder.query(
9604                &local_var_str
9605                    .into_iter()
9606                    .map(|p| ("vlan_translation_policy".to_owned(), p.to_string()))
9607                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9608            ),
9609            _ => local_var_req_builder.query(&[(
9610                "vlan_translation_policy",
9611                &local_var_str
9612                    .into_iter()
9613                    .map(|p| p.to_string())
9614                    .collect::<Vec<String>>()
9615                    .join(",")
9616                    .to_string(),
9617            )]),
9618        };
9619    }
9620    if let Some(ref local_var_str) = vlan_translation_policy__n {
9621        local_var_req_builder = match "multi" {
9622            "multi" => local_var_req_builder.query(
9623                &local_var_str
9624                    .into_iter()
9625                    .map(|p| ("vlan_translation_policy__n".to_owned(), p.to_string()))
9626                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9627            ),
9628            _ => local_var_req_builder.query(&[(
9629                "vlan_translation_policy__n",
9630                &local_var_str
9631                    .into_iter()
9632                    .map(|p| p.to_string())
9633                    .collect::<Vec<String>>()
9634                    .join(",")
9635                    .to_string(),
9636            )]),
9637        };
9638    }
9639    if let Some(ref local_var_str) = vlan_translation_policy_id {
9640        local_var_req_builder = match "multi" {
9641            "multi" => local_var_req_builder.query(
9642                &local_var_str
9643                    .into_iter()
9644                    .map(|p| ("vlan_translation_policy_id".to_owned(), p.to_string()))
9645                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9646            ),
9647            _ => local_var_req_builder.query(&[(
9648                "vlan_translation_policy_id",
9649                &local_var_str
9650                    .into_iter()
9651                    .map(|p| p.to_string())
9652                    .collect::<Vec<String>>()
9653                    .join(",")
9654                    .to_string(),
9655            )]),
9656        };
9657    }
9658    if let Some(ref local_var_str) = vlan_translation_policy_id__n {
9659        local_var_req_builder = match "multi" {
9660            "multi" => local_var_req_builder.query(
9661                &local_var_str
9662                    .into_iter()
9663                    .map(|p| ("vlan_translation_policy_id__n".to_owned(), p.to_string()))
9664                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9665            ),
9666            _ => local_var_req_builder.query(&[(
9667                "vlan_translation_policy_id__n",
9668                &local_var_str
9669                    .into_iter()
9670                    .map(|p| p.to_string())
9671                    .collect::<Vec<String>>()
9672                    .join(",")
9673                    .to_string(),
9674            )]),
9675        };
9676    }
9677    if let Some(ref local_var_str) = vrf {
9678        local_var_req_builder = match "multi" {
9679            "multi" => local_var_req_builder.query(
9680                &local_var_str
9681                    .into_iter()
9682                    .map(|p| ("vrf".to_owned(), p.to_string()))
9683                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9684            ),
9685            _ => local_var_req_builder.query(&[(
9686                "vrf",
9687                &local_var_str
9688                    .into_iter()
9689                    .map(|p| p.to_string())
9690                    .collect::<Vec<String>>()
9691                    .join(",")
9692                    .to_string(),
9693            )]),
9694        };
9695    }
9696    if let Some(ref local_var_str) = vrf__n {
9697        local_var_req_builder = match "multi" {
9698            "multi" => local_var_req_builder.query(
9699                &local_var_str
9700                    .into_iter()
9701                    .map(|p| ("vrf__n".to_owned(), p.to_string()))
9702                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9703            ),
9704            _ => local_var_req_builder.query(&[(
9705                "vrf__n",
9706                &local_var_str
9707                    .into_iter()
9708                    .map(|p| p.to_string())
9709                    .collect::<Vec<String>>()
9710                    .join(",")
9711                    .to_string(),
9712            )]),
9713        };
9714    }
9715    if let Some(ref local_var_str) = vrf_id {
9716        local_var_req_builder = match "multi" {
9717            "multi" => local_var_req_builder.query(
9718                &local_var_str
9719                    .into_iter()
9720                    .map(|p| ("vrf_id".to_owned(), p.to_string()))
9721                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9722            ),
9723            _ => local_var_req_builder.query(&[(
9724                "vrf_id",
9725                &local_var_str
9726                    .into_iter()
9727                    .map(|p| p.to_string())
9728                    .collect::<Vec<String>>()
9729                    .join(",")
9730                    .to_string(),
9731            )]),
9732        };
9733    }
9734    if let Some(ref local_var_str) = vrf_id__n {
9735        local_var_req_builder = match "multi" {
9736            "multi" => local_var_req_builder.query(
9737                &local_var_str
9738                    .into_iter()
9739                    .map(|p| ("vrf_id__n".to_owned(), p.to_string()))
9740                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9741            ),
9742            _ => local_var_req_builder.query(&[(
9743                "vrf_id__n",
9744                &local_var_str
9745                    .into_iter()
9746                    .map(|p| p.to_string())
9747                    .collect::<Vec<String>>()
9748                    .join(",")
9749                    .to_string(),
9750            )]),
9751        };
9752    }
9753    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
9754        local_var_req_builder =
9755            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
9756    }
9757    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
9758        let local_var_key = local_var_apikey.key.clone();
9759        let local_var_value = match local_var_apikey.prefix {
9760            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
9761            None => local_var_key,
9762        };
9763        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
9764    };
9765
9766    let local_var_req = local_var_req_builder.build()?;
9767    let local_var_resp = local_var_client.execute(local_var_req).await?;
9768
9769    let local_var_status = local_var_resp.status();
9770    let local_var_content = local_var_resp.text().await?;
9771
9772    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
9773        serde_json::from_str(&local_var_content).map_err(Error::from)
9774    } else {
9775        let local_var_entity: Option<VirtualizationInterfacesListError> =
9776            serde_json::from_str(&local_var_content).ok();
9777        let local_var_error = ResponseContent {
9778            status: local_var_status,
9779            content: local_var_content,
9780            entity: local_var_entity,
9781        };
9782        Err(Error::ResponseError(local_var_error))
9783    }
9784}
9785
9786/// Patch a interface object.
9787pub async fn virtualization_interfaces_partial_update(
9788    configuration: &configuration::Configuration,
9789    id: i32,
9790    patched_writable_vm_interface_request: Option<crate::models::PatchedWritableVmInterfaceRequest>,
9791) -> Result<crate::models::VmInterface, Error<VirtualizationInterfacesPartialUpdateError>> {
9792    let local_var_configuration = configuration;
9793
9794    let local_var_client = &local_var_configuration.client;
9795
9796    let local_var_uri_str = format!(
9797        "{}/api/virtualization/interfaces/{id}/",
9798        local_var_configuration.base_path,
9799        id = id
9800    );
9801    let mut local_var_req_builder =
9802        local_var_client.request(reqwest::Method::PATCH, local_var_uri_str.as_str());
9803
9804    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
9805        local_var_req_builder =
9806            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
9807    }
9808    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
9809        let local_var_key = local_var_apikey.key.clone();
9810        let local_var_value = match local_var_apikey.prefix {
9811            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
9812            None => local_var_key,
9813        };
9814        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
9815    };
9816    local_var_req_builder = local_var_req_builder.json(&patched_writable_vm_interface_request);
9817
9818    let local_var_req = local_var_req_builder.build()?;
9819    let local_var_resp = local_var_client.execute(local_var_req).await?;
9820
9821    let local_var_status = local_var_resp.status();
9822    let local_var_content = local_var_resp.text().await?;
9823
9824    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
9825        serde_json::from_str(&local_var_content).map_err(Error::from)
9826    } else {
9827        let local_var_entity: Option<VirtualizationInterfacesPartialUpdateError> =
9828            serde_json::from_str(&local_var_content).ok();
9829        let local_var_error = ResponseContent {
9830            status: local_var_status,
9831            content: local_var_content,
9832            entity: local_var_entity,
9833        };
9834        Err(Error::ResponseError(local_var_error))
9835    }
9836}
9837
9838/// Get a interface object.
9839pub async fn virtualization_interfaces_retrieve(
9840    configuration: &configuration::Configuration,
9841    id: i32,
9842) -> Result<crate::models::VmInterface, Error<VirtualizationInterfacesRetrieveError>> {
9843    let local_var_configuration = configuration;
9844
9845    let local_var_client = &local_var_configuration.client;
9846
9847    let local_var_uri_str = format!(
9848        "{}/api/virtualization/interfaces/{id}/",
9849        local_var_configuration.base_path,
9850        id = id
9851    );
9852    let mut local_var_req_builder =
9853        local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
9854
9855    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
9856        local_var_req_builder =
9857            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
9858    }
9859    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
9860        let local_var_key = local_var_apikey.key.clone();
9861        let local_var_value = match local_var_apikey.prefix {
9862            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
9863            None => local_var_key,
9864        };
9865        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
9866    };
9867
9868    let local_var_req = local_var_req_builder.build()?;
9869    let local_var_resp = local_var_client.execute(local_var_req).await?;
9870
9871    let local_var_status = local_var_resp.status();
9872    let local_var_content = local_var_resp.text().await?;
9873
9874    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
9875        serde_json::from_str(&local_var_content).map_err(Error::from)
9876    } else {
9877        let local_var_entity: Option<VirtualizationInterfacesRetrieveError> =
9878            serde_json::from_str(&local_var_content).ok();
9879        let local_var_error = ResponseContent {
9880            status: local_var_status,
9881            content: local_var_content,
9882            entity: local_var_entity,
9883        };
9884        Err(Error::ResponseError(local_var_error))
9885    }
9886}
9887
9888/// Put a interface object.
9889pub async fn virtualization_interfaces_update(
9890    configuration: &configuration::Configuration,
9891    id: i32,
9892    writable_vm_interface_request: crate::models::WritableVmInterfaceRequest,
9893) -> Result<crate::models::VmInterface, Error<VirtualizationInterfacesUpdateError>> {
9894    let local_var_configuration = configuration;
9895
9896    let local_var_client = &local_var_configuration.client;
9897
9898    let local_var_uri_str = format!(
9899        "{}/api/virtualization/interfaces/{id}/",
9900        local_var_configuration.base_path,
9901        id = id
9902    );
9903    let mut local_var_req_builder =
9904        local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());
9905
9906    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
9907        local_var_req_builder =
9908            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
9909    }
9910    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
9911        let local_var_key = local_var_apikey.key.clone();
9912        let local_var_value = match local_var_apikey.prefix {
9913            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
9914            None => local_var_key,
9915        };
9916        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
9917    };
9918    local_var_req_builder = local_var_req_builder.json(&writable_vm_interface_request);
9919
9920    let local_var_req = local_var_req_builder.build()?;
9921    let local_var_resp = local_var_client.execute(local_var_req).await?;
9922
9923    let local_var_status = local_var_resp.status();
9924    let local_var_content = local_var_resp.text().await?;
9925
9926    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
9927        serde_json::from_str(&local_var_content).map_err(Error::from)
9928    } else {
9929        let local_var_entity: Option<VirtualizationInterfacesUpdateError> =
9930            serde_json::from_str(&local_var_content).ok();
9931        let local_var_error = ResponseContent {
9932            status: local_var_status,
9933            content: local_var_content,
9934            entity: local_var_entity,
9935        };
9936        Err(Error::ResponseError(local_var_error))
9937    }
9938}
9939
9940/// Delete a list of virtual disk objects.
9941pub async fn virtualization_virtual_disks_bulk_destroy(
9942    configuration: &configuration::Configuration,
9943    virtual_disk_request: Vec<crate::models::VirtualDiskRequest>,
9944) -> Result<(), Error<VirtualizationVirtualDisksBulkDestroyError>> {
9945    let local_var_configuration = configuration;
9946
9947    let local_var_client = &local_var_configuration.client;
9948
9949    let local_var_uri_str = format!(
9950        "{}/api/virtualization/virtual-disks/",
9951        local_var_configuration.base_path
9952    );
9953    let mut local_var_req_builder =
9954        local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());
9955
9956    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
9957        local_var_req_builder =
9958            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
9959    }
9960    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
9961        let local_var_key = local_var_apikey.key.clone();
9962        let local_var_value = match local_var_apikey.prefix {
9963            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
9964            None => local_var_key,
9965        };
9966        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
9967    };
9968    local_var_req_builder = local_var_req_builder.json(&virtual_disk_request);
9969
9970    let local_var_req = local_var_req_builder.build()?;
9971    let local_var_resp = local_var_client.execute(local_var_req).await?;
9972
9973    let local_var_status = local_var_resp.status();
9974    let local_var_content = local_var_resp.text().await?;
9975
9976    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
9977        Ok(())
9978    } else {
9979        let local_var_entity: Option<VirtualizationVirtualDisksBulkDestroyError> =
9980            serde_json::from_str(&local_var_content).ok();
9981        let local_var_error = ResponseContent {
9982            status: local_var_status,
9983            content: local_var_content,
9984            entity: local_var_entity,
9985        };
9986        Err(Error::ResponseError(local_var_error))
9987    }
9988}
9989
9990/// Patch a list of virtual disk objects.
9991pub async fn virtualization_virtual_disks_bulk_partial_update(
9992    configuration: &configuration::Configuration,
9993    virtual_disk_request: Vec<crate::models::VirtualDiskRequest>,
9994) -> Result<Vec<crate::models::VirtualDisk>, Error<VirtualizationVirtualDisksBulkPartialUpdateError>>
9995{
9996    let local_var_configuration = configuration;
9997
9998    let local_var_client = &local_var_configuration.client;
9999
10000    let local_var_uri_str = format!(
10001        "{}/api/virtualization/virtual-disks/",
10002        local_var_configuration.base_path
10003    );
10004    let mut local_var_req_builder =
10005        local_var_client.request(reqwest::Method::PATCH, local_var_uri_str.as_str());
10006
10007    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
10008        local_var_req_builder =
10009            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
10010    }
10011    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
10012        let local_var_key = local_var_apikey.key.clone();
10013        let local_var_value = match local_var_apikey.prefix {
10014            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
10015            None => local_var_key,
10016        };
10017        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
10018    };
10019    local_var_req_builder = local_var_req_builder.json(&virtual_disk_request);
10020
10021    let local_var_req = local_var_req_builder.build()?;
10022    let local_var_resp = local_var_client.execute(local_var_req).await?;
10023
10024    let local_var_status = local_var_resp.status();
10025    let local_var_content = local_var_resp.text().await?;
10026
10027    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
10028        serde_json::from_str(&local_var_content).map_err(Error::from)
10029    } else {
10030        let local_var_entity: Option<VirtualizationVirtualDisksBulkPartialUpdateError> =
10031            serde_json::from_str(&local_var_content).ok();
10032        let local_var_error = ResponseContent {
10033            status: local_var_status,
10034            content: local_var_content,
10035            entity: local_var_entity,
10036        };
10037        Err(Error::ResponseError(local_var_error))
10038    }
10039}
10040
10041/// Put a list of virtual disk objects.
10042pub async fn virtualization_virtual_disks_bulk_update(
10043    configuration: &configuration::Configuration,
10044    virtual_disk_request: Vec<crate::models::VirtualDiskRequest>,
10045) -> Result<Vec<crate::models::VirtualDisk>, Error<VirtualizationVirtualDisksBulkUpdateError>> {
10046    let local_var_configuration = configuration;
10047
10048    let local_var_client = &local_var_configuration.client;
10049
10050    let local_var_uri_str = format!(
10051        "{}/api/virtualization/virtual-disks/",
10052        local_var_configuration.base_path
10053    );
10054    let mut local_var_req_builder =
10055        local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());
10056
10057    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
10058        local_var_req_builder =
10059            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
10060    }
10061    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
10062        let local_var_key = local_var_apikey.key.clone();
10063        let local_var_value = match local_var_apikey.prefix {
10064            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
10065            None => local_var_key,
10066        };
10067        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
10068    };
10069    local_var_req_builder = local_var_req_builder.json(&virtual_disk_request);
10070
10071    let local_var_req = local_var_req_builder.build()?;
10072    let local_var_resp = local_var_client.execute(local_var_req).await?;
10073
10074    let local_var_status = local_var_resp.status();
10075    let local_var_content = local_var_resp.text().await?;
10076
10077    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
10078        serde_json::from_str(&local_var_content).map_err(Error::from)
10079    } else {
10080        let local_var_entity: Option<VirtualizationVirtualDisksBulkUpdateError> =
10081            serde_json::from_str(&local_var_content).ok();
10082        let local_var_error = ResponseContent {
10083            status: local_var_status,
10084            content: local_var_content,
10085            entity: local_var_entity,
10086        };
10087        Err(Error::ResponseError(local_var_error))
10088    }
10089}
10090
10091/// Post a list of virtual disk objects.
10092pub async fn virtualization_virtual_disks_create(
10093    configuration: &configuration::Configuration,
10094    virtualization_virtual_disks_create_request: crate::models::VirtualizationVirtualDisksCreateRequest,
10095) -> Result<crate::models::VirtualDisk, Error<VirtualizationVirtualDisksCreateError>> {
10096    let local_var_configuration = configuration;
10097
10098    let local_var_client = &local_var_configuration.client;
10099
10100    let local_var_uri_str = format!(
10101        "{}/api/virtualization/virtual-disks/",
10102        local_var_configuration.base_path
10103    );
10104    let mut local_var_req_builder =
10105        local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
10106
10107    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
10108        local_var_req_builder =
10109            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
10110    }
10111    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
10112        let local_var_key = local_var_apikey.key.clone();
10113        let local_var_value = match local_var_apikey.prefix {
10114            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
10115            None => local_var_key,
10116        };
10117        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
10118    };
10119    local_var_req_builder =
10120        local_var_req_builder.json(&virtualization_virtual_disks_create_request);
10121
10122    let local_var_req = local_var_req_builder.build()?;
10123    let local_var_resp = local_var_client.execute(local_var_req).await?;
10124
10125    let local_var_status = local_var_resp.status();
10126    let local_var_content = local_var_resp.text().await?;
10127
10128    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
10129        serde_json::from_str(&local_var_content).map_err(Error::from)
10130    } else {
10131        let local_var_entity: Option<VirtualizationVirtualDisksCreateError> =
10132            serde_json::from_str(&local_var_content).ok();
10133        let local_var_error = ResponseContent {
10134            status: local_var_status,
10135            content: local_var_content,
10136            entity: local_var_entity,
10137        };
10138        Err(Error::ResponseError(local_var_error))
10139    }
10140}
10141
10142/// Delete a virtual disk object.
10143pub async fn virtualization_virtual_disks_destroy(
10144    configuration: &configuration::Configuration,
10145    id: i32,
10146) -> Result<(), Error<VirtualizationVirtualDisksDestroyError>> {
10147    let local_var_configuration = configuration;
10148
10149    let local_var_client = &local_var_configuration.client;
10150
10151    let local_var_uri_str = format!(
10152        "{}/api/virtualization/virtual-disks/{id}/",
10153        local_var_configuration.base_path,
10154        id = id
10155    );
10156    let mut local_var_req_builder =
10157        local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());
10158
10159    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
10160        local_var_req_builder =
10161            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
10162    }
10163    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
10164        let local_var_key = local_var_apikey.key.clone();
10165        let local_var_value = match local_var_apikey.prefix {
10166            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
10167            None => local_var_key,
10168        };
10169        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
10170    };
10171
10172    let local_var_req = local_var_req_builder.build()?;
10173    let local_var_resp = local_var_client.execute(local_var_req).await?;
10174
10175    let local_var_status = local_var_resp.status();
10176    let local_var_content = local_var_resp.text().await?;
10177
10178    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
10179        Ok(())
10180    } else {
10181        let local_var_entity: Option<VirtualizationVirtualDisksDestroyError> =
10182            serde_json::from_str(&local_var_content).ok();
10183        let local_var_error = ResponseContent {
10184            status: local_var_status,
10185            content: local_var_content,
10186            entity: local_var_entity,
10187        };
10188        Err(Error::ResponseError(local_var_error))
10189    }
10190}
10191
10192/// Get a list of virtual disk objects.
10193pub async fn virtualization_virtual_disks_list(
10194    configuration: &configuration::Configuration,
10195    created: Option<Vec<String>>,
10196    created__empty: Option<Vec<String>>,
10197    created__gt: Option<Vec<String>>,
10198    created__gte: Option<Vec<String>>,
10199    created__lt: Option<Vec<String>>,
10200    created__lte: Option<Vec<String>>,
10201    created__n: Option<Vec<String>>,
10202    created_by_request: Option<&str>,
10203    description: Option<Vec<String>>,
10204    description__empty: Option<bool>,
10205    description__ic: Option<Vec<String>>,
10206    description__ie: Option<Vec<String>>,
10207    description__iew: Option<Vec<String>>,
10208    description__iregex: Option<Vec<String>>,
10209    description__isw: Option<Vec<String>>,
10210    description__n: Option<Vec<String>>,
10211    description__nic: Option<Vec<String>>,
10212    description__nie: Option<Vec<String>>,
10213    description__niew: Option<Vec<String>>,
10214    description__nisw: Option<Vec<String>>,
10215    description__regex: Option<Vec<String>>,
10216    id: Option<Vec<i32>>,
10217    id__empty: Option<bool>,
10218    id__gt: Option<Vec<i32>>,
10219    id__gte: Option<Vec<i32>>,
10220    id__lt: Option<Vec<i32>>,
10221    id__lte: Option<Vec<i32>>,
10222    id__n: Option<Vec<i32>>,
10223    last_updated: Option<Vec<String>>,
10224    last_updated__empty: Option<Vec<String>>,
10225    last_updated__gt: Option<Vec<String>>,
10226    last_updated__gte: Option<Vec<String>>,
10227    last_updated__lt: Option<Vec<String>>,
10228    last_updated__lte: Option<Vec<String>>,
10229    last_updated__n: Option<Vec<String>>,
10230    limit: Option<i32>,
10231    modified_by_request: Option<&str>,
10232    name: Option<Vec<String>>,
10233    name__empty: Option<bool>,
10234    name__ic: Option<Vec<String>>,
10235    name__ie: Option<Vec<String>>,
10236    name__iew: Option<Vec<String>>,
10237    name__iregex: Option<Vec<String>>,
10238    name__isw: Option<Vec<String>>,
10239    name__n: Option<Vec<String>>,
10240    name__nic: Option<Vec<String>>,
10241    name__nie: Option<Vec<String>>,
10242    name__niew: Option<Vec<String>>,
10243    name__nisw: Option<Vec<String>>,
10244    name__regex: Option<Vec<String>>,
10245    offset: Option<i32>,
10246    ordering: Option<&str>,
10247    owner: Option<Vec<String>>,
10248    owner__n: Option<Vec<String>>,
10249    owner_group: Option<Vec<String>>,
10250    owner_group__n: Option<Vec<String>>,
10251    owner_group_id: Option<Vec<i32>>,
10252    owner_group_id__n: Option<Vec<i32>>,
10253    owner_id: Option<Vec<i32>>,
10254    owner_id__n: Option<Vec<i32>>,
10255    q: Option<&str>,
10256    size: Option<Vec<i32>>,
10257    size__empty: Option<bool>,
10258    size__gt: Option<Vec<i32>>,
10259    size__gte: Option<Vec<i32>>,
10260    size__lt: Option<Vec<i32>>,
10261    size__lte: Option<Vec<i32>>,
10262    size__n: Option<Vec<i32>>,
10263    start: Option<i32>,
10264    tag: Option<Vec<String>>,
10265    tag__n: Option<Vec<String>>,
10266    tag_id: Option<Vec<i32>>,
10267    tag_id__n: Option<Vec<i32>>,
10268    updated_by_request: Option<&str>,
10269    virtual_machine: Option<Vec<String>>,
10270    virtual_machine__n: Option<Vec<String>>,
10271    virtual_machine_id: Option<Vec<i32>>,
10272    virtual_machine_id__n: Option<Vec<i32>>,
10273) -> Result<crate::models::PaginatedVirtualDiskList, Error<VirtualizationVirtualDisksListError>> {
10274    let local_var_configuration = configuration;
10275
10276    let local_var_client = &local_var_configuration.client;
10277
10278    let local_var_uri_str = format!(
10279        "{}/api/virtualization/virtual-disks/",
10280        local_var_configuration.base_path
10281    );
10282    let mut local_var_req_builder =
10283        local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
10284
10285    if let Some(ref local_var_str) = created {
10286        local_var_req_builder = match "multi" {
10287            "multi" => local_var_req_builder.query(
10288                &local_var_str
10289                    .into_iter()
10290                    .map(|p| ("created".to_owned(), p.to_string()))
10291                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10292            ),
10293            _ => local_var_req_builder.query(&[(
10294                "created",
10295                &local_var_str
10296                    .into_iter()
10297                    .map(|p| p.to_string())
10298                    .collect::<Vec<String>>()
10299                    .join(",")
10300                    .to_string(),
10301            )]),
10302        };
10303    }
10304    if let Some(ref local_var_str) = created__empty {
10305        local_var_req_builder = match "multi" {
10306            "multi" => local_var_req_builder.query(
10307                &local_var_str
10308                    .into_iter()
10309                    .map(|p| ("created__empty".to_owned(), p.to_string()))
10310                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10311            ),
10312            _ => local_var_req_builder.query(&[(
10313                "created__empty",
10314                &local_var_str
10315                    .into_iter()
10316                    .map(|p| p.to_string())
10317                    .collect::<Vec<String>>()
10318                    .join(",")
10319                    .to_string(),
10320            )]),
10321        };
10322    }
10323    if let Some(ref local_var_str) = created__gt {
10324        local_var_req_builder = match "multi" {
10325            "multi" => local_var_req_builder.query(
10326                &local_var_str
10327                    .into_iter()
10328                    .map(|p| ("created__gt".to_owned(), p.to_string()))
10329                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10330            ),
10331            _ => local_var_req_builder.query(&[(
10332                "created__gt",
10333                &local_var_str
10334                    .into_iter()
10335                    .map(|p| p.to_string())
10336                    .collect::<Vec<String>>()
10337                    .join(",")
10338                    .to_string(),
10339            )]),
10340        };
10341    }
10342    if let Some(ref local_var_str) = created__gte {
10343        local_var_req_builder = match "multi" {
10344            "multi" => local_var_req_builder.query(
10345                &local_var_str
10346                    .into_iter()
10347                    .map(|p| ("created__gte".to_owned(), p.to_string()))
10348                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10349            ),
10350            _ => local_var_req_builder.query(&[(
10351                "created__gte",
10352                &local_var_str
10353                    .into_iter()
10354                    .map(|p| p.to_string())
10355                    .collect::<Vec<String>>()
10356                    .join(",")
10357                    .to_string(),
10358            )]),
10359        };
10360    }
10361    if let Some(ref local_var_str) = created__lt {
10362        local_var_req_builder = match "multi" {
10363            "multi" => local_var_req_builder.query(
10364                &local_var_str
10365                    .into_iter()
10366                    .map(|p| ("created__lt".to_owned(), p.to_string()))
10367                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10368            ),
10369            _ => local_var_req_builder.query(&[(
10370                "created__lt",
10371                &local_var_str
10372                    .into_iter()
10373                    .map(|p| p.to_string())
10374                    .collect::<Vec<String>>()
10375                    .join(",")
10376                    .to_string(),
10377            )]),
10378        };
10379    }
10380    if let Some(ref local_var_str) = created__lte {
10381        local_var_req_builder = match "multi" {
10382            "multi" => local_var_req_builder.query(
10383                &local_var_str
10384                    .into_iter()
10385                    .map(|p| ("created__lte".to_owned(), p.to_string()))
10386                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10387            ),
10388            _ => local_var_req_builder.query(&[(
10389                "created__lte",
10390                &local_var_str
10391                    .into_iter()
10392                    .map(|p| p.to_string())
10393                    .collect::<Vec<String>>()
10394                    .join(",")
10395                    .to_string(),
10396            )]),
10397        };
10398    }
10399    if let Some(ref local_var_str) = created__n {
10400        local_var_req_builder = match "multi" {
10401            "multi" => local_var_req_builder.query(
10402                &local_var_str
10403                    .into_iter()
10404                    .map(|p| ("created__n".to_owned(), p.to_string()))
10405                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10406            ),
10407            _ => local_var_req_builder.query(&[(
10408                "created__n",
10409                &local_var_str
10410                    .into_iter()
10411                    .map(|p| p.to_string())
10412                    .collect::<Vec<String>>()
10413                    .join(",")
10414                    .to_string(),
10415            )]),
10416        };
10417    }
10418    if let Some(ref local_var_str) = created_by_request {
10419        local_var_req_builder =
10420            local_var_req_builder.query(&[("created_by_request", &local_var_str.to_string())]);
10421    }
10422    if let Some(ref local_var_str) = description {
10423        local_var_req_builder = match "multi" {
10424            "multi" => local_var_req_builder.query(
10425                &local_var_str
10426                    .into_iter()
10427                    .map(|p| ("description".to_owned(), p.to_string()))
10428                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10429            ),
10430            _ => local_var_req_builder.query(&[(
10431                "description",
10432                &local_var_str
10433                    .into_iter()
10434                    .map(|p| p.to_string())
10435                    .collect::<Vec<String>>()
10436                    .join(",")
10437                    .to_string(),
10438            )]),
10439        };
10440    }
10441    if let Some(ref local_var_str) = description__empty {
10442        local_var_req_builder =
10443            local_var_req_builder.query(&[("description__empty", &local_var_str.to_string())]);
10444    }
10445    if let Some(ref local_var_str) = description__ic {
10446        local_var_req_builder = match "multi" {
10447            "multi" => local_var_req_builder.query(
10448                &local_var_str
10449                    .into_iter()
10450                    .map(|p| ("description__ic".to_owned(), p.to_string()))
10451                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10452            ),
10453            _ => local_var_req_builder.query(&[(
10454                "description__ic",
10455                &local_var_str
10456                    .into_iter()
10457                    .map(|p| p.to_string())
10458                    .collect::<Vec<String>>()
10459                    .join(",")
10460                    .to_string(),
10461            )]),
10462        };
10463    }
10464    if let Some(ref local_var_str) = description__ie {
10465        local_var_req_builder = match "multi" {
10466            "multi" => local_var_req_builder.query(
10467                &local_var_str
10468                    .into_iter()
10469                    .map(|p| ("description__ie".to_owned(), p.to_string()))
10470                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10471            ),
10472            _ => local_var_req_builder.query(&[(
10473                "description__ie",
10474                &local_var_str
10475                    .into_iter()
10476                    .map(|p| p.to_string())
10477                    .collect::<Vec<String>>()
10478                    .join(",")
10479                    .to_string(),
10480            )]),
10481        };
10482    }
10483    if let Some(ref local_var_str) = description__iew {
10484        local_var_req_builder = match "multi" {
10485            "multi" => local_var_req_builder.query(
10486                &local_var_str
10487                    .into_iter()
10488                    .map(|p| ("description__iew".to_owned(), p.to_string()))
10489                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10490            ),
10491            _ => local_var_req_builder.query(&[(
10492                "description__iew",
10493                &local_var_str
10494                    .into_iter()
10495                    .map(|p| p.to_string())
10496                    .collect::<Vec<String>>()
10497                    .join(",")
10498                    .to_string(),
10499            )]),
10500        };
10501    }
10502    if let Some(ref local_var_str) = description__iregex {
10503        local_var_req_builder = match "multi" {
10504            "multi" => local_var_req_builder.query(
10505                &local_var_str
10506                    .into_iter()
10507                    .map(|p| ("description__iregex".to_owned(), p.to_string()))
10508                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10509            ),
10510            _ => local_var_req_builder.query(&[(
10511                "description__iregex",
10512                &local_var_str
10513                    .into_iter()
10514                    .map(|p| p.to_string())
10515                    .collect::<Vec<String>>()
10516                    .join(",")
10517                    .to_string(),
10518            )]),
10519        };
10520    }
10521    if let Some(ref local_var_str) = description__isw {
10522        local_var_req_builder = match "multi" {
10523            "multi" => local_var_req_builder.query(
10524                &local_var_str
10525                    .into_iter()
10526                    .map(|p| ("description__isw".to_owned(), p.to_string()))
10527                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10528            ),
10529            _ => local_var_req_builder.query(&[(
10530                "description__isw",
10531                &local_var_str
10532                    .into_iter()
10533                    .map(|p| p.to_string())
10534                    .collect::<Vec<String>>()
10535                    .join(",")
10536                    .to_string(),
10537            )]),
10538        };
10539    }
10540    if let Some(ref local_var_str) = description__n {
10541        local_var_req_builder = match "multi" {
10542            "multi" => local_var_req_builder.query(
10543                &local_var_str
10544                    .into_iter()
10545                    .map(|p| ("description__n".to_owned(), p.to_string()))
10546                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10547            ),
10548            _ => local_var_req_builder.query(&[(
10549                "description__n",
10550                &local_var_str
10551                    .into_iter()
10552                    .map(|p| p.to_string())
10553                    .collect::<Vec<String>>()
10554                    .join(",")
10555                    .to_string(),
10556            )]),
10557        };
10558    }
10559    if let Some(ref local_var_str) = description__nic {
10560        local_var_req_builder = match "multi" {
10561            "multi" => local_var_req_builder.query(
10562                &local_var_str
10563                    .into_iter()
10564                    .map(|p| ("description__nic".to_owned(), p.to_string()))
10565                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10566            ),
10567            _ => local_var_req_builder.query(&[(
10568                "description__nic",
10569                &local_var_str
10570                    .into_iter()
10571                    .map(|p| p.to_string())
10572                    .collect::<Vec<String>>()
10573                    .join(",")
10574                    .to_string(),
10575            )]),
10576        };
10577    }
10578    if let Some(ref local_var_str) = description__nie {
10579        local_var_req_builder = match "multi" {
10580            "multi" => local_var_req_builder.query(
10581                &local_var_str
10582                    .into_iter()
10583                    .map(|p| ("description__nie".to_owned(), p.to_string()))
10584                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10585            ),
10586            _ => local_var_req_builder.query(&[(
10587                "description__nie",
10588                &local_var_str
10589                    .into_iter()
10590                    .map(|p| p.to_string())
10591                    .collect::<Vec<String>>()
10592                    .join(",")
10593                    .to_string(),
10594            )]),
10595        };
10596    }
10597    if let Some(ref local_var_str) = description__niew {
10598        local_var_req_builder = match "multi" {
10599            "multi" => local_var_req_builder.query(
10600                &local_var_str
10601                    .into_iter()
10602                    .map(|p| ("description__niew".to_owned(), p.to_string()))
10603                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10604            ),
10605            _ => local_var_req_builder.query(&[(
10606                "description__niew",
10607                &local_var_str
10608                    .into_iter()
10609                    .map(|p| p.to_string())
10610                    .collect::<Vec<String>>()
10611                    .join(",")
10612                    .to_string(),
10613            )]),
10614        };
10615    }
10616    if let Some(ref local_var_str) = description__nisw {
10617        local_var_req_builder = match "multi" {
10618            "multi" => local_var_req_builder.query(
10619                &local_var_str
10620                    .into_iter()
10621                    .map(|p| ("description__nisw".to_owned(), p.to_string()))
10622                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10623            ),
10624            _ => local_var_req_builder.query(&[(
10625                "description__nisw",
10626                &local_var_str
10627                    .into_iter()
10628                    .map(|p| p.to_string())
10629                    .collect::<Vec<String>>()
10630                    .join(",")
10631                    .to_string(),
10632            )]),
10633        };
10634    }
10635    if let Some(ref local_var_str) = description__regex {
10636        local_var_req_builder = match "multi" {
10637            "multi" => local_var_req_builder.query(
10638                &local_var_str
10639                    .into_iter()
10640                    .map(|p| ("description__regex".to_owned(), p.to_string()))
10641                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10642            ),
10643            _ => local_var_req_builder.query(&[(
10644                "description__regex",
10645                &local_var_str
10646                    .into_iter()
10647                    .map(|p| p.to_string())
10648                    .collect::<Vec<String>>()
10649                    .join(",")
10650                    .to_string(),
10651            )]),
10652        };
10653    }
10654    if let Some(ref local_var_str) = id {
10655        local_var_req_builder = match "multi" {
10656            "multi" => local_var_req_builder.query(
10657                &local_var_str
10658                    .into_iter()
10659                    .map(|p| ("id".to_owned(), p.to_string()))
10660                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10661            ),
10662            _ => local_var_req_builder.query(&[(
10663                "id",
10664                &local_var_str
10665                    .into_iter()
10666                    .map(|p| p.to_string())
10667                    .collect::<Vec<String>>()
10668                    .join(",")
10669                    .to_string(),
10670            )]),
10671        };
10672    }
10673    if let Some(ref local_var_str) = id__empty {
10674        local_var_req_builder =
10675            local_var_req_builder.query(&[("id__empty", &local_var_str.to_string())]);
10676    }
10677    if let Some(ref local_var_str) = id__gt {
10678        local_var_req_builder = match "multi" {
10679            "multi" => local_var_req_builder.query(
10680                &local_var_str
10681                    .into_iter()
10682                    .map(|p| ("id__gt".to_owned(), p.to_string()))
10683                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10684            ),
10685            _ => local_var_req_builder.query(&[(
10686                "id__gt",
10687                &local_var_str
10688                    .into_iter()
10689                    .map(|p| p.to_string())
10690                    .collect::<Vec<String>>()
10691                    .join(",")
10692                    .to_string(),
10693            )]),
10694        };
10695    }
10696    if let Some(ref local_var_str) = id__gte {
10697        local_var_req_builder = match "multi" {
10698            "multi" => local_var_req_builder.query(
10699                &local_var_str
10700                    .into_iter()
10701                    .map(|p| ("id__gte".to_owned(), p.to_string()))
10702                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10703            ),
10704            _ => local_var_req_builder.query(&[(
10705                "id__gte",
10706                &local_var_str
10707                    .into_iter()
10708                    .map(|p| p.to_string())
10709                    .collect::<Vec<String>>()
10710                    .join(",")
10711                    .to_string(),
10712            )]),
10713        };
10714    }
10715    if let Some(ref local_var_str) = id__lt {
10716        local_var_req_builder = match "multi" {
10717            "multi" => local_var_req_builder.query(
10718                &local_var_str
10719                    .into_iter()
10720                    .map(|p| ("id__lt".to_owned(), p.to_string()))
10721                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10722            ),
10723            _ => local_var_req_builder.query(&[(
10724                "id__lt",
10725                &local_var_str
10726                    .into_iter()
10727                    .map(|p| p.to_string())
10728                    .collect::<Vec<String>>()
10729                    .join(",")
10730                    .to_string(),
10731            )]),
10732        };
10733    }
10734    if let Some(ref local_var_str) = id__lte {
10735        local_var_req_builder = match "multi" {
10736            "multi" => local_var_req_builder.query(
10737                &local_var_str
10738                    .into_iter()
10739                    .map(|p| ("id__lte".to_owned(), p.to_string()))
10740                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10741            ),
10742            _ => local_var_req_builder.query(&[(
10743                "id__lte",
10744                &local_var_str
10745                    .into_iter()
10746                    .map(|p| p.to_string())
10747                    .collect::<Vec<String>>()
10748                    .join(",")
10749                    .to_string(),
10750            )]),
10751        };
10752    }
10753    if let Some(ref local_var_str) = id__n {
10754        local_var_req_builder = match "multi" {
10755            "multi" => local_var_req_builder.query(
10756                &local_var_str
10757                    .into_iter()
10758                    .map(|p| ("id__n".to_owned(), p.to_string()))
10759                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10760            ),
10761            _ => local_var_req_builder.query(&[(
10762                "id__n",
10763                &local_var_str
10764                    .into_iter()
10765                    .map(|p| p.to_string())
10766                    .collect::<Vec<String>>()
10767                    .join(",")
10768                    .to_string(),
10769            )]),
10770        };
10771    }
10772    if let Some(ref local_var_str) = last_updated {
10773        local_var_req_builder = match "multi" {
10774            "multi" => local_var_req_builder.query(
10775                &local_var_str
10776                    .into_iter()
10777                    .map(|p| ("last_updated".to_owned(), p.to_string()))
10778                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10779            ),
10780            _ => local_var_req_builder.query(&[(
10781                "last_updated",
10782                &local_var_str
10783                    .into_iter()
10784                    .map(|p| p.to_string())
10785                    .collect::<Vec<String>>()
10786                    .join(",")
10787                    .to_string(),
10788            )]),
10789        };
10790    }
10791    if let Some(ref local_var_str) = last_updated__empty {
10792        local_var_req_builder = match "multi" {
10793            "multi" => local_var_req_builder.query(
10794                &local_var_str
10795                    .into_iter()
10796                    .map(|p| ("last_updated__empty".to_owned(), p.to_string()))
10797                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10798            ),
10799            _ => local_var_req_builder.query(&[(
10800                "last_updated__empty",
10801                &local_var_str
10802                    .into_iter()
10803                    .map(|p| p.to_string())
10804                    .collect::<Vec<String>>()
10805                    .join(",")
10806                    .to_string(),
10807            )]),
10808        };
10809    }
10810    if let Some(ref local_var_str) = last_updated__gt {
10811        local_var_req_builder = match "multi" {
10812            "multi" => local_var_req_builder.query(
10813                &local_var_str
10814                    .into_iter()
10815                    .map(|p| ("last_updated__gt".to_owned(), p.to_string()))
10816                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10817            ),
10818            _ => local_var_req_builder.query(&[(
10819                "last_updated__gt",
10820                &local_var_str
10821                    .into_iter()
10822                    .map(|p| p.to_string())
10823                    .collect::<Vec<String>>()
10824                    .join(",")
10825                    .to_string(),
10826            )]),
10827        };
10828    }
10829    if let Some(ref local_var_str) = last_updated__gte {
10830        local_var_req_builder = match "multi" {
10831            "multi" => local_var_req_builder.query(
10832                &local_var_str
10833                    .into_iter()
10834                    .map(|p| ("last_updated__gte".to_owned(), p.to_string()))
10835                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10836            ),
10837            _ => local_var_req_builder.query(&[(
10838                "last_updated__gte",
10839                &local_var_str
10840                    .into_iter()
10841                    .map(|p| p.to_string())
10842                    .collect::<Vec<String>>()
10843                    .join(",")
10844                    .to_string(),
10845            )]),
10846        };
10847    }
10848    if let Some(ref local_var_str) = last_updated__lt {
10849        local_var_req_builder = match "multi" {
10850            "multi" => local_var_req_builder.query(
10851                &local_var_str
10852                    .into_iter()
10853                    .map(|p| ("last_updated__lt".to_owned(), p.to_string()))
10854                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10855            ),
10856            _ => local_var_req_builder.query(&[(
10857                "last_updated__lt",
10858                &local_var_str
10859                    .into_iter()
10860                    .map(|p| p.to_string())
10861                    .collect::<Vec<String>>()
10862                    .join(",")
10863                    .to_string(),
10864            )]),
10865        };
10866    }
10867    if let Some(ref local_var_str) = last_updated__lte {
10868        local_var_req_builder = match "multi" {
10869            "multi" => local_var_req_builder.query(
10870                &local_var_str
10871                    .into_iter()
10872                    .map(|p| ("last_updated__lte".to_owned(), p.to_string()))
10873                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10874            ),
10875            _ => local_var_req_builder.query(&[(
10876                "last_updated__lte",
10877                &local_var_str
10878                    .into_iter()
10879                    .map(|p| p.to_string())
10880                    .collect::<Vec<String>>()
10881                    .join(",")
10882                    .to_string(),
10883            )]),
10884        };
10885    }
10886    if let Some(ref local_var_str) = last_updated__n {
10887        local_var_req_builder = match "multi" {
10888            "multi" => local_var_req_builder.query(
10889                &local_var_str
10890                    .into_iter()
10891                    .map(|p| ("last_updated__n".to_owned(), p.to_string()))
10892                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10893            ),
10894            _ => local_var_req_builder.query(&[(
10895                "last_updated__n",
10896                &local_var_str
10897                    .into_iter()
10898                    .map(|p| p.to_string())
10899                    .collect::<Vec<String>>()
10900                    .join(",")
10901                    .to_string(),
10902            )]),
10903        };
10904    }
10905    if let Some(ref local_var_str) = limit {
10906        local_var_req_builder =
10907            local_var_req_builder.query(&[("limit", &local_var_str.to_string())]);
10908    }
10909    if let Some(ref local_var_str) = modified_by_request {
10910        local_var_req_builder =
10911            local_var_req_builder.query(&[("modified_by_request", &local_var_str.to_string())]);
10912    }
10913    if let Some(ref local_var_str) = name {
10914        local_var_req_builder = match "multi" {
10915            "multi" => local_var_req_builder.query(
10916                &local_var_str
10917                    .into_iter()
10918                    .map(|p| ("name".to_owned(), p.to_string()))
10919                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10920            ),
10921            _ => local_var_req_builder.query(&[(
10922                "name",
10923                &local_var_str
10924                    .into_iter()
10925                    .map(|p| p.to_string())
10926                    .collect::<Vec<String>>()
10927                    .join(",")
10928                    .to_string(),
10929            )]),
10930        };
10931    }
10932    if let Some(ref local_var_str) = name__empty {
10933        local_var_req_builder =
10934            local_var_req_builder.query(&[("name__empty", &local_var_str.to_string())]);
10935    }
10936    if let Some(ref local_var_str) = name__ic {
10937        local_var_req_builder = match "multi" {
10938            "multi" => local_var_req_builder.query(
10939                &local_var_str
10940                    .into_iter()
10941                    .map(|p| ("name__ic".to_owned(), p.to_string()))
10942                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10943            ),
10944            _ => local_var_req_builder.query(&[(
10945                "name__ic",
10946                &local_var_str
10947                    .into_iter()
10948                    .map(|p| p.to_string())
10949                    .collect::<Vec<String>>()
10950                    .join(",")
10951                    .to_string(),
10952            )]),
10953        };
10954    }
10955    if let Some(ref local_var_str) = name__ie {
10956        local_var_req_builder = match "multi" {
10957            "multi" => local_var_req_builder.query(
10958                &local_var_str
10959                    .into_iter()
10960                    .map(|p| ("name__ie".to_owned(), p.to_string()))
10961                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10962            ),
10963            _ => local_var_req_builder.query(&[(
10964                "name__ie",
10965                &local_var_str
10966                    .into_iter()
10967                    .map(|p| p.to_string())
10968                    .collect::<Vec<String>>()
10969                    .join(",")
10970                    .to_string(),
10971            )]),
10972        };
10973    }
10974    if let Some(ref local_var_str) = name__iew {
10975        local_var_req_builder = match "multi" {
10976            "multi" => local_var_req_builder.query(
10977                &local_var_str
10978                    .into_iter()
10979                    .map(|p| ("name__iew".to_owned(), p.to_string()))
10980                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10981            ),
10982            _ => local_var_req_builder.query(&[(
10983                "name__iew",
10984                &local_var_str
10985                    .into_iter()
10986                    .map(|p| p.to_string())
10987                    .collect::<Vec<String>>()
10988                    .join(",")
10989                    .to_string(),
10990            )]),
10991        };
10992    }
10993    if let Some(ref local_var_str) = name__iregex {
10994        local_var_req_builder = match "multi" {
10995            "multi" => local_var_req_builder.query(
10996                &local_var_str
10997                    .into_iter()
10998                    .map(|p| ("name__iregex".to_owned(), p.to_string()))
10999                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11000            ),
11001            _ => local_var_req_builder.query(&[(
11002                "name__iregex",
11003                &local_var_str
11004                    .into_iter()
11005                    .map(|p| p.to_string())
11006                    .collect::<Vec<String>>()
11007                    .join(",")
11008                    .to_string(),
11009            )]),
11010        };
11011    }
11012    if let Some(ref local_var_str) = name__isw {
11013        local_var_req_builder = match "multi" {
11014            "multi" => local_var_req_builder.query(
11015                &local_var_str
11016                    .into_iter()
11017                    .map(|p| ("name__isw".to_owned(), p.to_string()))
11018                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11019            ),
11020            _ => local_var_req_builder.query(&[(
11021                "name__isw",
11022                &local_var_str
11023                    .into_iter()
11024                    .map(|p| p.to_string())
11025                    .collect::<Vec<String>>()
11026                    .join(",")
11027                    .to_string(),
11028            )]),
11029        };
11030    }
11031    if let Some(ref local_var_str) = name__n {
11032        local_var_req_builder = match "multi" {
11033            "multi" => local_var_req_builder.query(
11034                &local_var_str
11035                    .into_iter()
11036                    .map(|p| ("name__n".to_owned(), p.to_string()))
11037                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11038            ),
11039            _ => local_var_req_builder.query(&[(
11040                "name__n",
11041                &local_var_str
11042                    .into_iter()
11043                    .map(|p| p.to_string())
11044                    .collect::<Vec<String>>()
11045                    .join(",")
11046                    .to_string(),
11047            )]),
11048        };
11049    }
11050    if let Some(ref local_var_str) = name__nic {
11051        local_var_req_builder = match "multi" {
11052            "multi" => local_var_req_builder.query(
11053                &local_var_str
11054                    .into_iter()
11055                    .map(|p| ("name__nic".to_owned(), p.to_string()))
11056                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11057            ),
11058            _ => local_var_req_builder.query(&[(
11059                "name__nic",
11060                &local_var_str
11061                    .into_iter()
11062                    .map(|p| p.to_string())
11063                    .collect::<Vec<String>>()
11064                    .join(",")
11065                    .to_string(),
11066            )]),
11067        };
11068    }
11069    if let Some(ref local_var_str) = name__nie {
11070        local_var_req_builder = match "multi" {
11071            "multi" => local_var_req_builder.query(
11072                &local_var_str
11073                    .into_iter()
11074                    .map(|p| ("name__nie".to_owned(), p.to_string()))
11075                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11076            ),
11077            _ => local_var_req_builder.query(&[(
11078                "name__nie",
11079                &local_var_str
11080                    .into_iter()
11081                    .map(|p| p.to_string())
11082                    .collect::<Vec<String>>()
11083                    .join(",")
11084                    .to_string(),
11085            )]),
11086        };
11087    }
11088    if let Some(ref local_var_str) = name__niew {
11089        local_var_req_builder = match "multi" {
11090            "multi" => local_var_req_builder.query(
11091                &local_var_str
11092                    .into_iter()
11093                    .map(|p| ("name__niew".to_owned(), p.to_string()))
11094                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11095            ),
11096            _ => local_var_req_builder.query(&[(
11097                "name__niew",
11098                &local_var_str
11099                    .into_iter()
11100                    .map(|p| p.to_string())
11101                    .collect::<Vec<String>>()
11102                    .join(",")
11103                    .to_string(),
11104            )]),
11105        };
11106    }
11107    if let Some(ref local_var_str) = name__nisw {
11108        local_var_req_builder = match "multi" {
11109            "multi" => local_var_req_builder.query(
11110                &local_var_str
11111                    .into_iter()
11112                    .map(|p| ("name__nisw".to_owned(), p.to_string()))
11113                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11114            ),
11115            _ => local_var_req_builder.query(&[(
11116                "name__nisw",
11117                &local_var_str
11118                    .into_iter()
11119                    .map(|p| p.to_string())
11120                    .collect::<Vec<String>>()
11121                    .join(",")
11122                    .to_string(),
11123            )]),
11124        };
11125    }
11126    if let Some(ref local_var_str) = name__regex {
11127        local_var_req_builder = match "multi" {
11128            "multi" => local_var_req_builder.query(
11129                &local_var_str
11130                    .into_iter()
11131                    .map(|p| ("name__regex".to_owned(), p.to_string()))
11132                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11133            ),
11134            _ => local_var_req_builder.query(&[(
11135                "name__regex",
11136                &local_var_str
11137                    .into_iter()
11138                    .map(|p| p.to_string())
11139                    .collect::<Vec<String>>()
11140                    .join(",")
11141                    .to_string(),
11142            )]),
11143        };
11144    }
11145    if let Some(ref local_var_str) = offset {
11146        local_var_req_builder =
11147            local_var_req_builder.query(&[("offset", &local_var_str.to_string())]);
11148    }
11149    if let Some(ref local_var_str) = ordering {
11150        local_var_req_builder =
11151            local_var_req_builder.query(&[("ordering", &local_var_str.to_string())]);
11152    }
11153    if let Some(ref local_var_str) = owner {
11154        local_var_req_builder = match "multi" {
11155            "multi" => local_var_req_builder.query(
11156                &local_var_str
11157                    .into_iter()
11158                    .map(|p| ("owner".to_owned(), p.to_string()))
11159                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11160            ),
11161            _ => local_var_req_builder.query(&[(
11162                "owner",
11163                &local_var_str
11164                    .into_iter()
11165                    .map(|p| p.to_string())
11166                    .collect::<Vec<String>>()
11167                    .join(",")
11168                    .to_string(),
11169            )]),
11170        };
11171    }
11172    if let Some(ref local_var_str) = owner__n {
11173        local_var_req_builder = match "multi" {
11174            "multi" => local_var_req_builder.query(
11175                &local_var_str
11176                    .into_iter()
11177                    .map(|p| ("owner__n".to_owned(), p.to_string()))
11178                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11179            ),
11180            _ => local_var_req_builder.query(&[(
11181                "owner__n",
11182                &local_var_str
11183                    .into_iter()
11184                    .map(|p| p.to_string())
11185                    .collect::<Vec<String>>()
11186                    .join(",")
11187                    .to_string(),
11188            )]),
11189        };
11190    }
11191    if let Some(ref local_var_str) = owner_group {
11192        local_var_req_builder = match "multi" {
11193            "multi" => local_var_req_builder.query(
11194                &local_var_str
11195                    .into_iter()
11196                    .map(|p| ("owner_group".to_owned(), p.to_string()))
11197                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11198            ),
11199            _ => local_var_req_builder.query(&[(
11200                "owner_group",
11201                &local_var_str
11202                    .into_iter()
11203                    .map(|p| p.to_string())
11204                    .collect::<Vec<String>>()
11205                    .join(",")
11206                    .to_string(),
11207            )]),
11208        };
11209    }
11210    if let Some(ref local_var_str) = owner_group__n {
11211        local_var_req_builder = match "multi" {
11212            "multi" => local_var_req_builder.query(
11213                &local_var_str
11214                    .into_iter()
11215                    .map(|p| ("owner_group__n".to_owned(), p.to_string()))
11216                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11217            ),
11218            _ => local_var_req_builder.query(&[(
11219                "owner_group__n",
11220                &local_var_str
11221                    .into_iter()
11222                    .map(|p| p.to_string())
11223                    .collect::<Vec<String>>()
11224                    .join(",")
11225                    .to_string(),
11226            )]),
11227        };
11228    }
11229    if let Some(ref local_var_str) = owner_group_id {
11230        local_var_req_builder = match "multi" {
11231            "multi" => local_var_req_builder.query(
11232                &local_var_str
11233                    .into_iter()
11234                    .map(|p| ("owner_group_id".to_owned(), p.to_string()))
11235                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11236            ),
11237            _ => local_var_req_builder.query(&[(
11238                "owner_group_id",
11239                &local_var_str
11240                    .into_iter()
11241                    .map(|p| p.to_string())
11242                    .collect::<Vec<String>>()
11243                    .join(",")
11244                    .to_string(),
11245            )]),
11246        };
11247    }
11248    if let Some(ref local_var_str) = owner_group_id__n {
11249        local_var_req_builder = match "multi" {
11250            "multi" => local_var_req_builder.query(
11251                &local_var_str
11252                    .into_iter()
11253                    .map(|p| ("owner_group_id__n".to_owned(), p.to_string()))
11254                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11255            ),
11256            _ => local_var_req_builder.query(&[(
11257                "owner_group_id__n",
11258                &local_var_str
11259                    .into_iter()
11260                    .map(|p| p.to_string())
11261                    .collect::<Vec<String>>()
11262                    .join(",")
11263                    .to_string(),
11264            )]),
11265        };
11266    }
11267    if let Some(ref local_var_str) = owner_id {
11268        local_var_req_builder = match "multi" {
11269            "multi" => local_var_req_builder.query(
11270                &local_var_str
11271                    .into_iter()
11272                    .map(|p| ("owner_id".to_owned(), p.to_string()))
11273                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11274            ),
11275            _ => local_var_req_builder.query(&[(
11276                "owner_id",
11277                &local_var_str
11278                    .into_iter()
11279                    .map(|p| p.to_string())
11280                    .collect::<Vec<String>>()
11281                    .join(",")
11282                    .to_string(),
11283            )]),
11284        };
11285    }
11286    if let Some(ref local_var_str) = owner_id__n {
11287        local_var_req_builder = match "multi" {
11288            "multi" => local_var_req_builder.query(
11289                &local_var_str
11290                    .into_iter()
11291                    .map(|p| ("owner_id__n".to_owned(), p.to_string()))
11292                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11293            ),
11294            _ => local_var_req_builder.query(&[(
11295                "owner_id__n",
11296                &local_var_str
11297                    .into_iter()
11298                    .map(|p| p.to_string())
11299                    .collect::<Vec<String>>()
11300                    .join(",")
11301                    .to_string(),
11302            )]),
11303        };
11304    }
11305    if let Some(ref local_var_str) = q {
11306        local_var_req_builder = local_var_req_builder.query(&[("q", &local_var_str.to_string())]);
11307    }
11308    if let Some(ref local_var_str) = size {
11309        local_var_req_builder = match "multi" {
11310            "multi" => local_var_req_builder.query(
11311                &local_var_str
11312                    .into_iter()
11313                    .map(|p| ("size".to_owned(), p.to_string()))
11314                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11315            ),
11316            _ => local_var_req_builder.query(&[(
11317                "size",
11318                &local_var_str
11319                    .into_iter()
11320                    .map(|p| p.to_string())
11321                    .collect::<Vec<String>>()
11322                    .join(",")
11323                    .to_string(),
11324            )]),
11325        };
11326    }
11327    if let Some(ref local_var_str) = size__empty {
11328        local_var_req_builder =
11329            local_var_req_builder.query(&[("size__empty", &local_var_str.to_string())]);
11330    }
11331    if let Some(ref local_var_str) = size__gt {
11332        local_var_req_builder = match "multi" {
11333            "multi" => local_var_req_builder.query(
11334                &local_var_str
11335                    .into_iter()
11336                    .map(|p| ("size__gt".to_owned(), p.to_string()))
11337                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11338            ),
11339            _ => local_var_req_builder.query(&[(
11340                "size__gt",
11341                &local_var_str
11342                    .into_iter()
11343                    .map(|p| p.to_string())
11344                    .collect::<Vec<String>>()
11345                    .join(",")
11346                    .to_string(),
11347            )]),
11348        };
11349    }
11350    if let Some(ref local_var_str) = size__gte {
11351        local_var_req_builder = match "multi" {
11352            "multi" => local_var_req_builder.query(
11353                &local_var_str
11354                    .into_iter()
11355                    .map(|p| ("size__gte".to_owned(), p.to_string()))
11356                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11357            ),
11358            _ => local_var_req_builder.query(&[(
11359                "size__gte",
11360                &local_var_str
11361                    .into_iter()
11362                    .map(|p| p.to_string())
11363                    .collect::<Vec<String>>()
11364                    .join(",")
11365                    .to_string(),
11366            )]),
11367        };
11368    }
11369    if let Some(ref local_var_str) = size__lt {
11370        local_var_req_builder = match "multi" {
11371            "multi" => local_var_req_builder.query(
11372                &local_var_str
11373                    .into_iter()
11374                    .map(|p| ("size__lt".to_owned(), p.to_string()))
11375                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11376            ),
11377            _ => local_var_req_builder.query(&[(
11378                "size__lt",
11379                &local_var_str
11380                    .into_iter()
11381                    .map(|p| p.to_string())
11382                    .collect::<Vec<String>>()
11383                    .join(",")
11384                    .to_string(),
11385            )]),
11386        };
11387    }
11388    if let Some(ref local_var_str) = size__lte {
11389        local_var_req_builder = match "multi" {
11390            "multi" => local_var_req_builder.query(
11391                &local_var_str
11392                    .into_iter()
11393                    .map(|p| ("size__lte".to_owned(), p.to_string()))
11394                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11395            ),
11396            _ => local_var_req_builder.query(&[(
11397                "size__lte",
11398                &local_var_str
11399                    .into_iter()
11400                    .map(|p| p.to_string())
11401                    .collect::<Vec<String>>()
11402                    .join(",")
11403                    .to_string(),
11404            )]),
11405        };
11406    }
11407    if let Some(ref local_var_str) = size__n {
11408        local_var_req_builder = match "multi" {
11409            "multi" => local_var_req_builder.query(
11410                &local_var_str
11411                    .into_iter()
11412                    .map(|p| ("size__n".to_owned(), p.to_string()))
11413                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11414            ),
11415            _ => local_var_req_builder.query(&[(
11416                "size__n",
11417                &local_var_str
11418                    .into_iter()
11419                    .map(|p| p.to_string())
11420                    .collect::<Vec<String>>()
11421                    .join(",")
11422                    .to_string(),
11423            )]),
11424        };
11425    }
11426    if let Some(ref local_var_str) = start {
11427        local_var_req_builder =
11428            local_var_req_builder.query(&[("start", &local_var_str.to_string())]);
11429    }
11430    if let Some(ref local_var_str) = tag {
11431        local_var_req_builder = match "multi" {
11432            "multi" => local_var_req_builder.query(
11433                &local_var_str
11434                    .into_iter()
11435                    .map(|p| ("tag".to_owned(), p.to_string()))
11436                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11437            ),
11438            _ => local_var_req_builder.query(&[(
11439                "tag",
11440                &local_var_str
11441                    .into_iter()
11442                    .map(|p| p.to_string())
11443                    .collect::<Vec<String>>()
11444                    .join(",")
11445                    .to_string(),
11446            )]),
11447        };
11448    }
11449    if let Some(ref local_var_str) = tag__n {
11450        local_var_req_builder = match "multi" {
11451            "multi" => local_var_req_builder.query(
11452                &local_var_str
11453                    .into_iter()
11454                    .map(|p| ("tag__n".to_owned(), p.to_string()))
11455                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11456            ),
11457            _ => local_var_req_builder.query(&[(
11458                "tag__n",
11459                &local_var_str
11460                    .into_iter()
11461                    .map(|p| p.to_string())
11462                    .collect::<Vec<String>>()
11463                    .join(",")
11464                    .to_string(),
11465            )]),
11466        };
11467    }
11468    if let Some(ref local_var_str) = tag_id {
11469        local_var_req_builder = match "multi" {
11470            "multi" => local_var_req_builder.query(
11471                &local_var_str
11472                    .into_iter()
11473                    .map(|p| ("tag_id".to_owned(), p.to_string()))
11474                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11475            ),
11476            _ => local_var_req_builder.query(&[(
11477                "tag_id",
11478                &local_var_str
11479                    .into_iter()
11480                    .map(|p| p.to_string())
11481                    .collect::<Vec<String>>()
11482                    .join(",")
11483                    .to_string(),
11484            )]),
11485        };
11486    }
11487    if let Some(ref local_var_str) = tag_id__n {
11488        local_var_req_builder = match "multi" {
11489            "multi" => local_var_req_builder.query(
11490                &local_var_str
11491                    .into_iter()
11492                    .map(|p| ("tag_id__n".to_owned(), p.to_string()))
11493                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11494            ),
11495            _ => local_var_req_builder.query(&[(
11496                "tag_id__n",
11497                &local_var_str
11498                    .into_iter()
11499                    .map(|p| p.to_string())
11500                    .collect::<Vec<String>>()
11501                    .join(",")
11502                    .to_string(),
11503            )]),
11504        };
11505    }
11506    if let Some(ref local_var_str) = updated_by_request {
11507        local_var_req_builder =
11508            local_var_req_builder.query(&[("updated_by_request", &local_var_str.to_string())]);
11509    }
11510    if let Some(ref local_var_str) = virtual_machine {
11511        local_var_req_builder = match "multi" {
11512            "multi" => local_var_req_builder.query(
11513                &local_var_str
11514                    .into_iter()
11515                    .map(|p| ("virtual_machine".to_owned(), p.to_string()))
11516                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11517            ),
11518            _ => local_var_req_builder.query(&[(
11519                "virtual_machine",
11520                &local_var_str
11521                    .into_iter()
11522                    .map(|p| p.to_string())
11523                    .collect::<Vec<String>>()
11524                    .join(",")
11525                    .to_string(),
11526            )]),
11527        };
11528    }
11529    if let Some(ref local_var_str) = virtual_machine__n {
11530        local_var_req_builder = match "multi" {
11531            "multi" => local_var_req_builder.query(
11532                &local_var_str
11533                    .into_iter()
11534                    .map(|p| ("virtual_machine__n".to_owned(), p.to_string()))
11535                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11536            ),
11537            _ => local_var_req_builder.query(&[(
11538                "virtual_machine__n",
11539                &local_var_str
11540                    .into_iter()
11541                    .map(|p| p.to_string())
11542                    .collect::<Vec<String>>()
11543                    .join(",")
11544                    .to_string(),
11545            )]),
11546        };
11547    }
11548    if let Some(ref local_var_str) = virtual_machine_id {
11549        local_var_req_builder = match "multi" {
11550            "multi" => local_var_req_builder.query(
11551                &local_var_str
11552                    .into_iter()
11553                    .map(|p| ("virtual_machine_id".to_owned(), p.to_string()))
11554                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11555            ),
11556            _ => local_var_req_builder.query(&[(
11557                "virtual_machine_id",
11558                &local_var_str
11559                    .into_iter()
11560                    .map(|p| p.to_string())
11561                    .collect::<Vec<String>>()
11562                    .join(",")
11563                    .to_string(),
11564            )]),
11565        };
11566    }
11567    if let Some(ref local_var_str) = virtual_machine_id__n {
11568        local_var_req_builder = match "multi" {
11569            "multi" => local_var_req_builder.query(
11570                &local_var_str
11571                    .into_iter()
11572                    .map(|p| ("virtual_machine_id__n".to_owned(), p.to_string()))
11573                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11574            ),
11575            _ => local_var_req_builder.query(&[(
11576                "virtual_machine_id__n",
11577                &local_var_str
11578                    .into_iter()
11579                    .map(|p| p.to_string())
11580                    .collect::<Vec<String>>()
11581                    .join(",")
11582                    .to_string(),
11583            )]),
11584        };
11585    }
11586    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
11587        local_var_req_builder =
11588            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
11589    }
11590    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
11591        let local_var_key = local_var_apikey.key.clone();
11592        let local_var_value = match local_var_apikey.prefix {
11593            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
11594            None => local_var_key,
11595        };
11596        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
11597    };
11598
11599    let local_var_req = local_var_req_builder.build()?;
11600    let local_var_resp = local_var_client.execute(local_var_req).await?;
11601
11602    let local_var_status = local_var_resp.status();
11603    let local_var_content = local_var_resp.text().await?;
11604
11605    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
11606        serde_json::from_str(&local_var_content).map_err(Error::from)
11607    } else {
11608        let local_var_entity: Option<VirtualizationVirtualDisksListError> =
11609            serde_json::from_str(&local_var_content).ok();
11610        let local_var_error = ResponseContent {
11611            status: local_var_status,
11612            content: local_var_content,
11613            entity: local_var_entity,
11614        };
11615        Err(Error::ResponseError(local_var_error))
11616    }
11617}
11618
11619/// Patch a virtual disk object.
11620pub async fn virtualization_virtual_disks_partial_update(
11621    configuration: &configuration::Configuration,
11622    id: i32,
11623    patched_virtual_disk_request: Option<crate::models::PatchedVirtualDiskRequest>,
11624) -> Result<crate::models::VirtualDisk, Error<VirtualizationVirtualDisksPartialUpdateError>> {
11625    let local_var_configuration = configuration;
11626
11627    let local_var_client = &local_var_configuration.client;
11628
11629    let local_var_uri_str = format!(
11630        "{}/api/virtualization/virtual-disks/{id}/",
11631        local_var_configuration.base_path,
11632        id = id
11633    );
11634    let mut local_var_req_builder =
11635        local_var_client.request(reqwest::Method::PATCH, local_var_uri_str.as_str());
11636
11637    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
11638        local_var_req_builder =
11639            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
11640    }
11641    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
11642        let local_var_key = local_var_apikey.key.clone();
11643        let local_var_value = match local_var_apikey.prefix {
11644            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
11645            None => local_var_key,
11646        };
11647        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
11648    };
11649    local_var_req_builder = local_var_req_builder.json(&patched_virtual_disk_request);
11650
11651    let local_var_req = local_var_req_builder.build()?;
11652    let local_var_resp = local_var_client.execute(local_var_req).await?;
11653
11654    let local_var_status = local_var_resp.status();
11655    let local_var_content = local_var_resp.text().await?;
11656
11657    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
11658        serde_json::from_str(&local_var_content).map_err(Error::from)
11659    } else {
11660        let local_var_entity: Option<VirtualizationVirtualDisksPartialUpdateError> =
11661            serde_json::from_str(&local_var_content).ok();
11662        let local_var_error = ResponseContent {
11663            status: local_var_status,
11664            content: local_var_content,
11665            entity: local_var_entity,
11666        };
11667        Err(Error::ResponseError(local_var_error))
11668    }
11669}
11670
11671/// Get a virtual disk object.
11672pub async fn virtualization_virtual_disks_retrieve(
11673    configuration: &configuration::Configuration,
11674    id: i32,
11675) -> Result<crate::models::VirtualDisk, Error<VirtualizationVirtualDisksRetrieveError>> {
11676    let local_var_configuration = configuration;
11677
11678    let local_var_client = &local_var_configuration.client;
11679
11680    let local_var_uri_str = format!(
11681        "{}/api/virtualization/virtual-disks/{id}/",
11682        local_var_configuration.base_path,
11683        id = id
11684    );
11685    let mut local_var_req_builder =
11686        local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
11687
11688    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
11689        local_var_req_builder =
11690            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
11691    }
11692    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
11693        let local_var_key = local_var_apikey.key.clone();
11694        let local_var_value = match local_var_apikey.prefix {
11695            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
11696            None => local_var_key,
11697        };
11698        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
11699    };
11700
11701    let local_var_req = local_var_req_builder.build()?;
11702    let local_var_resp = local_var_client.execute(local_var_req).await?;
11703
11704    let local_var_status = local_var_resp.status();
11705    let local_var_content = local_var_resp.text().await?;
11706
11707    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
11708        serde_json::from_str(&local_var_content).map_err(Error::from)
11709    } else {
11710        let local_var_entity: Option<VirtualizationVirtualDisksRetrieveError> =
11711            serde_json::from_str(&local_var_content).ok();
11712        let local_var_error = ResponseContent {
11713            status: local_var_status,
11714            content: local_var_content,
11715            entity: local_var_entity,
11716        };
11717        Err(Error::ResponseError(local_var_error))
11718    }
11719}
11720
11721/// Put a virtual disk object.
11722pub async fn virtualization_virtual_disks_update(
11723    configuration: &configuration::Configuration,
11724    id: i32,
11725    virtual_disk_request: crate::models::VirtualDiskRequest,
11726) -> Result<crate::models::VirtualDisk, Error<VirtualizationVirtualDisksUpdateError>> {
11727    let local_var_configuration = configuration;
11728
11729    let local_var_client = &local_var_configuration.client;
11730
11731    let local_var_uri_str = format!(
11732        "{}/api/virtualization/virtual-disks/{id}/",
11733        local_var_configuration.base_path,
11734        id = id
11735    );
11736    let mut local_var_req_builder =
11737        local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());
11738
11739    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
11740        local_var_req_builder =
11741            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
11742    }
11743    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
11744        let local_var_key = local_var_apikey.key.clone();
11745        let local_var_value = match local_var_apikey.prefix {
11746            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
11747            None => local_var_key,
11748        };
11749        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
11750    };
11751    local_var_req_builder = local_var_req_builder.json(&virtual_disk_request);
11752
11753    let local_var_req = local_var_req_builder.build()?;
11754    let local_var_resp = local_var_client.execute(local_var_req).await?;
11755
11756    let local_var_status = local_var_resp.status();
11757    let local_var_content = local_var_resp.text().await?;
11758
11759    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
11760        serde_json::from_str(&local_var_content).map_err(Error::from)
11761    } else {
11762        let local_var_entity: Option<VirtualizationVirtualDisksUpdateError> =
11763            serde_json::from_str(&local_var_content).ok();
11764        let local_var_error = ResponseContent {
11765            status: local_var_status,
11766            content: local_var_content,
11767            entity: local_var_entity,
11768        };
11769        Err(Error::ResponseError(local_var_error))
11770    }
11771}
11772
11773/// Delete a list of virtual machine type objects.
11774pub async fn virtualization_virtual_machine_types_bulk_destroy(
11775    configuration: &configuration::Configuration,
11776    virtual_machine_type_request: Vec<crate::models::VirtualMachineTypeRequest>,
11777) -> Result<(), Error<VirtualizationVirtualMachineTypesBulkDestroyError>> {
11778    let local_var_configuration = configuration;
11779
11780    let local_var_client = &local_var_configuration.client;
11781
11782    let local_var_uri_str = format!(
11783        "{}/api/virtualization/virtual-machine-types/",
11784        local_var_configuration.base_path
11785    );
11786    let mut local_var_req_builder =
11787        local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());
11788
11789    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
11790        local_var_req_builder =
11791            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
11792    }
11793    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
11794        let local_var_key = local_var_apikey.key.clone();
11795        let local_var_value = match local_var_apikey.prefix {
11796            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
11797            None => local_var_key,
11798        };
11799        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
11800    };
11801    local_var_req_builder = local_var_req_builder.json(&virtual_machine_type_request);
11802
11803    let local_var_req = local_var_req_builder.build()?;
11804    let local_var_resp = local_var_client.execute(local_var_req).await?;
11805
11806    let local_var_status = local_var_resp.status();
11807    let local_var_content = local_var_resp.text().await?;
11808
11809    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
11810        Ok(())
11811    } else {
11812        let local_var_entity: Option<VirtualizationVirtualMachineTypesBulkDestroyError> =
11813            serde_json::from_str(&local_var_content).ok();
11814        let local_var_error = ResponseContent {
11815            status: local_var_status,
11816            content: local_var_content,
11817            entity: local_var_entity,
11818        };
11819        Err(Error::ResponseError(local_var_error))
11820    }
11821}
11822
11823/// Patch a list of virtual machine type objects.
11824pub async fn virtualization_virtual_machine_types_bulk_partial_update(
11825    configuration: &configuration::Configuration,
11826    virtual_machine_type_request: Vec<crate::models::VirtualMachineTypeRequest>,
11827) -> Result<
11828    Vec<crate::models::VirtualMachineType>,
11829    Error<VirtualizationVirtualMachineTypesBulkPartialUpdateError>,
11830> {
11831    let local_var_configuration = configuration;
11832
11833    let local_var_client = &local_var_configuration.client;
11834
11835    let local_var_uri_str = format!(
11836        "{}/api/virtualization/virtual-machine-types/",
11837        local_var_configuration.base_path
11838    );
11839    let mut local_var_req_builder =
11840        local_var_client.request(reqwest::Method::PATCH, local_var_uri_str.as_str());
11841
11842    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
11843        local_var_req_builder =
11844            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
11845    }
11846    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
11847        let local_var_key = local_var_apikey.key.clone();
11848        let local_var_value = match local_var_apikey.prefix {
11849            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
11850            None => local_var_key,
11851        };
11852        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
11853    };
11854    local_var_req_builder = local_var_req_builder.json(&virtual_machine_type_request);
11855
11856    let local_var_req = local_var_req_builder.build()?;
11857    let local_var_resp = local_var_client.execute(local_var_req).await?;
11858
11859    let local_var_status = local_var_resp.status();
11860    let local_var_content = local_var_resp.text().await?;
11861
11862    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
11863        serde_json::from_str(&local_var_content).map_err(Error::from)
11864    } else {
11865        let local_var_entity: Option<VirtualizationVirtualMachineTypesBulkPartialUpdateError> =
11866            serde_json::from_str(&local_var_content).ok();
11867        let local_var_error = ResponseContent {
11868            status: local_var_status,
11869            content: local_var_content,
11870            entity: local_var_entity,
11871        };
11872        Err(Error::ResponseError(local_var_error))
11873    }
11874}
11875
11876/// Put a list of virtual machine type objects.
11877pub async fn virtualization_virtual_machine_types_bulk_update(
11878    configuration: &configuration::Configuration,
11879    virtual_machine_type_request: Vec<crate::models::VirtualMachineTypeRequest>,
11880) -> Result<
11881    Vec<crate::models::VirtualMachineType>,
11882    Error<VirtualizationVirtualMachineTypesBulkUpdateError>,
11883> {
11884    let local_var_configuration = configuration;
11885
11886    let local_var_client = &local_var_configuration.client;
11887
11888    let local_var_uri_str = format!(
11889        "{}/api/virtualization/virtual-machine-types/",
11890        local_var_configuration.base_path
11891    );
11892    let mut local_var_req_builder =
11893        local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());
11894
11895    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
11896        local_var_req_builder =
11897            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
11898    }
11899    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
11900        let local_var_key = local_var_apikey.key.clone();
11901        let local_var_value = match local_var_apikey.prefix {
11902            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
11903            None => local_var_key,
11904        };
11905        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
11906    };
11907    local_var_req_builder = local_var_req_builder.json(&virtual_machine_type_request);
11908
11909    let local_var_req = local_var_req_builder.build()?;
11910    let local_var_resp = local_var_client.execute(local_var_req).await?;
11911
11912    let local_var_status = local_var_resp.status();
11913    let local_var_content = local_var_resp.text().await?;
11914
11915    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
11916        serde_json::from_str(&local_var_content).map_err(Error::from)
11917    } else {
11918        let local_var_entity: Option<VirtualizationVirtualMachineTypesBulkUpdateError> =
11919            serde_json::from_str(&local_var_content).ok();
11920        let local_var_error = ResponseContent {
11921            status: local_var_status,
11922            content: local_var_content,
11923            entity: local_var_entity,
11924        };
11925        Err(Error::ResponseError(local_var_error))
11926    }
11927}
11928
11929/// Post a list of virtual machine type objects.
11930pub async fn virtualization_virtual_machine_types_create(
11931    configuration: &configuration::Configuration,
11932    virtualization_virtual_machine_types_create_request: crate::models::VirtualizationVirtualMachineTypesCreateRequest,
11933) -> Result<crate::models::VirtualMachineType, Error<VirtualizationVirtualMachineTypesCreateError>>
11934{
11935    let local_var_configuration = configuration;
11936
11937    let local_var_client = &local_var_configuration.client;
11938
11939    let local_var_uri_str = format!(
11940        "{}/api/virtualization/virtual-machine-types/",
11941        local_var_configuration.base_path
11942    );
11943    let mut local_var_req_builder =
11944        local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
11945
11946    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
11947        local_var_req_builder =
11948            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
11949    }
11950    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
11951        let local_var_key = local_var_apikey.key.clone();
11952        let local_var_value = match local_var_apikey.prefix {
11953            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
11954            None => local_var_key,
11955        };
11956        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
11957    };
11958    local_var_req_builder =
11959        local_var_req_builder.json(&virtualization_virtual_machine_types_create_request);
11960
11961    let local_var_req = local_var_req_builder.build()?;
11962    let local_var_resp = local_var_client.execute(local_var_req).await?;
11963
11964    let local_var_status = local_var_resp.status();
11965    let local_var_content = local_var_resp.text().await?;
11966
11967    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
11968        serde_json::from_str(&local_var_content).map_err(Error::from)
11969    } else {
11970        let local_var_entity: Option<VirtualizationVirtualMachineTypesCreateError> =
11971            serde_json::from_str(&local_var_content).ok();
11972        let local_var_error = ResponseContent {
11973            status: local_var_status,
11974            content: local_var_content,
11975            entity: local_var_entity,
11976        };
11977        Err(Error::ResponseError(local_var_error))
11978    }
11979}
11980
11981/// Delete a virtual machine type object.
11982pub async fn virtualization_virtual_machine_types_destroy(
11983    configuration: &configuration::Configuration,
11984    id: i32,
11985) -> Result<(), Error<VirtualizationVirtualMachineTypesDestroyError>> {
11986    let local_var_configuration = configuration;
11987
11988    let local_var_client = &local_var_configuration.client;
11989
11990    let local_var_uri_str = format!(
11991        "{}/api/virtualization/virtual-machine-types/{id}/",
11992        local_var_configuration.base_path,
11993        id = id
11994    );
11995    let mut local_var_req_builder =
11996        local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());
11997
11998    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
11999        local_var_req_builder =
12000            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
12001    }
12002    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
12003        let local_var_key = local_var_apikey.key.clone();
12004        let local_var_value = match local_var_apikey.prefix {
12005            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
12006            None => local_var_key,
12007        };
12008        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
12009    };
12010
12011    let local_var_req = local_var_req_builder.build()?;
12012    let local_var_resp = local_var_client.execute(local_var_req).await?;
12013
12014    let local_var_status = local_var_resp.status();
12015    let local_var_content = local_var_resp.text().await?;
12016
12017    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
12018        Ok(())
12019    } else {
12020        let local_var_entity: Option<VirtualizationVirtualMachineTypesDestroyError> =
12021            serde_json::from_str(&local_var_content).ok();
12022        let local_var_error = ResponseContent {
12023            status: local_var_status,
12024            content: local_var_content,
12025            entity: local_var_entity,
12026        };
12027        Err(Error::ResponseError(local_var_error))
12028    }
12029}
12030
12031/// Get a list of virtual machine type objects.
12032pub async fn virtualization_virtual_machine_types_list(
12033    configuration: &configuration::Configuration,
12034    created: Option<Vec<String>>,
12035    created__empty: Option<Vec<String>>,
12036    created__gt: Option<Vec<String>>,
12037    created__gte: Option<Vec<String>>,
12038    created__lt: Option<Vec<String>>,
12039    created__lte: Option<Vec<String>>,
12040    created__n: Option<Vec<String>>,
12041    created_by_request: Option<&str>,
12042    default_memory: Option<Vec<i32>>,
12043    default_memory__empty: Option<bool>,
12044    default_memory__gt: Option<Vec<i32>>,
12045    default_memory__gte: Option<Vec<i32>>,
12046    default_memory__lt: Option<Vec<i32>>,
12047    default_memory__lte: Option<Vec<i32>>,
12048    default_memory__n: Option<Vec<i32>>,
12049    default_platform: Option<Vec<String>>,
12050    default_platform__n: Option<Vec<String>>,
12051    default_platform_id: Option<Vec<String>>,
12052    default_platform_id__n: Option<Vec<String>>,
12053    default_vcpus: Option<Vec<f64>>,
12054    default_vcpus__empty: Option<bool>,
12055    default_vcpus__gt: Option<Vec<f64>>,
12056    default_vcpus__gte: Option<Vec<f64>>,
12057    default_vcpus__lt: Option<Vec<f64>>,
12058    default_vcpus__lte: Option<Vec<f64>>,
12059    default_vcpus__n: Option<Vec<f64>>,
12060    description: Option<Vec<String>>,
12061    description__empty: Option<bool>,
12062    description__ic: Option<Vec<String>>,
12063    description__ie: Option<Vec<String>>,
12064    description__iew: Option<Vec<String>>,
12065    description__iregex: Option<Vec<String>>,
12066    description__isw: Option<Vec<String>>,
12067    description__n: Option<Vec<String>>,
12068    description__nic: Option<Vec<String>>,
12069    description__nie: Option<Vec<String>>,
12070    description__niew: Option<Vec<String>>,
12071    description__nisw: Option<Vec<String>>,
12072    description__regex: Option<Vec<String>>,
12073    id: Option<Vec<i32>>,
12074    id__empty: Option<bool>,
12075    id__gt: Option<Vec<i32>>,
12076    id__gte: Option<Vec<i32>>,
12077    id__lt: Option<Vec<i32>>,
12078    id__lte: Option<Vec<i32>>,
12079    id__n: Option<Vec<i32>>,
12080    last_updated: Option<Vec<String>>,
12081    last_updated__empty: Option<Vec<String>>,
12082    last_updated__gt: Option<Vec<String>>,
12083    last_updated__gte: Option<Vec<String>>,
12084    last_updated__lt: Option<Vec<String>>,
12085    last_updated__lte: Option<Vec<String>>,
12086    last_updated__n: Option<Vec<String>>,
12087    limit: Option<i32>,
12088    modified_by_request: Option<&str>,
12089    name: Option<Vec<String>>,
12090    name__empty: Option<bool>,
12091    name__ic: Option<Vec<String>>,
12092    name__ie: Option<Vec<String>>,
12093    name__iew: Option<Vec<String>>,
12094    name__iregex: Option<Vec<String>>,
12095    name__isw: Option<Vec<String>>,
12096    name__n: Option<Vec<String>>,
12097    name__nic: Option<Vec<String>>,
12098    name__nie: Option<Vec<String>>,
12099    name__niew: Option<Vec<String>>,
12100    name__nisw: Option<Vec<String>>,
12101    name__regex: Option<Vec<String>>,
12102    offset: Option<i32>,
12103    ordering: Option<&str>,
12104    owner: Option<Vec<String>>,
12105    owner__n: Option<Vec<String>>,
12106    owner_group: Option<Vec<String>>,
12107    owner_group__n: Option<Vec<String>>,
12108    owner_group_id: Option<Vec<i32>>,
12109    owner_group_id__n: Option<Vec<i32>>,
12110    owner_id: Option<Vec<i32>>,
12111    owner_id__n: Option<Vec<i32>>,
12112    q: Option<&str>,
12113    slug: Option<Vec<String>>,
12114    slug__empty: Option<bool>,
12115    slug__ic: Option<Vec<String>>,
12116    slug__ie: Option<Vec<String>>,
12117    slug__iew: Option<Vec<String>>,
12118    slug__iregex: Option<Vec<String>>,
12119    slug__isw: Option<Vec<String>>,
12120    slug__n: Option<Vec<String>>,
12121    slug__nic: Option<Vec<String>>,
12122    slug__nie: Option<Vec<String>>,
12123    slug__niew: Option<Vec<String>>,
12124    slug__nisw: Option<Vec<String>>,
12125    slug__regex: Option<Vec<String>>,
12126    start: Option<i32>,
12127    tag: Option<Vec<String>>,
12128    tag__n: Option<Vec<String>>,
12129    tag_id: Option<Vec<i32>>,
12130    tag_id__n: Option<Vec<i32>>,
12131    updated_by_request: Option<&str>,
12132    virtual_machine_count: Option<Vec<i32>>,
12133    virtual_machine_count__empty: Option<bool>,
12134    virtual_machine_count__gt: Option<Vec<i32>>,
12135    virtual_machine_count__gte: Option<Vec<i32>>,
12136    virtual_machine_count__lt: Option<Vec<i32>>,
12137    virtual_machine_count__lte: Option<Vec<i32>>,
12138    virtual_machine_count__n: Option<Vec<i32>>,
12139) -> Result<
12140    crate::models::PaginatedVirtualMachineTypeList,
12141    Error<VirtualizationVirtualMachineTypesListError>,
12142> {
12143    let local_var_configuration = configuration;
12144
12145    let local_var_client = &local_var_configuration.client;
12146
12147    let local_var_uri_str = format!(
12148        "{}/api/virtualization/virtual-machine-types/",
12149        local_var_configuration.base_path
12150    );
12151    let mut local_var_req_builder =
12152        local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
12153
12154    if let Some(ref local_var_str) = created {
12155        local_var_req_builder = match "multi" {
12156            "multi" => local_var_req_builder.query(
12157                &local_var_str
12158                    .into_iter()
12159                    .map(|p| ("created".to_owned(), p.to_string()))
12160                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12161            ),
12162            _ => local_var_req_builder.query(&[(
12163                "created",
12164                &local_var_str
12165                    .into_iter()
12166                    .map(|p| p.to_string())
12167                    .collect::<Vec<String>>()
12168                    .join(",")
12169                    .to_string(),
12170            )]),
12171        };
12172    }
12173    if let Some(ref local_var_str) = created__empty {
12174        local_var_req_builder = match "multi" {
12175            "multi" => local_var_req_builder.query(
12176                &local_var_str
12177                    .into_iter()
12178                    .map(|p| ("created__empty".to_owned(), p.to_string()))
12179                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12180            ),
12181            _ => local_var_req_builder.query(&[(
12182                "created__empty",
12183                &local_var_str
12184                    .into_iter()
12185                    .map(|p| p.to_string())
12186                    .collect::<Vec<String>>()
12187                    .join(",")
12188                    .to_string(),
12189            )]),
12190        };
12191    }
12192    if let Some(ref local_var_str) = created__gt {
12193        local_var_req_builder = match "multi" {
12194            "multi" => local_var_req_builder.query(
12195                &local_var_str
12196                    .into_iter()
12197                    .map(|p| ("created__gt".to_owned(), p.to_string()))
12198                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12199            ),
12200            _ => local_var_req_builder.query(&[(
12201                "created__gt",
12202                &local_var_str
12203                    .into_iter()
12204                    .map(|p| p.to_string())
12205                    .collect::<Vec<String>>()
12206                    .join(",")
12207                    .to_string(),
12208            )]),
12209        };
12210    }
12211    if let Some(ref local_var_str) = created__gte {
12212        local_var_req_builder = match "multi" {
12213            "multi" => local_var_req_builder.query(
12214                &local_var_str
12215                    .into_iter()
12216                    .map(|p| ("created__gte".to_owned(), p.to_string()))
12217                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12218            ),
12219            _ => local_var_req_builder.query(&[(
12220                "created__gte",
12221                &local_var_str
12222                    .into_iter()
12223                    .map(|p| p.to_string())
12224                    .collect::<Vec<String>>()
12225                    .join(",")
12226                    .to_string(),
12227            )]),
12228        };
12229    }
12230    if let Some(ref local_var_str) = created__lt {
12231        local_var_req_builder = match "multi" {
12232            "multi" => local_var_req_builder.query(
12233                &local_var_str
12234                    .into_iter()
12235                    .map(|p| ("created__lt".to_owned(), p.to_string()))
12236                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12237            ),
12238            _ => local_var_req_builder.query(&[(
12239                "created__lt",
12240                &local_var_str
12241                    .into_iter()
12242                    .map(|p| p.to_string())
12243                    .collect::<Vec<String>>()
12244                    .join(",")
12245                    .to_string(),
12246            )]),
12247        };
12248    }
12249    if let Some(ref local_var_str) = created__lte {
12250        local_var_req_builder = match "multi" {
12251            "multi" => local_var_req_builder.query(
12252                &local_var_str
12253                    .into_iter()
12254                    .map(|p| ("created__lte".to_owned(), p.to_string()))
12255                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12256            ),
12257            _ => local_var_req_builder.query(&[(
12258                "created__lte",
12259                &local_var_str
12260                    .into_iter()
12261                    .map(|p| p.to_string())
12262                    .collect::<Vec<String>>()
12263                    .join(",")
12264                    .to_string(),
12265            )]),
12266        };
12267    }
12268    if let Some(ref local_var_str) = created__n {
12269        local_var_req_builder = match "multi" {
12270            "multi" => local_var_req_builder.query(
12271                &local_var_str
12272                    .into_iter()
12273                    .map(|p| ("created__n".to_owned(), p.to_string()))
12274                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12275            ),
12276            _ => local_var_req_builder.query(&[(
12277                "created__n",
12278                &local_var_str
12279                    .into_iter()
12280                    .map(|p| p.to_string())
12281                    .collect::<Vec<String>>()
12282                    .join(",")
12283                    .to_string(),
12284            )]),
12285        };
12286    }
12287    if let Some(ref local_var_str) = created_by_request {
12288        local_var_req_builder =
12289            local_var_req_builder.query(&[("created_by_request", &local_var_str.to_string())]);
12290    }
12291    if let Some(ref local_var_str) = default_memory {
12292        local_var_req_builder = match "multi" {
12293            "multi" => local_var_req_builder.query(
12294                &local_var_str
12295                    .into_iter()
12296                    .map(|p| ("default_memory".to_owned(), p.to_string()))
12297                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12298            ),
12299            _ => local_var_req_builder.query(&[(
12300                "default_memory",
12301                &local_var_str
12302                    .into_iter()
12303                    .map(|p| p.to_string())
12304                    .collect::<Vec<String>>()
12305                    .join(",")
12306                    .to_string(),
12307            )]),
12308        };
12309    }
12310    if let Some(ref local_var_str) = default_memory__empty {
12311        local_var_req_builder =
12312            local_var_req_builder.query(&[("default_memory__empty", &local_var_str.to_string())]);
12313    }
12314    if let Some(ref local_var_str) = default_memory__gt {
12315        local_var_req_builder = match "multi" {
12316            "multi" => local_var_req_builder.query(
12317                &local_var_str
12318                    .into_iter()
12319                    .map(|p| ("default_memory__gt".to_owned(), p.to_string()))
12320                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12321            ),
12322            _ => local_var_req_builder.query(&[(
12323                "default_memory__gt",
12324                &local_var_str
12325                    .into_iter()
12326                    .map(|p| p.to_string())
12327                    .collect::<Vec<String>>()
12328                    .join(",")
12329                    .to_string(),
12330            )]),
12331        };
12332    }
12333    if let Some(ref local_var_str) = default_memory__gte {
12334        local_var_req_builder = match "multi" {
12335            "multi" => local_var_req_builder.query(
12336                &local_var_str
12337                    .into_iter()
12338                    .map(|p| ("default_memory__gte".to_owned(), p.to_string()))
12339                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12340            ),
12341            _ => local_var_req_builder.query(&[(
12342                "default_memory__gte",
12343                &local_var_str
12344                    .into_iter()
12345                    .map(|p| p.to_string())
12346                    .collect::<Vec<String>>()
12347                    .join(",")
12348                    .to_string(),
12349            )]),
12350        };
12351    }
12352    if let Some(ref local_var_str) = default_memory__lt {
12353        local_var_req_builder = match "multi" {
12354            "multi" => local_var_req_builder.query(
12355                &local_var_str
12356                    .into_iter()
12357                    .map(|p| ("default_memory__lt".to_owned(), p.to_string()))
12358                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12359            ),
12360            _ => local_var_req_builder.query(&[(
12361                "default_memory__lt",
12362                &local_var_str
12363                    .into_iter()
12364                    .map(|p| p.to_string())
12365                    .collect::<Vec<String>>()
12366                    .join(",")
12367                    .to_string(),
12368            )]),
12369        };
12370    }
12371    if let Some(ref local_var_str) = default_memory__lte {
12372        local_var_req_builder = match "multi" {
12373            "multi" => local_var_req_builder.query(
12374                &local_var_str
12375                    .into_iter()
12376                    .map(|p| ("default_memory__lte".to_owned(), p.to_string()))
12377                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12378            ),
12379            _ => local_var_req_builder.query(&[(
12380                "default_memory__lte",
12381                &local_var_str
12382                    .into_iter()
12383                    .map(|p| p.to_string())
12384                    .collect::<Vec<String>>()
12385                    .join(",")
12386                    .to_string(),
12387            )]),
12388        };
12389    }
12390    if let Some(ref local_var_str) = default_memory__n {
12391        local_var_req_builder = match "multi" {
12392            "multi" => local_var_req_builder.query(
12393                &local_var_str
12394                    .into_iter()
12395                    .map(|p| ("default_memory__n".to_owned(), p.to_string()))
12396                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12397            ),
12398            _ => local_var_req_builder.query(&[(
12399                "default_memory__n",
12400                &local_var_str
12401                    .into_iter()
12402                    .map(|p| p.to_string())
12403                    .collect::<Vec<String>>()
12404                    .join(",")
12405                    .to_string(),
12406            )]),
12407        };
12408    }
12409    if let Some(ref local_var_str) = default_platform {
12410        local_var_req_builder = match "multi" {
12411            "multi" => local_var_req_builder.query(
12412                &local_var_str
12413                    .into_iter()
12414                    .map(|p| ("default_platform".to_owned(), p.to_string()))
12415                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12416            ),
12417            _ => local_var_req_builder.query(&[(
12418                "default_platform",
12419                &local_var_str
12420                    .into_iter()
12421                    .map(|p| p.to_string())
12422                    .collect::<Vec<String>>()
12423                    .join(",")
12424                    .to_string(),
12425            )]),
12426        };
12427    }
12428    if let Some(ref local_var_str) = default_platform__n {
12429        local_var_req_builder = match "multi" {
12430            "multi" => local_var_req_builder.query(
12431                &local_var_str
12432                    .into_iter()
12433                    .map(|p| ("default_platform__n".to_owned(), p.to_string()))
12434                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12435            ),
12436            _ => local_var_req_builder.query(&[(
12437                "default_platform__n",
12438                &local_var_str
12439                    .into_iter()
12440                    .map(|p| p.to_string())
12441                    .collect::<Vec<String>>()
12442                    .join(",")
12443                    .to_string(),
12444            )]),
12445        };
12446    }
12447    if let Some(ref local_var_str) = default_platform_id {
12448        local_var_req_builder = match "multi" {
12449            "multi" => local_var_req_builder.query(
12450                &local_var_str
12451                    .into_iter()
12452                    .map(|p| ("default_platform_id".to_owned(), p.to_string()))
12453                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12454            ),
12455            _ => local_var_req_builder.query(&[(
12456                "default_platform_id",
12457                &local_var_str
12458                    .into_iter()
12459                    .map(|p| p.to_string())
12460                    .collect::<Vec<String>>()
12461                    .join(",")
12462                    .to_string(),
12463            )]),
12464        };
12465    }
12466    if let Some(ref local_var_str) = default_platform_id__n {
12467        local_var_req_builder = match "multi" {
12468            "multi" => local_var_req_builder.query(
12469                &local_var_str
12470                    .into_iter()
12471                    .map(|p| ("default_platform_id__n".to_owned(), p.to_string()))
12472                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12473            ),
12474            _ => local_var_req_builder.query(&[(
12475                "default_platform_id__n",
12476                &local_var_str
12477                    .into_iter()
12478                    .map(|p| p.to_string())
12479                    .collect::<Vec<String>>()
12480                    .join(",")
12481                    .to_string(),
12482            )]),
12483        };
12484    }
12485    if let Some(ref local_var_str) = default_vcpus {
12486        local_var_req_builder = match "multi" {
12487            "multi" => local_var_req_builder.query(
12488                &local_var_str
12489                    .into_iter()
12490                    .map(|p| ("default_vcpus".to_owned(), p.to_string()))
12491                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12492            ),
12493            _ => local_var_req_builder.query(&[(
12494                "default_vcpus",
12495                &local_var_str
12496                    .into_iter()
12497                    .map(|p| p.to_string())
12498                    .collect::<Vec<String>>()
12499                    .join(",")
12500                    .to_string(),
12501            )]),
12502        };
12503    }
12504    if let Some(ref local_var_str) = default_vcpus__empty {
12505        local_var_req_builder =
12506            local_var_req_builder.query(&[("default_vcpus__empty", &local_var_str.to_string())]);
12507    }
12508    if let Some(ref local_var_str) = default_vcpus__gt {
12509        local_var_req_builder = match "multi" {
12510            "multi" => local_var_req_builder.query(
12511                &local_var_str
12512                    .into_iter()
12513                    .map(|p| ("default_vcpus__gt".to_owned(), p.to_string()))
12514                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12515            ),
12516            _ => local_var_req_builder.query(&[(
12517                "default_vcpus__gt",
12518                &local_var_str
12519                    .into_iter()
12520                    .map(|p| p.to_string())
12521                    .collect::<Vec<String>>()
12522                    .join(",")
12523                    .to_string(),
12524            )]),
12525        };
12526    }
12527    if let Some(ref local_var_str) = default_vcpus__gte {
12528        local_var_req_builder = match "multi" {
12529            "multi" => local_var_req_builder.query(
12530                &local_var_str
12531                    .into_iter()
12532                    .map(|p| ("default_vcpus__gte".to_owned(), p.to_string()))
12533                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12534            ),
12535            _ => local_var_req_builder.query(&[(
12536                "default_vcpus__gte",
12537                &local_var_str
12538                    .into_iter()
12539                    .map(|p| p.to_string())
12540                    .collect::<Vec<String>>()
12541                    .join(",")
12542                    .to_string(),
12543            )]),
12544        };
12545    }
12546    if let Some(ref local_var_str) = default_vcpus__lt {
12547        local_var_req_builder = match "multi" {
12548            "multi" => local_var_req_builder.query(
12549                &local_var_str
12550                    .into_iter()
12551                    .map(|p| ("default_vcpus__lt".to_owned(), p.to_string()))
12552                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12553            ),
12554            _ => local_var_req_builder.query(&[(
12555                "default_vcpus__lt",
12556                &local_var_str
12557                    .into_iter()
12558                    .map(|p| p.to_string())
12559                    .collect::<Vec<String>>()
12560                    .join(",")
12561                    .to_string(),
12562            )]),
12563        };
12564    }
12565    if let Some(ref local_var_str) = default_vcpus__lte {
12566        local_var_req_builder = match "multi" {
12567            "multi" => local_var_req_builder.query(
12568                &local_var_str
12569                    .into_iter()
12570                    .map(|p| ("default_vcpus__lte".to_owned(), p.to_string()))
12571                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12572            ),
12573            _ => local_var_req_builder.query(&[(
12574                "default_vcpus__lte",
12575                &local_var_str
12576                    .into_iter()
12577                    .map(|p| p.to_string())
12578                    .collect::<Vec<String>>()
12579                    .join(",")
12580                    .to_string(),
12581            )]),
12582        };
12583    }
12584    if let Some(ref local_var_str) = default_vcpus__n {
12585        local_var_req_builder = match "multi" {
12586            "multi" => local_var_req_builder.query(
12587                &local_var_str
12588                    .into_iter()
12589                    .map(|p| ("default_vcpus__n".to_owned(), p.to_string()))
12590                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12591            ),
12592            _ => local_var_req_builder.query(&[(
12593                "default_vcpus__n",
12594                &local_var_str
12595                    .into_iter()
12596                    .map(|p| p.to_string())
12597                    .collect::<Vec<String>>()
12598                    .join(",")
12599                    .to_string(),
12600            )]),
12601        };
12602    }
12603    if let Some(ref local_var_str) = description {
12604        local_var_req_builder = match "multi" {
12605            "multi" => local_var_req_builder.query(
12606                &local_var_str
12607                    .into_iter()
12608                    .map(|p| ("description".to_owned(), p.to_string()))
12609                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12610            ),
12611            _ => local_var_req_builder.query(&[(
12612                "description",
12613                &local_var_str
12614                    .into_iter()
12615                    .map(|p| p.to_string())
12616                    .collect::<Vec<String>>()
12617                    .join(",")
12618                    .to_string(),
12619            )]),
12620        };
12621    }
12622    if let Some(ref local_var_str) = description__empty {
12623        local_var_req_builder =
12624            local_var_req_builder.query(&[("description__empty", &local_var_str.to_string())]);
12625    }
12626    if let Some(ref local_var_str) = description__ic {
12627        local_var_req_builder = match "multi" {
12628            "multi" => local_var_req_builder.query(
12629                &local_var_str
12630                    .into_iter()
12631                    .map(|p| ("description__ic".to_owned(), p.to_string()))
12632                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12633            ),
12634            _ => local_var_req_builder.query(&[(
12635                "description__ic",
12636                &local_var_str
12637                    .into_iter()
12638                    .map(|p| p.to_string())
12639                    .collect::<Vec<String>>()
12640                    .join(",")
12641                    .to_string(),
12642            )]),
12643        };
12644    }
12645    if let Some(ref local_var_str) = description__ie {
12646        local_var_req_builder = match "multi" {
12647            "multi" => local_var_req_builder.query(
12648                &local_var_str
12649                    .into_iter()
12650                    .map(|p| ("description__ie".to_owned(), p.to_string()))
12651                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12652            ),
12653            _ => local_var_req_builder.query(&[(
12654                "description__ie",
12655                &local_var_str
12656                    .into_iter()
12657                    .map(|p| p.to_string())
12658                    .collect::<Vec<String>>()
12659                    .join(",")
12660                    .to_string(),
12661            )]),
12662        };
12663    }
12664    if let Some(ref local_var_str) = description__iew {
12665        local_var_req_builder = match "multi" {
12666            "multi" => local_var_req_builder.query(
12667                &local_var_str
12668                    .into_iter()
12669                    .map(|p| ("description__iew".to_owned(), p.to_string()))
12670                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12671            ),
12672            _ => local_var_req_builder.query(&[(
12673                "description__iew",
12674                &local_var_str
12675                    .into_iter()
12676                    .map(|p| p.to_string())
12677                    .collect::<Vec<String>>()
12678                    .join(",")
12679                    .to_string(),
12680            )]),
12681        };
12682    }
12683    if let Some(ref local_var_str) = description__iregex {
12684        local_var_req_builder = match "multi" {
12685            "multi" => local_var_req_builder.query(
12686                &local_var_str
12687                    .into_iter()
12688                    .map(|p| ("description__iregex".to_owned(), p.to_string()))
12689                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12690            ),
12691            _ => local_var_req_builder.query(&[(
12692                "description__iregex",
12693                &local_var_str
12694                    .into_iter()
12695                    .map(|p| p.to_string())
12696                    .collect::<Vec<String>>()
12697                    .join(",")
12698                    .to_string(),
12699            )]),
12700        };
12701    }
12702    if let Some(ref local_var_str) = description__isw {
12703        local_var_req_builder = match "multi" {
12704            "multi" => local_var_req_builder.query(
12705                &local_var_str
12706                    .into_iter()
12707                    .map(|p| ("description__isw".to_owned(), p.to_string()))
12708                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12709            ),
12710            _ => local_var_req_builder.query(&[(
12711                "description__isw",
12712                &local_var_str
12713                    .into_iter()
12714                    .map(|p| p.to_string())
12715                    .collect::<Vec<String>>()
12716                    .join(",")
12717                    .to_string(),
12718            )]),
12719        };
12720    }
12721    if let Some(ref local_var_str) = description__n {
12722        local_var_req_builder = match "multi" {
12723            "multi" => local_var_req_builder.query(
12724                &local_var_str
12725                    .into_iter()
12726                    .map(|p| ("description__n".to_owned(), p.to_string()))
12727                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12728            ),
12729            _ => local_var_req_builder.query(&[(
12730                "description__n",
12731                &local_var_str
12732                    .into_iter()
12733                    .map(|p| p.to_string())
12734                    .collect::<Vec<String>>()
12735                    .join(",")
12736                    .to_string(),
12737            )]),
12738        };
12739    }
12740    if let Some(ref local_var_str) = description__nic {
12741        local_var_req_builder = match "multi" {
12742            "multi" => local_var_req_builder.query(
12743                &local_var_str
12744                    .into_iter()
12745                    .map(|p| ("description__nic".to_owned(), p.to_string()))
12746                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12747            ),
12748            _ => local_var_req_builder.query(&[(
12749                "description__nic",
12750                &local_var_str
12751                    .into_iter()
12752                    .map(|p| p.to_string())
12753                    .collect::<Vec<String>>()
12754                    .join(",")
12755                    .to_string(),
12756            )]),
12757        };
12758    }
12759    if let Some(ref local_var_str) = description__nie {
12760        local_var_req_builder = match "multi" {
12761            "multi" => local_var_req_builder.query(
12762                &local_var_str
12763                    .into_iter()
12764                    .map(|p| ("description__nie".to_owned(), p.to_string()))
12765                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12766            ),
12767            _ => local_var_req_builder.query(&[(
12768                "description__nie",
12769                &local_var_str
12770                    .into_iter()
12771                    .map(|p| p.to_string())
12772                    .collect::<Vec<String>>()
12773                    .join(",")
12774                    .to_string(),
12775            )]),
12776        };
12777    }
12778    if let Some(ref local_var_str) = description__niew {
12779        local_var_req_builder = match "multi" {
12780            "multi" => local_var_req_builder.query(
12781                &local_var_str
12782                    .into_iter()
12783                    .map(|p| ("description__niew".to_owned(), p.to_string()))
12784                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12785            ),
12786            _ => local_var_req_builder.query(&[(
12787                "description__niew",
12788                &local_var_str
12789                    .into_iter()
12790                    .map(|p| p.to_string())
12791                    .collect::<Vec<String>>()
12792                    .join(",")
12793                    .to_string(),
12794            )]),
12795        };
12796    }
12797    if let Some(ref local_var_str) = description__nisw {
12798        local_var_req_builder = match "multi" {
12799            "multi" => local_var_req_builder.query(
12800                &local_var_str
12801                    .into_iter()
12802                    .map(|p| ("description__nisw".to_owned(), p.to_string()))
12803                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12804            ),
12805            _ => local_var_req_builder.query(&[(
12806                "description__nisw",
12807                &local_var_str
12808                    .into_iter()
12809                    .map(|p| p.to_string())
12810                    .collect::<Vec<String>>()
12811                    .join(",")
12812                    .to_string(),
12813            )]),
12814        };
12815    }
12816    if let Some(ref local_var_str) = description__regex {
12817        local_var_req_builder = match "multi" {
12818            "multi" => local_var_req_builder.query(
12819                &local_var_str
12820                    .into_iter()
12821                    .map(|p| ("description__regex".to_owned(), p.to_string()))
12822                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12823            ),
12824            _ => local_var_req_builder.query(&[(
12825                "description__regex",
12826                &local_var_str
12827                    .into_iter()
12828                    .map(|p| p.to_string())
12829                    .collect::<Vec<String>>()
12830                    .join(",")
12831                    .to_string(),
12832            )]),
12833        };
12834    }
12835    if let Some(ref local_var_str) = id {
12836        local_var_req_builder = match "multi" {
12837            "multi" => local_var_req_builder.query(
12838                &local_var_str
12839                    .into_iter()
12840                    .map(|p| ("id".to_owned(), p.to_string()))
12841                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12842            ),
12843            _ => local_var_req_builder.query(&[(
12844                "id",
12845                &local_var_str
12846                    .into_iter()
12847                    .map(|p| p.to_string())
12848                    .collect::<Vec<String>>()
12849                    .join(",")
12850                    .to_string(),
12851            )]),
12852        };
12853    }
12854    if let Some(ref local_var_str) = id__empty {
12855        local_var_req_builder =
12856            local_var_req_builder.query(&[("id__empty", &local_var_str.to_string())]);
12857    }
12858    if let Some(ref local_var_str) = id__gt {
12859        local_var_req_builder = match "multi" {
12860            "multi" => local_var_req_builder.query(
12861                &local_var_str
12862                    .into_iter()
12863                    .map(|p| ("id__gt".to_owned(), p.to_string()))
12864                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12865            ),
12866            _ => local_var_req_builder.query(&[(
12867                "id__gt",
12868                &local_var_str
12869                    .into_iter()
12870                    .map(|p| p.to_string())
12871                    .collect::<Vec<String>>()
12872                    .join(",")
12873                    .to_string(),
12874            )]),
12875        };
12876    }
12877    if let Some(ref local_var_str) = id__gte {
12878        local_var_req_builder = match "multi" {
12879            "multi" => local_var_req_builder.query(
12880                &local_var_str
12881                    .into_iter()
12882                    .map(|p| ("id__gte".to_owned(), p.to_string()))
12883                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12884            ),
12885            _ => local_var_req_builder.query(&[(
12886                "id__gte",
12887                &local_var_str
12888                    .into_iter()
12889                    .map(|p| p.to_string())
12890                    .collect::<Vec<String>>()
12891                    .join(",")
12892                    .to_string(),
12893            )]),
12894        };
12895    }
12896    if let Some(ref local_var_str) = id__lt {
12897        local_var_req_builder = match "multi" {
12898            "multi" => local_var_req_builder.query(
12899                &local_var_str
12900                    .into_iter()
12901                    .map(|p| ("id__lt".to_owned(), p.to_string()))
12902                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12903            ),
12904            _ => local_var_req_builder.query(&[(
12905                "id__lt",
12906                &local_var_str
12907                    .into_iter()
12908                    .map(|p| p.to_string())
12909                    .collect::<Vec<String>>()
12910                    .join(",")
12911                    .to_string(),
12912            )]),
12913        };
12914    }
12915    if let Some(ref local_var_str) = id__lte {
12916        local_var_req_builder = match "multi" {
12917            "multi" => local_var_req_builder.query(
12918                &local_var_str
12919                    .into_iter()
12920                    .map(|p| ("id__lte".to_owned(), p.to_string()))
12921                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12922            ),
12923            _ => local_var_req_builder.query(&[(
12924                "id__lte",
12925                &local_var_str
12926                    .into_iter()
12927                    .map(|p| p.to_string())
12928                    .collect::<Vec<String>>()
12929                    .join(",")
12930                    .to_string(),
12931            )]),
12932        };
12933    }
12934    if let Some(ref local_var_str) = id__n {
12935        local_var_req_builder = match "multi" {
12936            "multi" => local_var_req_builder.query(
12937                &local_var_str
12938                    .into_iter()
12939                    .map(|p| ("id__n".to_owned(), p.to_string()))
12940                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12941            ),
12942            _ => local_var_req_builder.query(&[(
12943                "id__n",
12944                &local_var_str
12945                    .into_iter()
12946                    .map(|p| p.to_string())
12947                    .collect::<Vec<String>>()
12948                    .join(",")
12949                    .to_string(),
12950            )]),
12951        };
12952    }
12953    if let Some(ref local_var_str) = last_updated {
12954        local_var_req_builder = match "multi" {
12955            "multi" => local_var_req_builder.query(
12956                &local_var_str
12957                    .into_iter()
12958                    .map(|p| ("last_updated".to_owned(), p.to_string()))
12959                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12960            ),
12961            _ => local_var_req_builder.query(&[(
12962                "last_updated",
12963                &local_var_str
12964                    .into_iter()
12965                    .map(|p| p.to_string())
12966                    .collect::<Vec<String>>()
12967                    .join(",")
12968                    .to_string(),
12969            )]),
12970        };
12971    }
12972    if let Some(ref local_var_str) = last_updated__empty {
12973        local_var_req_builder = match "multi" {
12974            "multi" => local_var_req_builder.query(
12975                &local_var_str
12976                    .into_iter()
12977                    .map(|p| ("last_updated__empty".to_owned(), p.to_string()))
12978                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12979            ),
12980            _ => local_var_req_builder.query(&[(
12981                "last_updated__empty",
12982                &local_var_str
12983                    .into_iter()
12984                    .map(|p| p.to_string())
12985                    .collect::<Vec<String>>()
12986                    .join(",")
12987                    .to_string(),
12988            )]),
12989        };
12990    }
12991    if let Some(ref local_var_str) = last_updated__gt {
12992        local_var_req_builder = match "multi" {
12993            "multi" => local_var_req_builder.query(
12994                &local_var_str
12995                    .into_iter()
12996                    .map(|p| ("last_updated__gt".to_owned(), p.to_string()))
12997                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12998            ),
12999            _ => local_var_req_builder.query(&[(
13000                "last_updated__gt",
13001                &local_var_str
13002                    .into_iter()
13003                    .map(|p| p.to_string())
13004                    .collect::<Vec<String>>()
13005                    .join(",")
13006                    .to_string(),
13007            )]),
13008        };
13009    }
13010    if let Some(ref local_var_str) = last_updated__gte {
13011        local_var_req_builder = match "multi" {
13012            "multi" => local_var_req_builder.query(
13013                &local_var_str
13014                    .into_iter()
13015                    .map(|p| ("last_updated__gte".to_owned(), p.to_string()))
13016                    .collect::<Vec<(std::string::String, std::string::String)>>(),
13017            ),
13018            _ => local_var_req_builder.query(&[(
13019                "last_updated__gte",
13020                &local_var_str
13021                    .into_iter()
13022                    .map(|p| p.to_string())
13023                    .collect::<Vec<String>>()
13024                    .join(",")
13025                    .to_string(),
13026            )]),
13027        };
13028    }
13029    if let Some(ref local_var_str) = last_updated__lt {
13030        local_var_req_builder = match "multi" {
13031            "multi" => local_var_req_builder.query(
13032                &local_var_str
13033                    .into_iter()
13034                    .map(|p| ("last_updated__lt".to_owned(), p.to_string()))
13035                    .collect::<Vec<(std::string::String, std::string::String)>>(),
13036            ),
13037            _ => local_var_req_builder.query(&[(
13038                "last_updated__lt",
13039                &local_var_str
13040                    .into_iter()
13041                    .map(|p| p.to_string())
13042                    .collect::<Vec<String>>()
13043                    .join(",")
13044                    .to_string(),
13045            )]),
13046        };
13047    }
13048    if let Some(ref local_var_str) = last_updated__lte {
13049        local_var_req_builder = match "multi" {
13050            "multi" => local_var_req_builder.query(
13051                &local_var_str
13052                    .into_iter()
13053                    .map(|p| ("last_updated__lte".to_owned(), p.to_string()))
13054                    .collect::<Vec<(std::string::String, std::string::String)>>(),
13055            ),
13056            _ => local_var_req_builder.query(&[(
13057                "last_updated__lte",
13058                &local_var_str
13059                    .into_iter()
13060                    .map(|p| p.to_string())
13061                    .collect::<Vec<String>>()
13062                    .join(",")
13063                    .to_string(),
13064            )]),
13065        };
13066    }
13067    if let Some(ref local_var_str) = last_updated__n {
13068        local_var_req_builder = match "multi" {
13069            "multi" => local_var_req_builder.query(
13070                &local_var_str
13071                    .into_iter()
13072                    .map(|p| ("last_updated__n".to_owned(), p.to_string()))
13073                    .collect::<Vec<(std::string::String, std::string::String)>>(),
13074            ),
13075            _ => local_var_req_builder.query(&[(
13076                "last_updated__n",
13077                &local_var_str
13078                    .into_iter()
13079                    .map(|p| p.to_string())
13080                    .collect::<Vec<String>>()
13081                    .join(",")
13082                    .to_string(),
13083            )]),
13084        };
13085    }
13086    if let Some(ref local_var_str) = limit {
13087        local_var_req_builder =
13088            local_var_req_builder.query(&[("limit", &local_var_str.to_string())]);
13089    }
13090    if let Some(ref local_var_str) = modified_by_request {
13091        local_var_req_builder =
13092            local_var_req_builder.query(&[("modified_by_request", &local_var_str.to_string())]);
13093    }
13094    if let Some(ref local_var_str) = name {
13095        local_var_req_builder = match "multi" {
13096            "multi" => local_var_req_builder.query(
13097                &local_var_str
13098                    .into_iter()
13099                    .map(|p| ("name".to_owned(), p.to_string()))
13100                    .collect::<Vec<(std::string::String, std::string::String)>>(),
13101            ),
13102            _ => local_var_req_builder.query(&[(
13103                "name",
13104                &local_var_str
13105                    .into_iter()
13106                    .map(|p| p.to_string())
13107                    .collect::<Vec<String>>()
13108                    .join(",")
13109                    .to_string(),
13110            )]),
13111        };
13112    }
13113    if let Some(ref local_var_str) = name__empty {
13114        local_var_req_builder =
13115            local_var_req_builder.query(&[("name__empty", &local_var_str.to_string())]);
13116    }
13117    if let Some(ref local_var_str) = name__ic {
13118        local_var_req_builder = match "multi" {
13119            "multi" => local_var_req_builder.query(
13120                &local_var_str
13121                    .into_iter()
13122                    .map(|p| ("name__ic".to_owned(), p.to_string()))
13123                    .collect::<Vec<(std::string::String, std::string::String)>>(),
13124            ),
13125            _ => local_var_req_builder.query(&[(
13126                "name__ic",
13127                &local_var_str
13128                    .into_iter()
13129                    .map(|p| p.to_string())
13130                    .collect::<Vec<String>>()
13131                    .join(",")
13132                    .to_string(),
13133            )]),
13134        };
13135    }
13136    if let Some(ref local_var_str) = name__ie {
13137        local_var_req_builder = match "multi" {
13138            "multi" => local_var_req_builder.query(
13139                &local_var_str
13140                    .into_iter()
13141                    .map(|p| ("name__ie".to_owned(), p.to_string()))
13142                    .collect::<Vec<(std::string::String, std::string::String)>>(),
13143            ),
13144            _ => local_var_req_builder.query(&[(
13145                "name__ie",
13146                &local_var_str
13147                    .into_iter()
13148                    .map(|p| p.to_string())
13149                    .collect::<Vec<String>>()
13150                    .join(",")
13151                    .to_string(),
13152            )]),
13153        };
13154    }
13155    if let Some(ref local_var_str) = name__iew {
13156        local_var_req_builder = match "multi" {
13157            "multi" => local_var_req_builder.query(
13158                &local_var_str
13159                    .into_iter()
13160                    .map(|p| ("name__iew".to_owned(), p.to_string()))
13161                    .collect::<Vec<(std::string::String, std::string::String)>>(),
13162            ),
13163            _ => local_var_req_builder.query(&[(
13164                "name__iew",
13165                &local_var_str
13166                    .into_iter()
13167                    .map(|p| p.to_string())
13168                    .collect::<Vec<String>>()
13169                    .join(",")
13170                    .to_string(),
13171            )]),
13172        };
13173    }
13174    if let Some(ref local_var_str) = name__iregex {
13175        local_var_req_builder = match "multi" {
13176            "multi" => local_var_req_builder.query(
13177                &local_var_str
13178                    .into_iter()
13179                    .map(|p| ("name__iregex".to_owned(), p.to_string()))
13180                    .collect::<Vec<(std::string::String, std::string::String)>>(),
13181            ),
13182            _ => local_var_req_builder.query(&[(
13183                "name__iregex",
13184                &local_var_str
13185                    .into_iter()
13186                    .map(|p| p.to_string())
13187                    .collect::<Vec<String>>()
13188                    .join(",")
13189                    .to_string(),
13190            )]),
13191        };
13192    }
13193    if let Some(ref local_var_str) = name__isw {
13194        local_var_req_builder = match "multi" {
13195            "multi" => local_var_req_builder.query(
13196                &local_var_str
13197                    .into_iter()
13198                    .map(|p| ("name__isw".to_owned(), p.to_string()))
13199                    .collect::<Vec<(std::string::String, std::string::String)>>(),
13200            ),
13201            _ => local_var_req_builder.query(&[(
13202                "name__isw",
13203                &local_var_str
13204                    .into_iter()
13205                    .map(|p| p.to_string())
13206                    .collect::<Vec<String>>()
13207                    .join(",")
13208                    .to_string(),
13209            )]),
13210        };
13211    }
13212    if let Some(ref local_var_str) = name__n {
13213        local_var_req_builder = match "multi" {
13214            "multi" => local_var_req_builder.query(
13215                &local_var_str
13216                    .into_iter()
13217                    .map(|p| ("name__n".to_owned(), p.to_string()))
13218                    .collect::<Vec<(std::string::String, std::string::String)>>(),
13219            ),
13220            _ => local_var_req_builder.query(&[(
13221                "name__n",
13222                &local_var_str
13223                    .into_iter()
13224                    .map(|p| p.to_string())
13225                    .collect::<Vec<String>>()
13226                    .join(",")
13227                    .to_string(),
13228            )]),
13229        };
13230    }
13231    if let Some(ref local_var_str) = name__nic {
13232        local_var_req_builder = match "multi" {
13233            "multi" => local_var_req_builder.query(
13234                &local_var_str
13235                    .into_iter()
13236                    .map(|p| ("name__nic".to_owned(), p.to_string()))
13237                    .collect::<Vec<(std::string::String, std::string::String)>>(),
13238            ),
13239            _ => local_var_req_builder.query(&[(
13240                "name__nic",
13241                &local_var_str
13242                    .into_iter()
13243                    .map(|p| p.to_string())
13244                    .collect::<Vec<String>>()
13245                    .join(",")
13246                    .to_string(),
13247            )]),
13248        };
13249    }
13250    if let Some(ref local_var_str) = name__nie {
13251        local_var_req_builder = match "multi" {
13252            "multi" => local_var_req_builder.query(
13253                &local_var_str
13254                    .into_iter()
13255                    .map(|p| ("name__nie".to_owned(), p.to_string()))
13256                    .collect::<Vec<(std::string::String, std::string::String)>>(),
13257            ),
13258            _ => local_var_req_builder.query(&[(
13259                "name__nie",
13260                &local_var_str
13261                    .into_iter()
13262                    .map(|p| p.to_string())
13263                    .collect::<Vec<String>>()
13264                    .join(",")
13265                    .to_string(),
13266            )]),
13267        };
13268    }
13269    if let Some(ref local_var_str) = name__niew {
13270        local_var_req_builder = match "multi" {
13271            "multi" => local_var_req_builder.query(
13272                &local_var_str
13273                    .into_iter()
13274                    .map(|p| ("name__niew".to_owned(), p.to_string()))
13275                    .collect::<Vec<(std::string::String, std::string::String)>>(),
13276            ),
13277            _ => local_var_req_builder.query(&[(
13278                "name__niew",
13279                &local_var_str
13280                    .into_iter()
13281                    .map(|p| p.to_string())
13282                    .collect::<Vec<String>>()
13283                    .join(",")
13284                    .to_string(),
13285            )]),
13286        };
13287    }
13288    if let Some(ref local_var_str) = name__nisw {
13289        local_var_req_builder = match "multi" {
13290            "multi" => local_var_req_builder.query(
13291                &local_var_str
13292                    .into_iter()
13293                    .map(|p| ("name__nisw".to_owned(), p.to_string()))
13294                    .collect::<Vec<(std::string::String, std::string::String)>>(),
13295            ),
13296            _ => local_var_req_builder.query(&[(
13297                "name__nisw",
13298                &local_var_str
13299                    .into_iter()
13300                    .map(|p| p.to_string())
13301                    .collect::<Vec<String>>()
13302                    .join(",")
13303                    .to_string(),
13304            )]),
13305        };
13306    }
13307    if let Some(ref local_var_str) = name__regex {
13308        local_var_req_builder = match "multi" {
13309            "multi" => local_var_req_builder.query(
13310                &local_var_str
13311                    .into_iter()
13312                    .map(|p| ("name__regex".to_owned(), p.to_string()))
13313                    .collect::<Vec<(std::string::String, std::string::String)>>(),
13314            ),
13315            _ => local_var_req_builder.query(&[(
13316                "name__regex",
13317                &local_var_str
13318                    .into_iter()
13319                    .map(|p| p.to_string())
13320                    .collect::<Vec<String>>()
13321                    .join(",")
13322                    .to_string(),
13323            )]),
13324        };
13325    }
13326    if let Some(ref local_var_str) = offset {
13327        local_var_req_builder =
13328            local_var_req_builder.query(&[("offset", &local_var_str.to_string())]);
13329    }
13330    if let Some(ref local_var_str) = ordering {
13331        local_var_req_builder =
13332            local_var_req_builder.query(&[("ordering", &local_var_str.to_string())]);
13333    }
13334    if let Some(ref local_var_str) = owner {
13335        local_var_req_builder = match "multi" {
13336            "multi" => local_var_req_builder.query(
13337                &local_var_str
13338                    .into_iter()
13339                    .map(|p| ("owner".to_owned(), p.to_string()))
13340                    .collect::<Vec<(std::string::String, std::string::String)>>(),
13341            ),
13342            _ => local_var_req_builder.query(&[(
13343                "owner",
13344                &local_var_str
13345                    .into_iter()
13346                    .map(|p| p.to_string())
13347                    .collect::<Vec<String>>()
13348                    .join(",")
13349                    .to_string(),
13350            )]),
13351        };
13352    }
13353    if let Some(ref local_var_str) = owner__n {
13354        local_var_req_builder = match "multi" {
13355            "multi" => local_var_req_builder.query(
13356                &local_var_str
13357                    .into_iter()
13358                    .map(|p| ("owner__n".to_owned(), p.to_string()))
13359                    .collect::<Vec<(std::string::String, std::string::String)>>(),
13360            ),
13361            _ => local_var_req_builder.query(&[(
13362                "owner__n",
13363                &local_var_str
13364                    .into_iter()
13365                    .map(|p| p.to_string())
13366                    .collect::<Vec<String>>()
13367                    .join(",")
13368                    .to_string(),
13369            )]),
13370        };
13371    }
13372    if let Some(ref local_var_str) = owner_group {
13373        local_var_req_builder = match "multi" {
13374            "multi" => local_var_req_builder.query(
13375                &local_var_str
13376                    .into_iter()
13377                    .map(|p| ("owner_group".to_owned(), p.to_string()))
13378                    .collect::<Vec<(std::string::String, std::string::String)>>(),
13379            ),
13380            _ => local_var_req_builder.query(&[(
13381                "owner_group",
13382                &local_var_str
13383                    .into_iter()
13384                    .map(|p| p.to_string())
13385                    .collect::<Vec<String>>()
13386                    .join(",")
13387                    .to_string(),
13388            )]),
13389        };
13390    }
13391    if let Some(ref local_var_str) = owner_group__n {
13392        local_var_req_builder = match "multi" {
13393            "multi" => local_var_req_builder.query(
13394                &local_var_str
13395                    .into_iter()
13396                    .map(|p| ("owner_group__n".to_owned(), p.to_string()))
13397                    .collect::<Vec<(std::string::String, std::string::String)>>(),
13398            ),
13399            _ => local_var_req_builder.query(&[(
13400                "owner_group__n",
13401                &local_var_str
13402                    .into_iter()
13403                    .map(|p| p.to_string())
13404                    .collect::<Vec<String>>()
13405                    .join(",")
13406                    .to_string(),
13407            )]),
13408        };
13409    }
13410    if let Some(ref local_var_str) = owner_group_id {
13411        local_var_req_builder = match "multi" {
13412            "multi" => local_var_req_builder.query(
13413                &local_var_str
13414                    .into_iter()
13415                    .map(|p| ("owner_group_id".to_owned(), p.to_string()))
13416                    .collect::<Vec<(std::string::String, std::string::String)>>(),
13417            ),
13418            _ => local_var_req_builder.query(&[(
13419                "owner_group_id",
13420                &local_var_str
13421                    .into_iter()
13422                    .map(|p| p.to_string())
13423                    .collect::<Vec<String>>()
13424                    .join(",")
13425                    .to_string(),
13426            )]),
13427        };
13428    }
13429    if let Some(ref local_var_str) = owner_group_id__n {
13430        local_var_req_builder = match "multi" {
13431            "multi" => local_var_req_builder.query(
13432                &local_var_str
13433                    .into_iter()
13434                    .map(|p| ("owner_group_id__n".to_owned(), p.to_string()))
13435                    .collect::<Vec<(std::string::String, std::string::String)>>(),
13436            ),
13437            _ => local_var_req_builder.query(&[(
13438                "owner_group_id__n",
13439                &local_var_str
13440                    .into_iter()
13441                    .map(|p| p.to_string())
13442                    .collect::<Vec<String>>()
13443                    .join(",")
13444                    .to_string(),
13445            )]),
13446        };
13447    }
13448    if let Some(ref local_var_str) = owner_id {
13449        local_var_req_builder = match "multi" {
13450            "multi" => local_var_req_builder.query(
13451                &local_var_str
13452                    .into_iter()
13453                    .map(|p| ("owner_id".to_owned(), p.to_string()))
13454                    .collect::<Vec<(std::string::String, std::string::String)>>(),
13455            ),
13456            _ => local_var_req_builder.query(&[(
13457                "owner_id",
13458                &local_var_str
13459                    .into_iter()
13460                    .map(|p| p.to_string())
13461                    .collect::<Vec<String>>()
13462                    .join(",")
13463                    .to_string(),
13464            )]),
13465        };
13466    }
13467    if let Some(ref local_var_str) = owner_id__n {
13468        local_var_req_builder = match "multi" {
13469            "multi" => local_var_req_builder.query(
13470                &local_var_str
13471                    .into_iter()
13472                    .map(|p| ("owner_id__n".to_owned(), p.to_string()))
13473                    .collect::<Vec<(std::string::String, std::string::String)>>(),
13474            ),
13475            _ => local_var_req_builder.query(&[(
13476                "owner_id__n",
13477                &local_var_str
13478                    .into_iter()
13479                    .map(|p| p.to_string())
13480                    .collect::<Vec<String>>()
13481                    .join(",")
13482                    .to_string(),
13483            )]),
13484        };
13485    }
13486    if let Some(ref local_var_str) = q {
13487        local_var_req_builder = local_var_req_builder.query(&[("q", &local_var_str.to_string())]);
13488    }
13489    if let Some(ref local_var_str) = slug {
13490        local_var_req_builder = match "multi" {
13491            "multi" => local_var_req_builder.query(
13492                &local_var_str
13493                    .into_iter()
13494                    .map(|p| ("slug".to_owned(), p.to_string()))
13495                    .collect::<Vec<(std::string::String, std::string::String)>>(),
13496            ),
13497            _ => local_var_req_builder.query(&[(
13498                "slug",
13499                &local_var_str
13500                    .into_iter()
13501                    .map(|p| p.to_string())
13502                    .collect::<Vec<String>>()
13503                    .join(",")
13504                    .to_string(),
13505            )]),
13506        };
13507    }
13508    if let Some(ref local_var_str) = slug__empty {
13509        local_var_req_builder =
13510            local_var_req_builder.query(&[("slug__empty", &local_var_str.to_string())]);
13511    }
13512    if let Some(ref local_var_str) = slug__ic {
13513        local_var_req_builder = match "multi" {
13514            "multi" => local_var_req_builder.query(
13515                &local_var_str
13516                    .into_iter()
13517                    .map(|p| ("slug__ic".to_owned(), p.to_string()))
13518                    .collect::<Vec<(std::string::String, std::string::String)>>(),
13519            ),
13520            _ => local_var_req_builder.query(&[(
13521                "slug__ic",
13522                &local_var_str
13523                    .into_iter()
13524                    .map(|p| p.to_string())
13525                    .collect::<Vec<String>>()
13526                    .join(",")
13527                    .to_string(),
13528            )]),
13529        };
13530    }
13531    if let Some(ref local_var_str) = slug__ie {
13532        local_var_req_builder = match "multi" {
13533            "multi" => local_var_req_builder.query(
13534                &local_var_str
13535                    .into_iter()
13536                    .map(|p| ("slug__ie".to_owned(), p.to_string()))
13537                    .collect::<Vec<(std::string::String, std::string::String)>>(),
13538            ),
13539            _ => local_var_req_builder.query(&[(
13540                "slug__ie",
13541                &local_var_str
13542                    .into_iter()
13543                    .map(|p| p.to_string())
13544                    .collect::<Vec<String>>()
13545                    .join(",")
13546                    .to_string(),
13547            )]),
13548        };
13549    }
13550    if let Some(ref local_var_str) = slug__iew {
13551        local_var_req_builder = match "multi" {
13552            "multi" => local_var_req_builder.query(
13553                &local_var_str
13554                    .into_iter()
13555                    .map(|p| ("slug__iew".to_owned(), p.to_string()))
13556                    .collect::<Vec<(std::string::String, std::string::String)>>(),
13557            ),
13558            _ => local_var_req_builder.query(&[(
13559                "slug__iew",
13560                &local_var_str
13561                    .into_iter()
13562                    .map(|p| p.to_string())
13563                    .collect::<Vec<String>>()
13564                    .join(",")
13565                    .to_string(),
13566            )]),
13567        };
13568    }
13569    if let Some(ref local_var_str) = slug__iregex {
13570        local_var_req_builder = match "multi" {
13571            "multi" => local_var_req_builder.query(
13572                &local_var_str
13573                    .into_iter()
13574                    .map(|p| ("slug__iregex".to_owned(), p.to_string()))
13575                    .collect::<Vec<(std::string::String, std::string::String)>>(),
13576            ),
13577            _ => local_var_req_builder.query(&[(
13578                "slug__iregex",
13579                &local_var_str
13580                    .into_iter()
13581                    .map(|p| p.to_string())
13582                    .collect::<Vec<String>>()
13583                    .join(",")
13584                    .to_string(),
13585            )]),
13586        };
13587    }
13588    if let Some(ref local_var_str) = slug__isw {
13589        local_var_req_builder = match "multi" {
13590            "multi" => local_var_req_builder.query(
13591                &local_var_str
13592                    .into_iter()
13593                    .map(|p| ("slug__isw".to_owned(), p.to_string()))
13594                    .collect::<Vec<(std::string::String, std::string::String)>>(),
13595            ),
13596            _ => local_var_req_builder.query(&[(
13597                "slug__isw",
13598                &local_var_str
13599                    .into_iter()
13600                    .map(|p| p.to_string())
13601                    .collect::<Vec<String>>()
13602                    .join(",")
13603                    .to_string(),
13604            )]),
13605        };
13606    }
13607    if let Some(ref local_var_str) = slug__n {
13608        local_var_req_builder = match "multi" {
13609            "multi" => local_var_req_builder.query(
13610                &local_var_str
13611                    .into_iter()
13612                    .map(|p| ("slug__n".to_owned(), p.to_string()))
13613                    .collect::<Vec<(std::string::String, std::string::String)>>(),
13614            ),
13615            _ => local_var_req_builder.query(&[(
13616                "slug__n",
13617                &local_var_str
13618                    .into_iter()
13619                    .map(|p| p.to_string())
13620                    .collect::<Vec<String>>()
13621                    .join(",")
13622                    .to_string(),
13623            )]),
13624        };
13625    }
13626    if let Some(ref local_var_str) = slug__nic {
13627        local_var_req_builder = match "multi" {
13628            "multi" => local_var_req_builder.query(
13629                &local_var_str
13630                    .into_iter()
13631                    .map(|p| ("slug__nic".to_owned(), p.to_string()))
13632                    .collect::<Vec<(std::string::String, std::string::String)>>(),
13633            ),
13634            _ => local_var_req_builder.query(&[(
13635                "slug__nic",
13636                &local_var_str
13637                    .into_iter()
13638                    .map(|p| p.to_string())
13639                    .collect::<Vec<String>>()
13640                    .join(",")
13641                    .to_string(),
13642            )]),
13643        };
13644    }
13645    if let Some(ref local_var_str) = slug__nie {
13646        local_var_req_builder = match "multi" {
13647            "multi" => local_var_req_builder.query(
13648                &local_var_str
13649                    .into_iter()
13650                    .map(|p| ("slug__nie".to_owned(), p.to_string()))
13651                    .collect::<Vec<(std::string::String, std::string::String)>>(),
13652            ),
13653            _ => local_var_req_builder.query(&[(
13654                "slug__nie",
13655                &local_var_str
13656                    .into_iter()
13657                    .map(|p| p.to_string())
13658                    .collect::<Vec<String>>()
13659                    .join(",")
13660                    .to_string(),
13661            )]),
13662        };
13663    }
13664    if let Some(ref local_var_str) = slug__niew {
13665        local_var_req_builder = match "multi" {
13666            "multi" => local_var_req_builder.query(
13667                &local_var_str
13668                    .into_iter()
13669                    .map(|p| ("slug__niew".to_owned(), p.to_string()))
13670                    .collect::<Vec<(std::string::String, std::string::String)>>(),
13671            ),
13672            _ => local_var_req_builder.query(&[(
13673                "slug__niew",
13674                &local_var_str
13675                    .into_iter()
13676                    .map(|p| p.to_string())
13677                    .collect::<Vec<String>>()
13678                    .join(",")
13679                    .to_string(),
13680            )]),
13681        };
13682    }
13683    if let Some(ref local_var_str) = slug__nisw {
13684        local_var_req_builder = match "multi" {
13685            "multi" => local_var_req_builder.query(
13686                &local_var_str
13687                    .into_iter()
13688                    .map(|p| ("slug__nisw".to_owned(), p.to_string()))
13689                    .collect::<Vec<(std::string::String, std::string::String)>>(),
13690            ),
13691            _ => local_var_req_builder.query(&[(
13692                "slug__nisw",
13693                &local_var_str
13694                    .into_iter()
13695                    .map(|p| p.to_string())
13696                    .collect::<Vec<String>>()
13697                    .join(",")
13698                    .to_string(),
13699            )]),
13700        };
13701    }
13702    if let Some(ref local_var_str) = slug__regex {
13703        local_var_req_builder = match "multi" {
13704            "multi" => local_var_req_builder.query(
13705                &local_var_str
13706                    .into_iter()
13707                    .map(|p| ("slug__regex".to_owned(), p.to_string()))
13708                    .collect::<Vec<(std::string::String, std::string::String)>>(),
13709            ),
13710            _ => local_var_req_builder.query(&[(
13711                "slug__regex",
13712                &local_var_str
13713                    .into_iter()
13714                    .map(|p| p.to_string())
13715                    .collect::<Vec<String>>()
13716                    .join(",")
13717                    .to_string(),
13718            )]),
13719        };
13720    }
13721    if let Some(ref local_var_str) = start {
13722        local_var_req_builder =
13723            local_var_req_builder.query(&[("start", &local_var_str.to_string())]);
13724    }
13725    if let Some(ref local_var_str) = tag {
13726        local_var_req_builder = match "multi" {
13727            "multi" => local_var_req_builder.query(
13728                &local_var_str
13729                    .into_iter()
13730                    .map(|p| ("tag".to_owned(), p.to_string()))
13731                    .collect::<Vec<(std::string::String, std::string::String)>>(),
13732            ),
13733            _ => local_var_req_builder.query(&[(
13734                "tag",
13735                &local_var_str
13736                    .into_iter()
13737                    .map(|p| p.to_string())
13738                    .collect::<Vec<String>>()
13739                    .join(",")
13740                    .to_string(),
13741            )]),
13742        };
13743    }
13744    if let Some(ref local_var_str) = tag__n {
13745        local_var_req_builder = match "multi" {
13746            "multi" => local_var_req_builder.query(
13747                &local_var_str
13748                    .into_iter()
13749                    .map(|p| ("tag__n".to_owned(), p.to_string()))
13750                    .collect::<Vec<(std::string::String, std::string::String)>>(),
13751            ),
13752            _ => local_var_req_builder.query(&[(
13753                "tag__n",
13754                &local_var_str
13755                    .into_iter()
13756                    .map(|p| p.to_string())
13757                    .collect::<Vec<String>>()
13758                    .join(",")
13759                    .to_string(),
13760            )]),
13761        };
13762    }
13763    if let Some(ref local_var_str) = tag_id {
13764        local_var_req_builder = match "multi" {
13765            "multi" => local_var_req_builder.query(
13766                &local_var_str
13767                    .into_iter()
13768                    .map(|p| ("tag_id".to_owned(), p.to_string()))
13769                    .collect::<Vec<(std::string::String, std::string::String)>>(),
13770            ),
13771            _ => local_var_req_builder.query(&[(
13772                "tag_id",
13773                &local_var_str
13774                    .into_iter()
13775                    .map(|p| p.to_string())
13776                    .collect::<Vec<String>>()
13777                    .join(",")
13778                    .to_string(),
13779            )]),
13780        };
13781    }
13782    if let Some(ref local_var_str) = tag_id__n {
13783        local_var_req_builder = match "multi" {
13784            "multi" => local_var_req_builder.query(
13785                &local_var_str
13786                    .into_iter()
13787                    .map(|p| ("tag_id__n".to_owned(), p.to_string()))
13788                    .collect::<Vec<(std::string::String, std::string::String)>>(),
13789            ),
13790            _ => local_var_req_builder.query(&[(
13791                "tag_id__n",
13792                &local_var_str
13793                    .into_iter()
13794                    .map(|p| p.to_string())
13795                    .collect::<Vec<String>>()
13796                    .join(",")
13797                    .to_string(),
13798            )]),
13799        };
13800    }
13801    if let Some(ref local_var_str) = updated_by_request {
13802        local_var_req_builder =
13803            local_var_req_builder.query(&[("updated_by_request", &local_var_str.to_string())]);
13804    }
13805    if let Some(ref local_var_str) = virtual_machine_count {
13806        local_var_req_builder = match "multi" {
13807            "multi" => local_var_req_builder.query(
13808                &local_var_str
13809                    .into_iter()
13810                    .map(|p| ("virtual_machine_count".to_owned(), p.to_string()))
13811                    .collect::<Vec<(std::string::String, std::string::String)>>(),
13812            ),
13813            _ => local_var_req_builder.query(&[(
13814                "virtual_machine_count",
13815                &local_var_str
13816                    .into_iter()
13817                    .map(|p| p.to_string())
13818                    .collect::<Vec<String>>()
13819                    .join(",")
13820                    .to_string(),
13821            )]),
13822        };
13823    }
13824    if let Some(ref local_var_str) = virtual_machine_count__empty {
13825        local_var_req_builder = local_var_req_builder
13826            .query(&[("virtual_machine_count__empty", &local_var_str.to_string())]);
13827    }
13828    if let Some(ref local_var_str) = virtual_machine_count__gt {
13829        local_var_req_builder = match "multi" {
13830            "multi" => local_var_req_builder.query(
13831                &local_var_str
13832                    .into_iter()
13833                    .map(|p| ("virtual_machine_count__gt".to_owned(), p.to_string()))
13834                    .collect::<Vec<(std::string::String, std::string::String)>>(),
13835            ),
13836            _ => local_var_req_builder.query(&[(
13837                "virtual_machine_count__gt",
13838                &local_var_str
13839                    .into_iter()
13840                    .map(|p| p.to_string())
13841                    .collect::<Vec<String>>()
13842                    .join(",")
13843                    .to_string(),
13844            )]),
13845        };
13846    }
13847    if let Some(ref local_var_str) = virtual_machine_count__gte {
13848        local_var_req_builder = match "multi" {
13849            "multi" => local_var_req_builder.query(
13850                &local_var_str
13851                    .into_iter()
13852                    .map(|p| ("virtual_machine_count__gte".to_owned(), p.to_string()))
13853                    .collect::<Vec<(std::string::String, std::string::String)>>(),
13854            ),
13855            _ => local_var_req_builder.query(&[(
13856                "virtual_machine_count__gte",
13857                &local_var_str
13858                    .into_iter()
13859                    .map(|p| p.to_string())
13860                    .collect::<Vec<String>>()
13861                    .join(",")
13862                    .to_string(),
13863            )]),
13864        };
13865    }
13866    if let Some(ref local_var_str) = virtual_machine_count__lt {
13867        local_var_req_builder = match "multi" {
13868            "multi" => local_var_req_builder.query(
13869                &local_var_str
13870                    .into_iter()
13871                    .map(|p| ("virtual_machine_count__lt".to_owned(), p.to_string()))
13872                    .collect::<Vec<(std::string::String, std::string::String)>>(),
13873            ),
13874            _ => local_var_req_builder.query(&[(
13875                "virtual_machine_count__lt",
13876                &local_var_str
13877                    .into_iter()
13878                    .map(|p| p.to_string())
13879                    .collect::<Vec<String>>()
13880                    .join(",")
13881                    .to_string(),
13882            )]),
13883        };
13884    }
13885    if let Some(ref local_var_str) = virtual_machine_count__lte {
13886        local_var_req_builder = match "multi" {
13887            "multi" => local_var_req_builder.query(
13888                &local_var_str
13889                    .into_iter()
13890                    .map(|p| ("virtual_machine_count__lte".to_owned(), p.to_string()))
13891                    .collect::<Vec<(std::string::String, std::string::String)>>(),
13892            ),
13893            _ => local_var_req_builder.query(&[(
13894                "virtual_machine_count__lte",
13895                &local_var_str
13896                    .into_iter()
13897                    .map(|p| p.to_string())
13898                    .collect::<Vec<String>>()
13899                    .join(",")
13900                    .to_string(),
13901            )]),
13902        };
13903    }
13904    if let Some(ref local_var_str) = virtual_machine_count__n {
13905        local_var_req_builder = match "multi" {
13906            "multi" => local_var_req_builder.query(
13907                &local_var_str
13908                    .into_iter()
13909                    .map(|p| ("virtual_machine_count__n".to_owned(), p.to_string()))
13910                    .collect::<Vec<(std::string::String, std::string::String)>>(),
13911            ),
13912            _ => local_var_req_builder.query(&[(
13913                "virtual_machine_count__n",
13914                &local_var_str
13915                    .into_iter()
13916                    .map(|p| p.to_string())
13917                    .collect::<Vec<String>>()
13918                    .join(",")
13919                    .to_string(),
13920            )]),
13921        };
13922    }
13923    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
13924        local_var_req_builder =
13925            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
13926    }
13927    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
13928        let local_var_key = local_var_apikey.key.clone();
13929        let local_var_value = match local_var_apikey.prefix {
13930            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
13931            None => local_var_key,
13932        };
13933        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
13934    };
13935
13936    let local_var_req = local_var_req_builder.build()?;
13937    let local_var_resp = local_var_client.execute(local_var_req).await?;
13938
13939    let local_var_status = local_var_resp.status();
13940    let local_var_content = local_var_resp.text().await?;
13941
13942    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
13943        serde_json::from_str(&local_var_content).map_err(Error::from)
13944    } else {
13945        let local_var_entity: Option<VirtualizationVirtualMachineTypesListError> =
13946            serde_json::from_str(&local_var_content).ok();
13947        let local_var_error = ResponseContent {
13948            status: local_var_status,
13949            content: local_var_content,
13950            entity: local_var_entity,
13951        };
13952        Err(Error::ResponseError(local_var_error))
13953    }
13954}
13955
13956/// Patch a virtual machine type object.
13957pub async fn virtualization_virtual_machine_types_partial_update(
13958    configuration: &configuration::Configuration,
13959    id: i32,
13960    patched_virtual_machine_type_request: Option<crate::models::PatchedVirtualMachineTypeRequest>,
13961) -> Result<
13962    crate::models::VirtualMachineType,
13963    Error<VirtualizationVirtualMachineTypesPartialUpdateError>,
13964> {
13965    let local_var_configuration = configuration;
13966
13967    let local_var_client = &local_var_configuration.client;
13968
13969    let local_var_uri_str = format!(
13970        "{}/api/virtualization/virtual-machine-types/{id}/",
13971        local_var_configuration.base_path,
13972        id = id
13973    );
13974    let mut local_var_req_builder =
13975        local_var_client.request(reqwest::Method::PATCH, local_var_uri_str.as_str());
13976
13977    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
13978        local_var_req_builder =
13979            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
13980    }
13981    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
13982        let local_var_key = local_var_apikey.key.clone();
13983        let local_var_value = match local_var_apikey.prefix {
13984            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
13985            None => local_var_key,
13986        };
13987        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
13988    };
13989    local_var_req_builder = local_var_req_builder.json(&patched_virtual_machine_type_request);
13990
13991    let local_var_req = local_var_req_builder.build()?;
13992    let local_var_resp = local_var_client.execute(local_var_req).await?;
13993
13994    let local_var_status = local_var_resp.status();
13995    let local_var_content = local_var_resp.text().await?;
13996
13997    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
13998        serde_json::from_str(&local_var_content).map_err(Error::from)
13999    } else {
14000        let local_var_entity: Option<VirtualizationVirtualMachineTypesPartialUpdateError> =
14001            serde_json::from_str(&local_var_content).ok();
14002        let local_var_error = ResponseContent {
14003            status: local_var_status,
14004            content: local_var_content,
14005            entity: local_var_entity,
14006        };
14007        Err(Error::ResponseError(local_var_error))
14008    }
14009}
14010
14011/// Get a virtual machine type object.
14012pub async fn virtualization_virtual_machine_types_retrieve(
14013    configuration: &configuration::Configuration,
14014    id: i32,
14015) -> Result<crate::models::VirtualMachineType, Error<VirtualizationVirtualMachineTypesRetrieveError>>
14016{
14017    let local_var_configuration = configuration;
14018
14019    let local_var_client = &local_var_configuration.client;
14020
14021    let local_var_uri_str = format!(
14022        "{}/api/virtualization/virtual-machine-types/{id}/",
14023        local_var_configuration.base_path,
14024        id = id
14025    );
14026    let mut local_var_req_builder =
14027        local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
14028
14029    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
14030        local_var_req_builder =
14031            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
14032    }
14033    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
14034        let local_var_key = local_var_apikey.key.clone();
14035        let local_var_value = match local_var_apikey.prefix {
14036            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
14037            None => local_var_key,
14038        };
14039        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
14040    };
14041
14042    let local_var_req = local_var_req_builder.build()?;
14043    let local_var_resp = local_var_client.execute(local_var_req).await?;
14044
14045    let local_var_status = local_var_resp.status();
14046    let local_var_content = local_var_resp.text().await?;
14047
14048    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
14049        serde_json::from_str(&local_var_content).map_err(Error::from)
14050    } else {
14051        let local_var_entity: Option<VirtualizationVirtualMachineTypesRetrieveError> =
14052            serde_json::from_str(&local_var_content).ok();
14053        let local_var_error = ResponseContent {
14054            status: local_var_status,
14055            content: local_var_content,
14056            entity: local_var_entity,
14057        };
14058        Err(Error::ResponseError(local_var_error))
14059    }
14060}
14061
14062/// Put a virtual machine type object.
14063pub async fn virtualization_virtual_machine_types_update(
14064    configuration: &configuration::Configuration,
14065    id: i32,
14066    virtual_machine_type_request: crate::models::VirtualMachineTypeRequest,
14067) -> Result<crate::models::VirtualMachineType, Error<VirtualizationVirtualMachineTypesUpdateError>>
14068{
14069    let local_var_configuration = configuration;
14070
14071    let local_var_client = &local_var_configuration.client;
14072
14073    let local_var_uri_str = format!(
14074        "{}/api/virtualization/virtual-machine-types/{id}/",
14075        local_var_configuration.base_path,
14076        id = id
14077    );
14078    let mut local_var_req_builder =
14079        local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());
14080
14081    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
14082        local_var_req_builder =
14083            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
14084    }
14085    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
14086        let local_var_key = local_var_apikey.key.clone();
14087        let local_var_value = match local_var_apikey.prefix {
14088            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
14089            None => local_var_key,
14090        };
14091        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
14092    };
14093    local_var_req_builder = local_var_req_builder.json(&virtual_machine_type_request);
14094
14095    let local_var_req = local_var_req_builder.build()?;
14096    let local_var_resp = local_var_client.execute(local_var_req).await?;
14097
14098    let local_var_status = local_var_resp.status();
14099    let local_var_content = local_var_resp.text().await?;
14100
14101    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
14102        serde_json::from_str(&local_var_content).map_err(Error::from)
14103    } else {
14104        let local_var_entity: Option<VirtualizationVirtualMachineTypesUpdateError> =
14105            serde_json::from_str(&local_var_content).ok();
14106        let local_var_error = ResponseContent {
14107            status: local_var_status,
14108            content: local_var_content,
14109            entity: local_var_entity,
14110        };
14111        Err(Error::ResponseError(local_var_error))
14112    }
14113}
14114
14115/// Delete a list of virtual machine objects.
14116pub async fn virtualization_virtual_machines_bulk_destroy(
14117    configuration: &configuration::Configuration,
14118    virtual_machine_with_config_context_request: Vec<
14119        crate::models::VirtualMachineWithConfigContextRequest,
14120    >,
14121) -> Result<(), Error<VirtualizationVirtualMachinesBulkDestroyError>> {
14122    let local_var_configuration = configuration;
14123
14124    let local_var_client = &local_var_configuration.client;
14125
14126    let local_var_uri_str = format!(
14127        "{}/api/virtualization/virtual-machines/",
14128        local_var_configuration.base_path
14129    );
14130    let mut local_var_req_builder =
14131        local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());
14132
14133    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
14134        local_var_req_builder =
14135            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
14136    }
14137    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
14138        let local_var_key = local_var_apikey.key.clone();
14139        let local_var_value = match local_var_apikey.prefix {
14140            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
14141            None => local_var_key,
14142        };
14143        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
14144    };
14145    local_var_req_builder =
14146        local_var_req_builder.json(&virtual_machine_with_config_context_request);
14147
14148    let local_var_req = local_var_req_builder.build()?;
14149    let local_var_resp = local_var_client.execute(local_var_req).await?;
14150
14151    let local_var_status = local_var_resp.status();
14152    let local_var_content = local_var_resp.text().await?;
14153
14154    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
14155        Ok(())
14156    } else {
14157        let local_var_entity: Option<VirtualizationVirtualMachinesBulkDestroyError> =
14158            serde_json::from_str(&local_var_content).ok();
14159        let local_var_error = ResponseContent {
14160            status: local_var_status,
14161            content: local_var_content,
14162            entity: local_var_entity,
14163        };
14164        Err(Error::ResponseError(local_var_error))
14165    }
14166}
14167
14168/// Patch a list of virtual machine objects.
14169pub async fn virtualization_virtual_machines_bulk_partial_update(
14170    configuration: &configuration::Configuration,
14171    virtual_machine_with_config_context_request: Vec<
14172        crate::models::VirtualMachineWithConfigContextRequest,
14173    >,
14174) -> Result<
14175    Vec<crate::models::VirtualMachineWithConfigContext>,
14176    Error<VirtualizationVirtualMachinesBulkPartialUpdateError>,
14177> {
14178    let local_var_configuration = configuration;
14179
14180    let local_var_client = &local_var_configuration.client;
14181
14182    let local_var_uri_str = format!(
14183        "{}/api/virtualization/virtual-machines/",
14184        local_var_configuration.base_path
14185    );
14186    let mut local_var_req_builder =
14187        local_var_client.request(reqwest::Method::PATCH, local_var_uri_str.as_str());
14188
14189    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
14190        local_var_req_builder =
14191            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
14192    }
14193    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
14194        let local_var_key = local_var_apikey.key.clone();
14195        let local_var_value = match local_var_apikey.prefix {
14196            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
14197            None => local_var_key,
14198        };
14199        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
14200    };
14201    local_var_req_builder =
14202        local_var_req_builder.json(&virtual_machine_with_config_context_request);
14203
14204    let local_var_req = local_var_req_builder.build()?;
14205    let local_var_resp = local_var_client.execute(local_var_req).await?;
14206
14207    let local_var_status = local_var_resp.status();
14208    let local_var_content = local_var_resp.text().await?;
14209
14210    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
14211        serde_json::from_str(&local_var_content).map_err(Error::from)
14212    } else {
14213        let local_var_entity: Option<VirtualizationVirtualMachinesBulkPartialUpdateError> =
14214            serde_json::from_str(&local_var_content).ok();
14215        let local_var_error = ResponseContent {
14216            status: local_var_status,
14217            content: local_var_content,
14218            entity: local_var_entity,
14219        };
14220        Err(Error::ResponseError(local_var_error))
14221    }
14222}
14223
14224/// Put a list of virtual machine objects.
14225pub async fn virtualization_virtual_machines_bulk_update(
14226    configuration: &configuration::Configuration,
14227    virtual_machine_with_config_context_request: Vec<
14228        crate::models::VirtualMachineWithConfigContextRequest,
14229    >,
14230) -> Result<
14231    Vec<crate::models::VirtualMachineWithConfigContext>,
14232    Error<VirtualizationVirtualMachinesBulkUpdateError>,
14233> {
14234    let local_var_configuration = configuration;
14235
14236    let local_var_client = &local_var_configuration.client;
14237
14238    let local_var_uri_str = format!(
14239        "{}/api/virtualization/virtual-machines/",
14240        local_var_configuration.base_path
14241    );
14242    let mut local_var_req_builder =
14243        local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());
14244
14245    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
14246        local_var_req_builder =
14247            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
14248    }
14249    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
14250        let local_var_key = local_var_apikey.key.clone();
14251        let local_var_value = match local_var_apikey.prefix {
14252            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
14253            None => local_var_key,
14254        };
14255        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
14256    };
14257    local_var_req_builder =
14258        local_var_req_builder.json(&virtual_machine_with_config_context_request);
14259
14260    let local_var_req = local_var_req_builder.build()?;
14261    let local_var_resp = local_var_client.execute(local_var_req).await?;
14262
14263    let local_var_status = local_var_resp.status();
14264    let local_var_content = local_var_resp.text().await?;
14265
14266    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
14267        serde_json::from_str(&local_var_content).map_err(Error::from)
14268    } else {
14269        let local_var_entity: Option<VirtualizationVirtualMachinesBulkUpdateError> =
14270            serde_json::from_str(&local_var_content).ok();
14271        let local_var_error = ResponseContent {
14272            status: local_var_status,
14273            content: local_var_content,
14274            entity: local_var_entity,
14275        };
14276        Err(Error::ResponseError(local_var_error))
14277    }
14278}
14279
14280/// Post a list of virtual machine objects.
14281pub async fn virtualization_virtual_machines_create(
14282    configuration: &configuration::Configuration,
14283    virtualization_virtual_machines_create_request: crate::models::VirtualizationVirtualMachinesCreateRequest,
14284) -> Result<
14285    crate::models::VirtualMachineWithConfigContext,
14286    Error<VirtualizationVirtualMachinesCreateError>,
14287> {
14288    let local_var_configuration = configuration;
14289
14290    let local_var_client = &local_var_configuration.client;
14291
14292    let local_var_uri_str = format!(
14293        "{}/api/virtualization/virtual-machines/",
14294        local_var_configuration.base_path
14295    );
14296    let mut local_var_req_builder =
14297        local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
14298
14299    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
14300        local_var_req_builder =
14301            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
14302    }
14303    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
14304        let local_var_key = local_var_apikey.key.clone();
14305        let local_var_value = match local_var_apikey.prefix {
14306            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
14307            None => local_var_key,
14308        };
14309        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
14310    };
14311    local_var_req_builder =
14312        local_var_req_builder.json(&virtualization_virtual_machines_create_request);
14313
14314    let local_var_req = local_var_req_builder.build()?;
14315    let local_var_resp = local_var_client.execute(local_var_req).await?;
14316
14317    let local_var_status = local_var_resp.status();
14318    let local_var_content = local_var_resp.text().await?;
14319
14320    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
14321        serde_json::from_str(&local_var_content).map_err(Error::from)
14322    } else {
14323        let local_var_entity: Option<VirtualizationVirtualMachinesCreateError> =
14324            serde_json::from_str(&local_var_content).ok();
14325        let local_var_error = ResponseContent {
14326            status: local_var_status,
14327            content: local_var_content,
14328            entity: local_var_entity,
14329        };
14330        Err(Error::ResponseError(local_var_error))
14331    }
14332}
14333
14334/// Delete a virtual machine object.
14335pub async fn virtualization_virtual_machines_destroy(
14336    configuration: &configuration::Configuration,
14337    id: i32,
14338) -> Result<(), Error<VirtualizationVirtualMachinesDestroyError>> {
14339    let local_var_configuration = configuration;
14340
14341    let local_var_client = &local_var_configuration.client;
14342
14343    let local_var_uri_str = format!(
14344        "{}/api/virtualization/virtual-machines/{id}/",
14345        local_var_configuration.base_path,
14346        id = id
14347    );
14348    let mut local_var_req_builder =
14349        local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());
14350
14351    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
14352        local_var_req_builder =
14353            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
14354    }
14355    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
14356        let local_var_key = local_var_apikey.key.clone();
14357        let local_var_value = match local_var_apikey.prefix {
14358            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
14359            None => local_var_key,
14360        };
14361        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
14362    };
14363
14364    let local_var_req = local_var_req_builder.build()?;
14365    let local_var_resp = local_var_client.execute(local_var_req).await?;
14366
14367    let local_var_status = local_var_resp.status();
14368    let local_var_content = local_var_resp.text().await?;
14369
14370    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
14371        Ok(())
14372    } else {
14373        let local_var_entity: Option<VirtualizationVirtualMachinesDestroyError> =
14374            serde_json::from_str(&local_var_content).ok();
14375        let local_var_error = ResponseContent {
14376            status: local_var_status,
14377            content: local_var_content,
14378            entity: local_var_entity,
14379        };
14380        Err(Error::ResponseError(local_var_error))
14381    }
14382}
14383
14384/// Get a list of virtual machine objects.
14385pub async fn virtualization_virtual_machines_list(
14386    configuration: &configuration::Configuration,
14387    cluster: Option<Vec<String>>,
14388    cluster__n: Option<Vec<String>>,
14389    cluster_group: Option<Vec<String>>,
14390    cluster_group__n: Option<Vec<String>>,
14391    cluster_group_id: Option<Vec<i32>>,
14392    cluster_group_id__n: Option<Vec<i32>>,
14393    cluster_id: Option<Vec<i32>>,
14394    cluster_id__n: Option<Vec<i32>>,
14395    cluster_type: Option<Vec<String>>,
14396    cluster_type__n: Option<Vec<String>>,
14397    cluster_type_id: Option<Vec<i32>>,
14398    cluster_type_id__n: Option<Vec<i32>>,
14399    config_template_id: Option<Vec<i32>>,
14400    config_template_id__n: Option<Vec<i32>>,
14401    contact: Option<Vec<i32>>,
14402    contact__n: Option<Vec<i32>>,
14403    contact_group: Option<Vec<String>>,
14404    contact_group__n: Option<Vec<String>>,
14405    contact_role: Option<Vec<i32>>,
14406    contact_role__n: Option<Vec<i32>>,
14407    created: Option<Vec<String>>,
14408    created__empty: Option<Vec<String>>,
14409    created__gt: Option<Vec<String>>,
14410    created__gte: Option<Vec<String>>,
14411    created__lt: Option<Vec<String>>,
14412    created__lte: Option<Vec<String>>,
14413    created__n: Option<Vec<String>>,
14414    created_by_request: Option<&str>,
14415    description: Option<Vec<String>>,
14416    description__empty: Option<bool>,
14417    description__ic: Option<Vec<String>>,
14418    description__ie: Option<Vec<String>>,
14419    description__iew: Option<Vec<String>>,
14420    description__iregex: Option<Vec<String>>,
14421    description__isw: Option<Vec<String>>,
14422    description__n: Option<Vec<String>>,
14423    description__nic: Option<Vec<String>>,
14424    description__nie: Option<Vec<String>>,
14425    description__niew: Option<Vec<String>>,
14426    description__nisw: Option<Vec<String>>,
14427    description__regex: Option<Vec<String>>,
14428    device: Option<Vec<String>>,
14429    device__n: Option<Vec<String>>,
14430    device_id: Option<Vec<i32>>,
14431    device_id__n: Option<Vec<i32>>,
14432    disk: Option<Vec<i32>>,
14433    disk__empty: Option<bool>,
14434    disk__gt: Option<Vec<i32>>,
14435    disk__gte: Option<Vec<i32>>,
14436    disk__lt: Option<Vec<i32>>,
14437    disk__lte: Option<Vec<i32>>,
14438    disk__n: Option<Vec<i32>>,
14439    has_primary_ip: Option<bool>,
14440    id: Option<Vec<i32>>,
14441    id__empty: Option<bool>,
14442    id__gt: Option<Vec<i32>>,
14443    id__gte: Option<Vec<i32>>,
14444    id__lt: Option<Vec<i32>>,
14445    id__lte: Option<Vec<i32>>,
14446    id__n: Option<Vec<i32>>,
14447    interface_count: Option<Vec<i32>>,
14448    interface_count__empty: Option<bool>,
14449    interface_count__gt: Option<Vec<i32>>,
14450    interface_count__gte: Option<Vec<i32>>,
14451    interface_count__lt: Option<Vec<i32>>,
14452    interface_count__lte: Option<Vec<i32>>,
14453    interface_count__n: Option<Vec<i32>>,
14454    last_updated: Option<Vec<String>>,
14455    last_updated__empty: Option<Vec<String>>,
14456    last_updated__gt: Option<Vec<String>>,
14457    last_updated__gte: Option<Vec<String>>,
14458    last_updated__lt: Option<Vec<String>>,
14459    last_updated__lte: Option<Vec<String>>,
14460    last_updated__n: Option<Vec<String>>,
14461    limit: Option<i32>,
14462    local_context_data: Option<bool>,
14463    mac_address: Option<Vec<String>>,
14464    mac_address__ic: Option<Vec<String>>,
14465    mac_address__ie: Option<Vec<String>>,
14466    mac_address__iew: Option<Vec<String>>,
14467    mac_address__iregex: Option<Vec<String>>,
14468    mac_address__isw: Option<Vec<String>>,
14469    mac_address__n: Option<Vec<String>>,
14470    mac_address__nic: Option<Vec<String>>,
14471    mac_address__nie: Option<Vec<String>>,
14472    mac_address__niew: Option<Vec<String>>,
14473    mac_address__nisw: Option<Vec<String>>,
14474    mac_address__regex: Option<Vec<String>>,
14475    memory: Option<Vec<i32>>,
14476    memory__empty: Option<bool>,
14477    memory__gt: Option<Vec<i32>>,
14478    memory__gte: Option<Vec<i32>>,
14479    memory__lt: Option<Vec<i32>>,
14480    memory__lte: Option<Vec<i32>>,
14481    memory__n: Option<Vec<i32>>,
14482    modified_by_request: Option<&str>,
14483    name: Option<Vec<String>>,
14484    name__empty: Option<bool>,
14485    name__ic: Option<Vec<String>>,
14486    name__ie: Option<Vec<String>>,
14487    name__iew: Option<Vec<String>>,
14488    name__iregex: Option<Vec<String>>,
14489    name__isw: Option<Vec<String>>,
14490    name__n: Option<Vec<String>>,
14491    name__nic: Option<Vec<String>>,
14492    name__nie: Option<Vec<String>>,
14493    name__niew: Option<Vec<String>>,
14494    name__nisw: Option<Vec<String>>,
14495    name__regex: Option<Vec<String>>,
14496    offset: Option<i32>,
14497    ordering: Option<&str>,
14498    owner: Option<Vec<String>>,
14499    owner__n: Option<Vec<String>>,
14500    owner_group: Option<Vec<String>>,
14501    owner_group__n: Option<Vec<String>>,
14502    owner_group_id: Option<Vec<i32>>,
14503    owner_group_id__n: Option<Vec<i32>>,
14504    owner_id: Option<Vec<i32>>,
14505    owner_id__n: Option<Vec<i32>>,
14506    platform: Option<Vec<String>>,
14507    platform__n: Option<Vec<String>>,
14508    platform_id: Option<Vec<String>>,
14509    platform_id__n: Option<Vec<String>>,
14510    primary_ip4: Option<Vec<String>>,
14511    primary_ip4__n: Option<Vec<String>>,
14512    primary_ip4_id: Option<Vec<i32>>,
14513    primary_ip4_id__n: Option<Vec<i32>>,
14514    primary_ip6: Option<Vec<String>>,
14515    primary_ip6__n: Option<Vec<String>>,
14516    primary_ip6_id: Option<Vec<i32>>,
14517    primary_ip6_id__n: Option<Vec<i32>>,
14518    q: Option<&str>,
14519    region: Option<Vec<String>>,
14520    region__n: Option<Vec<String>>,
14521    region_id: Option<Vec<String>>,
14522    region_id__n: Option<Vec<String>>,
14523    role: Option<Vec<String>>,
14524    role__n: Option<Vec<String>>,
14525    role_id: Option<Vec<String>>,
14526    role_id__n: Option<Vec<String>>,
14527    serial: Option<Vec<String>>,
14528    serial__empty: Option<bool>,
14529    serial__ic: Option<Vec<String>>,
14530    serial__ie: Option<Vec<String>>,
14531    serial__iew: Option<Vec<String>>,
14532    serial__iregex: Option<Vec<String>>,
14533    serial__isw: Option<Vec<String>>,
14534    serial__n: Option<Vec<String>>,
14535    serial__nic: Option<Vec<String>>,
14536    serial__nie: Option<Vec<String>>,
14537    serial__niew: Option<Vec<String>>,
14538    serial__nisw: Option<Vec<String>>,
14539    serial__regex: Option<Vec<String>>,
14540    site: Option<Vec<String>>,
14541    site__n: Option<Vec<String>>,
14542    site_group: Option<Vec<String>>,
14543    site_group__n: Option<Vec<String>>,
14544    site_group_id: Option<Vec<String>>,
14545    site_group_id__n: Option<Vec<String>>,
14546    site_id: Option<Vec<i32>>,
14547    site_id__n: Option<Vec<i32>>,
14548    start: Option<i32>,
14549    start_on_boot: Option<Vec<String>>,
14550    start_on_boot__empty: Option<bool>,
14551    start_on_boot__ic: Option<Vec<String>>,
14552    start_on_boot__ie: Option<Vec<String>>,
14553    start_on_boot__iew: Option<Vec<String>>,
14554    start_on_boot__iregex: Option<Vec<String>>,
14555    start_on_boot__isw: Option<Vec<String>>,
14556    start_on_boot__n: Option<Vec<String>>,
14557    start_on_boot__nic: Option<Vec<String>>,
14558    start_on_boot__nie: Option<Vec<String>>,
14559    start_on_boot__niew: Option<Vec<String>>,
14560    start_on_boot__nisw: Option<Vec<String>>,
14561    start_on_boot__regex: Option<Vec<String>>,
14562    status: Option<Vec<String>>,
14563    status__empty: Option<bool>,
14564    status__ic: Option<Vec<String>>,
14565    status__ie: Option<Vec<String>>,
14566    status__iew: Option<Vec<String>>,
14567    status__iregex: Option<Vec<String>>,
14568    status__isw: Option<Vec<String>>,
14569    status__n: Option<Vec<String>>,
14570    status__nic: Option<Vec<String>>,
14571    status__nie: Option<Vec<String>>,
14572    status__niew: Option<Vec<String>>,
14573    status__nisw: Option<Vec<String>>,
14574    status__regex: Option<Vec<String>>,
14575    tag: Option<Vec<String>>,
14576    tag__n: Option<Vec<String>>,
14577    tag_id: Option<Vec<i32>>,
14578    tag_id__n: Option<Vec<i32>>,
14579    tenant: Option<Vec<String>>,
14580    tenant__n: Option<Vec<String>>,
14581    tenant_group: Option<Vec<String>>,
14582    tenant_group__n: Option<Vec<String>>,
14583    tenant_group_id: Option<Vec<String>>,
14584    tenant_group_id__n: Option<Vec<String>>,
14585    tenant_id: Option<Vec<i32>>,
14586    tenant_id__n: Option<Vec<i32>>,
14587    updated_by_request: Option<&str>,
14588    vcpus: Option<Vec<f64>>,
14589    vcpus__empty: Option<bool>,
14590    vcpus__gt: Option<Vec<f64>>,
14591    vcpus__gte: Option<Vec<f64>>,
14592    vcpus__lt: Option<Vec<f64>>,
14593    vcpus__lte: Option<Vec<f64>>,
14594    vcpus__n: Option<Vec<f64>>,
14595    virtual_disk_count: Option<Vec<i32>>,
14596    virtual_disk_count__empty: Option<bool>,
14597    virtual_disk_count__gt: Option<Vec<i32>>,
14598    virtual_disk_count__gte: Option<Vec<i32>>,
14599    virtual_disk_count__lt: Option<Vec<i32>>,
14600    virtual_disk_count__lte: Option<Vec<i32>>,
14601    virtual_disk_count__n: Option<Vec<i32>>,
14602    virtual_machine_type: Option<Vec<String>>,
14603    virtual_machine_type__n: Option<Vec<String>>,
14604    virtual_machine_type_id: Option<Vec<i32>>,
14605    virtual_machine_type_id__n: Option<Vec<i32>>,
14606) -> Result<
14607    crate::models::PaginatedVirtualMachineWithConfigContextList,
14608    Error<VirtualizationVirtualMachinesListError>,
14609> {
14610    let local_var_configuration = configuration;
14611
14612    let local_var_client = &local_var_configuration.client;
14613
14614    let local_var_uri_str = format!(
14615        "{}/api/virtualization/virtual-machines/",
14616        local_var_configuration.base_path
14617    );
14618    let mut local_var_req_builder =
14619        local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
14620
14621    if let Some(ref local_var_str) = cluster {
14622        local_var_req_builder = match "multi" {
14623            "multi" => local_var_req_builder.query(
14624                &local_var_str
14625                    .into_iter()
14626                    .map(|p| ("cluster".to_owned(), p.to_string()))
14627                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14628            ),
14629            _ => local_var_req_builder.query(&[(
14630                "cluster",
14631                &local_var_str
14632                    .into_iter()
14633                    .map(|p| p.to_string())
14634                    .collect::<Vec<String>>()
14635                    .join(",")
14636                    .to_string(),
14637            )]),
14638        };
14639    }
14640    if let Some(ref local_var_str) = cluster__n {
14641        local_var_req_builder = match "multi" {
14642            "multi" => local_var_req_builder.query(
14643                &local_var_str
14644                    .into_iter()
14645                    .map(|p| ("cluster__n".to_owned(), p.to_string()))
14646                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14647            ),
14648            _ => local_var_req_builder.query(&[(
14649                "cluster__n",
14650                &local_var_str
14651                    .into_iter()
14652                    .map(|p| p.to_string())
14653                    .collect::<Vec<String>>()
14654                    .join(",")
14655                    .to_string(),
14656            )]),
14657        };
14658    }
14659    if let Some(ref local_var_str) = cluster_group {
14660        local_var_req_builder = match "multi" {
14661            "multi" => local_var_req_builder.query(
14662                &local_var_str
14663                    .into_iter()
14664                    .map(|p| ("cluster_group".to_owned(), p.to_string()))
14665                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14666            ),
14667            _ => local_var_req_builder.query(&[(
14668                "cluster_group",
14669                &local_var_str
14670                    .into_iter()
14671                    .map(|p| p.to_string())
14672                    .collect::<Vec<String>>()
14673                    .join(",")
14674                    .to_string(),
14675            )]),
14676        };
14677    }
14678    if let Some(ref local_var_str) = cluster_group__n {
14679        local_var_req_builder = match "multi" {
14680            "multi" => local_var_req_builder.query(
14681                &local_var_str
14682                    .into_iter()
14683                    .map(|p| ("cluster_group__n".to_owned(), p.to_string()))
14684                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14685            ),
14686            _ => local_var_req_builder.query(&[(
14687                "cluster_group__n",
14688                &local_var_str
14689                    .into_iter()
14690                    .map(|p| p.to_string())
14691                    .collect::<Vec<String>>()
14692                    .join(",")
14693                    .to_string(),
14694            )]),
14695        };
14696    }
14697    if let Some(ref local_var_str) = cluster_group_id {
14698        local_var_req_builder = match "multi" {
14699            "multi" => local_var_req_builder.query(
14700                &local_var_str
14701                    .into_iter()
14702                    .map(|p| ("cluster_group_id".to_owned(), p.to_string()))
14703                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14704            ),
14705            _ => local_var_req_builder.query(&[(
14706                "cluster_group_id",
14707                &local_var_str
14708                    .into_iter()
14709                    .map(|p| p.to_string())
14710                    .collect::<Vec<String>>()
14711                    .join(",")
14712                    .to_string(),
14713            )]),
14714        };
14715    }
14716    if let Some(ref local_var_str) = cluster_group_id__n {
14717        local_var_req_builder = match "multi" {
14718            "multi" => local_var_req_builder.query(
14719                &local_var_str
14720                    .into_iter()
14721                    .map(|p| ("cluster_group_id__n".to_owned(), p.to_string()))
14722                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14723            ),
14724            _ => local_var_req_builder.query(&[(
14725                "cluster_group_id__n",
14726                &local_var_str
14727                    .into_iter()
14728                    .map(|p| p.to_string())
14729                    .collect::<Vec<String>>()
14730                    .join(",")
14731                    .to_string(),
14732            )]),
14733        };
14734    }
14735    if let Some(ref local_var_str) = cluster_id {
14736        local_var_req_builder = match "multi" {
14737            "multi" => local_var_req_builder.query(
14738                &local_var_str
14739                    .into_iter()
14740                    .map(|p| ("cluster_id".to_owned(), p.to_string()))
14741                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14742            ),
14743            _ => local_var_req_builder.query(&[(
14744                "cluster_id",
14745                &local_var_str
14746                    .into_iter()
14747                    .map(|p| p.to_string())
14748                    .collect::<Vec<String>>()
14749                    .join(",")
14750                    .to_string(),
14751            )]),
14752        };
14753    }
14754    if let Some(ref local_var_str) = cluster_id__n {
14755        local_var_req_builder = match "multi" {
14756            "multi" => local_var_req_builder.query(
14757                &local_var_str
14758                    .into_iter()
14759                    .map(|p| ("cluster_id__n".to_owned(), p.to_string()))
14760                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14761            ),
14762            _ => local_var_req_builder.query(&[(
14763                "cluster_id__n",
14764                &local_var_str
14765                    .into_iter()
14766                    .map(|p| p.to_string())
14767                    .collect::<Vec<String>>()
14768                    .join(",")
14769                    .to_string(),
14770            )]),
14771        };
14772    }
14773    if let Some(ref local_var_str) = cluster_type {
14774        local_var_req_builder = match "multi" {
14775            "multi" => local_var_req_builder.query(
14776                &local_var_str
14777                    .into_iter()
14778                    .map(|p| ("cluster_type".to_owned(), p.to_string()))
14779                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14780            ),
14781            _ => local_var_req_builder.query(&[(
14782                "cluster_type",
14783                &local_var_str
14784                    .into_iter()
14785                    .map(|p| p.to_string())
14786                    .collect::<Vec<String>>()
14787                    .join(",")
14788                    .to_string(),
14789            )]),
14790        };
14791    }
14792    if let Some(ref local_var_str) = cluster_type__n {
14793        local_var_req_builder = match "multi" {
14794            "multi" => local_var_req_builder.query(
14795                &local_var_str
14796                    .into_iter()
14797                    .map(|p| ("cluster_type__n".to_owned(), p.to_string()))
14798                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14799            ),
14800            _ => local_var_req_builder.query(&[(
14801                "cluster_type__n",
14802                &local_var_str
14803                    .into_iter()
14804                    .map(|p| p.to_string())
14805                    .collect::<Vec<String>>()
14806                    .join(",")
14807                    .to_string(),
14808            )]),
14809        };
14810    }
14811    if let Some(ref local_var_str) = cluster_type_id {
14812        local_var_req_builder = match "multi" {
14813            "multi" => local_var_req_builder.query(
14814                &local_var_str
14815                    .into_iter()
14816                    .map(|p| ("cluster_type_id".to_owned(), p.to_string()))
14817                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14818            ),
14819            _ => local_var_req_builder.query(&[(
14820                "cluster_type_id",
14821                &local_var_str
14822                    .into_iter()
14823                    .map(|p| p.to_string())
14824                    .collect::<Vec<String>>()
14825                    .join(",")
14826                    .to_string(),
14827            )]),
14828        };
14829    }
14830    if let Some(ref local_var_str) = cluster_type_id__n {
14831        local_var_req_builder = match "multi" {
14832            "multi" => local_var_req_builder.query(
14833                &local_var_str
14834                    .into_iter()
14835                    .map(|p| ("cluster_type_id__n".to_owned(), p.to_string()))
14836                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14837            ),
14838            _ => local_var_req_builder.query(&[(
14839                "cluster_type_id__n",
14840                &local_var_str
14841                    .into_iter()
14842                    .map(|p| p.to_string())
14843                    .collect::<Vec<String>>()
14844                    .join(",")
14845                    .to_string(),
14846            )]),
14847        };
14848    }
14849    if let Some(ref local_var_str) = config_template_id {
14850        local_var_req_builder = match "multi" {
14851            "multi" => local_var_req_builder.query(
14852                &local_var_str
14853                    .into_iter()
14854                    .map(|p| ("config_template_id".to_owned(), p.to_string()))
14855                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14856            ),
14857            _ => local_var_req_builder.query(&[(
14858                "config_template_id",
14859                &local_var_str
14860                    .into_iter()
14861                    .map(|p| p.to_string())
14862                    .collect::<Vec<String>>()
14863                    .join(",")
14864                    .to_string(),
14865            )]),
14866        };
14867    }
14868    if let Some(ref local_var_str) = config_template_id__n {
14869        local_var_req_builder = match "multi" {
14870            "multi" => local_var_req_builder.query(
14871                &local_var_str
14872                    .into_iter()
14873                    .map(|p| ("config_template_id__n".to_owned(), p.to_string()))
14874                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14875            ),
14876            _ => local_var_req_builder.query(&[(
14877                "config_template_id__n",
14878                &local_var_str
14879                    .into_iter()
14880                    .map(|p| p.to_string())
14881                    .collect::<Vec<String>>()
14882                    .join(",")
14883                    .to_string(),
14884            )]),
14885        };
14886    }
14887    if let Some(ref local_var_str) = contact {
14888        local_var_req_builder = match "multi" {
14889            "multi" => local_var_req_builder.query(
14890                &local_var_str
14891                    .into_iter()
14892                    .map(|p| ("contact".to_owned(), p.to_string()))
14893                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14894            ),
14895            _ => local_var_req_builder.query(&[(
14896                "contact",
14897                &local_var_str
14898                    .into_iter()
14899                    .map(|p| p.to_string())
14900                    .collect::<Vec<String>>()
14901                    .join(",")
14902                    .to_string(),
14903            )]),
14904        };
14905    }
14906    if let Some(ref local_var_str) = contact__n {
14907        local_var_req_builder = match "multi" {
14908            "multi" => local_var_req_builder.query(
14909                &local_var_str
14910                    .into_iter()
14911                    .map(|p| ("contact__n".to_owned(), p.to_string()))
14912                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14913            ),
14914            _ => local_var_req_builder.query(&[(
14915                "contact__n",
14916                &local_var_str
14917                    .into_iter()
14918                    .map(|p| p.to_string())
14919                    .collect::<Vec<String>>()
14920                    .join(",")
14921                    .to_string(),
14922            )]),
14923        };
14924    }
14925    if let Some(ref local_var_str) = contact_group {
14926        local_var_req_builder = match "multi" {
14927            "multi" => local_var_req_builder.query(
14928                &local_var_str
14929                    .into_iter()
14930                    .map(|p| ("contact_group".to_owned(), p.to_string()))
14931                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14932            ),
14933            _ => local_var_req_builder.query(&[(
14934                "contact_group",
14935                &local_var_str
14936                    .into_iter()
14937                    .map(|p| p.to_string())
14938                    .collect::<Vec<String>>()
14939                    .join(",")
14940                    .to_string(),
14941            )]),
14942        };
14943    }
14944    if let Some(ref local_var_str) = contact_group__n {
14945        local_var_req_builder = match "multi" {
14946            "multi" => local_var_req_builder.query(
14947                &local_var_str
14948                    .into_iter()
14949                    .map(|p| ("contact_group__n".to_owned(), p.to_string()))
14950                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14951            ),
14952            _ => local_var_req_builder.query(&[(
14953                "contact_group__n",
14954                &local_var_str
14955                    .into_iter()
14956                    .map(|p| p.to_string())
14957                    .collect::<Vec<String>>()
14958                    .join(",")
14959                    .to_string(),
14960            )]),
14961        };
14962    }
14963    if let Some(ref local_var_str) = contact_role {
14964        local_var_req_builder = match "multi" {
14965            "multi" => local_var_req_builder.query(
14966                &local_var_str
14967                    .into_iter()
14968                    .map(|p| ("contact_role".to_owned(), p.to_string()))
14969                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14970            ),
14971            _ => local_var_req_builder.query(&[(
14972                "contact_role",
14973                &local_var_str
14974                    .into_iter()
14975                    .map(|p| p.to_string())
14976                    .collect::<Vec<String>>()
14977                    .join(",")
14978                    .to_string(),
14979            )]),
14980        };
14981    }
14982    if let Some(ref local_var_str) = contact_role__n {
14983        local_var_req_builder = match "multi" {
14984            "multi" => local_var_req_builder.query(
14985                &local_var_str
14986                    .into_iter()
14987                    .map(|p| ("contact_role__n".to_owned(), p.to_string()))
14988                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14989            ),
14990            _ => local_var_req_builder.query(&[(
14991                "contact_role__n",
14992                &local_var_str
14993                    .into_iter()
14994                    .map(|p| p.to_string())
14995                    .collect::<Vec<String>>()
14996                    .join(",")
14997                    .to_string(),
14998            )]),
14999        };
15000    }
15001    if let Some(ref local_var_str) = created {
15002        local_var_req_builder = match "multi" {
15003            "multi" => local_var_req_builder.query(
15004                &local_var_str
15005                    .into_iter()
15006                    .map(|p| ("created".to_owned(), p.to_string()))
15007                    .collect::<Vec<(std::string::String, std::string::String)>>(),
15008            ),
15009            _ => local_var_req_builder.query(&[(
15010                "created",
15011                &local_var_str
15012                    .into_iter()
15013                    .map(|p| p.to_string())
15014                    .collect::<Vec<String>>()
15015                    .join(",")
15016                    .to_string(),
15017            )]),
15018        };
15019    }
15020    if let Some(ref local_var_str) = created__empty {
15021        local_var_req_builder = match "multi" {
15022            "multi" => local_var_req_builder.query(
15023                &local_var_str
15024                    .into_iter()
15025                    .map(|p| ("created__empty".to_owned(), p.to_string()))
15026                    .collect::<Vec<(std::string::String, std::string::String)>>(),
15027            ),
15028            _ => local_var_req_builder.query(&[(
15029                "created__empty",
15030                &local_var_str
15031                    .into_iter()
15032                    .map(|p| p.to_string())
15033                    .collect::<Vec<String>>()
15034                    .join(",")
15035                    .to_string(),
15036            )]),
15037        };
15038    }
15039    if let Some(ref local_var_str) = created__gt {
15040        local_var_req_builder = match "multi" {
15041            "multi" => local_var_req_builder.query(
15042                &local_var_str
15043                    .into_iter()
15044                    .map(|p| ("created__gt".to_owned(), p.to_string()))
15045                    .collect::<Vec<(std::string::String, std::string::String)>>(),
15046            ),
15047            _ => local_var_req_builder.query(&[(
15048                "created__gt",
15049                &local_var_str
15050                    .into_iter()
15051                    .map(|p| p.to_string())
15052                    .collect::<Vec<String>>()
15053                    .join(",")
15054                    .to_string(),
15055            )]),
15056        };
15057    }
15058    if let Some(ref local_var_str) = created__gte {
15059        local_var_req_builder = match "multi" {
15060            "multi" => local_var_req_builder.query(
15061                &local_var_str
15062                    .into_iter()
15063                    .map(|p| ("created__gte".to_owned(), p.to_string()))
15064                    .collect::<Vec<(std::string::String, std::string::String)>>(),
15065            ),
15066            _ => local_var_req_builder.query(&[(
15067                "created__gte",
15068                &local_var_str
15069                    .into_iter()
15070                    .map(|p| p.to_string())
15071                    .collect::<Vec<String>>()
15072                    .join(",")
15073                    .to_string(),
15074            )]),
15075        };
15076    }
15077    if let Some(ref local_var_str) = created__lt {
15078        local_var_req_builder = match "multi" {
15079            "multi" => local_var_req_builder.query(
15080                &local_var_str
15081                    .into_iter()
15082                    .map(|p| ("created__lt".to_owned(), p.to_string()))
15083                    .collect::<Vec<(std::string::String, std::string::String)>>(),
15084            ),
15085            _ => local_var_req_builder.query(&[(
15086                "created__lt",
15087                &local_var_str
15088                    .into_iter()
15089                    .map(|p| p.to_string())
15090                    .collect::<Vec<String>>()
15091                    .join(",")
15092                    .to_string(),
15093            )]),
15094        };
15095    }
15096    if let Some(ref local_var_str) = created__lte {
15097        local_var_req_builder = match "multi" {
15098            "multi" => local_var_req_builder.query(
15099                &local_var_str
15100                    .into_iter()
15101                    .map(|p| ("created__lte".to_owned(), p.to_string()))
15102                    .collect::<Vec<(std::string::String, std::string::String)>>(),
15103            ),
15104            _ => local_var_req_builder.query(&[(
15105                "created__lte",
15106                &local_var_str
15107                    .into_iter()
15108                    .map(|p| p.to_string())
15109                    .collect::<Vec<String>>()
15110                    .join(",")
15111                    .to_string(),
15112            )]),
15113        };
15114    }
15115    if let Some(ref local_var_str) = created__n {
15116        local_var_req_builder = match "multi" {
15117            "multi" => local_var_req_builder.query(
15118                &local_var_str
15119                    .into_iter()
15120                    .map(|p| ("created__n".to_owned(), p.to_string()))
15121                    .collect::<Vec<(std::string::String, std::string::String)>>(),
15122            ),
15123            _ => local_var_req_builder.query(&[(
15124                "created__n",
15125                &local_var_str
15126                    .into_iter()
15127                    .map(|p| p.to_string())
15128                    .collect::<Vec<String>>()
15129                    .join(",")
15130                    .to_string(),
15131            )]),
15132        };
15133    }
15134    if let Some(ref local_var_str) = created_by_request {
15135        local_var_req_builder =
15136            local_var_req_builder.query(&[("created_by_request", &local_var_str.to_string())]);
15137    }
15138    if let Some(ref local_var_str) = description {
15139        local_var_req_builder = match "multi" {
15140            "multi" => local_var_req_builder.query(
15141                &local_var_str
15142                    .into_iter()
15143                    .map(|p| ("description".to_owned(), p.to_string()))
15144                    .collect::<Vec<(std::string::String, std::string::String)>>(),
15145            ),
15146            _ => local_var_req_builder.query(&[(
15147                "description",
15148                &local_var_str
15149                    .into_iter()
15150                    .map(|p| p.to_string())
15151                    .collect::<Vec<String>>()
15152                    .join(",")
15153                    .to_string(),
15154            )]),
15155        };
15156    }
15157    if let Some(ref local_var_str) = description__empty {
15158        local_var_req_builder =
15159            local_var_req_builder.query(&[("description__empty", &local_var_str.to_string())]);
15160    }
15161    if let Some(ref local_var_str) = description__ic {
15162        local_var_req_builder = match "multi" {
15163            "multi" => local_var_req_builder.query(
15164                &local_var_str
15165                    .into_iter()
15166                    .map(|p| ("description__ic".to_owned(), p.to_string()))
15167                    .collect::<Vec<(std::string::String, std::string::String)>>(),
15168            ),
15169            _ => local_var_req_builder.query(&[(
15170                "description__ic",
15171                &local_var_str
15172                    .into_iter()
15173                    .map(|p| p.to_string())
15174                    .collect::<Vec<String>>()
15175                    .join(",")
15176                    .to_string(),
15177            )]),
15178        };
15179    }
15180    if let Some(ref local_var_str) = description__ie {
15181        local_var_req_builder = match "multi" {
15182            "multi" => local_var_req_builder.query(
15183                &local_var_str
15184                    .into_iter()
15185                    .map(|p| ("description__ie".to_owned(), p.to_string()))
15186                    .collect::<Vec<(std::string::String, std::string::String)>>(),
15187            ),
15188            _ => local_var_req_builder.query(&[(
15189                "description__ie",
15190                &local_var_str
15191                    .into_iter()
15192                    .map(|p| p.to_string())
15193                    .collect::<Vec<String>>()
15194                    .join(",")
15195                    .to_string(),
15196            )]),
15197        };
15198    }
15199    if let Some(ref local_var_str) = description__iew {
15200        local_var_req_builder = match "multi" {
15201            "multi" => local_var_req_builder.query(
15202                &local_var_str
15203                    .into_iter()
15204                    .map(|p| ("description__iew".to_owned(), p.to_string()))
15205                    .collect::<Vec<(std::string::String, std::string::String)>>(),
15206            ),
15207            _ => local_var_req_builder.query(&[(
15208                "description__iew",
15209                &local_var_str
15210                    .into_iter()
15211                    .map(|p| p.to_string())
15212                    .collect::<Vec<String>>()
15213                    .join(",")
15214                    .to_string(),
15215            )]),
15216        };
15217    }
15218    if let Some(ref local_var_str) = description__iregex {
15219        local_var_req_builder = match "multi" {
15220            "multi" => local_var_req_builder.query(
15221                &local_var_str
15222                    .into_iter()
15223                    .map(|p| ("description__iregex".to_owned(), p.to_string()))
15224                    .collect::<Vec<(std::string::String, std::string::String)>>(),
15225            ),
15226            _ => local_var_req_builder.query(&[(
15227                "description__iregex",
15228                &local_var_str
15229                    .into_iter()
15230                    .map(|p| p.to_string())
15231                    .collect::<Vec<String>>()
15232                    .join(",")
15233                    .to_string(),
15234            )]),
15235        };
15236    }
15237    if let Some(ref local_var_str) = description__isw {
15238        local_var_req_builder = match "multi" {
15239            "multi" => local_var_req_builder.query(
15240                &local_var_str
15241                    .into_iter()
15242                    .map(|p| ("description__isw".to_owned(), p.to_string()))
15243                    .collect::<Vec<(std::string::String, std::string::String)>>(),
15244            ),
15245            _ => local_var_req_builder.query(&[(
15246                "description__isw",
15247                &local_var_str
15248                    .into_iter()
15249                    .map(|p| p.to_string())
15250                    .collect::<Vec<String>>()
15251                    .join(",")
15252                    .to_string(),
15253            )]),
15254        };
15255    }
15256    if let Some(ref local_var_str) = description__n {
15257        local_var_req_builder = match "multi" {
15258            "multi" => local_var_req_builder.query(
15259                &local_var_str
15260                    .into_iter()
15261                    .map(|p| ("description__n".to_owned(), p.to_string()))
15262                    .collect::<Vec<(std::string::String, std::string::String)>>(),
15263            ),
15264            _ => local_var_req_builder.query(&[(
15265                "description__n",
15266                &local_var_str
15267                    .into_iter()
15268                    .map(|p| p.to_string())
15269                    .collect::<Vec<String>>()
15270                    .join(",")
15271                    .to_string(),
15272            )]),
15273        };
15274    }
15275    if let Some(ref local_var_str) = description__nic {
15276        local_var_req_builder = match "multi" {
15277            "multi" => local_var_req_builder.query(
15278                &local_var_str
15279                    .into_iter()
15280                    .map(|p| ("description__nic".to_owned(), p.to_string()))
15281                    .collect::<Vec<(std::string::String, std::string::String)>>(),
15282            ),
15283            _ => local_var_req_builder.query(&[(
15284                "description__nic",
15285                &local_var_str
15286                    .into_iter()
15287                    .map(|p| p.to_string())
15288                    .collect::<Vec<String>>()
15289                    .join(",")
15290                    .to_string(),
15291            )]),
15292        };
15293    }
15294    if let Some(ref local_var_str) = description__nie {
15295        local_var_req_builder = match "multi" {
15296            "multi" => local_var_req_builder.query(
15297                &local_var_str
15298                    .into_iter()
15299                    .map(|p| ("description__nie".to_owned(), p.to_string()))
15300                    .collect::<Vec<(std::string::String, std::string::String)>>(),
15301            ),
15302            _ => local_var_req_builder.query(&[(
15303                "description__nie",
15304                &local_var_str
15305                    .into_iter()
15306                    .map(|p| p.to_string())
15307                    .collect::<Vec<String>>()
15308                    .join(",")
15309                    .to_string(),
15310            )]),
15311        };
15312    }
15313    if let Some(ref local_var_str) = description__niew {
15314        local_var_req_builder = match "multi" {
15315            "multi" => local_var_req_builder.query(
15316                &local_var_str
15317                    .into_iter()
15318                    .map(|p| ("description__niew".to_owned(), p.to_string()))
15319                    .collect::<Vec<(std::string::String, std::string::String)>>(),
15320            ),
15321            _ => local_var_req_builder.query(&[(
15322                "description__niew",
15323                &local_var_str
15324                    .into_iter()
15325                    .map(|p| p.to_string())
15326                    .collect::<Vec<String>>()
15327                    .join(",")
15328                    .to_string(),
15329            )]),
15330        };
15331    }
15332    if let Some(ref local_var_str) = description__nisw {
15333        local_var_req_builder = match "multi" {
15334            "multi" => local_var_req_builder.query(
15335                &local_var_str
15336                    .into_iter()
15337                    .map(|p| ("description__nisw".to_owned(), p.to_string()))
15338                    .collect::<Vec<(std::string::String, std::string::String)>>(),
15339            ),
15340            _ => local_var_req_builder.query(&[(
15341                "description__nisw",
15342                &local_var_str
15343                    .into_iter()
15344                    .map(|p| p.to_string())
15345                    .collect::<Vec<String>>()
15346                    .join(",")
15347                    .to_string(),
15348            )]),
15349        };
15350    }
15351    if let Some(ref local_var_str) = description__regex {
15352        local_var_req_builder = match "multi" {
15353            "multi" => local_var_req_builder.query(
15354                &local_var_str
15355                    .into_iter()
15356                    .map(|p| ("description__regex".to_owned(), p.to_string()))
15357                    .collect::<Vec<(std::string::String, std::string::String)>>(),
15358            ),
15359            _ => local_var_req_builder.query(&[(
15360                "description__regex",
15361                &local_var_str
15362                    .into_iter()
15363                    .map(|p| p.to_string())
15364                    .collect::<Vec<String>>()
15365                    .join(",")
15366                    .to_string(),
15367            )]),
15368        };
15369    }
15370    if let Some(ref local_var_str) = device {
15371        local_var_req_builder = match "multi" {
15372            "multi" => local_var_req_builder.query(
15373                &local_var_str
15374                    .into_iter()
15375                    .map(|p| ("device".to_owned(), p.to_string()))
15376                    .collect::<Vec<(std::string::String, std::string::String)>>(),
15377            ),
15378            _ => local_var_req_builder.query(&[(
15379                "device",
15380                &local_var_str
15381                    .into_iter()
15382                    .map(|p| p.to_string())
15383                    .collect::<Vec<String>>()
15384                    .join(",")
15385                    .to_string(),
15386            )]),
15387        };
15388    }
15389    if let Some(ref local_var_str) = device__n {
15390        local_var_req_builder = match "multi" {
15391            "multi" => local_var_req_builder.query(
15392                &local_var_str
15393                    .into_iter()
15394                    .map(|p| ("device__n".to_owned(), p.to_string()))
15395                    .collect::<Vec<(std::string::String, std::string::String)>>(),
15396            ),
15397            _ => local_var_req_builder.query(&[(
15398                "device__n",
15399                &local_var_str
15400                    .into_iter()
15401                    .map(|p| p.to_string())
15402                    .collect::<Vec<String>>()
15403                    .join(",")
15404                    .to_string(),
15405            )]),
15406        };
15407    }
15408    if let Some(ref local_var_str) = device_id {
15409        local_var_req_builder = match "multi" {
15410            "multi" => local_var_req_builder.query(
15411                &local_var_str
15412                    .into_iter()
15413                    .map(|p| ("device_id".to_owned(), p.to_string()))
15414                    .collect::<Vec<(std::string::String, std::string::String)>>(),
15415            ),
15416            _ => local_var_req_builder.query(&[(
15417                "device_id",
15418                &local_var_str
15419                    .into_iter()
15420                    .map(|p| p.to_string())
15421                    .collect::<Vec<String>>()
15422                    .join(",")
15423                    .to_string(),
15424            )]),
15425        };
15426    }
15427    if let Some(ref local_var_str) = device_id__n {
15428        local_var_req_builder = match "multi" {
15429            "multi" => local_var_req_builder.query(
15430                &local_var_str
15431                    .into_iter()
15432                    .map(|p| ("device_id__n".to_owned(), p.to_string()))
15433                    .collect::<Vec<(std::string::String, std::string::String)>>(),
15434            ),
15435            _ => local_var_req_builder.query(&[(
15436                "device_id__n",
15437                &local_var_str
15438                    .into_iter()
15439                    .map(|p| p.to_string())
15440                    .collect::<Vec<String>>()
15441                    .join(",")
15442                    .to_string(),
15443            )]),
15444        };
15445    }
15446    if let Some(ref local_var_str) = disk {
15447        local_var_req_builder = match "multi" {
15448            "multi" => local_var_req_builder.query(
15449                &local_var_str
15450                    .into_iter()
15451                    .map(|p| ("disk".to_owned(), p.to_string()))
15452                    .collect::<Vec<(std::string::String, std::string::String)>>(),
15453            ),
15454            _ => local_var_req_builder.query(&[(
15455                "disk",
15456                &local_var_str
15457                    .into_iter()
15458                    .map(|p| p.to_string())
15459                    .collect::<Vec<String>>()
15460                    .join(",")
15461                    .to_string(),
15462            )]),
15463        };
15464    }
15465    if let Some(ref local_var_str) = disk__empty {
15466        local_var_req_builder =
15467            local_var_req_builder.query(&[("disk__empty", &local_var_str.to_string())]);
15468    }
15469    if let Some(ref local_var_str) = disk__gt {
15470        local_var_req_builder = match "multi" {
15471            "multi" => local_var_req_builder.query(
15472                &local_var_str
15473                    .into_iter()
15474                    .map(|p| ("disk__gt".to_owned(), p.to_string()))
15475                    .collect::<Vec<(std::string::String, std::string::String)>>(),
15476            ),
15477            _ => local_var_req_builder.query(&[(
15478                "disk__gt",
15479                &local_var_str
15480                    .into_iter()
15481                    .map(|p| p.to_string())
15482                    .collect::<Vec<String>>()
15483                    .join(",")
15484                    .to_string(),
15485            )]),
15486        };
15487    }
15488    if let Some(ref local_var_str) = disk__gte {
15489        local_var_req_builder = match "multi" {
15490            "multi" => local_var_req_builder.query(
15491                &local_var_str
15492                    .into_iter()
15493                    .map(|p| ("disk__gte".to_owned(), p.to_string()))
15494                    .collect::<Vec<(std::string::String, std::string::String)>>(),
15495            ),
15496            _ => local_var_req_builder.query(&[(
15497                "disk__gte",
15498                &local_var_str
15499                    .into_iter()
15500                    .map(|p| p.to_string())
15501                    .collect::<Vec<String>>()
15502                    .join(",")
15503                    .to_string(),
15504            )]),
15505        };
15506    }
15507    if let Some(ref local_var_str) = disk__lt {
15508        local_var_req_builder = match "multi" {
15509            "multi" => local_var_req_builder.query(
15510                &local_var_str
15511                    .into_iter()
15512                    .map(|p| ("disk__lt".to_owned(), p.to_string()))
15513                    .collect::<Vec<(std::string::String, std::string::String)>>(),
15514            ),
15515            _ => local_var_req_builder.query(&[(
15516                "disk__lt",
15517                &local_var_str
15518                    .into_iter()
15519                    .map(|p| p.to_string())
15520                    .collect::<Vec<String>>()
15521                    .join(",")
15522                    .to_string(),
15523            )]),
15524        };
15525    }
15526    if let Some(ref local_var_str) = disk__lte {
15527        local_var_req_builder = match "multi" {
15528            "multi" => local_var_req_builder.query(
15529                &local_var_str
15530                    .into_iter()
15531                    .map(|p| ("disk__lte".to_owned(), p.to_string()))
15532                    .collect::<Vec<(std::string::String, std::string::String)>>(),
15533            ),
15534            _ => local_var_req_builder.query(&[(
15535                "disk__lte",
15536                &local_var_str
15537                    .into_iter()
15538                    .map(|p| p.to_string())
15539                    .collect::<Vec<String>>()
15540                    .join(",")
15541                    .to_string(),
15542            )]),
15543        };
15544    }
15545    if let Some(ref local_var_str) = disk__n {
15546        local_var_req_builder = match "multi" {
15547            "multi" => local_var_req_builder.query(
15548                &local_var_str
15549                    .into_iter()
15550                    .map(|p| ("disk__n".to_owned(), p.to_string()))
15551                    .collect::<Vec<(std::string::String, std::string::String)>>(),
15552            ),
15553            _ => local_var_req_builder.query(&[(
15554                "disk__n",
15555                &local_var_str
15556                    .into_iter()
15557                    .map(|p| p.to_string())
15558                    .collect::<Vec<String>>()
15559                    .join(",")
15560                    .to_string(),
15561            )]),
15562        };
15563    }
15564    if let Some(ref local_var_str) = has_primary_ip {
15565        local_var_req_builder =
15566            local_var_req_builder.query(&[("has_primary_ip", &local_var_str.to_string())]);
15567    }
15568    if let Some(ref local_var_str) = id {
15569        local_var_req_builder = match "multi" {
15570            "multi" => local_var_req_builder.query(
15571                &local_var_str
15572                    .into_iter()
15573                    .map(|p| ("id".to_owned(), p.to_string()))
15574                    .collect::<Vec<(std::string::String, std::string::String)>>(),
15575            ),
15576            _ => local_var_req_builder.query(&[(
15577                "id",
15578                &local_var_str
15579                    .into_iter()
15580                    .map(|p| p.to_string())
15581                    .collect::<Vec<String>>()
15582                    .join(",")
15583                    .to_string(),
15584            )]),
15585        };
15586    }
15587    if let Some(ref local_var_str) = id__empty {
15588        local_var_req_builder =
15589            local_var_req_builder.query(&[("id__empty", &local_var_str.to_string())]);
15590    }
15591    if let Some(ref local_var_str) = id__gt {
15592        local_var_req_builder = match "multi" {
15593            "multi" => local_var_req_builder.query(
15594                &local_var_str
15595                    .into_iter()
15596                    .map(|p| ("id__gt".to_owned(), p.to_string()))
15597                    .collect::<Vec<(std::string::String, std::string::String)>>(),
15598            ),
15599            _ => local_var_req_builder.query(&[(
15600                "id__gt",
15601                &local_var_str
15602                    .into_iter()
15603                    .map(|p| p.to_string())
15604                    .collect::<Vec<String>>()
15605                    .join(",")
15606                    .to_string(),
15607            )]),
15608        };
15609    }
15610    if let Some(ref local_var_str) = id__gte {
15611        local_var_req_builder = match "multi" {
15612            "multi" => local_var_req_builder.query(
15613                &local_var_str
15614                    .into_iter()
15615                    .map(|p| ("id__gte".to_owned(), p.to_string()))
15616                    .collect::<Vec<(std::string::String, std::string::String)>>(),
15617            ),
15618            _ => local_var_req_builder.query(&[(
15619                "id__gte",
15620                &local_var_str
15621                    .into_iter()
15622                    .map(|p| p.to_string())
15623                    .collect::<Vec<String>>()
15624                    .join(",")
15625                    .to_string(),
15626            )]),
15627        };
15628    }
15629    if let Some(ref local_var_str) = id__lt {
15630        local_var_req_builder = match "multi" {
15631            "multi" => local_var_req_builder.query(
15632                &local_var_str
15633                    .into_iter()
15634                    .map(|p| ("id__lt".to_owned(), p.to_string()))
15635                    .collect::<Vec<(std::string::String, std::string::String)>>(),
15636            ),
15637            _ => local_var_req_builder.query(&[(
15638                "id__lt",
15639                &local_var_str
15640                    .into_iter()
15641                    .map(|p| p.to_string())
15642                    .collect::<Vec<String>>()
15643                    .join(",")
15644                    .to_string(),
15645            )]),
15646        };
15647    }
15648    if let Some(ref local_var_str) = id__lte {
15649        local_var_req_builder = match "multi" {
15650            "multi" => local_var_req_builder.query(
15651                &local_var_str
15652                    .into_iter()
15653                    .map(|p| ("id__lte".to_owned(), p.to_string()))
15654                    .collect::<Vec<(std::string::String, std::string::String)>>(),
15655            ),
15656            _ => local_var_req_builder.query(&[(
15657                "id__lte",
15658                &local_var_str
15659                    .into_iter()
15660                    .map(|p| p.to_string())
15661                    .collect::<Vec<String>>()
15662                    .join(",")
15663                    .to_string(),
15664            )]),
15665        };
15666    }
15667    if let Some(ref local_var_str) = id__n {
15668        local_var_req_builder = match "multi" {
15669            "multi" => local_var_req_builder.query(
15670                &local_var_str
15671                    .into_iter()
15672                    .map(|p| ("id__n".to_owned(), p.to_string()))
15673                    .collect::<Vec<(std::string::String, std::string::String)>>(),
15674            ),
15675            _ => local_var_req_builder.query(&[(
15676                "id__n",
15677                &local_var_str
15678                    .into_iter()
15679                    .map(|p| p.to_string())
15680                    .collect::<Vec<String>>()
15681                    .join(",")
15682                    .to_string(),
15683            )]),
15684        };
15685    }
15686    if let Some(ref local_var_str) = interface_count {
15687        local_var_req_builder = match "multi" {
15688            "multi" => local_var_req_builder.query(
15689                &local_var_str
15690                    .into_iter()
15691                    .map(|p| ("interface_count".to_owned(), p.to_string()))
15692                    .collect::<Vec<(std::string::String, std::string::String)>>(),
15693            ),
15694            _ => local_var_req_builder.query(&[(
15695                "interface_count",
15696                &local_var_str
15697                    .into_iter()
15698                    .map(|p| p.to_string())
15699                    .collect::<Vec<String>>()
15700                    .join(",")
15701                    .to_string(),
15702            )]),
15703        };
15704    }
15705    if let Some(ref local_var_str) = interface_count__empty {
15706        local_var_req_builder =
15707            local_var_req_builder.query(&[("interface_count__empty", &local_var_str.to_string())]);
15708    }
15709    if let Some(ref local_var_str) = interface_count__gt {
15710        local_var_req_builder = match "multi" {
15711            "multi" => local_var_req_builder.query(
15712                &local_var_str
15713                    .into_iter()
15714                    .map(|p| ("interface_count__gt".to_owned(), p.to_string()))
15715                    .collect::<Vec<(std::string::String, std::string::String)>>(),
15716            ),
15717            _ => local_var_req_builder.query(&[(
15718                "interface_count__gt",
15719                &local_var_str
15720                    .into_iter()
15721                    .map(|p| p.to_string())
15722                    .collect::<Vec<String>>()
15723                    .join(",")
15724                    .to_string(),
15725            )]),
15726        };
15727    }
15728    if let Some(ref local_var_str) = interface_count__gte {
15729        local_var_req_builder = match "multi" {
15730            "multi" => local_var_req_builder.query(
15731                &local_var_str
15732                    .into_iter()
15733                    .map(|p| ("interface_count__gte".to_owned(), p.to_string()))
15734                    .collect::<Vec<(std::string::String, std::string::String)>>(),
15735            ),
15736            _ => local_var_req_builder.query(&[(
15737                "interface_count__gte",
15738                &local_var_str
15739                    .into_iter()
15740                    .map(|p| p.to_string())
15741                    .collect::<Vec<String>>()
15742                    .join(",")
15743                    .to_string(),
15744            )]),
15745        };
15746    }
15747    if let Some(ref local_var_str) = interface_count__lt {
15748        local_var_req_builder = match "multi" {
15749            "multi" => local_var_req_builder.query(
15750                &local_var_str
15751                    .into_iter()
15752                    .map(|p| ("interface_count__lt".to_owned(), p.to_string()))
15753                    .collect::<Vec<(std::string::String, std::string::String)>>(),
15754            ),
15755            _ => local_var_req_builder.query(&[(
15756                "interface_count__lt",
15757                &local_var_str
15758                    .into_iter()
15759                    .map(|p| p.to_string())
15760                    .collect::<Vec<String>>()
15761                    .join(",")
15762                    .to_string(),
15763            )]),
15764        };
15765    }
15766    if let Some(ref local_var_str) = interface_count__lte {
15767        local_var_req_builder = match "multi" {
15768            "multi" => local_var_req_builder.query(
15769                &local_var_str
15770                    .into_iter()
15771                    .map(|p| ("interface_count__lte".to_owned(), p.to_string()))
15772                    .collect::<Vec<(std::string::String, std::string::String)>>(),
15773            ),
15774            _ => local_var_req_builder.query(&[(
15775                "interface_count__lte",
15776                &local_var_str
15777                    .into_iter()
15778                    .map(|p| p.to_string())
15779                    .collect::<Vec<String>>()
15780                    .join(",")
15781                    .to_string(),
15782            )]),
15783        };
15784    }
15785    if let Some(ref local_var_str) = interface_count__n {
15786        local_var_req_builder = match "multi" {
15787            "multi" => local_var_req_builder.query(
15788                &local_var_str
15789                    .into_iter()
15790                    .map(|p| ("interface_count__n".to_owned(), p.to_string()))
15791                    .collect::<Vec<(std::string::String, std::string::String)>>(),
15792            ),
15793            _ => local_var_req_builder.query(&[(
15794                "interface_count__n",
15795                &local_var_str
15796                    .into_iter()
15797                    .map(|p| p.to_string())
15798                    .collect::<Vec<String>>()
15799                    .join(",")
15800                    .to_string(),
15801            )]),
15802        };
15803    }
15804    if let Some(ref local_var_str) = last_updated {
15805        local_var_req_builder = match "multi" {
15806            "multi" => local_var_req_builder.query(
15807                &local_var_str
15808                    .into_iter()
15809                    .map(|p| ("last_updated".to_owned(), p.to_string()))
15810                    .collect::<Vec<(std::string::String, std::string::String)>>(),
15811            ),
15812            _ => local_var_req_builder.query(&[(
15813                "last_updated",
15814                &local_var_str
15815                    .into_iter()
15816                    .map(|p| p.to_string())
15817                    .collect::<Vec<String>>()
15818                    .join(",")
15819                    .to_string(),
15820            )]),
15821        };
15822    }
15823    if let Some(ref local_var_str) = last_updated__empty {
15824        local_var_req_builder = match "multi" {
15825            "multi" => local_var_req_builder.query(
15826                &local_var_str
15827                    .into_iter()
15828                    .map(|p| ("last_updated__empty".to_owned(), p.to_string()))
15829                    .collect::<Vec<(std::string::String, std::string::String)>>(),
15830            ),
15831            _ => local_var_req_builder.query(&[(
15832                "last_updated__empty",
15833                &local_var_str
15834                    .into_iter()
15835                    .map(|p| p.to_string())
15836                    .collect::<Vec<String>>()
15837                    .join(",")
15838                    .to_string(),
15839            )]),
15840        };
15841    }
15842    if let Some(ref local_var_str) = last_updated__gt {
15843        local_var_req_builder = match "multi" {
15844            "multi" => local_var_req_builder.query(
15845                &local_var_str
15846                    .into_iter()
15847                    .map(|p| ("last_updated__gt".to_owned(), p.to_string()))
15848                    .collect::<Vec<(std::string::String, std::string::String)>>(),
15849            ),
15850            _ => local_var_req_builder.query(&[(
15851                "last_updated__gt",
15852                &local_var_str
15853                    .into_iter()
15854                    .map(|p| p.to_string())
15855                    .collect::<Vec<String>>()
15856                    .join(",")
15857                    .to_string(),
15858            )]),
15859        };
15860    }
15861    if let Some(ref local_var_str) = last_updated__gte {
15862        local_var_req_builder = match "multi" {
15863            "multi" => local_var_req_builder.query(
15864                &local_var_str
15865                    .into_iter()
15866                    .map(|p| ("last_updated__gte".to_owned(), p.to_string()))
15867                    .collect::<Vec<(std::string::String, std::string::String)>>(),
15868            ),
15869            _ => local_var_req_builder.query(&[(
15870                "last_updated__gte",
15871                &local_var_str
15872                    .into_iter()
15873                    .map(|p| p.to_string())
15874                    .collect::<Vec<String>>()
15875                    .join(",")
15876                    .to_string(),
15877            )]),
15878        };
15879    }
15880    if let Some(ref local_var_str) = last_updated__lt {
15881        local_var_req_builder = match "multi" {
15882            "multi" => local_var_req_builder.query(
15883                &local_var_str
15884                    .into_iter()
15885                    .map(|p| ("last_updated__lt".to_owned(), p.to_string()))
15886                    .collect::<Vec<(std::string::String, std::string::String)>>(),
15887            ),
15888            _ => local_var_req_builder.query(&[(
15889                "last_updated__lt",
15890                &local_var_str
15891                    .into_iter()
15892                    .map(|p| p.to_string())
15893                    .collect::<Vec<String>>()
15894                    .join(",")
15895                    .to_string(),
15896            )]),
15897        };
15898    }
15899    if let Some(ref local_var_str) = last_updated__lte {
15900        local_var_req_builder = match "multi" {
15901            "multi" => local_var_req_builder.query(
15902                &local_var_str
15903                    .into_iter()
15904                    .map(|p| ("last_updated__lte".to_owned(), p.to_string()))
15905                    .collect::<Vec<(std::string::String, std::string::String)>>(),
15906            ),
15907            _ => local_var_req_builder.query(&[(
15908                "last_updated__lte",
15909                &local_var_str
15910                    .into_iter()
15911                    .map(|p| p.to_string())
15912                    .collect::<Vec<String>>()
15913                    .join(",")
15914                    .to_string(),
15915            )]),
15916        };
15917    }
15918    if let Some(ref local_var_str) = last_updated__n {
15919        local_var_req_builder = match "multi" {
15920            "multi" => local_var_req_builder.query(
15921                &local_var_str
15922                    .into_iter()
15923                    .map(|p| ("last_updated__n".to_owned(), p.to_string()))
15924                    .collect::<Vec<(std::string::String, std::string::String)>>(),
15925            ),
15926            _ => local_var_req_builder.query(&[(
15927                "last_updated__n",
15928                &local_var_str
15929                    .into_iter()
15930                    .map(|p| p.to_string())
15931                    .collect::<Vec<String>>()
15932                    .join(",")
15933                    .to_string(),
15934            )]),
15935        };
15936    }
15937    if let Some(ref local_var_str) = limit {
15938        local_var_req_builder =
15939            local_var_req_builder.query(&[("limit", &local_var_str.to_string())]);
15940    }
15941    if let Some(ref local_var_str) = local_context_data {
15942        local_var_req_builder =
15943            local_var_req_builder.query(&[("local_context_data", &local_var_str.to_string())]);
15944    }
15945    if let Some(ref local_var_str) = mac_address {
15946        local_var_req_builder = match "multi" {
15947            "multi" => local_var_req_builder.query(
15948                &local_var_str
15949                    .into_iter()
15950                    .map(|p| ("mac_address".to_owned(), p.to_string()))
15951                    .collect::<Vec<(std::string::String, std::string::String)>>(),
15952            ),
15953            _ => local_var_req_builder.query(&[(
15954                "mac_address",
15955                &local_var_str
15956                    .into_iter()
15957                    .map(|p| p.to_string())
15958                    .collect::<Vec<String>>()
15959                    .join(",")
15960                    .to_string(),
15961            )]),
15962        };
15963    }
15964    if let Some(ref local_var_str) = mac_address__ic {
15965        local_var_req_builder = match "multi" {
15966            "multi" => local_var_req_builder.query(
15967                &local_var_str
15968                    .into_iter()
15969                    .map(|p| ("mac_address__ic".to_owned(), p.to_string()))
15970                    .collect::<Vec<(std::string::String, std::string::String)>>(),
15971            ),
15972            _ => local_var_req_builder.query(&[(
15973                "mac_address__ic",
15974                &local_var_str
15975                    .into_iter()
15976                    .map(|p| p.to_string())
15977                    .collect::<Vec<String>>()
15978                    .join(",")
15979                    .to_string(),
15980            )]),
15981        };
15982    }
15983    if let Some(ref local_var_str) = mac_address__ie {
15984        local_var_req_builder = match "multi" {
15985            "multi" => local_var_req_builder.query(
15986                &local_var_str
15987                    .into_iter()
15988                    .map(|p| ("mac_address__ie".to_owned(), p.to_string()))
15989                    .collect::<Vec<(std::string::String, std::string::String)>>(),
15990            ),
15991            _ => local_var_req_builder.query(&[(
15992                "mac_address__ie",
15993                &local_var_str
15994                    .into_iter()
15995                    .map(|p| p.to_string())
15996                    .collect::<Vec<String>>()
15997                    .join(",")
15998                    .to_string(),
15999            )]),
16000        };
16001    }
16002    if let Some(ref local_var_str) = mac_address__iew {
16003        local_var_req_builder = match "multi" {
16004            "multi" => local_var_req_builder.query(
16005                &local_var_str
16006                    .into_iter()
16007                    .map(|p| ("mac_address__iew".to_owned(), p.to_string()))
16008                    .collect::<Vec<(std::string::String, std::string::String)>>(),
16009            ),
16010            _ => local_var_req_builder.query(&[(
16011                "mac_address__iew",
16012                &local_var_str
16013                    .into_iter()
16014                    .map(|p| p.to_string())
16015                    .collect::<Vec<String>>()
16016                    .join(",")
16017                    .to_string(),
16018            )]),
16019        };
16020    }
16021    if let Some(ref local_var_str) = mac_address__iregex {
16022        local_var_req_builder = match "multi" {
16023            "multi" => local_var_req_builder.query(
16024                &local_var_str
16025                    .into_iter()
16026                    .map(|p| ("mac_address__iregex".to_owned(), p.to_string()))
16027                    .collect::<Vec<(std::string::String, std::string::String)>>(),
16028            ),
16029            _ => local_var_req_builder.query(&[(
16030                "mac_address__iregex",
16031                &local_var_str
16032                    .into_iter()
16033                    .map(|p| p.to_string())
16034                    .collect::<Vec<String>>()
16035                    .join(",")
16036                    .to_string(),
16037            )]),
16038        };
16039    }
16040    if let Some(ref local_var_str) = mac_address__isw {
16041        local_var_req_builder = match "multi" {
16042            "multi" => local_var_req_builder.query(
16043                &local_var_str
16044                    .into_iter()
16045                    .map(|p| ("mac_address__isw".to_owned(), p.to_string()))
16046                    .collect::<Vec<(std::string::String, std::string::String)>>(),
16047            ),
16048            _ => local_var_req_builder.query(&[(
16049                "mac_address__isw",
16050                &local_var_str
16051                    .into_iter()
16052                    .map(|p| p.to_string())
16053                    .collect::<Vec<String>>()
16054                    .join(",")
16055                    .to_string(),
16056            )]),
16057        };
16058    }
16059    if let Some(ref local_var_str) = mac_address__n {
16060        local_var_req_builder = match "multi" {
16061            "multi" => local_var_req_builder.query(
16062                &local_var_str
16063                    .into_iter()
16064                    .map(|p| ("mac_address__n".to_owned(), p.to_string()))
16065                    .collect::<Vec<(std::string::String, std::string::String)>>(),
16066            ),
16067            _ => local_var_req_builder.query(&[(
16068                "mac_address__n",
16069                &local_var_str
16070                    .into_iter()
16071                    .map(|p| p.to_string())
16072                    .collect::<Vec<String>>()
16073                    .join(",")
16074                    .to_string(),
16075            )]),
16076        };
16077    }
16078    if let Some(ref local_var_str) = mac_address__nic {
16079        local_var_req_builder = match "multi" {
16080            "multi" => local_var_req_builder.query(
16081                &local_var_str
16082                    .into_iter()
16083                    .map(|p| ("mac_address__nic".to_owned(), p.to_string()))
16084                    .collect::<Vec<(std::string::String, std::string::String)>>(),
16085            ),
16086            _ => local_var_req_builder.query(&[(
16087                "mac_address__nic",
16088                &local_var_str
16089                    .into_iter()
16090                    .map(|p| p.to_string())
16091                    .collect::<Vec<String>>()
16092                    .join(",")
16093                    .to_string(),
16094            )]),
16095        };
16096    }
16097    if let Some(ref local_var_str) = mac_address__nie {
16098        local_var_req_builder = match "multi" {
16099            "multi" => local_var_req_builder.query(
16100                &local_var_str
16101                    .into_iter()
16102                    .map(|p| ("mac_address__nie".to_owned(), p.to_string()))
16103                    .collect::<Vec<(std::string::String, std::string::String)>>(),
16104            ),
16105            _ => local_var_req_builder.query(&[(
16106                "mac_address__nie",
16107                &local_var_str
16108                    .into_iter()
16109                    .map(|p| p.to_string())
16110                    .collect::<Vec<String>>()
16111                    .join(",")
16112                    .to_string(),
16113            )]),
16114        };
16115    }
16116    if let Some(ref local_var_str) = mac_address__niew {
16117        local_var_req_builder = match "multi" {
16118            "multi" => local_var_req_builder.query(
16119                &local_var_str
16120                    .into_iter()
16121                    .map(|p| ("mac_address__niew".to_owned(), p.to_string()))
16122                    .collect::<Vec<(std::string::String, std::string::String)>>(),
16123            ),
16124            _ => local_var_req_builder.query(&[(
16125                "mac_address__niew",
16126                &local_var_str
16127                    .into_iter()
16128                    .map(|p| p.to_string())
16129                    .collect::<Vec<String>>()
16130                    .join(",")
16131                    .to_string(),
16132            )]),
16133        };
16134    }
16135    if let Some(ref local_var_str) = mac_address__nisw {
16136        local_var_req_builder = match "multi" {
16137            "multi" => local_var_req_builder.query(
16138                &local_var_str
16139                    .into_iter()
16140                    .map(|p| ("mac_address__nisw".to_owned(), p.to_string()))
16141                    .collect::<Vec<(std::string::String, std::string::String)>>(),
16142            ),
16143            _ => local_var_req_builder.query(&[(
16144                "mac_address__nisw",
16145                &local_var_str
16146                    .into_iter()
16147                    .map(|p| p.to_string())
16148                    .collect::<Vec<String>>()
16149                    .join(",")
16150                    .to_string(),
16151            )]),
16152        };
16153    }
16154    if let Some(ref local_var_str) = mac_address__regex {
16155        local_var_req_builder = match "multi" {
16156            "multi" => local_var_req_builder.query(
16157                &local_var_str
16158                    .into_iter()
16159                    .map(|p| ("mac_address__regex".to_owned(), p.to_string()))
16160                    .collect::<Vec<(std::string::String, std::string::String)>>(),
16161            ),
16162            _ => local_var_req_builder.query(&[(
16163                "mac_address__regex",
16164                &local_var_str
16165                    .into_iter()
16166                    .map(|p| p.to_string())
16167                    .collect::<Vec<String>>()
16168                    .join(",")
16169                    .to_string(),
16170            )]),
16171        };
16172    }
16173    if let Some(ref local_var_str) = memory {
16174        local_var_req_builder = match "multi" {
16175            "multi" => local_var_req_builder.query(
16176                &local_var_str
16177                    .into_iter()
16178                    .map(|p| ("memory".to_owned(), p.to_string()))
16179                    .collect::<Vec<(std::string::String, std::string::String)>>(),
16180            ),
16181            _ => local_var_req_builder.query(&[(
16182                "memory",
16183                &local_var_str
16184                    .into_iter()
16185                    .map(|p| p.to_string())
16186                    .collect::<Vec<String>>()
16187                    .join(",")
16188                    .to_string(),
16189            )]),
16190        };
16191    }
16192    if let Some(ref local_var_str) = memory__empty {
16193        local_var_req_builder =
16194            local_var_req_builder.query(&[("memory__empty", &local_var_str.to_string())]);
16195    }
16196    if let Some(ref local_var_str) = memory__gt {
16197        local_var_req_builder = match "multi" {
16198            "multi" => local_var_req_builder.query(
16199                &local_var_str
16200                    .into_iter()
16201                    .map(|p| ("memory__gt".to_owned(), p.to_string()))
16202                    .collect::<Vec<(std::string::String, std::string::String)>>(),
16203            ),
16204            _ => local_var_req_builder.query(&[(
16205                "memory__gt",
16206                &local_var_str
16207                    .into_iter()
16208                    .map(|p| p.to_string())
16209                    .collect::<Vec<String>>()
16210                    .join(",")
16211                    .to_string(),
16212            )]),
16213        };
16214    }
16215    if let Some(ref local_var_str) = memory__gte {
16216        local_var_req_builder = match "multi" {
16217            "multi" => local_var_req_builder.query(
16218                &local_var_str
16219                    .into_iter()
16220                    .map(|p| ("memory__gte".to_owned(), p.to_string()))
16221                    .collect::<Vec<(std::string::String, std::string::String)>>(),
16222            ),
16223            _ => local_var_req_builder.query(&[(
16224                "memory__gte",
16225                &local_var_str
16226                    .into_iter()
16227                    .map(|p| p.to_string())
16228                    .collect::<Vec<String>>()
16229                    .join(",")
16230                    .to_string(),
16231            )]),
16232        };
16233    }
16234    if let Some(ref local_var_str) = memory__lt {
16235        local_var_req_builder = match "multi" {
16236            "multi" => local_var_req_builder.query(
16237                &local_var_str
16238                    .into_iter()
16239                    .map(|p| ("memory__lt".to_owned(), p.to_string()))
16240                    .collect::<Vec<(std::string::String, std::string::String)>>(),
16241            ),
16242            _ => local_var_req_builder.query(&[(
16243                "memory__lt",
16244                &local_var_str
16245                    .into_iter()
16246                    .map(|p| p.to_string())
16247                    .collect::<Vec<String>>()
16248                    .join(",")
16249                    .to_string(),
16250            )]),
16251        };
16252    }
16253    if let Some(ref local_var_str) = memory__lte {
16254        local_var_req_builder = match "multi" {
16255            "multi" => local_var_req_builder.query(
16256                &local_var_str
16257                    .into_iter()
16258                    .map(|p| ("memory__lte".to_owned(), p.to_string()))
16259                    .collect::<Vec<(std::string::String, std::string::String)>>(),
16260            ),
16261            _ => local_var_req_builder.query(&[(
16262                "memory__lte",
16263                &local_var_str
16264                    .into_iter()
16265                    .map(|p| p.to_string())
16266                    .collect::<Vec<String>>()
16267                    .join(",")
16268                    .to_string(),
16269            )]),
16270        };
16271    }
16272    if let Some(ref local_var_str) = memory__n {
16273        local_var_req_builder = match "multi" {
16274            "multi" => local_var_req_builder.query(
16275                &local_var_str
16276                    .into_iter()
16277                    .map(|p| ("memory__n".to_owned(), p.to_string()))
16278                    .collect::<Vec<(std::string::String, std::string::String)>>(),
16279            ),
16280            _ => local_var_req_builder.query(&[(
16281                "memory__n",
16282                &local_var_str
16283                    .into_iter()
16284                    .map(|p| p.to_string())
16285                    .collect::<Vec<String>>()
16286                    .join(",")
16287                    .to_string(),
16288            )]),
16289        };
16290    }
16291    if let Some(ref local_var_str) = modified_by_request {
16292        local_var_req_builder =
16293            local_var_req_builder.query(&[("modified_by_request", &local_var_str.to_string())]);
16294    }
16295    if let Some(ref local_var_str) = name {
16296        local_var_req_builder = match "multi" {
16297            "multi" => local_var_req_builder.query(
16298                &local_var_str
16299                    .into_iter()
16300                    .map(|p| ("name".to_owned(), p.to_string()))
16301                    .collect::<Vec<(std::string::String, std::string::String)>>(),
16302            ),
16303            _ => local_var_req_builder.query(&[(
16304                "name",
16305                &local_var_str
16306                    .into_iter()
16307                    .map(|p| p.to_string())
16308                    .collect::<Vec<String>>()
16309                    .join(",")
16310                    .to_string(),
16311            )]),
16312        };
16313    }
16314    if let Some(ref local_var_str) = name__empty {
16315        local_var_req_builder =
16316            local_var_req_builder.query(&[("name__empty", &local_var_str.to_string())]);
16317    }
16318    if let Some(ref local_var_str) = name__ic {
16319        local_var_req_builder = match "multi" {
16320            "multi" => local_var_req_builder.query(
16321                &local_var_str
16322                    .into_iter()
16323                    .map(|p| ("name__ic".to_owned(), p.to_string()))
16324                    .collect::<Vec<(std::string::String, std::string::String)>>(),
16325            ),
16326            _ => local_var_req_builder.query(&[(
16327                "name__ic",
16328                &local_var_str
16329                    .into_iter()
16330                    .map(|p| p.to_string())
16331                    .collect::<Vec<String>>()
16332                    .join(",")
16333                    .to_string(),
16334            )]),
16335        };
16336    }
16337    if let Some(ref local_var_str) = name__ie {
16338        local_var_req_builder = match "multi" {
16339            "multi" => local_var_req_builder.query(
16340                &local_var_str
16341                    .into_iter()
16342                    .map(|p| ("name__ie".to_owned(), p.to_string()))
16343                    .collect::<Vec<(std::string::String, std::string::String)>>(),
16344            ),
16345            _ => local_var_req_builder.query(&[(
16346                "name__ie",
16347                &local_var_str
16348                    .into_iter()
16349                    .map(|p| p.to_string())
16350                    .collect::<Vec<String>>()
16351                    .join(",")
16352                    .to_string(),
16353            )]),
16354        };
16355    }
16356    if let Some(ref local_var_str) = name__iew {
16357        local_var_req_builder = match "multi" {
16358            "multi" => local_var_req_builder.query(
16359                &local_var_str
16360                    .into_iter()
16361                    .map(|p| ("name__iew".to_owned(), p.to_string()))
16362                    .collect::<Vec<(std::string::String, std::string::String)>>(),
16363            ),
16364            _ => local_var_req_builder.query(&[(
16365                "name__iew",
16366                &local_var_str
16367                    .into_iter()
16368                    .map(|p| p.to_string())
16369                    .collect::<Vec<String>>()
16370                    .join(",")
16371                    .to_string(),
16372            )]),
16373        };
16374    }
16375    if let Some(ref local_var_str) = name__iregex {
16376        local_var_req_builder = match "multi" {
16377            "multi" => local_var_req_builder.query(
16378                &local_var_str
16379                    .into_iter()
16380                    .map(|p| ("name__iregex".to_owned(), p.to_string()))
16381                    .collect::<Vec<(std::string::String, std::string::String)>>(),
16382            ),
16383            _ => local_var_req_builder.query(&[(
16384                "name__iregex",
16385                &local_var_str
16386                    .into_iter()
16387                    .map(|p| p.to_string())
16388                    .collect::<Vec<String>>()
16389                    .join(",")
16390                    .to_string(),
16391            )]),
16392        };
16393    }
16394    if let Some(ref local_var_str) = name__isw {
16395        local_var_req_builder = match "multi" {
16396            "multi" => local_var_req_builder.query(
16397                &local_var_str
16398                    .into_iter()
16399                    .map(|p| ("name__isw".to_owned(), p.to_string()))
16400                    .collect::<Vec<(std::string::String, std::string::String)>>(),
16401            ),
16402            _ => local_var_req_builder.query(&[(
16403                "name__isw",
16404                &local_var_str
16405                    .into_iter()
16406                    .map(|p| p.to_string())
16407                    .collect::<Vec<String>>()
16408                    .join(",")
16409                    .to_string(),
16410            )]),
16411        };
16412    }
16413    if let Some(ref local_var_str) = name__n {
16414        local_var_req_builder = match "multi" {
16415            "multi" => local_var_req_builder.query(
16416                &local_var_str
16417                    .into_iter()
16418                    .map(|p| ("name__n".to_owned(), p.to_string()))
16419                    .collect::<Vec<(std::string::String, std::string::String)>>(),
16420            ),
16421            _ => local_var_req_builder.query(&[(
16422                "name__n",
16423                &local_var_str
16424                    .into_iter()
16425                    .map(|p| p.to_string())
16426                    .collect::<Vec<String>>()
16427                    .join(",")
16428                    .to_string(),
16429            )]),
16430        };
16431    }
16432    if let Some(ref local_var_str) = name__nic {
16433        local_var_req_builder = match "multi" {
16434            "multi" => local_var_req_builder.query(
16435                &local_var_str
16436                    .into_iter()
16437                    .map(|p| ("name__nic".to_owned(), p.to_string()))
16438                    .collect::<Vec<(std::string::String, std::string::String)>>(),
16439            ),
16440            _ => local_var_req_builder.query(&[(
16441                "name__nic",
16442                &local_var_str
16443                    .into_iter()
16444                    .map(|p| p.to_string())
16445                    .collect::<Vec<String>>()
16446                    .join(",")
16447                    .to_string(),
16448            )]),
16449        };
16450    }
16451    if let Some(ref local_var_str) = name__nie {
16452        local_var_req_builder = match "multi" {
16453            "multi" => local_var_req_builder.query(
16454                &local_var_str
16455                    .into_iter()
16456                    .map(|p| ("name__nie".to_owned(), p.to_string()))
16457                    .collect::<Vec<(std::string::String, std::string::String)>>(),
16458            ),
16459            _ => local_var_req_builder.query(&[(
16460                "name__nie",
16461                &local_var_str
16462                    .into_iter()
16463                    .map(|p| p.to_string())
16464                    .collect::<Vec<String>>()
16465                    .join(",")
16466                    .to_string(),
16467            )]),
16468        };
16469    }
16470    if let Some(ref local_var_str) = name__niew {
16471        local_var_req_builder = match "multi" {
16472            "multi" => local_var_req_builder.query(
16473                &local_var_str
16474                    .into_iter()
16475                    .map(|p| ("name__niew".to_owned(), p.to_string()))
16476                    .collect::<Vec<(std::string::String, std::string::String)>>(),
16477            ),
16478            _ => local_var_req_builder.query(&[(
16479                "name__niew",
16480                &local_var_str
16481                    .into_iter()
16482                    .map(|p| p.to_string())
16483                    .collect::<Vec<String>>()
16484                    .join(",")
16485                    .to_string(),
16486            )]),
16487        };
16488    }
16489    if let Some(ref local_var_str) = name__nisw {
16490        local_var_req_builder = match "multi" {
16491            "multi" => local_var_req_builder.query(
16492                &local_var_str
16493                    .into_iter()
16494                    .map(|p| ("name__nisw".to_owned(), p.to_string()))
16495                    .collect::<Vec<(std::string::String, std::string::String)>>(),
16496            ),
16497            _ => local_var_req_builder.query(&[(
16498                "name__nisw",
16499                &local_var_str
16500                    .into_iter()
16501                    .map(|p| p.to_string())
16502                    .collect::<Vec<String>>()
16503                    .join(",")
16504                    .to_string(),
16505            )]),
16506        };
16507    }
16508    if let Some(ref local_var_str) = name__regex {
16509        local_var_req_builder = match "multi" {
16510            "multi" => local_var_req_builder.query(
16511                &local_var_str
16512                    .into_iter()
16513                    .map(|p| ("name__regex".to_owned(), p.to_string()))
16514                    .collect::<Vec<(std::string::String, std::string::String)>>(),
16515            ),
16516            _ => local_var_req_builder.query(&[(
16517                "name__regex",
16518                &local_var_str
16519                    .into_iter()
16520                    .map(|p| p.to_string())
16521                    .collect::<Vec<String>>()
16522                    .join(",")
16523                    .to_string(),
16524            )]),
16525        };
16526    }
16527    if let Some(ref local_var_str) = offset {
16528        local_var_req_builder =
16529            local_var_req_builder.query(&[("offset", &local_var_str.to_string())]);
16530    }
16531    if let Some(ref local_var_str) = ordering {
16532        local_var_req_builder =
16533            local_var_req_builder.query(&[("ordering", &local_var_str.to_string())]);
16534    }
16535    if let Some(ref local_var_str) = owner {
16536        local_var_req_builder = match "multi" {
16537            "multi" => local_var_req_builder.query(
16538                &local_var_str
16539                    .into_iter()
16540                    .map(|p| ("owner".to_owned(), p.to_string()))
16541                    .collect::<Vec<(std::string::String, std::string::String)>>(),
16542            ),
16543            _ => local_var_req_builder.query(&[(
16544                "owner",
16545                &local_var_str
16546                    .into_iter()
16547                    .map(|p| p.to_string())
16548                    .collect::<Vec<String>>()
16549                    .join(",")
16550                    .to_string(),
16551            )]),
16552        };
16553    }
16554    if let Some(ref local_var_str) = owner__n {
16555        local_var_req_builder = match "multi" {
16556            "multi" => local_var_req_builder.query(
16557                &local_var_str
16558                    .into_iter()
16559                    .map(|p| ("owner__n".to_owned(), p.to_string()))
16560                    .collect::<Vec<(std::string::String, std::string::String)>>(),
16561            ),
16562            _ => local_var_req_builder.query(&[(
16563                "owner__n",
16564                &local_var_str
16565                    .into_iter()
16566                    .map(|p| p.to_string())
16567                    .collect::<Vec<String>>()
16568                    .join(",")
16569                    .to_string(),
16570            )]),
16571        };
16572    }
16573    if let Some(ref local_var_str) = owner_group {
16574        local_var_req_builder = match "multi" {
16575            "multi" => local_var_req_builder.query(
16576                &local_var_str
16577                    .into_iter()
16578                    .map(|p| ("owner_group".to_owned(), p.to_string()))
16579                    .collect::<Vec<(std::string::String, std::string::String)>>(),
16580            ),
16581            _ => local_var_req_builder.query(&[(
16582                "owner_group",
16583                &local_var_str
16584                    .into_iter()
16585                    .map(|p| p.to_string())
16586                    .collect::<Vec<String>>()
16587                    .join(",")
16588                    .to_string(),
16589            )]),
16590        };
16591    }
16592    if let Some(ref local_var_str) = owner_group__n {
16593        local_var_req_builder = match "multi" {
16594            "multi" => local_var_req_builder.query(
16595                &local_var_str
16596                    .into_iter()
16597                    .map(|p| ("owner_group__n".to_owned(), p.to_string()))
16598                    .collect::<Vec<(std::string::String, std::string::String)>>(),
16599            ),
16600            _ => local_var_req_builder.query(&[(
16601                "owner_group__n",
16602                &local_var_str
16603                    .into_iter()
16604                    .map(|p| p.to_string())
16605                    .collect::<Vec<String>>()
16606                    .join(",")
16607                    .to_string(),
16608            )]),
16609        };
16610    }
16611    if let Some(ref local_var_str) = owner_group_id {
16612        local_var_req_builder = match "multi" {
16613            "multi" => local_var_req_builder.query(
16614                &local_var_str
16615                    .into_iter()
16616                    .map(|p| ("owner_group_id".to_owned(), p.to_string()))
16617                    .collect::<Vec<(std::string::String, std::string::String)>>(),
16618            ),
16619            _ => local_var_req_builder.query(&[(
16620                "owner_group_id",
16621                &local_var_str
16622                    .into_iter()
16623                    .map(|p| p.to_string())
16624                    .collect::<Vec<String>>()
16625                    .join(",")
16626                    .to_string(),
16627            )]),
16628        };
16629    }
16630    if let Some(ref local_var_str) = owner_group_id__n {
16631        local_var_req_builder = match "multi" {
16632            "multi" => local_var_req_builder.query(
16633                &local_var_str
16634                    .into_iter()
16635                    .map(|p| ("owner_group_id__n".to_owned(), p.to_string()))
16636                    .collect::<Vec<(std::string::String, std::string::String)>>(),
16637            ),
16638            _ => local_var_req_builder.query(&[(
16639                "owner_group_id__n",
16640                &local_var_str
16641                    .into_iter()
16642                    .map(|p| p.to_string())
16643                    .collect::<Vec<String>>()
16644                    .join(",")
16645                    .to_string(),
16646            )]),
16647        };
16648    }
16649    if let Some(ref local_var_str) = owner_id {
16650        local_var_req_builder = match "multi" {
16651            "multi" => local_var_req_builder.query(
16652                &local_var_str
16653                    .into_iter()
16654                    .map(|p| ("owner_id".to_owned(), p.to_string()))
16655                    .collect::<Vec<(std::string::String, std::string::String)>>(),
16656            ),
16657            _ => local_var_req_builder.query(&[(
16658                "owner_id",
16659                &local_var_str
16660                    .into_iter()
16661                    .map(|p| p.to_string())
16662                    .collect::<Vec<String>>()
16663                    .join(",")
16664                    .to_string(),
16665            )]),
16666        };
16667    }
16668    if let Some(ref local_var_str) = owner_id__n {
16669        local_var_req_builder = match "multi" {
16670            "multi" => local_var_req_builder.query(
16671                &local_var_str
16672                    .into_iter()
16673                    .map(|p| ("owner_id__n".to_owned(), p.to_string()))
16674                    .collect::<Vec<(std::string::String, std::string::String)>>(),
16675            ),
16676            _ => local_var_req_builder.query(&[(
16677                "owner_id__n",
16678                &local_var_str
16679                    .into_iter()
16680                    .map(|p| p.to_string())
16681                    .collect::<Vec<String>>()
16682                    .join(",")
16683                    .to_string(),
16684            )]),
16685        };
16686    }
16687    if let Some(ref local_var_str) = platform {
16688        local_var_req_builder = match "multi" {
16689            "multi" => local_var_req_builder.query(
16690                &local_var_str
16691                    .into_iter()
16692                    .map(|p| ("platform".to_owned(), p.to_string()))
16693                    .collect::<Vec<(std::string::String, std::string::String)>>(),
16694            ),
16695            _ => local_var_req_builder.query(&[(
16696                "platform",
16697                &local_var_str
16698                    .into_iter()
16699                    .map(|p| p.to_string())
16700                    .collect::<Vec<String>>()
16701                    .join(",")
16702                    .to_string(),
16703            )]),
16704        };
16705    }
16706    if let Some(ref local_var_str) = platform__n {
16707        local_var_req_builder = match "multi" {
16708            "multi" => local_var_req_builder.query(
16709                &local_var_str
16710                    .into_iter()
16711                    .map(|p| ("platform__n".to_owned(), p.to_string()))
16712                    .collect::<Vec<(std::string::String, std::string::String)>>(),
16713            ),
16714            _ => local_var_req_builder.query(&[(
16715                "platform__n",
16716                &local_var_str
16717                    .into_iter()
16718                    .map(|p| p.to_string())
16719                    .collect::<Vec<String>>()
16720                    .join(",")
16721                    .to_string(),
16722            )]),
16723        };
16724    }
16725    if let Some(ref local_var_str) = platform_id {
16726        local_var_req_builder = match "multi" {
16727            "multi" => local_var_req_builder.query(
16728                &local_var_str
16729                    .into_iter()
16730                    .map(|p| ("platform_id".to_owned(), p.to_string()))
16731                    .collect::<Vec<(std::string::String, std::string::String)>>(),
16732            ),
16733            _ => local_var_req_builder.query(&[(
16734                "platform_id",
16735                &local_var_str
16736                    .into_iter()
16737                    .map(|p| p.to_string())
16738                    .collect::<Vec<String>>()
16739                    .join(",")
16740                    .to_string(),
16741            )]),
16742        };
16743    }
16744    if let Some(ref local_var_str) = platform_id__n {
16745        local_var_req_builder = match "multi" {
16746            "multi" => local_var_req_builder.query(
16747                &local_var_str
16748                    .into_iter()
16749                    .map(|p| ("platform_id__n".to_owned(), p.to_string()))
16750                    .collect::<Vec<(std::string::String, std::string::String)>>(),
16751            ),
16752            _ => local_var_req_builder.query(&[(
16753                "platform_id__n",
16754                &local_var_str
16755                    .into_iter()
16756                    .map(|p| p.to_string())
16757                    .collect::<Vec<String>>()
16758                    .join(",")
16759                    .to_string(),
16760            )]),
16761        };
16762    }
16763    if let Some(ref local_var_str) = primary_ip4 {
16764        local_var_req_builder = match "multi" {
16765            "multi" => local_var_req_builder.query(
16766                &local_var_str
16767                    .into_iter()
16768                    .map(|p| ("primary_ip4".to_owned(), p.to_string()))
16769                    .collect::<Vec<(std::string::String, std::string::String)>>(),
16770            ),
16771            _ => local_var_req_builder.query(&[(
16772                "primary_ip4",
16773                &local_var_str
16774                    .into_iter()
16775                    .map(|p| p.to_string())
16776                    .collect::<Vec<String>>()
16777                    .join(",")
16778                    .to_string(),
16779            )]),
16780        };
16781    }
16782    if let Some(ref local_var_str) = primary_ip4__n {
16783        local_var_req_builder = match "multi" {
16784            "multi" => local_var_req_builder.query(
16785                &local_var_str
16786                    .into_iter()
16787                    .map(|p| ("primary_ip4__n".to_owned(), p.to_string()))
16788                    .collect::<Vec<(std::string::String, std::string::String)>>(),
16789            ),
16790            _ => local_var_req_builder.query(&[(
16791                "primary_ip4__n",
16792                &local_var_str
16793                    .into_iter()
16794                    .map(|p| p.to_string())
16795                    .collect::<Vec<String>>()
16796                    .join(",")
16797                    .to_string(),
16798            )]),
16799        };
16800    }
16801    if let Some(ref local_var_str) = primary_ip4_id {
16802        local_var_req_builder = match "multi" {
16803            "multi" => local_var_req_builder.query(
16804                &local_var_str
16805                    .into_iter()
16806                    .map(|p| ("primary_ip4_id".to_owned(), p.to_string()))
16807                    .collect::<Vec<(std::string::String, std::string::String)>>(),
16808            ),
16809            _ => local_var_req_builder.query(&[(
16810                "primary_ip4_id",
16811                &local_var_str
16812                    .into_iter()
16813                    .map(|p| p.to_string())
16814                    .collect::<Vec<String>>()
16815                    .join(",")
16816                    .to_string(),
16817            )]),
16818        };
16819    }
16820    if let Some(ref local_var_str) = primary_ip4_id__n {
16821        local_var_req_builder = match "multi" {
16822            "multi" => local_var_req_builder.query(
16823                &local_var_str
16824                    .into_iter()
16825                    .map(|p| ("primary_ip4_id__n".to_owned(), p.to_string()))
16826                    .collect::<Vec<(std::string::String, std::string::String)>>(),
16827            ),
16828            _ => local_var_req_builder.query(&[(
16829                "primary_ip4_id__n",
16830                &local_var_str
16831                    .into_iter()
16832                    .map(|p| p.to_string())
16833                    .collect::<Vec<String>>()
16834                    .join(",")
16835                    .to_string(),
16836            )]),
16837        };
16838    }
16839    if let Some(ref local_var_str) = primary_ip6 {
16840        local_var_req_builder = match "multi" {
16841            "multi" => local_var_req_builder.query(
16842                &local_var_str
16843                    .into_iter()
16844                    .map(|p| ("primary_ip6".to_owned(), p.to_string()))
16845                    .collect::<Vec<(std::string::String, std::string::String)>>(),
16846            ),
16847            _ => local_var_req_builder.query(&[(
16848                "primary_ip6",
16849                &local_var_str
16850                    .into_iter()
16851                    .map(|p| p.to_string())
16852                    .collect::<Vec<String>>()
16853                    .join(",")
16854                    .to_string(),
16855            )]),
16856        };
16857    }
16858    if let Some(ref local_var_str) = primary_ip6__n {
16859        local_var_req_builder = match "multi" {
16860            "multi" => local_var_req_builder.query(
16861                &local_var_str
16862                    .into_iter()
16863                    .map(|p| ("primary_ip6__n".to_owned(), p.to_string()))
16864                    .collect::<Vec<(std::string::String, std::string::String)>>(),
16865            ),
16866            _ => local_var_req_builder.query(&[(
16867                "primary_ip6__n",
16868                &local_var_str
16869                    .into_iter()
16870                    .map(|p| p.to_string())
16871                    .collect::<Vec<String>>()
16872                    .join(",")
16873                    .to_string(),
16874            )]),
16875        };
16876    }
16877    if let Some(ref local_var_str) = primary_ip6_id {
16878        local_var_req_builder = match "multi" {
16879            "multi" => local_var_req_builder.query(
16880                &local_var_str
16881                    .into_iter()
16882                    .map(|p| ("primary_ip6_id".to_owned(), p.to_string()))
16883                    .collect::<Vec<(std::string::String, std::string::String)>>(),
16884            ),
16885            _ => local_var_req_builder.query(&[(
16886                "primary_ip6_id",
16887                &local_var_str
16888                    .into_iter()
16889                    .map(|p| p.to_string())
16890                    .collect::<Vec<String>>()
16891                    .join(",")
16892                    .to_string(),
16893            )]),
16894        };
16895    }
16896    if let Some(ref local_var_str) = primary_ip6_id__n {
16897        local_var_req_builder = match "multi" {
16898            "multi" => local_var_req_builder.query(
16899                &local_var_str
16900                    .into_iter()
16901                    .map(|p| ("primary_ip6_id__n".to_owned(), p.to_string()))
16902                    .collect::<Vec<(std::string::String, std::string::String)>>(),
16903            ),
16904            _ => local_var_req_builder.query(&[(
16905                "primary_ip6_id__n",
16906                &local_var_str
16907                    .into_iter()
16908                    .map(|p| p.to_string())
16909                    .collect::<Vec<String>>()
16910                    .join(",")
16911                    .to_string(),
16912            )]),
16913        };
16914    }
16915    if let Some(ref local_var_str) = q {
16916        local_var_req_builder = local_var_req_builder.query(&[("q", &local_var_str.to_string())]);
16917    }
16918    if let Some(ref local_var_str) = region {
16919        local_var_req_builder = match "multi" {
16920            "multi" => local_var_req_builder.query(
16921                &local_var_str
16922                    .into_iter()
16923                    .map(|p| ("region".to_owned(), p.to_string()))
16924                    .collect::<Vec<(std::string::String, std::string::String)>>(),
16925            ),
16926            _ => local_var_req_builder.query(&[(
16927                "region",
16928                &local_var_str
16929                    .into_iter()
16930                    .map(|p| p.to_string())
16931                    .collect::<Vec<String>>()
16932                    .join(",")
16933                    .to_string(),
16934            )]),
16935        };
16936    }
16937    if let Some(ref local_var_str) = region__n {
16938        local_var_req_builder = match "multi" {
16939            "multi" => local_var_req_builder.query(
16940                &local_var_str
16941                    .into_iter()
16942                    .map(|p| ("region__n".to_owned(), p.to_string()))
16943                    .collect::<Vec<(std::string::String, std::string::String)>>(),
16944            ),
16945            _ => local_var_req_builder.query(&[(
16946                "region__n",
16947                &local_var_str
16948                    .into_iter()
16949                    .map(|p| p.to_string())
16950                    .collect::<Vec<String>>()
16951                    .join(",")
16952                    .to_string(),
16953            )]),
16954        };
16955    }
16956    if let Some(ref local_var_str) = region_id {
16957        local_var_req_builder = match "multi" {
16958            "multi" => local_var_req_builder.query(
16959                &local_var_str
16960                    .into_iter()
16961                    .map(|p| ("region_id".to_owned(), p.to_string()))
16962                    .collect::<Vec<(std::string::String, std::string::String)>>(),
16963            ),
16964            _ => local_var_req_builder.query(&[(
16965                "region_id",
16966                &local_var_str
16967                    .into_iter()
16968                    .map(|p| p.to_string())
16969                    .collect::<Vec<String>>()
16970                    .join(",")
16971                    .to_string(),
16972            )]),
16973        };
16974    }
16975    if let Some(ref local_var_str) = region_id__n {
16976        local_var_req_builder = match "multi" {
16977            "multi" => local_var_req_builder.query(
16978                &local_var_str
16979                    .into_iter()
16980                    .map(|p| ("region_id__n".to_owned(), p.to_string()))
16981                    .collect::<Vec<(std::string::String, std::string::String)>>(),
16982            ),
16983            _ => local_var_req_builder.query(&[(
16984                "region_id__n",
16985                &local_var_str
16986                    .into_iter()
16987                    .map(|p| p.to_string())
16988                    .collect::<Vec<String>>()
16989                    .join(",")
16990                    .to_string(),
16991            )]),
16992        };
16993    }
16994    if let Some(ref local_var_str) = role {
16995        local_var_req_builder = match "multi" {
16996            "multi" => local_var_req_builder.query(
16997                &local_var_str
16998                    .into_iter()
16999                    .map(|p| ("role".to_owned(), p.to_string()))
17000                    .collect::<Vec<(std::string::String, std::string::String)>>(),
17001            ),
17002            _ => local_var_req_builder.query(&[(
17003                "role",
17004                &local_var_str
17005                    .into_iter()
17006                    .map(|p| p.to_string())
17007                    .collect::<Vec<String>>()
17008                    .join(",")
17009                    .to_string(),
17010            )]),
17011        };
17012    }
17013    if let Some(ref local_var_str) = role__n {
17014        local_var_req_builder = match "multi" {
17015            "multi" => local_var_req_builder.query(
17016                &local_var_str
17017                    .into_iter()
17018                    .map(|p| ("role__n".to_owned(), p.to_string()))
17019                    .collect::<Vec<(std::string::String, std::string::String)>>(),
17020            ),
17021            _ => local_var_req_builder.query(&[(
17022                "role__n",
17023                &local_var_str
17024                    .into_iter()
17025                    .map(|p| p.to_string())
17026                    .collect::<Vec<String>>()
17027                    .join(",")
17028                    .to_string(),
17029            )]),
17030        };
17031    }
17032    if let Some(ref local_var_str) = role_id {
17033        local_var_req_builder = match "multi" {
17034            "multi" => local_var_req_builder.query(
17035                &local_var_str
17036                    .into_iter()
17037                    .map(|p| ("role_id".to_owned(), p.to_string()))
17038                    .collect::<Vec<(std::string::String, std::string::String)>>(),
17039            ),
17040            _ => local_var_req_builder.query(&[(
17041                "role_id",
17042                &local_var_str
17043                    .into_iter()
17044                    .map(|p| p.to_string())
17045                    .collect::<Vec<String>>()
17046                    .join(",")
17047                    .to_string(),
17048            )]),
17049        };
17050    }
17051    if let Some(ref local_var_str) = role_id__n {
17052        local_var_req_builder = match "multi" {
17053            "multi" => local_var_req_builder.query(
17054                &local_var_str
17055                    .into_iter()
17056                    .map(|p| ("role_id__n".to_owned(), p.to_string()))
17057                    .collect::<Vec<(std::string::String, std::string::String)>>(),
17058            ),
17059            _ => local_var_req_builder.query(&[(
17060                "role_id__n",
17061                &local_var_str
17062                    .into_iter()
17063                    .map(|p| p.to_string())
17064                    .collect::<Vec<String>>()
17065                    .join(",")
17066                    .to_string(),
17067            )]),
17068        };
17069    }
17070    if let Some(ref local_var_str) = serial {
17071        local_var_req_builder = match "multi" {
17072            "multi" => local_var_req_builder.query(
17073                &local_var_str
17074                    .into_iter()
17075                    .map(|p| ("serial".to_owned(), p.to_string()))
17076                    .collect::<Vec<(std::string::String, std::string::String)>>(),
17077            ),
17078            _ => local_var_req_builder.query(&[(
17079                "serial",
17080                &local_var_str
17081                    .into_iter()
17082                    .map(|p| p.to_string())
17083                    .collect::<Vec<String>>()
17084                    .join(",")
17085                    .to_string(),
17086            )]),
17087        };
17088    }
17089    if let Some(ref local_var_str) = serial__empty {
17090        local_var_req_builder =
17091            local_var_req_builder.query(&[("serial__empty", &local_var_str.to_string())]);
17092    }
17093    if let Some(ref local_var_str) = serial__ic {
17094        local_var_req_builder = match "multi" {
17095            "multi" => local_var_req_builder.query(
17096                &local_var_str
17097                    .into_iter()
17098                    .map(|p| ("serial__ic".to_owned(), p.to_string()))
17099                    .collect::<Vec<(std::string::String, std::string::String)>>(),
17100            ),
17101            _ => local_var_req_builder.query(&[(
17102                "serial__ic",
17103                &local_var_str
17104                    .into_iter()
17105                    .map(|p| p.to_string())
17106                    .collect::<Vec<String>>()
17107                    .join(",")
17108                    .to_string(),
17109            )]),
17110        };
17111    }
17112    if let Some(ref local_var_str) = serial__ie {
17113        local_var_req_builder = match "multi" {
17114            "multi" => local_var_req_builder.query(
17115                &local_var_str
17116                    .into_iter()
17117                    .map(|p| ("serial__ie".to_owned(), p.to_string()))
17118                    .collect::<Vec<(std::string::String, std::string::String)>>(),
17119            ),
17120            _ => local_var_req_builder.query(&[(
17121                "serial__ie",
17122                &local_var_str
17123                    .into_iter()
17124                    .map(|p| p.to_string())
17125                    .collect::<Vec<String>>()
17126                    .join(",")
17127                    .to_string(),
17128            )]),
17129        };
17130    }
17131    if let Some(ref local_var_str) = serial__iew {
17132        local_var_req_builder = match "multi" {
17133            "multi" => local_var_req_builder.query(
17134                &local_var_str
17135                    .into_iter()
17136                    .map(|p| ("serial__iew".to_owned(), p.to_string()))
17137                    .collect::<Vec<(std::string::String, std::string::String)>>(),
17138            ),
17139            _ => local_var_req_builder.query(&[(
17140                "serial__iew",
17141                &local_var_str
17142                    .into_iter()
17143                    .map(|p| p.to_string())
17144                    .collect::<Vec<String>>()
17145                    .join(",")
17146                    .to_string(),
17147            )]),
17148        };
17149    }
17150    if let Some(ref local_var_str) = serial__iregex {
17151        local_var_req_builder = match "multi" {
17152            "multi" => local_var_req_builder.query(
17153                &local_var_str
17154                    .into_iter()
17155                    .map(|p| ("serial__iregex".to_owned(), p.to_string()))
17156                    .collect::<Vec<(std::string::String, std::string::String)>>(),
17157            ),
17158            _ => local_var_req_builder.query(&[(
17159                "serial__iregex",
17160                &local_var_str
17161                    .into_iter()
17162                    .map(|p| p.to_string())
17163                    .collect::<Vec<String>>()
17164                    .join(",")
17165                    .to_string(),
17166            )]),
17167        };
17168    }
17169    if let Some(ref local_var_str) = serial__isw {
17170        local_var_req_builder = match "multi" {
17171            "multi" => local_var_req_builder.query(
17172                &local_var_str
17173                    .into_iter()
17174                    .map(|p| ("serial__isw".to_owned(), p.to_string()))
17175                    .collect::<Vec<(std::string::String, std::string::String)>>(),
17176            ),
17177            _ => local_var_req_builder.query(&[(
17178                "serial__isw",
17179                &local_var_str
17180                    .into_iter()
17181                    .map(|p| p.to_string())
17182                    .collect::<Vec<String>>()
17183                    .join(",")
17184                    .to_string(),
17185            )]),
17186        };
17187    }
17188    if let Some(ref local_var_str) = serial__n {
17189        local_var_req_builder = match "multi" {
17190            "multi" => local_var_req_builder.query(
17191                &local_var_str
17192                    .into_iter()
17193                    .map(|p| ("serial__n".to_owned(), p.to_string()))
17194                    .collect::<Vec<(std::string::String, std::string::String)>>(),
17195            ),
17196            _ => local_var_req_builder.query(&[(
17197                "serial__n",
17198                &local_var_str
17199                    .into_iter()
17200                    .map(|p| p.to_string())
17201                    .collect::<Vec<String>>()
17202                    .join(",")
17203                    .to_string(),
17204            )]),
17205        };
17206    }
17207    if let Some(ref local_var_str) = serial__nic {
17208        local_var_req_builder = match "multi" {
17209            "multi" => local_var_req_builder.query(
17210                &local_var_str
17211                    .into_iter()
17212                    .map(|p| ("serial__nic".to_owned(), p.to_string()))
17213                    .collect::<Vec<(std::string::String, std::string::String)>>(),
17214            ),
17215            _ => local_var_req_builder.query(&[(
17216                "serial__nic",
17217                &local_var_str
17218                    .into_iter()
17219                    .map(|p| p.to_string())
17220                    .collect::<Vec<String>>()
17221                    .join(",")
17222                    .to_string(),
17223            )]),
17224        };
17225    }
17226    if let Some(ref local_var_str) = serial__nie {
17227        local_var_req_builder = match "multi" {
17228            "multi" => local_var_req_builder.query(
17229                &local_var_str
17230                    .into_iter()
17231                    .map(|p| ("serial__nie".to_owned(), p.to_string()))
17232                    .collect::<Vec<(std::string::String, std::string::String)>>(),
17233            ),
17234            _ => local_var_req_builder.query(&[(
17235                "serial__nie",
17236                &local_var_str
17237                    .into_iter()
17238                    .map(|p| p.to_string())
17239                    .collect::<Vec<String>>()
17240                    .join(",")
17241                    .to_string(),
17242            )]),
17243        };
17244    }
17245    if let Some(ref local_var_str) = serial__niew {
17246        local_var_req_builder = match "multi" {
17247            "multi" => local_var_req_builder.query(
17248                &local_var_str
17249                    .into_iter()
17250                    .map(|p| ("serial__niew".to_owned(), p.to_string()))
17251                    .collect::<Vec<(std::string::String, std::string::String)>>(),
17252            ),
17253            _ => local_var_req_builder.query(&[(
17254                "serial__niew",
17255                &local_var_str
17256                    .into_iter()
17257                    .map(|p| p.to_string())
17258                    .collect::<Vec<String>>()
17259                    .join(",")
17260                    .to_string(),
17261            )]),
17262        };
17263    }
17264    if let Some(ref local_var_str) = serial__nisw {
17265        local_var_req_builder = match "multi" {
17266            "multi" => local_var_req_builder.query(
17267                &local_var_str
17268                    .into_iter()
17269                    .map(|p| ("serial__nisw".to_owned(), p.to_string()))
17270                    .collect::<Vec<(std::string::String, std::string::String)>>(),
17271            ),
17272            _ => local_var_req_builder.query(&[(
17273                "serial__nisw",
17274                &local_var_str
17275                    .into_iter()
17276                    .map(|p| p.to_string())
17277                    .collect::<Vec<String>>()
17278                    .join(",")
17279                    .to_string(),
17280            )]),
17281        };
17282    }
17283    if let Some(ref local_var_str) = serial__regex {
17284        local_var_req_builder = match "multi" {
17285            "multi" => local_var_req_builder.query(
17286                &local_var_str
17287                    .into_iter()
17288                    .map(|p| ("serial__regex".to_owned(), p.to_string()))
17289                    .collect::<Vec<(std::string::String, std::string::String)>>(),
17290            ),
17291            _ => local_var_req_builder.query(&[(
17292                "serial__regex",
17293                &local_var_str
17294                    .into_iter()
17295                    .map(|p| p.to_string())
17296                    .collect::<Vec<String>>()
17297                    .join(",")
17298                    .to_string(),
17299            )]),
17300        };
17301    }
17302    if let Some(ref local_var_str) = site {
17303        local_var_req_builder = match "multi" {
17304            "multi" => local_var_req_builder.query(
17305                &local_var_str
17306                    .into_iter()
17307                    .map(|p| ("site".to_owned(), p.to_string()))
17308                    .collect::<Vec<(std::string::String, std::string::String)>>(),
17309            ),
17310            _ => local_var_req_builder.query(&[(
17311                "site",
17312                &local_var_str
17313                    .into_iter()
17314                    .map(|p| p.to_string())
17315                    .collect::<Vec<String>>()
17316                    .join(",")
17317                    .to_string(),
17318            )]),
17319        };
17320    }
17321    if let Some(ref local_var_str) = site__n {
17322        local_var_req_builder = match "multi" {
17323            "multi" => local_var_req_builder.query(
17324                &local_var_str
17325                    .into_iter()
17326                    .map(|p| ("site__n".to_owned(), p.to_string()))
17327                    .collect::<Vec<(std::string::String, std::string::String)>>(),
17328            ),
17329            _ => local_var_req_builder.query(&[(
17330                "site__n",
17331                &local_var_str
17332                    .into_iter()
17333                    .map(|p| p.to_string())
17334                    .collect::<Vec<String>>()
17335                    .join(",")
17336                    .to_string(),
17337            )]),
17338        };
17339    }
17340    if let Some(ref local_var_str) = site_group {
17341        local_var_req_builder = match "multi" {
17342            "multi" => local_var_req_builder.query(
17343                &local_var_str
17344                    .into_iter()
17345                    .map(|p| ("site_group".to_owned(), p.to_string()))
17346                    .collect::<Vec<(std::string::String, std::string::String)>>(),
17347            ),
17348            _ => local_var_req_builder.query(&[(
17349                "site_group",
17350                &local_var_str
17351                    .into_iter()
17352                    .map(|p| p.to_string())
17353                    .collect::<Vec<String>>()
17354                    .join(",")
17355                    .to_string(),
17356            )]),
17357        };
17358    }
17359    if let Some(ref local_var_str) = site_group__n {
17360        local_var_req_builder = match "multi" {
17361            "multi" => local_var_req_builder.query(
17362                &local_var_str
17363                    .into_iter()
17364                    .map(|p| ("site_group__n".to_owned(), p.to_string()))
17365                    .collect::<Vec<(std::string::String, std::string::String)>>(),
17366            ),
17367            _ => local_var_req_builder.query(&[(
17368                "site_group__n",
17369                &local_var_str
17370                    .into_iter()
17371                    .map(|p| p.to_string())
17372                    .collect::<Vec<String>>()
17373                    .join(",")
17374                    .to_string(),
17375            )]),
17376        };
17377    }
17378    if let Some(ref local_var_str) = site_group_id {
17379        local_var_req_builder = match "multi" {
17380            "multi" => local_var_req_builder.query(
17381                &local_var_str
17382                    .into_iter()
17383                    .map(|p| ("site_group_id".to_owned(), p.to_string()))
17384                    .collect::<Vec<(std::string::String, std::string::String)>>(),
17385            ),
17386            _ => local_var_req_builder.query(&[(
17387                "site_group_id",
17388                &local_var_str
17389                    .into_iter()
17390                    .map(|p| p.to_string())
17391                    .collect::<Vec<String>>()
17392                    .join(",")
17393                    .to_string(),
17394            )]),
17395        };
17396    }
17397    if let Some(ref local_var_str) = site_group_id__n {
17398        local_var_req_builder = match "multi" {
17399            "multi" => local_var_req_builder.query(
17400                &local_var_str
17401                    .into_iter()
17402                    .map(|p| ("site_group_id__n".to_owned(), p.to_string()))
17403                    .collect::<Vec<(std::string::String, std::string::String)>>(),
17404            ),
17405            _ => local_var_req_builder.query(&[(
17406                "site_group_id__n",
17407                &local_var_str
17408                    .into_iter()
17409                    .map(|p| p.to_string())
17410                    .collect::<Vec<String>>()
17411                    .join(",")
17412                    .to_string(),
17413            )]),
17414        };
17415    }
17416    if let Some(ref local_var_str) = site_id {
17417        local_var_req_builder = match "multi" {
17418            "multi" => local_var_req_builder.query(
17419                &local_var_str
17420                    .into_iter()
17421                    .map(|p| ("site_id".to_owned(), p.to_string()))
17422                    .collect::<Vec<(std::string::String, std::string::String)>>(),
17423            ),
17424            _ => local_var_req_builder.query(&[(
17425                "site_id",
17426                &local_var_str
17427                    .into_iter()
17428                    .map(|p| p.to_string())
17429                    .collect::<Vec<String>>()
17430                    .join(",")
17431                    .to_string(),
17432            )]),
17433        };
17434    }
17435    if let Some(ref local_var_str) = site_id__n {
17436        local_var_req_builder = match "multi" {
17437            "multi" => local_var_req_builder.query(
17438                &local_var_str
17439                    .into_iter()
17440                    .map(|p| ("site_id__n".to_owned(), p.to_string()))
17441                    .collect::<Vec<(std::string::String, std::string::String)>>(),
17442            ),
17443            _ => local_var_req_builder.query(&[(
17444                "site_id__n",
17445                &local_var_str
17446                    .into_iter()
17447                    .map(|p| p.to_string())
17448                    .collect::<Vec<String>>()
17449                    .join(",")
17450                    .to_string(),
17451            )]),
17452        };
17453    }
17454    if let Some(ref local_var_str) = start {
17455        local_var_req_builder =
17456            local_var_req_builder.query(&[("start", &local_var_str.to_string())]);
17457    }
17458    if let Some(ref local_var_str) = start_on_boot {
17459        local_var_req_builder = match "multi" {
17460            "multi" => local_var_req_builder.query(
17461                &local_var_str
17462                    .into_iter()
17463                    .map(|p| ("start_on_boot".to_owned(), p.to_string()))
17464                    .collect::<Vec<(std::string::String, std::string::String)>>(),
17465            ),
17466            _ => local_var_req_builder.query(&[(
17467                "start_on_boot",
17468                &local_var_str
17469                    .into_iter()
17470                    .map(|p| p.to_string())
17471                    .collect::<Vec<String>>()
17472                    .join(",")
17473                    .to_string(),
17474            )]),
17475        };
17476    }
17477    if let Some(ref local_var_str) = start_on_boot__empty {
17478        local_var_req_builder =
17479            local_var_req_builder.query(&[("start_on_boot__empty", &local_var_str.to_string())]);
17480    }
17481    if let Some(ref local_var_str) = start_on_boot__ic {
17482        local_var_req_builder = match "multi" {
17483            "multi" => local_var_req_builder.query(
17484                &local_var_str
17485                    .into_iter()
17486                    .map(|p| ("start_on_boot__ic".to_owned(), p.to_string()))
17487                    .collect::<Vec<(std::string::String, std::string::String)>>(),
17488            ),
17489            _ => local_var_req_builder.query(&[(
17490                "start_on_boot__ic",
17491                &local_var_str
17492                    .into_iter()
17493                    .map(|p| p.to_string())
17494                    .collect::<Vec<String>>()
17495                    .join(",")
17496                    .to_string(),
17497            )]),
17498        };
17499    }
17500    if let Some(ref local_var_str) = start_on_boot__ie {
17501        local_var_req_builder = match "multi" {
17502            "multi" => local_var_req_builder.query(
17503                &local_var_str
17504                    .into_iter()
17505                    .map(|p| ("start_on_boot__ie".to_owned(), p.to_string()))
17506                    .collect::<Vec<(std::string::String, std::string::String)>>(),
17507            ),
17508            _ => local_var_req_builder.query(&[(
17509                "start_on_boot__ie",
17510                &local_var_str
17511                    .into_iter()
17512                    .map(|p| p.to_string())
17513                    .collect::<Vec<String>>()
17514                    .join(",")
17515                    .to_string(),
17516            )]),
17517        };
17518    }
17519    if let Some(ref local_var_str) = start_on_boot__iew {
17520        local_var_req_builder = match "multi" {
17521            "multi" => local_var_req_builder.query(
17522                &local_var_str
17523                    .into_iter()
17524                    .map(|p| ("start_on_boot__iew".to_owned(), p.to_string()))
17525                    .collect::<Vec<(std::string::String, std::string::String)>>(),
17526            ),
17527            _ => local_var_req_builder.query(&[(
17528                "start_on_boot__iew",
17529                &local_var_str
17530                    .into_iter()
17531                    .map(|p| p.to_string())
17532                    .collect::<Vec<String>>()
17533                    .join(",")
17534                    .to_string(),
17535            )]),
17536        };
17537    }
17538    if let Some(ref local_var_str) = start_on_boot__iregex {
17539        local_var_req_builder = match "multi" {
17540            "multi" => local_var_req_builder.query(
17541                &local_var_str
17542                    .into_iter()
17543                    .map(|p| ("start_on_boot__iregex".to_owned(), p.to_string()))
17544                    .collect::<Vec<(std::string::String, std::string::String)>>(),
17545            ),
17546            _ => local_var_req_builder.query(&[(
17547                "start_on_boot__iregex",
17548                &local_var_str
17549                    .into_iter()
17550                    .map(|p| p.to_string())
17551                    .collect::<Vec<String>>()
17552                    .join(",")
17553                    .to_string(),
17554            )]),
17555        };
17556    }
17557    if let Some(ref local_var_str) = start_on_boot__isw {
17558        local_var_req_builder = match "multi" {
17559            "multi" => local_var_req_builder.query(
17560                &local_var_str
17561                    .into_iter()
17562                    .map(|p| ("start_on_boot__isw".to_owned(), p.to_string()))
17563                    .collect::<Vec<(std::string::String, std::string::String)>>(),
17564            ),
17565            _ => local_var_req_builder.query(&[(
17566                "start_on_boot__isw",
17567                &local_var_str
17568                    .into_iter()
17569                    .map(|p| p.to_string())
17570                    .collect::<Vec<String>>()
17571                    .join(",")
17572                    .to_string(),
17573            )]),
17574        };
17575    }
17576    if let Some(ref local_var_str) = start_on_boot__n {
17577        local_var_req_builder = match "multi" {
17578            "multi" => local_var_req_builder.query(
17579                &local_var_str
17580                    .into_iter()
17581                    .map(|p| ("start_on_boot__n".to_owned(), p.to_string()))
17582                    .collect::<Vec<(std::string::String, std::string::String)>>(),
17583            ),
17584            _ => local_var_req_builder.query(&[(
17585                "start_on_boot__n",
17586                &local_var_str
17587                    .into_iter()
17588                    .map(|p| p.to_string())
17589                    .collect::<Vec<String>>()
17590                    .join(",")
17591                    .to_string(),
17592            )]),
17593        };
17594    }
17595    if let Some(ref local_var_str) = start_on_boot__nic {
17596        local_var_req_builder = match "multi" {
17597            "multi" => local_var_req_builder.query(
17598                &local_var_str
17599                    .into_iter()
17600                    .map(|p| ("start_on_boot__nic".to_owned(), p.to_string()))
17601                    .collect::<Vec<(std::string::String, std::string::String)>>(),
17602            ),
17603            _ => local_var_req_builder.query(&[(
17604                "start_on_boot__nic",
17605                &local_var_str
17606                    .into_iter()
17607                    .map(|p| p.to_string())
17608                    .collect::<Vec<String>>()
17609                    .join(",")
17610                    .to_string(),
17611            )]),
17612        };
17613    }
17614    if let Some(ref local_var_str) = start_on_boot__nie {
17615        local_var_req_builder = match "multi" {
17616            "multi" => local_var_req_builder.query(
17617                &local_var_str
17618                    .into_iter()
17619                    .map(|p| ("start_on_boot__nie".to_owned(), p.to_string()))
17620                    .collect::<Vec<(std::string::String, std::string::String)>>(),
17621            ),
17622            _ => local_var_req_builder.query(&[(
17623                "start_on_boot__nie",
17624                &local_var_str
17625                    .into_iter()
17626                    .map(|p| p.to_string())
17627                    .collect::<Vec<String>>()
17628                    .join(",")
17629                    .to_string(),
17630            )]),
17631        };
17632    }
17633    if let Some(ref local_var_str) = start_on_boot__niew {
17634        local_var_req_builder = match "multi" {
17635            "multi" => local_var_req_builder.query(
17636                &local_var_str
17637                    .into_iter()
17638                    .map(|p| ("start_on_boot__niew".to_owned(), p.to_string()))
17639                    .collect::<Vec<(std::string::String, std::string::String)>>(),
17640            ),
17641            _ => local_var_req_builder.query(&[(
17642                "start_on_boot__niew",
17643                &local_var_str
17644                    .into_iter()
17645                    .map(|p| p.to_string())
17646                    .collect::<Vec<String>>()
17647                    .join(",")
17648                    .to_string(),
17649            )]),
17650        };
17651    }
17652    if let Some(ref local_var_str) = start_on_boot__nisw {
17653        local_var_req_builder = match "multi" {
17654            "multi" => local_var_req_builder.query(
17655                &local_var_str
17656                    .into_iter()
17657                    .map(|p| ("start_on_boot__nisw".to_owned(), p.to_string()))
17658                    .collect::<Vec<(std::string::String, std::string::String)>>(),
17659            ),
17660            _ => local_var_req_builder.query(&[(
17661                "start_on_boot__nisw",
17662                &local_var_str
17663                    .into_iter()
17664                    .map(|p| p.to_string())
17665                    .collect::<Vec<String>>()
17666                    .join(",")
17667                    .to_string(),
17668            )]),
17669        };
17670    }
17671    if let Some(ref local_var_str) = start_on_boot__regex {
17672        local_var_req_builder = match "multi" {
17673            "multi" => local_var_req_builder.query(
17674                &local_var_str
17675                    .into_iter()
17676                    .map(|p| ("start_on_boot__regex".to_owned(), p.to_string()))
17677                    .collect::<Vec<(std::string::String, std::string::String)>>(),
17678            ),
17679            _ => local_var_req_builder.query(&[(
17680                "start_on_boot__regex",
17681                &local_var_str
17682                    .into_iter()
17683                    .map(|p| p.to_string())
17684                    .collect::<Vec<String>>()
17685                    .join(",")
17686                    .to_string(),
17687            )]),
17688        };
17689    }
17690    if let Some(ref local_var_str) = status {
17691        local_var_req_builder = match "multi" {
17692            "multi" => local_var_req_builder.query(
17693                &local_var_str
17694                    .into_iter()
17695                    .map(|p| ("status".to_owned(), p.to_string()))
17696                    .collect::<Vec<(std::string::String, std::string::String)>>(),
17697            ),
17698            _ => local_var_req_builder.query(&[(
17699                "status",
17700                &local_var_str
17701                    .into_iter()
17702                    .map(|p| p.to_string())
17703                    .collect::<Vec<String>>()
17704                    .join(",")
17705                    .to_string(),
17706            )]),
17707        };
17708    }
17709    if let Some(ref local_var_str) = status__empty {
17710        local_var_req_builder =
17711            local_var_req_builder.query(&[("status__empty", &local_var_str.to_string())]);
17712    }
17713    if let Some(ref local_var_str) = status__ic {
17714        local_var_req_builder = match "multi" {
17715            "multi" => local_var_req_builder.query(
17716                &local_var_str
17717                    .into_iter()
17718                    .map(|p| ("status__ic".to_owned(), p.to_string()))
17719                    .collect::<Vec<(std::string::String, std::string::String)>>(),
17720            ),
17721            _ => local_var_req_builder.query(&[(
17722                "status__ic",
17723                &local_var_str
17724                    .into_iter()
17725                    .map(|p| p.to_string())
17726                    .collect::<Vec<String>>()
17727                    .join(",")
17728                    .to_string(),
17729            )]),
17730        };
17731    }
17732    if let Some(ref local_var_str) = status__ie {
17733        local_var_req_builder = match "multi" {
17734            "multi" => local_var_req_builder.query(
17735                &local_var_str
17736                    .into_iter()
17737                    .map(|p| ("status__ie".to_owned(), p.to_string()))
17738                    .collect::<Vec<(std::string::String, std::string::String)>>(),
17739            ),
17740            _ => local_var_req_builder.query(&[(
17741                "status__ie",
17742                &local_var_str
17743                    .into_iter()
17744                    .map(|p| p.to_string())
17745                    .collect::<Vec<String>>()
17746                    .join(",")
17747                    .to_string(),
17748            )]),
17749        };
17750    }
17751    if let Some(ref local_var_str) = status__iew {
17752        local_var_req_builder = match "multi" {
17753            "multi" => local_var_req_builder.query(
17754                &local_var_str
17755                    .into_iter()
17756                    .map(|p| ("status__iew".to_owned(), p.to_string()))
17757                    .collect::<Vec<(std::string::String, std::string::String)>>(),
17758            ),
17759            _ => local_var_req_builder.query(&[(
17760                "status__iew",
17761                &local_var_str
17762                    .into_iter()
17763                    .map(|p| p.to_string())
17764                    .collect::<Vec<String>>()
17765                    .join(",")
17766                    .to_string(),
17767            )]),
17768        };
17769    }
17770    if let Some(ref local_var_str) = status__iregex {
17771        local_var_req_builder = match "multi" {
17772            "multi" => local_var_req_builder.query(
17773                &local_var_str
17774                    .into_iter()
17775                    .map(|p| ("status__iregex".to_owned(), p.to_string()))
17776                    .collect::<Vec<(std::string::String, std::string::String)>>(),
17777            ),
17778            _ => local_var_req_builder.query(&[(
17779                "status__iregex",
17780                &local_var_str
17781                    .into_iter()
17782                    .map(|p| p.to_string())
17783                    .collect::<Vec<String>>()
17784                    .join(",")
17785                    .to_string(),
17786            )]),
17787        };
17788    }
17789    if let Some(ref local_var_str) = status__isw {
17790        local_var_req_builder = match "multi" {
17791            "multi" => local_var_req_builder.query(
17792                &local_var_str
17793                    .into_iter()
17794                    .map(|p| ("status__isw".to_owned(), p.to_string()))
17795                    .collect::<Vec<(std::string::String, std::string::String)>>(),
17796            ),
17797            _ => local_var_req_builder.query(&[(
17798                "status__isw",
17799                &local_var_str
17800                    .into_iter()
17801                    .map(|p| p.to_string())
17802                    .collect::<Vec<String>>()
17803                    .join(",")
17804                    .to_string(),
17805            )]),
17806        };
17807    }
17808    if let Some(ref local_var_str) = status__n {
17809        local_var_req_builder = match "multi" {
17810            "multi" => local_var_req_builder.query(
17811                &local_var_str
17812                    .into_iter()
17813                    .map(|p| ("status__n".to_owned(), p.to_string()))
17814                    .collect::<Vec<(std::string::String, std::string::String)>>(),
17815            ),
17816            _ => local_var_req_builder.query(&[(
17817                "status__n",
17818                &local_var_str
17819                    .into_iter()
17820                    .map(|p| p.to_string())
17821                    .collect::<Vec<String>>()
17822                    .join(",")
17823                    .to_string(),
17824            )]),
17825        };
17826    }
17827    if let Some(ref local_var_str) = status__nic {
17828        local_var_req_builder = match "multi" {
17829            "multi" => local_var_req_builder.query(
17830                &local_var_str
17831                    .into_iter()
17832                    .map(|p| ("status__nic".to_owned(), p.to_string()))
17833                    .collect::<Vec<(std::string::String, std::string::String)>>(),
17834            ),
17835            _ => local_var_req_builder.query(&[(
17836                "status__nic",
17837                &local_var_str
17838                    .into_iter()
17839                    .map(|p| p.to_string())
17840                    .collect::<Vec<String>>()
17841                    .join(",")
17842                    .to_string(),
17843            )]),
17844        };
17845    }
17846    if let Some(ref local_var_str) = status__nie {
17847        local_var_req_builder = match "multi" {
17848            "multi" => local_var_req_builder.query(
17849                &local_var_str
17850                    .into_iter()
17851                    .map(|p| ("status__nie".to_owned(), p.to_string()))
17852                    .collect::<Vec<(std::string::String, std::string::String)>>(),
17853            ),
17854            _ => local_var_req_builder.query(&[(
17855                "status__nie",
17856                &local_var_str
17857                    .into_iter()
17858                    .map(|p| p.to_string())
17859                    .collect::<Vec<String>>()
17860                    .join(",")
17861                    .to_string(),
17862            )]),
17863        };
17864    }
17865    if let Some(ref local_var_str) = status__niew {
17866        local_var_req_builder = match "multi" {
17867            "multi" => local_var_req_builder.query(
17868                &local_var_str
17869                    .into_iter()
17870                    .map(|p| ("status__niew".to_owned(), p.to_string()))
17871                    .collect::<Vec<(std::string::String, std::string::String)>>(),
17872            ),
17873            _ => local_var_req_builder.query(&[(
17874                "status__niew",
17875                &local_var_str
17876                    .into_iter()
17877                    .map(|p| p.to_string())
17878                    .collect::<Vec<String>>()
17879                    .join(",")
17880                    .to_string(),
17881            )]),
17882        };
17883    }
17884    if let Some(ref local_var_str) = status__nisw {
17885        local_var_req_builder = match "multi" {
17886            "multi" => local_var_req_builder.query(
17887                &local_var_str
17888                    .into_iter()
17889                    .map(|p| ("status__nisw".to_owned(), p.to_string()))
17890                    .collect::<Vec<(std::string::String, std::string::String)>>(),
17891            ),
17892            _ => local_var_req_builder.query(&[(
17893                "status__nisw",
17894                &local_var_str
17895                    .into_iter()
17896                    .map(|p| p.to_string())
17897                    .collect::<Vec<String>>()
17898                    .join(",")
17899                    .to_string(),
17900            )]),
17901        };
17902    }
17903    if let Some(ref local_var_str) = status__regex {
17904        local_var_req_builder = match "multi" {
17905            "multi" => local_var_req_builder.query(
17906                &local_var_str
17907                    .into_iter()
17908                    .map(|p| ("status__regex".to_owned(), p.to_string()))
17909                    .collect::<Vec<(std::string::String, std::string::String)>>(),
17910            ),
17911            _ => local_var_req_builder.query(&[(
17912                "status__regex",
17913                &local_var_str
17914                    .into_iter()
17915                    .map(|p| p.to_string())
17916                    .collect::<Vec<String>>()
17917                    .join(",")
17918                    .to_string(),
17919            )]),
17920        };
17921    }
17922    if let Some(ref local_var_str) = tag {
17923        local_var_req_builder = match "multi" {
17924            "multi" => local_var_req_builder.query(
17925                &local_var_str
17926                    .into_iter()
17927                    .map(|p| ("tag".to_owned(), p.to_string()))
17928                    .collect::<Vec<(std::string::String, std::string::String)>>(),
17929            ),
17930            _ => local_var_req_builder.query(&[(
17931                "tag",
17932                &local_var_str
17933                    .into_iter()
17934                    .map(|p| p.to_string())
17935                    .collect::<Vec<String>>()
17936                    .join(",")
17937                    .to_string(),
17938            )]),
17939        };
17940    }
17941    if let Some(ref local_var_str) = tag__n {
17942        local_var_req_builder = match "multi" {
17943            "multi" => local_var_req_builder.query(
17944                &local_var_str
17945                    .into_iter()
17946                    .map(|p| ("tag__n".to_owned(), p.to_string()))
17947                    .collect::<Vec<(std::string::String, std::string::String)>>(),
17948            ),
17949            _ => local_var_req_builder.query(&[(
17950                "tag__n",
17951                &local_var_str
17952                    .into_iter()
17953                    .map(|p| p.to_string())
17954                    .collect::<Vec<String>>()
17955                    .join(",")
17956                    .to_string(),
17957            )]),
17958        };
17959    }
17960    if let Some(ref local_var_str) = tag_id {
17961        local_var_req_builder = match "multi" {
17962            "multi" => local_var_req_builder.query(
17963                &local_var_str
17964                    .into_iter()
17965                    .map(|p| ("tag_id".to_owned(), p.to_string()))
17966                    .collect::<Vec<(std::string::String, std::string::String)>>(),
17967            ),
17968            _ => local_var_req_builder.query(&[(
17969                "tag_id",
17970                &local_var_str
17971                    .into_iter()
17972                    .map(|p| p.to_string())
17973                    .collect::<Vec<String>>()
17974                    .join(",")
17975                    .to_string(),
17976            )]),
17977        };
17978    }
17979    if let Some(ref local_var_str) = tag_id__n {
17980        local_var_req_builder = match "multi" {
17981            "multi" => local_var_req_builder.query(
17982                &local_var_str
17983                    .into_iter()
17984                    .map(|p| ("tag_id__n".to_owned(), p.to_string()))
17985                    .collect::<Vec<(std::string::String, std::string::String)>>(),
17986            ),
17987            _ => local_var_req_builder.query(&[(
17988                "tag_id__n",
17989                &local_var_str
17990                    .into_iter()
17991                    .map(|p| p.to_string())
17992                    .collect::<Vec<String>>()
17993                    .join(",")
17994                    .to_string(),
17995            )]),
17996        };
17997    }
17998    if let Some(ref local_var_str) = tenant {
17999        local_var_req_builder = match "multi" {
18000            "multi" => local_var_req_builder.query(
18001                &local_var_str
18002                    .into_iter()
18003                    .map(|p| ("tenant".to_owned(), p.to_string()))
18004                    .collect::<Vec<(std::string::String, std::string::String)>>(),
18005            ),
18006            _ => local_var_req_builder.query(&[(
18007                "tenant",
18008                &local_var_str
18009                    .into_iter()
18010                    .map(|p| p.to_string())
18011                    .collect::<Vec<String>>()
18012                    .join(",")
18013                    .to_string(),
18014            )]),
18015        };
18016    }
18017    if let Some(ref local_var_str) = tenant__n {
18018        local_var_req_builder = match "multi" {
18019            "multi" => local_var_req_builder.query(
18020                &local_var_str
18021                    .into_iter()
18022                    .map(|p| ("tenant__n".to_owned(), p.to_string()))
18023                    .collect::<Vec<(std::string::String, std::string::String)>>(),
18024            ),
18025            _ => local_var_req_builder.query(&[(
18026                "tenant__n",
18027                &local_var_str
18028                    .into_iter()
18029                    .map(|p| p.to_string())
18030                    .collect::<Vec<String>>()
18031                    .join(",")
18032                    .to_string(),
18033            )]),
18034        };
18035    }
18036    if let Some(ref local_var_str) = tenant_group {
18037        local_var_req_builder = match "multi" {
18038            "multi" => local_var_req_builder.query(
18039                &local_var_str
18040                    .into_iter()
18041                    .map(|p| ("tenant_group".to_owned(), p.to_string()))
18042                    .collect::<Vec<(std::string::String, std::string::String)>>(),
18043            ),
18044            _ => local_var_req_builder.query(&[(
18045                "tenant_group",
18046                &local_var_str
18047                    .into_iter()
18048                    .map(|p| p.to_string())
18049                    .collect::<Vec<String>>()
18050                    .join(",")
18051                    .to_string(),
18052            )]),
18053        };
18054    }
18055    if let Some(ref local_var_str) = tenant_group__n {
18056        local_var_req_builder = match "multi" {
18057            "multi" => local_var_req_builder.query(
18058                &local_var_str
18059                    .into_iter()
18060                    .map(|p| ("tenant_group__n".to_owned(), p.to_string()))
18061                    .collect::<Vec<(std::string::String, std::string::String)>>(),
18062            ),
18063            _ => local_var_req_builder.query(&[(
18064                "tenant_group__n",
18065                &local_var_str
18066                    .into_iter()
18067                    .map(|p| p.to_string())
18068                    .collect::<Vec<String>>()
18069                    .join(",")
18070                    .to_string(),
18071            )]),
18072        };
18073    }
18074    if let Some(ref local_var_str) = tenant_group_id {
18075        local_var_req_builder = match "multi" {
18076            "multi" => local_var_req_builder.query(
18077                &local_var_str
18078                    .into_iter()
18079                    .map(|p| ("tenant_group_id".to_owned(), p.to_string()))
18080                    .collect::<Vec<(std::string::String, std::string::String)>>(),
18081            ),
18082            _ => local_var_req_builder.query(&[(
18083                "tenant_group_id",
18084                &local_var_str
18085                    .into_iter()
18086                    .map(|p| p.to_string())
18087                    .collect::<Vec<String>>()
18088                    .join(",")
18089                    .to_string(),
18090            )]),
18091        };
18092    }
18093    if let Some(ref local_var_str) = tenant_group_id__n {
18094        local_var_req_builder = match "multi" {
18095            "multi" => local_var_req_builder.query(
18096                &local_var_str
18097                    .into_iter()
18098                    .map(|p| ("tenant_group_id__n".to_owned(), p.to_string()))
18099                    .collect::<Vec<(std::string::String, std::string::String)>>(),
18100            ),
18101            _ => local_var_req_builder.query(&[(
18102                "tenant_group_id__n",
18103                &local_var_str
18104                    .into_iter()
18105                    .map(|p| p.to_string())
18106                    .collect::<Vec<String>>()
18107                    .join(",")
18108                    .to_string(),
18109            )]),
18110        };
18111    }
18112    if let Some(ref local_var_str) = tenant_id {
18113        local_var_req_builder = match "multi" {
18114            "multi" => local_var_req_builder.query(
18115                &local_var_str
18116                    .into_iter()
18117                    .map(|p| ("tenant_id".to_owned(), p.to_string()))
18118                    .collect::<Vec<(std::string::String, std::string::String)>>(),
18119            ),
18120            _ => local_var_req_builder.query(&[(
18121                "tenant_id",
18122                &local_var_str
18123                    .into_iter()
18124                    .map(|p| p.to_string())
18125                    .collect::<Vec<String>>()
18126                    .join(",")
18127                    .to_string(),
18128            )]),
18129        };
18130    }
18131    if let Some(ref local_var_str) = tenant_id__n {
18132        local_var_req_builder = match "multi" {
18133            "multi" => local_var_req_builder.query(
18134                &local_var_str
18135                    .into_iter()
18136                    .map(|p| ("tenant_id__n".to_owned(), p.to_string()))
18137                    .collect::<Vec<(std::string::String, std::string::String)>>(),
18138            ),
18139            _ => local_var_req_builder.query(&[(
18140                "tenant_id__n",
18141                &local_var_str
18142                    .into_iter()
18143                    .map(|p| p.to_string())
18144                    .collect::<Vec<String>>()
18145                    .join(",")
18146                    .to_string(),
18147            )]),
18148        };
18149    }
18150    if let Some(ref local_var_str) = updated_by_request {
18151        local_var_req_builder =
18152            local_var_req_builder.query(&[("updated_by_request", &local_var_str.to_string())]);
18153    }
18154    if let Some(ref local_var_str) = vcpus {
18155        local_var_req_builder = match "multi" {
18156            "multi" => local_var_req_builder.query(
18157                &local_var_str
18158                    .into_iter()
18159                    .map(|p| ("vcpus".to_owned(), p.to_string()))
18160                    .collect::<Vec<(std::string::String, std::string::String)>>(),
18161            ),
18162            _ => local_var_req_builder.query(&[(
18163                "vcpus",
18164                &local_var_str
18165                    .into_iter()
18166                    .map(|p| p.to_string())
18167                    .collect::<Vec<String>>()
18168                    .join(",")
18169                    .to_string(),
18170            )]),
18171        };
18172    }
18173    if let Some(ref local_var_str) = vcpus__empty {
18174        local_var_req_builder =
18175            local_var_req_builder.query(&[("vcpus__empty", &local_var_str.to_string())]);
18176    }
18177    if let Some(ref local_var_str) = vcpus__gt {
18178        local_var_req_builder = match "multi" {
18179            "multi" => local_var_req_builder.query(
18180                &local_var_str
18181                    .into_iter()
18182                    .map(|p| ("vcpus__gt".to_owned(), p.to_string()))
18183                    .collect::<Vec<(std::string::String, std::string::String)>>(),
18184            ),
18185            _ => local_var_req_builder.query(&[(
18186                "vcpus__gt",
18187                &local_var_str
18188                    .into_iter()
18189                    .map(|p| p.to_string())
18190                    .collect::<Vec<String>>()
18191                    .join(",")
18192                    .to_string(),
18193            )]),
18194        };
18195    }
18196    if let Some(ref local_var_str) = vcpus__gte {
18197        local_var_req_builder = match "multi" {
18198            "multi" => local_var_req_builder.query(
18199                &local_var_str
18200                    .into_iter()
18201                    .map(|p| ("vcpus__gte".to_owned(), p.to_string()))
18202                    .collect::<Vec<(std::string::String, std::string::String)>>(),
18203            ),
18204            _ => local_var_req_builder.query(&[(
18205                "vcpus__gte",
18206                &local_var_str
18207                    .into_iter()
18208                    .map(|p| p.to_string())
18209                    .collect::<Vec<String>>()
18210                    .join(",")
18211                    .to_string(),
18212            )]),
18213        };
18214    }
18215    if let Some(ref local_var_str) = vcpus__lt {
18216        local_var_req_builder = match "multi" {
18217            "multi" => local_var_req_builder.query(
18218                &local_var_str
18219                    .into_iter()
18220                    .map(|p| ("vcpus__lt".to_owned(), p.to_string()))
18221                    .collect::<Vec<(std::string::String, std::string::String)>>(),
18222            ),
18223            _ => local_var_req_builder.query(&[(
18224                "vcpus__lt",
18225                &local_var_str
18226                    .into_iter()
18227                    .map(|p| p.to_string())
18228                    .collect::<Vec<String>>()
18229                    .join(",")
18230                    .to_string(),
18231            )]),
18232        };
18233    }
18234    if let Some(ref local_var_str) = vcpus__lte {
18235        local_var_req_builder = match "multi" {
18236            "multi" => local_var_req_builder.query(
18237                &local_var_str
18238                    .into_iter()
18239                    .map(|p| ("vcpus__lte".to_owned(), p.to_string()))
18240                    .collect::<Vec<(std::string::String, std::string::String)>>(),
18241            ),
18242            _ => local_var_req_builder.query(&[(
18243                "vcpus__lte",
18244                &local_var_str
18245                    .into_iter()
18246                    .map(|p| p.to_string())
18247                    .collect::<Vec<String>>()
18248                    .join(",")
18249                    .to_string(),
18250            )]),
18251        };
18252    }
18253    if let Some(ref local_var_str) = vcpus__n {
18254        local_var_req_builder = match "multi" {
18255            "multi" => local_var_req_builder.query(
18256                &local_var_str
18257                    .into_iter()
18258                    .map(|p| ("vcpus__n".to_owned(), p.to_string()))
18259                    .collect::<Vec<(std::string::String, std::string::String)>>(),
18260            ),
18261            _ => local_var_req_builder.query(&[(
18262                "vcpus__n",
18263                &local_var_str
18264                    .into_iter()
18265                    .map(|p| p.to_string())
18266                    .collect::<Vec<String>>()
18267                    .join(",")
18268                    .to_string(),
18269            )]),
18270        };
18271    }
18272    if let Some(ref local_var_str) = virtual_disk_count {
18273        local_var_req_builder = match "multi" {
18274            "multi" => local_var_req_builder.query(
18275                &local_var_str
18276                    .into_iter()
18277                    .map(|p| ("virtual_disk_count".to_owned(), p.to_string()))
18278                    .collect::<Vec<(std::string::String, std::string::String)>>(),
18279            ),
18280            _ => local_var_req_builder.query(&[(
18281                "virtual_disk_count",
18282                &local_var_str
18283                    .into_iter()
18284                    .map(|p| p.to_string())
18285                    .collect::<Vec<String>>()
18286                    .join(",")
18287                    .to_string(),
18288            )]),
18289        };
18290    }
18291    if let Some(ref local_var_str) = virtual_disk_count__empty {
18292        local_var_req_builder = local_var_req_builder
18293            .query(&[("virtual_disk_count__empty", &local_var_str.to_string())]);
18294    }
18295    if let Some(ref local_var_str) = virtual_disk_count__gt {
18296        local_var_req_builder = match "multi" {
18297            "multi" => local_var_req_builder.query(
18298                &local_var_str
18299                    .into_iter()
18300                    .map(|p| ("virtual_disk_count__gt".to_owned(), p.to_string()))
18301                    .collect::<Vec<(std::string::String, std::string::String)>>(),
18302            ),
18303            _ => local_var_req_builder.query(&[(
18304                "virtual_disk_count__gt",
18305                &local_var_str
18306                    .into_iter()
18307                    .map(|p| p.to_string())
18308                    .collect::<Vec<String>>()
18309                    .join(",")
18310                    .to_string(),
18311            )]),
18312        };
18313    }
18314    if let Some(ref local_var_str) = virtual_disk_count__gte {
18315        local_var_req_builder = match "multi" {
18316            "multi" => local_var_req_builder.query(
18317                &local_var_str
18318                    .into_iter()
18319                    .map(|p| ("virtual_disk_count__gte".to_owned(), p.to_string()))
18320                    .collect::<Vec<(std::string::String, std::string::String)>>(),
18321            ),
18322            _ => local_var_req_builder.query(&[(
18323                "virtual_disk_count__gte",
18324                &local_var_str
18325                    .into_iter()
18326                    .map(|p| p.to_string())
18327                    .collect::<Vec<String>>()
18328                    .join(",")
18329                    .to_string(),
18330            )]),
18331        };
18332    }
18333    if let Some(ref local_var_str) = virtual_disk_count__lt {
18334        local_var_req_builder = match "multi" {
18335            "multi" => local_var_req_builder.query(
18336                &local_var_str
18337                    .into_iter()
18338                    .map(|p| ("virtual_disk_count__lt".to_owned(), p.to_string()))
18339                    .collect::<Vec<(std::string::String, std::string::String)>>(),
18340            ),
18341            _ => local_var_req_builder.query(&[(
18342                "virtual_disk_count__lt",
18343                &local_var_str
18344                    .into_iter()
18345                    .map(|p| p.to_string())
18346                    .collect::<Vec<String>>()
18347                    .join(",")
18348                    .to_string(),
18349            )]),
18350        };
18351    }
18352    if let Some(ref local_var_str) = virtual_disk_count__lte {
18353        local_var_req_builder = match "multi" {
18354            "multi" => local_var_req_builder.query(
18355                &local_var_str
18356                    .into_iter()
18357                    .map(|p| ("virtual_disk_count__lte".to_owned(), p.to_string()))
18358                    .collect::<Vec<(std::string::String, std::string::String)>>(),
18359            ),
18360            _ => local_var_req_builder.query(&[(
18361                "virtual_disk_count__lte",
18362                &local_var_str
18363                    .into_iter()
18364                    .map(|p| p.to_string())
18365                    .collect::<Vec<String>>()
18366                    .join(",")
18367                    .to_string(),
18368            )]),
18369        };
18370    }
18371    if let Some(ref local_var_str) = virtual_disk_count__n {
18372        local_var_req_builder = match "multi" {
18373            "multi" => local_var_req_builder.query(
18374                &local_var_str
18375                    .into_iter()
18376                    .map(|p| ("virtual_disk_count__n".to_owned(), p.to_string()))
18377                    .collect::<Vec<(std::string::String, std::string::String)>>(),
18378            ),
18379            _ => local_var_req_builder.query(&[(
18380                "virtual_disk_count__n",
18381                &local_var_str
18382                    .into_iter()
18383                    .map(|p| p.to_string())
18384                    .collect::<Vec<String>>()
18385                    .join(",")
18386                    .to_string(),
18387            )]),
18388        };
18389    }
18390    if let Some(ref local_var_str) = virtual_machine_type {
18391        local_var_req_builder = match "multi" {
18392            "multi" => local_var_req_builder.query(
18393                &local_var_str
18394                    .into_iter()
18395                    .map(|p| ("virtual_machine_type".to_owned(), p.to_string()))
18396                    .collect::<Vec<(std::string::String, std::string::String)>>(),
18397            ),
18398            _ => local_var_req_builder.query(&[(
18399                "virtual_machine_type",
18400                &local_var_str
18401                    .into_iter()
18402                    .map(|p| p.to_string())
18403                    .collect::<Vec<String>>()
18404                    .join(",")
18405                    .to_string(),
18406            )]),
18407        };
18408    }
18409    if let Some(ref local_var_str) = virtual_machine_type__n {
18410        local_var_req_builder = match "multi" {
18411            "multi" => local_var_req_builder.query(
18412                &local_var_str
18413                    .into_iter()
18414                    .map(|p| ("virtual_machine_type__n".to_owned(), p.to_string()))
18415                    .collect::<Vec<(std::string::String, std::string::String)>>(),
18416            ),
18417            _ => local_var_req_builder.query(&[(
18418                "virtual_machine_type__n",
18419                &local_var_str
18420                    .into_iter()
18421                    .map(|p| p.to_string())
18422                    .collect::<Vec<String>>()
18423                    .join(",")
18424                    .to_string(),
18425            )]),
18426        };
18427    }
18428    if let Some(ref local_var_str) = virtual_machine_type_id {
18429        local_var_req_builder = match "multi" {
18430            "multi" => local_var_req_builder.query(
18431                &local_var_str
18432                    .into_iter()
18433                    .map(|p| ("virtual_machine_type_id".to_owned(), p.to_string()))
18434                    .collect::<Vec<(std::string::String, std::string::String)>>(),
18435            ),
18436            _ => local_var_req_builder.query(&[(
18437                "virtual_machine_type_id",
18438                &local_var_str
18439                    .into_iter()
18440                    .map(|p| p.to_string())
18441                    .collect::<Vec<String>>()
18442                    .join(",")
18443                    .to_string(),
18444            )]),
18445        };
18446    }
18447    if let Some(ref local_var_str) = virtual_machine_type_id__n {
18448        local_var_req_builder = match "multi" {
18449            "multi" => local_var_req_builder.query(
18450                &local_var_str
18451                    .into_iter()
18452                    .map(|p| ("virtual_machine_type_id__n".to_owned(), p.to_string()))
18453                    .collect::<Vec<(std::string::String, std::string::String)>>(),
18454            ),
18455            _ => local_var_req_builder.query(&[(
18456                "virtual_machine_type_id__n",
18457                &local_var_str
18458                    .into_iter()
18459                    .map(|p| p.to_string())
18460                    .collect::<Vec<String>>()
18461                    .join(",")
18462                    .to_string(),
18463            )]),
18464        };
18465    }
18466    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
18467        local_var_req_builder =
18468            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
18469    }
18470    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
18471        let local_var_key = local_var_apikey.key.clone();
18472        let local_var_value = match local_var_apikey.prefix {
18473            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
18474            None => local_var_key,
18475        };
18476        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
18477    };
18478
18479    let local_var_req = local_var_req_builder.build()?;
18480    let local_var_resp = local_var_client.execute(local_var_req).await?;
18481
18482    let local_var_status = local_var_resp.status();
18483    let local_var_content = local_var_resp.text().await?;
18484
18485    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
18486        serde_json::from_str(&local_var_content).map_err(Error::from)
18487    } else {
18488        let local_var_entity: Option<VirtualizationVirtualMachinesListError> =
18489            serde_json::from_str(&local_var_content).ok();
18490        let local_var_error = ResponseContent {
18491            status: local_var_status,
18492            content: local_var_content,
18493            entity: local_var_entity,
18494        };
18495        Err(Error::ResponseError(local_var_error))
18496    }
18497}
18498
18499/// Patch a virtual machine object.
18500pub async fn virtualization_virtual_machines_partial_update(
18501    configuration: &configuration::Configuration,
18502    id: i32,
18503    patched_writable_virtual_machine_with_config_context_request: Option<
18504        crate::models::PatchedWritableVirtualMachineWithConfigContextRequest,
18505    >,
18506) -> Result<
18507    crate::models::VirtualMachineWithConfigContext,
18508    Error<VirtualizationVirtualMachinesPartialUpdateError>,
18509> {
18510    let local_var_configuration = configuration;
18511
18512    let local_var_client = &local_var_configuration.client;
18513
18514    let local_var_uri_str = format!(
18515        "{}/api/virtualization/virtual-machines/{id}/",
18516        local_var_configuration.base_path,
18517        id = id
18518    );
18519    let mut local_var_req_builder =
18520        local_var_client.request(reqwest::Method::PATCH, local_var_uri_str.as_str());
18521
18522    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
18523        local_var_req_builder =
18524            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
18525    }
18526    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
18527        let local_var_key = local_var_apikey.key.clone();
18528        let local_var_value = match local_var_apikey.prefix {
18529            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
18530            None => local_var_key,
18531        };
18532        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
18533    };
18534    local_var_req_builder =
18535        local_var_req_builder.json(&patched_writable_virtual_machine_with_config_context_request);
18536
18537    let local_var_req = local_var_req_builder.build()?;
18538    let local_var_resp = local_var_client.execute(local_var_req).await?;
18539
18540    let local_var_status = local_var_resp.status();
18541    let local_var_content = local_var_resp.text().await?;
18542
18543    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
18544        serde_json::from_str(&local_var_content).map_err(Error::from)
18545    } else {
18546        let local_var_entity: Option<VirtualizationVirtualMachinesPartialUpdateError> =
18547            serde_json::from_str(&local_var_content).ok();
18548        let local_var_error = ResponseContent {
18549            status: local_var_status,
18550            content: local_var_content,
18551            entity: local_var_entity,
18552        };
18553        Err(Error::ResponseError(local_var_error))
18554    }
18555}
18556
18557/// Resolve and render the preferred ConfigTemplate for this Device or Virtual Machine.
18558pub async fn virtualization_virtual_machines_render_config_create(
18559    configuration: &configuration::Configuration,
18560    id: i32,
18561    writable_virtual_machine_with_config_context_request: crate::models::WritableVirtualMachineWithConfigContextRequest,
18562    format: Option<&str>,
18563) -> Result<
18564    crate::models::VirtualMachineWithConfigContext,
18565    Error<VirtualizationVirtualMachinesRenderConfigCreateError>,
18566> {
18567    let local_var_configuration = configuration;
18568
18569    let local_var_client = &local_var_configuration.client;
18570
18571    let local_var_uri_str = format!(
18572        "{}/api/virtualization/virtual-machines/{id}/render-config/",
18573        local_var_configuration.base_path,
18574        id = id
18575    );
18576    let mut local_var_req_builder =
18577        local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
18578
18579    if let Some(ref local_var_str) = format {
18580        local_var_req_builder =
18581            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
18582    }
18583    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
18584        local_var_req_builder =
18585            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
18586    }
18587    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
18588        let local_var_key = local_var_apikey.key.clone();
18589        let local_var_value = match local_var_apikey.prefix {
18590            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
18591            None => local_var_key,
18592        };
18593        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
18594    };
18595    local_var_req_builder =
18596        local_var_req_builder.json(&writable_virtual_machine_with_config_context_request);
18597
18598    let local_var_req = local_var_req_builder.build()?;
18599    let local_var_resp = local_var_client.execute(local_var_req).await?;
18600
18601    let local_var_status = local_var_resp.status();
18602    let local_var_content = local_var_resp.text().await?;
18603
18604    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
18605        serde_json::from_str(&local_var_content).map_err(Error::from)
18606    } else {
18607        let local_var_entity: Option<VirtualizationVirtualMachinesRenderConfigCreateError> =
18608            serde_json::from_str(&local_var_content).ok();
18609        let local_var_error = ResponseContent {
18610            status: local_var_status,
18611            content: local_var_content,
18612            entity: local_var_entity,
18613        };
18614        Err(Error::ResponseError(local_var_error))
18615    }
18616}
18617
18618/// Get a virtual machine object.
18619pub async fn virtualization_virtual_machines_retrieve(
18620    configuration: &configuration::Configuration,
18621    id: i32,
18622) -> Result<
18623    crate::models::VirtualMachineWithConfigContext,
18624    Error<VirtualizationVirtualMachinesRetrieveError>,
18625> {
18626    let local_var_configuration = configuration;
18627
18628    let local_var_client = &local_var_configuration.client;
18629
18630    let local_var_uri_str = format!(
18631        "{}/api/virtualization/virtual-machines/{id}/",
18632        local_var_configuration.base_path,
18633        id = id
18634    );
18635    let mut local_var_req_builder =
18636        local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
18637
18638    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
18639        local_var_req_builder =
18640            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
18641    }
18642    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
18643        let local_var_key = local_var_apikey.key.clone();
18644        let local_var_value = match local_var_apikey.prefix {
18645            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
18646            None => local_var_key,
18647        };
18648        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
18649    };
18650
18651    let local_var_req = local_var_req_builder.build()?;
18652    let local_var_resp = local_var_client.execute(local_var_req).await?;
18653
18654    let local_var_status = local_var_resp.status();
18655    let local_var_content = local_var_resp.text().await?;
18656
18657    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
18658        serde_json::from_str(&local_var_content).map_err(Error::from)
18659    } else {
18660        let local_var_entity: Option<VirtualizationVirtualMachinesRetrieveError> =
18661            serde_json::from_str(&local_var_content).ok();
18662        let local_var_error = ResponseContent {
18663            status: local_var_status,
18664            content: local_var_content,
18665            entity: local_var_entity,
18666        };
18667        Err(Error::ResponseError(local_var_error))
18668    }
18669}
18670
18671/// Put a virtual machine object.
18672pub async fn virtualization_virtual_machines_update(
18673    configuration: &configuration::Configuration,
18674    id: i32,
18675    writable_virtual_machine_with_config_context_request: crate::models::WritableVirtualMachineWithConfigContextRequest,
18676) -> Result<
18677    crate::models::VirtualMachineWithConfigContext,
18678    Error<VirtualizationVirtualMachinesUpdateError>,
18679> {
18680    let local_var_configuration = configuration;
18681
18682    let local_var_client = &local_var_configuration.client;
18683
18684    let local_var_uri_str = format!(
18685        "{}/api/virtualization/virtual-machines/{id}/",
18686        local_var_configuration.base_path,
18687        id = id
18688    );
18689    let mut local_var_req_builder =
18690        local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());
18691
18692    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
18693        local_var_req_builder =
18694            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
18695    }
18696    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
18697        let local_var_key = local_var_apikey.key.clone();
18698        let local_var_value = match local_var_apikey.prefix {
18699            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
18700            None => local_var_key,
18701        };
18702        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
18703    };
18704    local_var_req_builder =
18705        local_var_req_builder.json(&writable_virtual_machine_with_config_context_request);
18706
18707    let local_var_req = local_var_req_builder.build()?;
18708    let local_var_resp = local_var_client.execute(local_var_req).await?;
18709
18710    let local_var_status = local_var_resp.status();
18711    let local_var_content = local_var_resp.text().await?;
18712
18713    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
18714        serde_json::from_str(&local_var_content).map_err(Error::from)
18715    } else {
18716        let local_var_entity: Option<VirtualizationVirtualMachinesUpdateError> =
18717            serde_json::from_str(&local_var_content).ok();
18718        let local_var_error = ResponseContent {
18719            status: local_var_status,
18720            content: local_var_content,
18721            entity: local_var_entity,
18722        };
18723        Err(Error::ResponseError(local_var_error))
18724    }
18725}
netbox_openapi/apis/virtualization_api.rs

netbox_openapi/apis/
virtualization_api.rs
