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.4.2-Docker-3.4.1 (4.4)
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_machines_bulk_destroy`]
332#[derive(Debug, Clone, Serialize, Deserialize)]
333#[serde(untagged)]
334pub enum VirtualizationVirtualMachinesBulkDestroyError {
335    UnknownValue(serde_json::Value),
336}
337
338/// struct for typed errors of method [`virtualization_virtual_machines_bulk_partial_update`]
339#[derive(Debug, Clone, Serialize, Deserialize)]
340#[serde(untagged)]
341pub enum VirtualizationVirtualMachinesBulkPartialUpdateError {
342    UnknownValue(serde_json::Value),
343}
344
345/// struct for typed errors of method [`virtualization_virtual_machines_bulk_update`]
346#[derive(Debug, Clone, Serialize, Deserialize)]
347#[serde(untagged)]
348pub enum VirtualizationVirtualMachinesBulkUpdateError {
349    UnknownValue(serde_json::Value),
350}
351
352/// struct for typed errors of method [`virtualization_virtual_machines_create`]
353#[derive(Debug, Clone, Serialize, Deserialize)]
354#[serde(untagged)]
355pub enum VirtualizationVirtualMachinesCreateError {
356    UnknownValue(serde_json::Value),
357}
358
359/// struct for typed errors of method [`virtualization_virtual_machines_destroy`]
360#[derive(Debug, Clone, Serialize, Deserialize)]
361#[serde(untagged)]
362pub enum VirtualizationVirtualMachinesDestroyError {
363    UnknownValue(serde_json::Value),
364}
365
366/// struct for typed errors of method [`virtualization_virtual_machines_list`]
367#[derive(Debug, Clone, Serialize, Deserialize)]
368#[serde(untagged)]
369pub enum VirtualizationVirtualMachinesListError {
370    UnknownValue(serde_json::Value),
371}
372
373/// struct for typed errors of method [`virtualization_virtual_machines_partial_update`]
374#[derive(Debug, Clone, Serialize, Deserialize)]
375#[serde(untagged)]
376pub enum VirtualizationVirtualMachinesPartialUpdateError {
377    UnknownValue(serde_json::Value),
378}
379
380/// struct for typed errors of method [`virtualization_virtual_machines_render_config_create`]
381#[derive(Debug, Clone, Serialize, Deserialize)]
382#[serde(untagged)]
383pub enum VirtualizationVirtualMachinesRenderConfigCreateError {
384    UnknownValue(serde_json::Value),
385}
386
387/// struct for typed errors of method [`virtualization_virtual_machines_retrieve`]
388#[derive(Debug, Clone, Serialize, Deserialize)]
389#[serde(untagged)]
390pub enum VirtualizationVirtualMachinesRetrieveError {
391    UnknownValue(serde_json::Value),
392}
393
394/// struct for typed errors of method [`virtualization_virtual_machines_update`]
395#[derive(Debug, Clone, Serialize, Deserialize)]
396#[serde(untagged)]
397pub enum VirtualizationVirtualMachinesUpdateError {
398    UnknownValue(serde_json::Value),
399}
400
401/// Delete a list of cluster group objects.
402pub async fn virtualization_cluster_groups_bulk_destroy(
403    configuration: &configuration::Configuration,
404    cluster_group_request: Vec<crate::models::ClusterGroupRequest>,
405) -> Result<(), Error<VirtualizationClusterGroupsBulkDestroyError>> {
406    let local_var_configuration = configuration;
407
408    let local_var_client = &local_var_configuration.client;
409
410    let local_var_uri_str = format!(
411        "{}/api/virtualization/cluster-groups/",
412        local_var_configuration.base_path
413    );
414    let mut local_var_req_builder =
415        local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());
416
417    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
418        local_var_req_builder =
419            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
420    }
421    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
422        let local_var_key = local_var_apikey.key.clone();
423        let local_var_value = match local_var_apikey.prefix {
424            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
425            None => local_var_key,
426        };
427        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
428    };
429    local_var_req_builder = local_var_req_builder.json(&cluster_group_request);
430
431    let local_var_req = local_var_req_builder.build()?;
432    let local_var_resp = local_var_client.execute(local_var_req).await?;
433
434    let local_var_status = local_var_resp.status();
435    let local_var_content = local_var_resp.text().await?;
436
437    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
438        Ok(())
439    } else {
440        let local_var_entity: Option<VirtualizationClusterGroupsBulkDestroyError> =
441            serde_json::from_str(&local_var_content).ok();
442        let local_var_error = ResponseContent {
443            status: local_var_status,
444            content: local_var_content,
445            entity: local_var_entity,
446        };
447        Err(Error::ResponseError(local_var_error))
448    }
449}
450
451/// Patch a list of cluster group objects.
452pub async fn virtualization_cluster_groups_bulk_partial_update(
453    configuration: &configuration::Configuration,
454    cluster_group_request: Vec<crate::models::ClusterGroupRequest>,
455) -> Result<
456    Vec<crate::models::ClusterGroup>,
457    Error<VirtualizationClusterGroupsBulkPartialUpdateError>,
458> {
459    let local_var_configuration = configuration;
460
461    let local_var_client = &local_var_configuration.client;
462
463    let local_var_uri_str = format!(
464        "{}/api/virtualization/cluster-groups/",
465        local_var_configuration.base_path
466    );
467    let mut local_var_req_builder =
468        local_var_client.request(reqwest::Method::PATCH, local_var_uri_str.as_str());
469
470    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
471        local_var_req_builder =
472            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
473    }
474    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
475        let local_var_key = local_var_apikey.key.clone();
476        let local_var_value = match local_var_apikey.prefix {
477            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
478            None => local_var_key,
479        };
480        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
481    };
482    local_var_req_builder = local_var_req_builder.json(&cluster_group_request);
483
484    let local_var_req = local_var_req_builder.build()?;
485    let local_var_resp = local_var_client.execute(local_var_req).await?;
486
487    let local_var_status = local_var_resp.status();
488    let local_var_content = local_var_resp.text().await?;
489
490    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
491        serde_json::from_str(&local_var_content).map_err(Error::from)
492    } else {
493        let local_var_entity: Option<VirtualizationClusterGroupsBulkPartialUpdateError> =
494            serde_json::from_str(&local_var_content).ok();
495        let local_var_error = ResponseContent {
496            status: local_var_status,
497            content: local_var_content,
498            entity: local_var_entity,
499        };
500        Err(Error::ResponseError(local_var_error))
501    }
502}
503
504/// Put a list of cluster group objects.
505pub async fn virtualization_cluster_groups_bulk_update(
506    configuration: &configuration::Configuration,
507    cluster_group_request: Vec<crate::models::ClusterGroupRequest>,
508) -> Result<Vec<crate::models::ClusterGroup>, Error<VirtualizationClusterGroupsBulkUpdateError>> {
509    let local_var_configuration = configuration;
510
511    let local_var_client = &local_var_configuration.client;
512
513    let local_var_uri_str = format!(
514        "{}/api/virtualization/cluster-groups/",
515        local_var_configuration.base_path
516    );
517    let mut local_var_req_builder =
518        local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());
519
520    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
521        local_var_req_builder =
522            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
523    }
524    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
525        let local_var_key = local_var_apikey.key.clone();
526        let local_var_value = match local_var_apikey.prefix {
527            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
528            None => local_var_key,
529        };
530        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
531    };
532    local_var_req_builder = local_var_req_builder.json(&cluster_group_request);
533
534    let local_var_req = local_var_req_builder.build()?;
535    let local_var_resp = local_var_client.execute(local_var_req).await?;
536
537    let local_var_status = local_var_resp.status();
538    let local_var_content = local_var_resp.text().await?;
539
540    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
541        serde_json::from_str(&local_var_content).map_err(Error::from)
542    } else {
543        let local_var_entity: Option<VirtualizationClusterGroupsBulkUpdateError> =
544            serde_json::from_str(&local_var_content).ok();
545        let local_var_error = ResponseContent {
546            status: local_var_status,
547            content: local_var_content,
548            entity: local_var_entity,
549        };
550        Err(Error::ResponseError(local_var_error))
551    }
552}
553
554/// Post a list of cluster group objects.
555pub async fn virtualization_cluster_groups_create(
556    configuration: &configuration::Configuration,
557    cluster_group_request: crate::models::ClusterGroupRequest,
558) -> Result<crate::models::ClusterGroup, Error<VirtualizationClusterGroupsCreateError>> {
559    let local_var_configuration = configuration;
560
561    let local_var_client = &local_var_configuration.client;
562
563    let local_var_uri_str = format!(
564        "{}/api/virtualization/cluster-groups/",
565        local_var_configuration.base_path
566    );
567    let mut local_var_req_builder =
568        local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
569
570    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
571        local_var_req_builder =
572            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
573    }
574    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
575        let local_var_key = local_var_apikey.key.clone();
576        let local_var_value = match local_var_apikey.prefix {
577            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
578            None => local_var_key,
579        };
580        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
581    };
582    local_var_req_builder = local_var_req_builder.json(&cluster_group_request);
583
584    let local_var_req = local_var_req_builder.build()?;
585    let local_var_resp = local_var_client.execute(local_var_req).await?;
586
587    let local_var_status = local_var_resp.status();
588    let local_var_content = local_var_resp.text().await?;
589
590    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
591        serde_json::from_str(&local_var_content).map_err(Error::from)
592    } else {
593        let local_var_entity: Option<VirtualizationClusterGroupsCreateError> =
594            serde_json::from_str(&local_var_content).ok();
595        let local_var_error = ResponseContent {
596            status: local_var_status,
597            content: local_var_content,
598            entity: local_var_entity,
599        };
600        Err(Error::ResponseError(local_var_error))
601    }
602}
603
604/// Delete a cluster group object.
605pub async fn virtualization_cluster_groups_destroy(
606    configuration: &configuration::Configuration,
607    id: i32,
608) -> Result<(), Error<VirtualizationClusterGroupsDestroyError>> {
609    let local_var_configuration = configuration;
610
611    let local_var_client = &local_var_configuration.client;
612
613    let local_var_uri_str = format!(
614        "{}/api/virtualization/cluster-groups/{id}/",
615        local_var_configuration.base_path,
616        id = id
617    );
618    let mut local_var_req_builder =
619        local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());
620
621    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
622        local_var_req_builder =
623            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
624    }
625    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
626        let local_var_key = local_var_apikey.key.clone();
627        let local_var_value = match local_var_apikey.prefix {
628            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
629            None => local_var_key,
630        };
631        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
632    };
633
634    let local_var_req = local_var_req_builder.build()?;
635    let local_var_resp = local_var_client.execute(local_var_req).await?;
636
637    let local_var_status = local_var_resp.status();
638    let local_var_content = local_var_resp.text().await?;
639
640    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
641        Ok(())
642    } else {
643        let local_var_entity: Option<VirtualizationClusterGroupsDestroyError> =
644            serde_json::from_str(&local_var_content).ok();
645        let local_var_error = ResponseContent {
646            status: local_var_status,
647            content: local_var_content,
648            entity: local_var_entity,
649        };
650        Err(Error::ResponseError(local_var_error))
651    }
652}
653
654/// Get a list of cluster group objects.
655pub async fn virtualization_cluster_groups_list(
656    configuration: &configuration::Configuration,
657    contact: Option<Vec<i32>>,
658    contact__n: Option<Vec<i32>>,
659    contact_group: Option<Vec<String>>,
660    contact_group__n: Option<Vec<String>>,
661    contact_role: Option<Vec<i32>>,
662    contact_role__n: Option<Vec<i32>>,
663    created: Option<Vec<String>>,
664    created__empty: Option<Vec<String>>,
665    created__gt: Option<Vec<String>>,
666    created__gte: Option<Vec<String>>,
667    created__lt: Option<Vec<String>>,
668    created__lte: Option<Vec<String>>,
669    created__n: Option<Vec<String>>,
670    created_by_request: Option<&str>,
671    description: Option<Vec<String>>,
672    description__empty: Option<bool>,
673    description__ic: Option<Vec<String>>,
674    description__ie: Option<Vec<String>>,
675    description__iew: Option<Vec<String>>,
676    description__iregex: Option<Vec<String>>,
677    description__isw: Option<Vec<String>>,
678    description__n: Option<Vec<String>>,
679    description__nic: Option<Vec<String>>,
680    description__nie: Option<Vec<String>>,
681    description__niew: Option<Vec<String>>,
682    description__nisw: Option<Vec<String>>,
683    description__regex: Option<Vec<String>>,
684    id: Option<Vec<i32>>,
685    id__empty: Option<bool>,
686    id__gt: Option<Vec<i32>>,
687    id__gte: Option<Vec<i32>>,
688    id__lt: Option<Vec<i32>>,
689    id__lte: Option<Vec<i32>>,
690    id__n: Option<Vec<i32>>,
691    last_updated: Option<Vec<String>>,
692    last_updated__empty: Option<Vec<String>>,
693    last_updated__gt: Option<Vec<String>>,
694    last_updated__gte: Option<Vec<String>>,
695    last_updated__lt: Option<Vec<String>>,
696    last_updated__lte: Option<Vec<String>>,
697    last_updated__n: Option<Vec<String>>,
698    limit: Option<i32>,
699    modified_by_request: Option<&str>,
700    name: Option<Vec<String>>,
701    name__empty: Option<bool>,
702    name__ic: Option<Vec<String>>,
703    name__ie: Option<Vec<String>>,
704    name__iew: Option<Vec<String>>,
705    name__iregex: Option<Vec<String>>,
706    name__isw: Option<Vec<String>>,
707    name__n: Option<Vec<String>>,
708    name__nic: Option<Vec<String>>,
709    name__nie: Option<Vec<String>>,
710    name__niew: Option<Vec<String>>,
711    name__nisw: Option<Vec<String>>,
712    name__regex: Option<Vec<String>>,
713    offset: Option<i32>,
714    ordering: Option<&str>,
715    q: Option<&str>,
716    slug: Option<Vec<String>>,
717    slug__empty: Option<bool>,
718    slug__ic: Option<Vec<String>>,
719    slug__ie: Option<Vec<String>>,
720    slug__iew: Option<Vec<String>>,
721    slug__iregex: Option<Vec<String>>,
722    slug__isw: Option<Vec<String>>,
723    slug__n: Option<Vec<String>>,
724    slug__nic: Option<Vec<String>>,
725    slug__nie: Option<Vec<String>>,
726    slug__niew: Option<Vec<String>>,
727    slug__nisw: Option<Vec<String>>,
728    slug__regex: Option<Vec<String>>,
729    tag: Option<Vec<String>>,
730    tag__n: Option<Vec<String>>,
731    tag_id: Option<Vec<i32>>,
732    tag_id__n: Option<Vec<i32>>,
733    updated_by_request: Option<&str>,
734) -> Result<crate::models::PaginatedClusterGroupList, Error<VirtualizationClusterGroupsListError>> {
735    let local_var_configuration = configuration;
736
737    let local_var_client = &local_var_configuration.client;
738
739    let local_var_uri_str = format!(
740        "{}/api/virtualization/cluster-groups/",
741        local_var_configuration.base_path
742    );
743    let mut local_var_req_builder =
744        local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
745
746    if let Some(ref local_var_str) = contact {
747        local_var_req_builder = match "multi" {
748            "multi" => local_var_req_builder.query(
749                &local_var_str
750                    .into_iter()
751                    .map(|p| ("contact".to_owned(), p.to_string()))
752                    .collect::<Vec<(std::string::String, std::string::String)>>(),
753            ),
754            _ => local_var_req_builder.query(&[(
755                "contact",
756                &local_var_str
757                    .into_iter()
758                    .map(|p| p.to_string())
759                    .collect::<Vec<String>>()
760                    .join(",")
761                    .to_string(),
762            )]),
763        };
764    }
765    if let Some(ref local_var_str) = contact__n {
766        local_var_req_builder = match "multi" {
767            "multi" => local_var_req_builder.query(
768                &local_var_str
769                    .into_iter()
770                    .map(|p| ("contact__n".to_owned(), p.to_string()))
771                    .collect::<Vec<(std::string::String, std::string::String)>>(),
772            ),
773            _ => local_var_req_builder.query(&[(
774                "contact__n",
775                &local_var_str
776                    .into_iter()
777                    .map(|p| p.to_string())
778                    .collect::<Vec<String>>()
779                    .join(",")
780                    .to_string(),
781            )]),
782        };
783    }
784    if let Some(ref local_var_str) = contact_group {
785        local_var_req_builder = match "multi" {
786            "multi" => local_var_req_builder.query(
787                &local_var_str
788                    .into_iter()
789                    .map(|p| ("contact_group".to_owned(), p.to_string()))
790                    .collect::<Vec<(std::string::String, std::string::String)>>(),
791            ),
792            _ => local_var_req_builder.query(&[(
793                "contact_group",
794                &local_var_str
795                    .into_iter()
796                    .map(|p| p.to_string())
797                    .collect::<Vec<String>>()
798                    .join(",")
799                    .to_string(),
800            )]),
801        };
802    }
803    if let Some(ref local_var_str) = contact_group__n {
804        local_var_req_builder = match "multi" {
805            "multi" => local_var_req_builder.query(
806                &local_var_str
807                    .into_iter()
808                    .map(|p| ("contact_group__n".to_owned(), p.to_string()))
809                    .collect::<Vec<(std::string::String, std::string::String)>>(),
810            ),
811            _ => local_var_req_builder.query(&[(
812                "contact_group__n",
813                &local_var_str
814                    .into_iter()
815                    .map(|p| p.to_string())
816                    .collect::<Vec<String>>()
817                    .join(",")
818                    .to_string(),
819            )]),
820        };
821    }
822    if let Some(ref local_var_str) = contact_role {
823        local_var_req_builder = match "multi" {
824            "multi" => local_var_req_builder.query(
825                &local_var_str
826                    .into_iter()
827                    .map(|p| ("contact_role".to_owned(), p.to_string()))
828                    .collect::<Vec<(std::string::String, std::string::String)>>(),
829            ),
830            _ => local_var_req_builder.query(&[(
831                "contact_role",
832                &local_var_str
833                    .into_iter()
834                    .map(|p| p.to_string())
835                    .collect::<Vec<String>>()
836                    .join(",")
837                    .to_string(),
838            )]),
839        };
840    }
841    if let Some(ref local_var_str) = contact_role__n {
842        local_var_req_builder = match "multi" {
843            "multi" => local_var_req_builder.query(
844                &local_var_str
845                    .into_iter()
846                    .map(|p| ("contact_role__n".to_owned(), p.to_string()))
847                    .collect::<Vec<(std::string::String, std::string::String)>>(),
848            ),
849            _ => local_var_req_builder.query(&[(
850                "contact_role__n",
851                &local_var_str
852                    .into_iter()
853                    .map(|p| p.to_string())
854                    .collect::<Vec<String>>()
855                    .join(",")
856                    .to_string(),
857            )]),
858        };
859    }
860    if let Some(ref local_var_str) = created {
861        local_var_req_builder = match "multi" {
862            "multi" => local_var_req_builder.query(
863                &local_var_str
864                    .into_iter()
865                    .map(|p| ("created".to_owned(), p.to_string()))
866                    .collect::<Vec<(std::string::String, std::string::String)>>(),
867            ),
868            _ => local_var_req_builder.query(&[(
869                "created",
870                &local_var_str
871                    .into_iter()
872                    .map(|p| p.to_string())
873                    .collect::<Vec<String>>()
874                    .join(",")
875                    .to_string(),
876            )]),
877        };
878    }
879    if let Some(ref local_var_str) = created__empty {
880        local_var_req_builder = match "multi" {
881            "multi" => local_var_req_builder.query(
882                &local_var_str
883                    .into_iter()
884                    .map(|p| ("created__empty".to_owned(), p.to_string()))
885                    .collect::<Vec<(std::string::String, std::string::String)>>(),
886            ),
887            _ => local_var_req_builder.query(&[(
888                "created__empty",
889                &local_var_str
890                    .into_iter()
891                    .map(|p| p.to_string())
892                    .collect::<Vec<String>>()
893                    .join(",")
894                    .to_string(),
895            )]),
896        };
897    }
898    if let Some(ref local_var_str) = created__gt {
899        local_var_req_builder = match "multi" {
900            "multi" => local_var_req_builder.query(
901                &local_var_str
902                    .into_iter()
903                    .map(|p| ("created__gt".to_owned(), p.to_string()))
904                    .collect::<Vec<(std::string::String, std::string::String)>>(),
905            ),
906            _ => local_var_req_builder.query(&[(
907                "created__gt",
908                &local_var_str
909                    .into_iter()
910                    .map(|p| p.to_string())
911                    .collect::<Vec<String>>()
912                    .join(",")
913                    .to_string(),
914            )]),
915        };
916    }
917    if let Some(ref local_var_str) = created__gte {
918        local_var_req_builder = match "multi" {
919            "multi" => local_var_req_builder.query(
920                &local_var_str
921                    .into_iter()
922                    .map(|p| ("created__gte".to_owned(), p.to_string()))
923                    .collect::<Vec<(std::string::String, std::string::String)>>(),
924            ),
925            _ => local_var_req_builder.query(&[(
926                "created__gte",
927                &local_var_str
928                    .into_iter()
929                    .map(|p| p.to_string())
930                    .collect::<Vec<String>>()
931                    .join(",")
932                    .to_string(),
933            )]),
934        };
935    }
936    if let Some(ref local_var_str) = created__lt {
937        local_var_req_builder = match "multi" {
938            "multi" => local_var_req_builder.query(
939                &local_var_str
940                    .into_iter()
941                    .map(|p| ("created__lt".to_owned(), p.to_string()))
942                    .collect::<Vec<(std::string::String, std::string::String)>>(),
943            ),
944            _ => local_var_req_builder.query(&[(
945                "created__lt",
946                &local_var_str
947                    .into_iter()
948                    .map(|p| p.to_string())
949                    .collect::<Vec<String>>()
950                    .join(",")
951                    .to_string(),
952            )]),
953        };
954    }
955    if let Some(ref local_var_str) = created__lte {
956        local_var_req_builder = match "multi" {
957            "multi" => local_var_req_builder.query(
958                &local_var_str
959                    .into_iter()
960                    .map(|p| ("created__lte".to_owned(), p.to_string()))
961                    .collect::<Vec<(std::string::String, std::string::String)>>(),
962            ),
963            _ => local_var_req_builder.query(&[(
964                "created__lte",
965                &local_var_str
966                    .into_iter()
967                    .map(|p| p.to_string())
968                    .collect::<Vec<String>>()
969                    .join(",")
970                    .to_string(),
971            )]),
972        };
973    }
974    if let Some(ref local_var_str) = created__n {
975        local_var_req_builder = match "multi" {
976            "multi" => local_var_req_builder.query(
977                &local_var_str
978                    .into_iter()
979                    .map(|p| ("created__n".to_owned(), p.to_string()))
980                    .collect::<Vec<(std::string::String, std::string::String)>>(),
981            ),
982            _ => local_var_req_builder.query(&[(
983                "created__n",
984                &local_var_str
985                    .into_iter()
986                    .map(|p| p.to_string())
987                    .collect::<Vec<String>>()
988                    .join(",")
989                    .to_string(),
990            )]),
991        };
992    }
993    if let Some(ref local_var_str) = created_by_request {
994        local_var_req_builder =
995            local_var_req_builder.query(&[("created_by_request", &local_var_str.to_string())]);
996    }
997    if let Some(ref local_var_str) = description {
998        local_var_req_builder = match "multi" {
999            "multi" => local_var_req_builder.query(
1000                &local_var_str
1001                    .into_iter()
1002                    .map(|p| ("description".to_owned(), p.to_string()))
1003                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1004            ),
1005            _ => local_var_req_builder.query(&[(
1006                "description",
1007                &local_var_str
1008                    .into_iter()
1009                    .map(|p| p.to_string())
1010                    .collect::<Vec<String>>()
1011                    .join(",")
1012                    .to_string(),
1013            )]),
1014        };
1015    }
1016    if let Some(ref local_var_str) = description__empty {
1017        local_var_req_builder =
1018            local_var_req_builder.query(&[("description__empty", &local_var_str.to_string())]);
1019    }
1020    if let Some(ref local_var_str) = description__ic {
1021        local_var_req_builder = match "multi" {
1022            "multi" => local_var_req_builder.query(
1023                &local_var_str
1024                    .into_iter()
1025                    .map(|p| ("description__ic".to_owned(), p.to_string()))
1026                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1027            ),
1028            _ => local_var_req_builder.query(&[(
1029                "description__ic",
1030                &local_var_str
1031                    .into_iter()
1032                    .map(|p| p.to_string())
1033                    .collect::<Vec<String>>()
1034                    .join(",")
1035                    .to_string(),
1036            )]),
1037        };
1038    }
1039    if let Some(ref local_var_str) = description__ie {
1040        local_var_req_builder = match "multi" {
1041            "multi" => local_var_req_builder.query(
1042                &local_var_str
1043                    .into_iter()
1044                    .map(|p| ("description__ie".to_owned(), p.to_string()))
1045                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1046            ),
1047            _ => local_var_req_builder.query(&[(
1048                "description__ie",
1049                &local_var_str
1050                    .into_iter()
1051                    .map(|p| p.to_string())
1052                    .collect::<Vec<String>>()
1053                    .join(",")
1054                    .to_string(),
1055            )]),
1056        };
1057    }
1058    if let Some(ref local_var_str) = description__iew {
1059        local_var_req_builder = match "multi" {
1060            "multi" => local_var_req_builder.query(
1061                &local_var_str
1062                    .into_iter()
1063                    .map(|p| ("description__iew".to_owned(), p.to_string()))
1064                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1065            ),
1066            _ => local_var_req_builder.query(&[(
1067                "description__iew",
1068                &local_var_str
1069                    .into_iter()
1070                    .map(|p| p.to_string())
1071                    .collect::<Vec<String>>()
1072                    .join(",")
1073                    .to_string(),
1074            )]),
1075        };
1076    }
1077    if let Some(ref local_var_str) = description__iregex {
1078        local_var_req_builder = match "multi" {
1079            "multi" => local_var_req_builder.query(
1080                &local_var_str
1081                    .into_iter()
1082                    .map(|p| ("description__iregex".to_owned(), p.to_string()))
1083                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1084            ),
1085            _ => local_var_req_builder.query(&[(
1086                "description__iregex",
1087                &local_var_str
1088                    .into_iter()
1089                    .map(|p| p.to_string())
1090                    .collect::<Vec<String>>()
1091                    .join(",")
1092                    .to_string(),
1093            )]),
1094        };
1095    }
1096    if let Some(ref local_var_str) = description__isw {
1097        local_var_req_builder = match "multi" {
1098            "multi" => local_var_req_builder.query(
1099                &local_var_str
1100                    .into_iter()
1101                    .map(|p| ("description__isw".to_owned(), p.to_string()))
1102                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1103            ),
1104            _ => local_var_req_builder.query(&[(
1105                "description__isw",
1106                &local_var_str
1107                    .into_iter()
1108                    .map(|p| p.to_string())
1109                    .collect::<Vec<String>>()
1110                    .join(",")
1111                    .to_string(),
1112            )]),
1113        };
1114    }
1115    if let Some(ref local_var_str) = description__n {
1116        local_var_req_builder = match "multi" {
1117            "multi" => local_var_req_builder.query(
1118                &local_var_str
1119                    .into_iter()
1120                    .map(|p| ("description__n".to_owned(), p.to_string()))
1121                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1122            ),
1123            _ => local_var_req_builder.query(&[(
1124                "description__n",
1125                &local_var_str
1126                    .into_iter()
1127                    .map(|p| p.to_string())
1128                    .collect::<Vec<String>>()
1129                    .join(",")
1130                    .to_string(),
1131            )]),
1132        };
1133    }
1134    if let Some(ref local_var_str) = description__nic {
1135        local_var_req_builder = match "multi" {
1136            "multi" => local_var_req_builder.query(
1137                &local_var_str
1138                    .into_iter()
1139                    .map(|p| ("description__nic".to_owned(), p.to_string()))
1140                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1141            ),
1142            _ => local_var_req_builder.query(&[(
1143                "description__nic",
1144                &local_var_str
1145                    .into_iter()
1146                    .map(|p| p.to_string())
1147                    .collect::<Vec<String>>()
1148                    .join(",")
1149                    .to_string(),
1150            )]),
1151        };
1152    }
1153    if let Some(ref local_var_str) = description__nie {
1154        local_var_req_builder = match "multi" {
1155            "multi" => local_var_req_builder.query(
1156                &local_var_str
1157                    .into_iter()
1158                    .map(|p| ("description__nie".to_owned(), p.to_string()))
1159                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1160            ),
1161            _ => local_var_req_builder.query(&[(
1162                "description__nie",
1163                &local_var_str
1164                    .into_iter()
1165                    .map(|p| p.to_string())
1166                    .collect::<Vec<String>>()
1167                    .join(",")
1168                    .to_string(),
1169            )]),
1170        };
1171    }
1172    if let Some(ref local_var_str) = description__niew {
1173        local_var_req_builder = match "multi" {
1174            "multi" => local_var_req_builder.query(
1175                &local_var_str
1176                    .into_iter()
1177                    .map(|p| ("description__niew".to_owned(), p.to_string()))
1178                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1179            ),
1180            _ => local_var_req_builder.query(&[(
1181                "description__niew",
1182                &local_var_str
1183                    .into_iter()
1184                    .map(|p| p.to_string())
1185                    .collect::<Vec<String>>()
1186                    .join(",")
1187                    .to_string(),
1188            )]),
1189        };
1190    }
1191    if let Some(ref local_var_str) = description__nisw {
1192        local_var_req_builder = match "multi" {
1193            "multi" => local_var_req_builder.query(
1194                &local_var_str
1195                    .into_iter()
1196                    .map(|p| ("description__nisw".to_owned(), p.to_string()))
1197                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1198            ),
1199            _ => local_var_req_builder.query(&[(
1200                "description__nisw",
1201                &local_var_str
1202                    .into_iter()
1203                    .map(|p| p.to_string())
1204                    .collect::<Vec<String>>()
1205                    .join(",")
1206                    .to_string(),
1207            )]),
1208        };
1209    }
1210    if let Some(ref local_var_str) = description__regex {
1211        local_var_req_builder = match "multi" {
1212            "multi" => local_var_req_builder.query(
1213                &local_var_str
1214                    .into_iter()
1215                    .map(|p| ("description__regex".to_owned(), p.to_string()))
1216                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1217            ),
1218            _ => local_var_req_builder.query(&[(
1219                "description__regex",
1220                &local_var_str
1221                    .into_iter()
1222                    .map(|p| p.to_string())
1223                    .collect::<Vec<String>>()
1224                    .join(",")
1225                    .to_string(),
1226            )]),
1227        };
1228    }
1229    if let Some(ref local_var_str) = id {
1230        local_var_req_builder = match "multi" {
1231            "multi" => local_var_req_builder.query(
1232                &local_var_str
1233                    .into_iter()
1234                    .map(|p| ("id".to_owned(), p.to_string()))
1235                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1236            ),
1237            _ => local_var_req_builder.query(&[(
1238                "id",
1239                &local_var_str
1240                    .into_iter()
1241                    .map(|p| p.to_string())
1242                    .collect::<Vec<String>>()
1243                    .join(",")
1244                    .to_string(),
1245            )]),
1246        };
1247    }
1248    if let Some(ref local_var_str) = id__empty {
1249        local_var_req_builder =
1250            local_var_req_builder.query(&[("id__empty", &local_var_str.to_string())]);
1251    }
1252    if let Some(ref local_var_str) = id__gt {
1253        local_var_req_builder = match "multi" {
1254            "multi" => local_var_req_builder.query(
1255                &local_var_str
1256                    .into_iter()
1257                    .map(|p| ("id__gt".to_owned(), p.to_string()))
1258                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1259            ),
1260            _ => local_var_req_builder.query(&[(
1261                "id__gt",
1262                &local_var_str
1263                    .into_iter()
1264                    .map(|p| p.to_string())
1265                    .collect::<Vec<String>>()
1266                    .join(",")
1267                    .to_string(),
1268            )]),
1269        };
1270    }
1271    if let Some(ref local_var_str) = id__gte {
1272        local_var_req_builder = match "multi" {
1273            "multi" => local_var_req_builder.query(
1274                &local_var_str
1275                    .into_iter()
1276                    .map(|p| ("id__gte".to_owned(), p.to_string()))
1277                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1278            ),
1279            _ => local_var_req_builder.query(&[(
1280                "id__gte",
1281                &local_var_str
1282                    .into_iter()
1283                    .map(|p| p.to_string())
1284                    .collect::<Vec<String>>()
1285                    .join(",")
1286                    .to_string(),
1287            )]),
1288        };
1289    }
1290    if let Some(ref local_var_str) = id__lt {
1291        local_var_req_builder = match "multi" {
1292            "multi" => local_var_req_builder.query(
1293                &local_var_str
1294                    .into_iter()
1295                    .map(|p| ("id__lt".to_owned(), p.to_string()))
1296                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1297            ),
1298            _ => local_var_req_builder.query(&[(
1299                "id__lt",
1300                &local_var_str
1301                    .into_iter()
1302                    .map(|p| p.to_string())
1303                    .collect::<Vec<String>>()
1304                    .join(",")
1305                    .to_string(),
1306            )]),
1307        };
1308    }
1309    if let Some(ref local_var_str) = id__lte {
1310        local_var_req_builder = match "multi" {
1311            "multi" => local_var_req_builder.query(
1312                &local_var_str
1313                    .into_iter()
1314                    .map(|p| ("id__lte".to_owned(), p.to_string()))
1315                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1316            ),
1317            _ => local_var_req_builder.query(&[(
1318                "id__lte",
1319                &local_var_str
1320                    .into_iter()
1321                    .map(|p| p.to_string())
1322                    .collect::<Vec<String>>()
1323                    .join(",")
1324                    .to_string(),
1325            )]),
1326        };
1327    }
1328    if let Some(ref local_var_str) = id__n {
1329        local_var_req_builder = match "multi" {
1330            "multi" => local_var_req_builder.query(
1331                &local_var_str
1332                    .into_iter()
1333                    .map(|p| ("id__n".to_owned(), p.to_string()))
1334                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1335            ),
1336            _ => local_var_req_builder.query(&[(
1337                "id__n",
1338                &local_var_str
1339                    .into_iter()
1340                    .map(|p| p.to_string())
1341                    .collect::<Vec<String>>()
1342                    .join(",")
1343                    .to_string(),
1344            )]),
1345        };
1346    }
1347    if let Some(ref local_var_str) = last_updated {
1348        local_var_req_builder = match "multi" {
1349            "multi" => local_var_req_builder.query(
1350                &local_var_str
1351                    .into_iter()
1352                    .map(|p| ("last_updated".to_owned(), p.to_string()))
1353                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1354            ),
1355            _ => local_var_req_builder.query(&[(
1356                "last_updated",
1357                &local_var_str
1358                    .into_iter()
1359                    .map(|p| p.to_string())
1360                    .collect::<Vec<String>>()
1361                    .join(",")
1362                    .to_string(),
1363            )]),
1364        };
1365    }
1366    if let Some(ref local_var_str) = last_updated__empty {
1367        local_var_req_builder = match "multi" {
1368            "multi" => local_var_req_builder.query(
1369                &local_var_str
1370                    .into_iter()
1371                    .map(|p| ("last_updated__empty".to_owned(), p.to_string()))
1372                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1373            ),
1374            _ => local_var_req_builder.query(&[(
1375                "last_updated__empty",
1376                &local_var_str
1377                    .into_iter()
1378                    .map(|p| p.to_string())
1379                    .collect::<Vec<String>>()
1380                    .join(",")
1381                    .to_string(),
1382            )]),
1383        };
1384    }
1385    if let Some(ref local_var_str) = last_updated__gt {
1386        local_var_req_builder = match "multi" {
1387            "multi" => local_var_req_builder.query(
1388                &local_var_str
1389                    .into_iter()
1390                    .map(|p| ("last_updated__gt".to_owned(), p.to_string()))
1391                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1392            ),
1393            _ => local_var_req_builder.query(&[(
1394                "last_updated__gt",
1395                &local_var_str
1396                    .into_iter()
1397                    .map(|p| p.to_string())
1398                    .collect::<Vec<String>>()
1399                    .join(",")
1400                    .to_string(),
1401            )]),
1402        };
1403    }
1404    if let Some(ref local_var_str) = last_updated__gte {
1405        local_var_req_builder = match "multi" {
1406            "multi" => local_var_req_builder.query(
1407                &local_var_str
1408                    .into_iter()
1409                    .map(|p| ("last_updated__gte".to_owned(), p.to_string()))
1410                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1411            ),
1412            _ => local_var_req_builder.query(&[(
1413                "last_updated__gte",
1414                &local_var_str
1415                    .into_iter()
1416                    .map(|p| p.to_string())
1417                    .collect::<Vec<String>>()
1418                    .join(",")
1419                    .to_string(),
1420            )]),
1421        };
1422    }
1423    if let Some(ref local_var_str) = last_updated__lt {
1424        local_var_req_builder = match "multi" {
1425            "multi" => local_var_req_builder.query(
1426                &local_var_str
1427                    .into_iter()
1428                    .map(|p| ("last_updated__lt".to_owned(), p.to_string()))
1429                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1430            ),
1431            _ => local_var_req_builder.query(&[(
1432                "last_updated__lt",
1433                &local_var_str
1434                    .into_iter()
1435                    .map(|p| p.to_string())
1436                    .collect::<Vec<String>>()
1437                    .join(",")
1438                    .to_string(),
1439            )]),
1440        };
1441    }
1442    if let Some(ref local_var_str) = last_updated__lte {
1443        local_var_req_builder = match "multi" {
1444            "multi" => local_var_req_builder.query(
1445                &local_var_str
1446                    .into_iter()
1447                    .map(|p| ("last_updated__lte".to_owned(), p.to_string()))
1448                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1449            ),
1450            _ => local_var_req_builder.query(&[(
1451                "last_updated__lte",
1452                &local_var_str
1453                    .into_iter()
1454                    .map(|p| p.to_string())
1455                    .collect::<Vec<String>>()
1456                    .join(",")
1457                    .to_string(),
1458            )]),
1459        };
1460    }
1461    if let Some(ref local_var_str) = last_updated__n {
1462        local_var_req_builder = match "multi" {
1463            "multi" => local_var_req_builder.query(
1464                &local_var_str
1465                    .into_iter()
1466                    .map(|p| ("last_updated__n".to_owned(), p.to_string()))
1467                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1468            ),
1469            _ => local_var_req_builder.query(&[(
1470                "last_updated__n",
1471                &local_var_str
1472                    .into_iter()
1473                    .map(|p| p.to_string())
1474                    .collect::<Vec<String>>()
1475                    .join(",")
1476                    .to_string(),
1477            )]),
1478        };
1479    }
1480    if let Some(ref local_var_str) = limit {
1481        local_var_req_builder =
1482            local_var_req_builder.query(&[("limit", &local_var_str.to_string())]);
1483    }
1484    if let Some(ref local_var_str) = modified_by_request {
1485        local_var_req_builder =
1486            local_var_req_builder.query(&[("modified_by_request", &local_var_str.to_string())]);
1487    }
1488    if let Some(ref local_var_str) = name {
1489        local_var_req_builder = match "multi" {
1490            "multi" => local_var_req_builder.query(
1491                &local_var_str
1492                    .into_iter()
1493                    .map(|p| ("name".to_owned(), p.to_string()))
1494                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1495            ),
1496            _ => local_var_req_builder.query(&[(
1497                "name",
1498                &local_var_str
1499                    .into_iter()
1500                    .map(|p| p.to_string())
1501                    .collect::<Vec<String>>()
1502                    .join(",")
1503                    .to_string(),
1504            )]),
1505        };
1506    }
1507    if let Some(ref local_var_str) = name__empty {
1508        local_var_req_builder =
1509            local_var_req_builder.query(&[("name__empty", &local_var_str.to_string())]);
1510    }
1511    if let Some(ref local_var_str) = name__ic {
1512        local_var_req_builder = match "multi" {
1513            "multi" => local_var_req_builder.query(
1514                &local_var_str
1515                    .into_iter()
1516                    .map(|p| ("name__ic".to_owned(), p.to_string()))
1517                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1518            ),
1519            _ => local_var_req_builder.query(&[(
1520                "name__ic",
1521                &local_var_str
1522                    .into_iter()
1523                    .map(|p| p.to_string())
1524                    .collect::<Vec<String>>()
1525                    .join(",")
1526                    .to_string(),
1527            )]),
1528        };
1529    }
1530    if let Some(ref local_var_str) = name__ie {
1531        local_var_req_builder = match "multi" {
1532            "multi" => local_var_req_builder.query(
1533                &local_var_str
1534                    .into_iter()
1535                    .map(|p| ("name__ie".to_owned(), p.to_string()))
1536                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1537            ),
1538            _ => local_var_req_builder.query(&[(
1539                "name__ie",
1540                &local_var_str
1541                    .into_iter()
1542                    .map(|p| p.to_string())
1543                    .collect::<Vec<String>>()
1544                    .join(",")
1545                    .to_string(),
1546            )]),
1547        };
1548    }
1549    if let Some(ref local_var_str) = name__iew {
1550        local_var_req_builder = match "multi" {
1551            "multi" => local_var_req_builder.query(
1552                &local_var_str
1553                    .into_iter()
1554                    .map(|p| ("name__iew".to_owned(), p.to_string()))
1555                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1556            ),
1557            _ => local_var_req_builder.query(&[(
1558                "name__iew",
1559                &local_var_str
1560                    .into_iter()
1561                    .map(|p| p.to_string())
1562                    .collect::<Vec<String>>()
1563                    .join(",")
1564                    .to_string(),
1565            )]),
1566        };
1567    }
1568    if let Some(ref local_var_str) = name__iregex {
1569        local_var_req_builder = match "multi" {
1570            "multi" => local_var_req_builder.query(
1571                &local_var_str
1572                    .into_iter()
1573                    .map(|p| ("name__iregex".to_owned(), p.to_string()))
1574                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1575            ),
1576            _ => local_var_req_builder.query(&[(
1577                "name__iregex",
1578                &local_var_str
1579                    .into_iter()
1580                    .map(|p| p.to_string())
1581                    .collect::<Vec<String>>()
1582                    .join(",")
1583                    .to_string(),
1584            )]),
1585        };
1586    }
1587    if let Some(ref local_var_str) = name__isw {
1588        local_var_req_builder = match "multi" {
1589            "multi" => local_var_req_builder.query(
1590                &local_var_str
1591                    .into_iter()
1592                    .map(|p| ("name__isw".to_owned(), p.to_string()))
1593                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1594            ),
1595            _ => local_var_req_builder.query(&[(
1596                "name__isw",
1597                &local_var_str
1598                    .into_iter()
1599                    .map(|p| p.to_string())
1600                    .collect::<Vec<String>>()
1601                    .join(",")
1602                    .to_string(),
1603            )]),
1604        };
1605    }
1606    if let Some(ref local_var_str) = name__n {
1607        local_var_req_builder = match "multi" {
1608            "multi" => local_var_req_builder.query(
1609                &local_var_str
1610                    .into_iter()
1611                    .map(|p| ("name__n".to_owned(), p.to_string()))
1612                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1613            ),
1614            _ => local_var_req_builder.query(&[(
1615                "name__n",
1616                &local_var_str
1617                    .into_iter()
1618                    .map(|p| p.to_string())
1619                    .collect::<Vec<String>>()
1620                    .join(",")
1621                    .to_string(),
1622            )]),
1623        };
1624    }
1625    if let Some(ref local_var_str) = name__nic {
1626        local_var_req_builder = match "multi" {
1627            "multi" => local_var_req_builder.query(
1628                &local_var_str
1629                    .into_iter()
1630                    .map(|p| ("name__nic".to_owned(), p.to_string()))
1631                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1632            ),
1633            _ => local_var_req_builder.query(&[(
1634                "name__nic",
1635                &local_var_str
1636                    .into_iter()
1637                    .map(|p| p.to_string())
1638                    .collect::<Vec<String>>()
1639                    .join(",")
1640                    .to_string(),
1641            )]),
1642        };
1643    }
1644    if let Some(ref local_var_str) = name__nie {
1645        local_var_req_builder = match "multi" {
1646            "multi" => local_var_req_builder.query(
1647                &local_var_str
1648                    .into_iter()
1649                    .map(|p| ("name__nie".to_owned(), p.to_string()))
1650                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1651            ),
1652            _ => local_var_req_builder.query(&[(
1653                "name__nie",
1654                &local_var_str
1655                    .into_iter()
1656                    .map(|p| p.to_string())
1657                    .collect::<Vec<String>>()
1658                    .join(",")
1659                    .to_string(),
1660            )]),
1661        };
1662    }
1663    if let Some(ref local_var_str) = name__niew {
1664        local_var_req_builder = match "multi" {
1665            "multi" => local_var_req_builder.query(
1666                &local_var_str
1667                    .into_iter()
1668                    .map(|p| ("name__niew".to_owned(), p.to_string()))
1669                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1670            ),
1671            _ => local_var_req_builder.query(&[(
1672                "name__niew",
1673                &local_var_str
1674                    .into_iter()
1675                    .map(|p| p.to_string())
1676                    .collect::<Vec<String>>()
1677                    .join(",")
1678                    .to_string(),
1679            )]),
1680        };
1681    }
1682    if let Some(ref local_var_str) = name__nisw {
1683        local_var_req_builder = match "multi" {
1684            "multi" => local_var_req_builder.query(
1685                &local_var_str
1686                    .into_iter()
1687                    .map(|p| ("name__nisw".to_owned(), p.to_string()))
1688                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1689            ),
1690            _ => local_var_req_builder.query(&[(
1691                "name__nisw",
1692                &local_var_str
1693                    .into_iter()
1694                    .map(|p| p.to_string())
1695                    .collect::<Vec<String>>()
1696                    .join(",")
1697                    .to_string(),
1698            )]),
1699        };
1700    }
1701    if let Some(ref local_var_str) = name__regex {
1702        local_var_req_builder = match "multi" {
1703            "multi" => local_var_req_builder.query(
1704                &local_var_str
1705                    .into_iter()
1706                    .map(|p| ("name__regex".to_owned(), p.to_string()))
1707                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1708            ),
1709            _ => local_var_req_builder.query(&[(
1710                "name__regex",
1711                &local_var_str
1712                    .into_iter()
1713                    .map(|p| p.to_string())
1714                    .collect::<Vec<String>>()
1715                    .join(",")
1716                    .to_string(),
1717            )]),
1718        };
1719    }
1720    if let Some(ref local_var_str) = offset {
1721        local_var_req_builder =
1722            local_var_req_builder.query(&[("offset", &local_var_str.to_string())]);
1723    }
1724    if let Some(ref local_var_str) = ordering {
1725        local_var_req_builder =
1726            local_var_req_builder.query(&[("ordering", &local_var_str.to_string())]);
1727    }
1728    if let Some(ref local_var_str) = q {
1729        local_var_req_builder = local_var_req_builder.query(&[("q", &local_var_str.to_string())]);
1730    }
1731    if let Some(ref local_var_str) = slug {
1732        local_var_req_builder = match "multi" {
1733            "multi" => local_var_req_builder.query(
1734                &local_var_str
1735                    .into_iter()
1736                    .map(|p| ("slug".to_owned(), p.to_string()))
1737                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1738            ),
1739            _ => local_var_req_builder.query(&[(
1740                "slug",
1741                &local_var_str
1742                    .into_iter()
1743                    .map(|p| p.to_string())
1744                    .collect::<Vec<String>>()
1745                    .join(",")
1746                    .to_string(),
1747            )]),
1748        };
1749    }
1750    if let Some(ref local_var_str) = slug__empty {
1751        local_var_req_builder =
1752            local_var_req_builder.query(&[("slug__empty", &local_var_str.to_string())]);
1753    }
1754    if let Some(ref local_var_str) = slug__ic {
1755        local_var_req_builder = match "multi" {
1756            "multi" => local_var_req_builder.query(
1757                &local_var_str
1758                    .into_iter()
1759                    .map(|p| ("slug__ic".to_owned(), p.to_string()))
1760                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1761            ),
1762            _ => local_var_req_builder.query(&[(
1763                "slug__ic",
1764                &local_var_str
1765                    .into_iter()
1766                    .map(|p| p.to_string())
1767                    .collect::<Vec<String>>()
1768                    .join(",")
1769                    .to_string(),
1770            )]),
1771        };
1772    }
1773    if let Some(ref local_var_str) = slug__ie {
1774        local_var_req_builder = match "multi" {
1775            "multi" => local_var_req_builder.query(
1776                &local_var_str
1777                    .into_iter()
1778                    .map(|p| ("slug__ie".to_owned(), p.to_string()))
1779                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1780            ),
1781            _ => local_var_req_builder.query(&[(
1782                "slug__ie",
1783                &local_var_str
1784                    .into_iter()
1785                    .map(|p| p.to_string())
1786                    .collect::<Vec<String>>()
1787                    .join(",")
1788                    .to_string(),
1789            )]),
1790        };
1791    }
1792    if let Some(ref local_var_str) = slug__iew {
1793        local_var_req_builder = match "multi" {
1794            "multi" => local_var_req_builder.query(
1795                &local_var_str
1796                    .into_iter()
1797                    .map(|p| ("slug__iew".to_owned(), p.to_string()))
1798                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1799            ),
1800            _ => local_var_req_builder.query(&[(
1801                "slug__iew",
1802                &local_var_str
1803                    .into_iter()
1804                    .map(|p| p.to_string())
1805                    .collect::<Vec<String>>()
1806                    .join(",")
1807                    .to_string(),
1808            )]),
1809        };
1810    }
1811    if let Some(ref local_var_str) = slug__iregex {
1812        local_var_req_builder = match "multi" {
1813            "multi" => local_var_req_builder.query(
1814                &local_var_str
1815                    .into_iter()
1816                    .map(|p| ("slug__iregex".to_owned(), p.to_string()))
1817                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1818            ),
1819            _ => local_var_req_builder.query(&[(
1820                "slug__iregex",
1821                &local_var_str
1822                    .into_iter()
1823                    .map(|p| p.to_string())
1824                    .collect::<Vec<String>>()
1825                    .join(",")
1826                    .to_string(),
1827            )]),
1828        };
1829    }
1830    if let Some(ref local_var_str) = slug__isw {
1831        local_var_req_builder = match "multi" {
1832            "multi" => local_var_req_builder.query(
1833                &local_var_str
1834                    .into_iter()
1835                    .map(|p| ("slug__isw".to_owned(), p.to_string()))
1836                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1837            ),
1838            _ => local_var_req_builder.query(&[(
1839                "slug__isw",
1840                &local_var_str
1841                    .into_iter()
1842                    .map(|p| p.to_string())
1843                    .collect::<Vec<String>>()
1844                    .join(",")
1845                    .to_string(),
1846            )]),
1847        };
1848    }
1849    if let Some(ref local_var_str) = slug__n {
1850        local_var_req_builder = match "multi" {
1851            "multi" => local_var_req_builder.query(
1852                &local_var_str
1853                    .into_iter()
1854                    .map(|p| ("slug__n".to_owned(), p.to_string()))
1855                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1856            ),
1857            _ => local_var_req_builder.query(&[(
1858                "slug__n",
1859                &local_var_str
1860                    .into_iter()
1861                    .map(|p| p.to_string())
1862                    .collect::<Vec<String>>()
1863                    .join(",")
1864                    .to_string(),
1865            )]),
1866        };
1867    }
1868    if let Some(ref local_var_str) = slug__nic {
1869        local_var_req_builder = match "multi" {
1870            "multi" => local_var_req_builder.query(
1871                &local_var_str
1872                    .into_iter()
1873                    .map(|p| ("slug__nic".to_owned(), p.to_string()))
1874                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1875            ),
1876            _ => local_var_req_builder.query(&[(
1877                "slug__nic",
1878                &local_var_str
1879                    .into_iter()
1880                    .map(|p| p.to_string())
1881                    .collect::<Vec<String>>()
1882                    .join(",")
1883                    .to_string(),
1884            )]),
1885        };
1886    }
1887    if let Some(ref local_var_str) = slug__nie {
1888        local_var_req_builder = match "multi" {
1889            "multi" => local_var_req_builder.query(
1890                &local_var_str
1891                    .into_iter()
1892                    .map(|p| ("slug__nie".to_owned(), p.to_string()))
1893                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1894            ),
1895            _ => local_var_req_builder.query(&[(
1896                "slug__nie",
1897                &local_var_str
1898                    .into_iter()
1899                    .map(|p| p.to_string())
1900                    .collect::<Vec<String>>()
1901                    .join(",")
1902                    .to_string(),
1903            )]),
1904        };
1905    }
1906    if let Some(ref local_var_str) = slug__niew {
1907        local_var_req_builder = match "multi" {
1908            "multi" => local_var_req_builder.query(
1909                &local_var_str
1910                    .into_iter()
1911                    .map(|p| ("slug__niew".to_owned(), p.to_string()))
1912                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1913            ),
1914            _ => local_var_req_builder.query(&[(
1915                "slug__niew",
1916                &local_var_str
1917                    .into_iter()
1918                    .map(|p| p.to_string())
1919                    .collect::<Vec<String>>()
1920                    .join(",")
1921                    .to_string(),
1922            )]),
1923        };
1924    }
1925    if let Some(ref local_var_str) = slug__nisw {
1926        local_var_req_builder = match "multi" {
1927            "multi" => local_var_req_builder.query(
1928                &local_var_str
1929                    .into_iter()
1930                    .map(|p| ("slug__nisw".to_owned(), p.to_string()))
1931                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1932            ),
1933            _ => local_var_req_builder.query(&[(
1934                "slug__nisw",
1935                &local_var_str
1936                    .into_iter()
1937                    .map(|p| p.to_string())
1938                    .collect::<Vec<String>>()
1939                    .join(",")
1940                    .to_string(),
1941            )]),
1942        };
1943    }
1944    if let Some(ref local_var_str) = slug__regex {
1945        local_var_req_builder = match "multi" {
1946            "multi" => local_var_req_builder.query(
1947                &local_var_str
1948                    .into_iter()
1949                    .map(|p| ("slug__regex".to_owned(), p.to_string()))
1950                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1951            ),
1952            _ => local_var_req_builder.query(&[(
1953                "slug__regex",
1954                &local_var_str
1955                    .into_iter()
1956                    .map(|p| p.to_string())
1957                    .collect::<Vec<String>>()
1958                    .join(",")
1959                    .to_string(),
1960            )]),
1961        };
1962    }
1963    if let Some(ref local_var_str) = tag {
1964        local_var_req_builder = match "multi" {
1965            "multi" => local_var_req_builder.query(
1966                &local_var_str
1967                    .into_iter()
1968                    .map(|p| ("tag".to_owned(), p.to_string()))
1969                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1970            ),
1971            _ => local_var_req_builder.query(&[(
1972                "tag",
1973                &local_var_str
1974                    .into_iter()
1975                    .map(|p| p.to_string())
1976                    .collect::<Vec<String>>()
1977                    .join(",")
1978                    .to_string(),
1979            )]),
1980        };
1981    }
1982    if let Some(ref local_var_str) = tag__n {
1983        local_var_req_builder = match "multi" {
1984            "multi" => local_var_req_builder.query(
1985                &local_var_str
1986                    .into_iter()
1987                    .map(|p| ("tag__n".to_owned(), p.to_string()))
1988                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1989            ),
1990            _ => local_var_req_builder.query(&[(
1991                "tag__n",
1992                &local_var_str
1993                    .into_iter()
1994                    .map(|p| p.to_string())
1995                    .collect::<Vec<String>>()
1996                    .join(",")
1997                    .to_string(),
1998            )]),
1999        };
2000    }
2001    if let Some(ref local_var_str) = tag_id {
2002        local_var_req_builder = match "multi" {
2003            "multi" => local_var_req_builder.query(
2004                &local_var_str
2005                    .into_iter()
2006                    .map(|p| ("tag_id".to_owned(), p.to_string()))
2007                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2008            ),
2009            _ => local_var_req_builder.query(&[(
2010                "tag_id",
2011                &local_var_str
2012                    .into_iter()
2013                    .map(|p| p.to_string())
2014                    .collect::<Vec<String>>()
2015                    .join(",")
2016                    .to_string(),
2017            )]),
2018        };
2019    }
2020    if let Some(ref local_var_str) = tag_id__n {
2021        local_var_req_builder = match "multi" {
2022            "multi" => local_var_req_builder.query(
2023                &local_var_str
2024                    .into_iter()
2025                    .map(|p| ("tag_id__n".to_owned(), p.to_string()))
2026                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2027            ),
2028            _ => local_var_req_builder.query(&[(
2029                "tag_id__n",
2030                &local_var_str
2031                    .into_iter()
2032                    .map(|p| p.to_string())
2033                    .collect::<Vec<String>>()
2034                    .join(",")
2035                    .to_string(),
2036            )]),
2037        };
2038    }
2039    if let Some(ref local_var_str) = updated_by_request {
2040        local_var_req_builder =
2041            local_var_req_builder.query(&[("updated_by_request", &local_var_str.to_string())]);
2042    }
2043    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
2044        local_var_req_builder =
2045            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
2046    }
2047    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
2048        let local_var_key = local_var_apikey.key.clone();
2049        let local_var_value = match local_var_apikey.prefix {
2050            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
2051            None => local_var_key,
2052        };
2053        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
2054    };
2055
2056    let local_var_req = local_var_req_builder.build()?;
2057    let local_var_resp = local_var_client.execute(local_var_req).await?;
2058
2059    let local_var_status = local_var_resp.status();
2060    let local_var_content = local_var_resp.text().await?;
2061
2062    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
2063        serde_json::from_str(&local_var_content).map_err(Error::from)
2064    } else {
2065        let local_var_entity: Option<VirtualizationClusterGroupsListError> =
2066            serde_json::from_str(&local_var_content).ok();
2067        let local_var_error = ResponseContent {
2068            status: local_var_status,
2069            content: local_var_content,
2070            entity: local_var_entity,
2071        };
2072        Err(Error::ResponseError(local_var_error))
2073    }
2074}
2075
2076/// Patch a cluster group object.
2077pub async fn virtualization_cluster_groups_partial_update(
2078    configuration: &configuration::Configuration,
2079    id: i32,
2080    patched_cluster_group_request: Option<crate::models::PatchedClusterGroupRequest>,
2081) -> Result<crate::models::ClusterGroup, Error<VirtualizationClusterGroupsPartialUpdateError>> {
2082    let local_var_configuration = configuration;
2083
2084    let local_var_client = &local_var_configuration.client;
2085
2086    let local_var_uri_str = format!(
2087        "{}/api/virtualization/cluster-groups/{id}/",
2088        local_var_configuration.base_path,
2089        id = id
2090    );
2091    let mut local_var_req_builder =
2092        local_var_client.request(reqwest::Method::PATCH, local_var_uri_str.as_str());
2093
2094    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
2095        local_var_req_builder =
2096            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
2097    }
2098    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
2099        let local_var_key = local_var_apikey.key.clone();
2100        let local_var_value = match local_var_apikey.prefix {
2101            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
2102            None => local_var_key,
2103        };
2104        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
2105    };
2106    local_var_req_builder = local_var_req_builder.json(&patched_cluster_group_request);
2107
2108    let local_var_req = local_var_req_builder.build()?;
2109    let local_var_resp = local_var_client.execute(local_var_req).await?;
2110
2111    let local_var_status = local_var_resp.status();
2112    let local_var_content = local_var_resp.text().await?;
2113
2114    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
2115        serde_json::from_str(&local_var_content).map_err(Error::from)
2116    } else {
2117        let local_var_entity: Option<VirtualizationClusterGroupsPartialUpdateError> =
2118            serde_json::from_str(&local_var_content).ok();
2119        let local_var_error = ResponseContent {
2120            status: local_var_status,
2121            content: local_var_content,
2122            entity: local_var_entity,
2123        };
2124        Err(Error::ResponseError(local_var_error))
2125    }
2126}
2127
2128/// Get a cluster group object.
2129pub async fn virtualization_cluster_groups_retrieve(
2130    configuration: &configuration::Configuration,
2131    id: i32,
2132) -> Result<crate::models::ClusterGroup, Error<VirtualizationClusterGroupsRetrieveError>> {
2133    let local_var_configuration = configuration;
2134
2135    let local_var_client = &local_var_configuration.client;
2136
2137    let local_var_uri_str = format!(
2138        "{}/api/virtualization/cluster-groups/{id}/",
2139        local_var_configuration.base_path,
2140        id = id
2141    );
2142    let mut local_var_req_builder =
2143        local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
2144
2145    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
2146        local_var_req_builder =
2147            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
2148    }
2149    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
2150        let local_var_key = local_var_apikey.key.clone();
2151        let local_var_value = match local_var_apikey.prefix {
2152            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
2153            None => local_var_key,
2154        };
2155        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
2156    };
2157
2158    let local_var_req = local_var_req_builder.build()?;
2159    let local_var_resp = local_var_client.execute(local_var_req).await?;
2160
2161    let local_var_status = local_var_resp.status();
2162    let local_var_content = local_var_resp.text().await?;
2163
2164    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
2165        serde_json::from_str(&local_var_content).map_err(Error::from)
2166    } else {
2167        let local_var_entity: Option<VirtualizationClusterGroupsRetrieveError> =
2168            serde_json::from_str(&local_var_content).ok();
2169        let local_var_error = ResponseContent {
2170            status: local_var_status,
2171            content: local_var_content,
2172            entity: local_var_entity,
2173        };
2174        Err(Error::ResponseError(local_var_error))
2175    }
2176}
2177
2178/// Put a cluster group object.
2179pub async fn virtualization_cluster_groups_update(
2180    configuration: &configuration::Configuration,
2181    id: i32,
2182    cluster_group_request: crate::models::ClusterGroupRequest,
2183) -> Result<crate::models::ClusterGroup, Error<VirtualizationClusterGroupsUpdateError>> {
2184    let local_var_configuration = configuration;
2185
2186    let local_var_client = &local_var_configuration.client;
2187
2188    let local_var_uri_str = format!(
2189        "{}/api/virtualization/cluster-groups/{id}/",
2190        local_var_configuration.base_path,
2191        id = id
2192    );
2193    let mut local_var_req_builder =
2194        local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());
2195
2196    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
2197        local_var_req_builder =
2198            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
2199    }
2200    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
2201        let local_var_key = local_var_apikey.key.clone();
2202        let local_var_value = match local_var_apikey.prefix {
2203            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
2204            None => local_var_key,
2205        };
2206        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
2207    };
2208    local_var_req_builder = local_var_req_builder.json(&cluster_group_request);
2209
2210    let local_var_req = local_var_req_builder.build()?;
2211    let local_var_resp = local_var_client.execute(local_var_req).await?;
2212
2213    let local_var_status = local_var_resp.status();
2214    let local_var_content = local_var_resp.text().await?;
2215
2216    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
2217        serde_json::from_str(&local_var_content).map_err(Error::from)
2218    } else {
2219        let local_var_entity: Option<VirtualizationClusterGroupsUpdateError> =
2220            serde_json::from_str(&local_var_content).ok();
2221        let local_var_error = ResponseContent {
2222            status: local_var_status,
2223            content: local_var_content,
2224            entity: local_var_entity,
2225        };
2226        Err(Error::ResponseError(local_var_error))
2227    }
2228}
2229
2230/// Delete a list of cluster type objects.
2231pub async fn virtualization_cluster_types_bulk_destroy(
2232    configuration: &configuration::Configuration,
2233    cluster_type_request: Vec<crate::models::ClusterTypeRequest>,
2234) -> Result<(), Error<VirtualizationClusterTypesBulkDestroyError>> {
2235    let local_var_configuration = configuration;
2236
2237    let local_var_client = &local_var_configuration.client;
2238
2239    let local_var_uri_str = format!(
2240        "{}/api/virtualization/cluster-types/",
2241        local_var_configuration.base_path
2242    );
2243    let mut local_var_req_builder =
2244        local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());
2245
2246    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
2247        local_var_req_builder =
2248            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
2249    }
2250    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
2251        let local_var_key = local_var_apikey.key.clone();
2252        let local_var_value = match local_var_apikey.prefix {
2253            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
2254            None => local_var_key,
2255        };
2256        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
2257    };
2258    local_var_req_builder = local_var_req_builder.json(&cluster_type_request);
2259
2260    let local_var_req = local_var_req_builder.build()?;
2261    let local_var_resp = local_var_client.execute(local_var_req).await?;
2262
2263    let local_var_status = local_var_resp.status();
2264    let local_var_content = local_var_resp.text().await?;
2265
2266    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
2267        Ok(())
2268    } else {
2269        let local_var_entity: Option<VirtualizationClusterTypesBulkDestroyError> =
2270            serde_json::from_str(&local_var_content).ok();
2271        let local_var_error = ResponseContent {
2272            status: local_var_status,
2273            content: local_var_content,
2274            entity: local_var_entity,
2275        };
2276        Err(Error::ResponseError(local_var_error))
2277    }
2278}
2279
2280/// Patch a list of cluster type objects.
2281pub async fn virtualization_cluster_types_bulk_partial_update(
2282    configuration: &configuration::Configuration,
2283    cluster_type_request: Vec<crate::models::ClusterTypeRequest>,
2284) -> Result<Vec<crate::models::ClusterType>, Error<VirtualizationClusterTypesBulkPartialUpdateError>>
2285{
2286    let local_var_configuration = configuration;
2287
2288    let local_var_client = &local_var_configuration.client;
2289
2290    let local_var_uri_str = format!(
2291        "{}/api/virtualization/cluster-types/",
2292        local_var_configuration.base_path
2293    );
2294    let mut local_var_req_builder =
2295        local_var_client.request(reqwest::Method::PATCH, local_var_uri_str.as_str());
2296
2297    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
2298        local_var_req_builder =
2299            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
2300    }
2301    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
2302        let local_var_key = local_var_apikey.key.clone();
2303        let local_var_value = match local_var_apikey.prefix {
2304            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
2305            None => local_var_key,
2306        };
2307        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
2308    };
2309    local_var_req_builder = local_var_req_builder.json(&cluster_type_request);
2310
2311    let local_var_req = local_var_req_builder.build()?;
2312    let local_var_resp = local_var_client.execute(local_var_req).await?;
2313
2314    let local_var_status = local_var_resp.status();
2315    let local_var_content = local_var_resp.text().await?;
2316
2317    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
2318        serde_json::from_str(&local_var_content).map_err(Error::from)
2319    } else {
2320        let local_var_entity: Option<VirtualizationClusterTypesBulkPartialUpdateError> =
2321            serde_json::from_str(&local_var_content).ok();
2322        let local_var_error = ResponseContent {
2323            status: local_var_status,
2324            content: local_var_content,
2325            entity: local_var_entity,
2326        };
2327        Err(Error::ResponseError(local_var_error))
2328    }
2329}
2330
2331/// Put a list of cluster type objects.
2332pub async fn virtualization_cluster_types_bulk_update(
2333    configuration: &configuration::Configuration,
2334    cluster_type_request: Vec<crate::models::ClusterTypeRequest>,
2335) -> Result<Vec<crate::models::ClusterType>, Error<VirtualizationClusterTypesBulkUpdateError>> {
2336    let local_var_configuration = configuration;
2337
2338    let local_var_client = &local_var_configuration.client;
2339
2340    let local_var_uri_str = format!(
2341        "{}/api/virtualization/cluster-types/",
2342        local_var_configuration.base_path
2343    );
2344    let mut local_var_req_builder =
2345        local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());
2346
2347    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
2348        local_var_req_builder =
2349            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
2350    }
2351    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
2352        let local_var_key = local_var_apikey.key.clone();
2353        let local_var_value = match local_var_apikey.prefix {
2354            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
2355            None => local_var_key,
2356        };
2357        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
2358    };
2359    local_var_req_builder = local_var_req_builder.json(&cluster_type_request);
2360
2361    let local_var_req = local_var_req_builder.build()?;
2362    let local_var_resp = local_var_client.execute(local_var_req).await?;
2363
2364    let local_var_status = local_var_resp.status();
2365    let local_var_content = local_var_resp.text().await?;
2366
2367    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
2368        serde_json::from_str(&local_var_content).map_err(Error::from)
2369    } else {
2370        let local_var_entity: Option<VirtualizationClusterTypesBulkUpdateError> =
2371            serde_json::from_str(&local_var_content).ok();
2372        let local_var_error = ResponseContent {
2373            status: local_var_status,
2374            content: local_var_content,
2375            entity: local_var_entity,
2376        };
2377        Err(Error::ResponseError(local_var_error))
2378    }
2379}
2380
2381/// Post a list of cluster type objects.
2382pub async fn virtualization_cluster_types_create(
2383    configuration: &configuration::Configuration,
2384    cluster_type_request: crate::models::ClusterTypeRequest,
2385) -> Result<crate::models::ClusterType, Error<VirtualizationClusterTypesCreateError>> {
2386    let local_var_configuration = configuration;
2387
2388    let local_var_client = &local_var_configuration.client;
2389
2390    let local_var_uri_str = format!(
2391        "{}/api/virtualization/cluster-types/",
2392        local_var_configuration.base_path
2393    );
2394    let mut local_var_req_builder =
2395        local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
2396
2397    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
2398        local_var_req_builder =
2399            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
2400    }
2401    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
2402        let local_var_key = local_var_apikey.key.clone();
2403        let local_var_value = match local_var_apikey.prefix {
2404            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
2405            None => local_var_key,
2406        };
2407        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
2408    };
2409    local_var_req_builder = local_var_req_builder.json(&cluster_type_request);
2410
2411    let local_var_req = local_var_req_builder.build()?;
2412    let local_var_resp = local_var_client.execute(local_var_req).await?;
2413
2414    let local_var_status = local_var_resp.status();
2415    let local_var_content = local_var_resp.text().await?;
2416
2417    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
2418        serde_json::from_str(&local_var_content).map_err(Error::from)
2419    } else {
2420        let local_var_entity: Option<VirtualizationClusterTypesCreateError> =
2421            serde_json::from_str(&local_var_content).ok();
2422        let local_var_error = ResponseContent {
2423            status: local_var_status,
2424            content: local_var_content,
2425            entity: local_var_entity,
2426        };
2427        Err(Error::ResponseError(local_var_error))
2428    }
2429}
2430
2431/// Delete a cluster type object.
2432pub async fn virtualization_cluster_types_destroy(
2433    configuration: &configuration::Configuration,
2434    id: i32,
2435) -> Result<(), Error<VirtualizationClusterTypesDestroyError>> {
2436    let local_var_configuration = configuration;
2437
2438    let local_var_client = &local_var_configuration.client;
2439
2440    let local_var_uri_str = format!(
2441        "{}/api/virtualization/cluster-types/{id}/",
2442        local_var_configuration.base_path,
2443        id = id
2444    );
2445    let mut local_var_req_builder =
2446        local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());
2447
2448    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
2449        local_var_req_builder =
2450            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
2451    }
2452    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
2453        let local_var_key = local_var_apikey.key.clone();
2454        let local_var_value = match local_var_apikey.prefix {
2455            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
2456            None => local_var_key,
2457        };
2458        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
2459    };
2460
2461    let local_var_req = local_var_req_builder.build()?;
2462    let local_var_resp = local_var_client.execute(local_var_req).await?;
2463
2464    let local_var_status = local_var_resp.status();
2465    let local_var_content = local_var_resp.text().await?;
2466
2467    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
2468        Ok(())
2469    } else {
2470        let local_var_entity: Option<VirtualizationClusterTypesDestroyError> =
2471            serde_json::from_str(&local_var_content).ok();
2472        let local_var_error = ResponseContent {
2473            status: local_var_status,
2474            content: local_var_content,
2475            entity: local_var_entity,
2476        };
2477        Err(Error::ResponseError(local_var_error))
2478    }
2479}
2480
2481/// Get a list of cluster type objects.
2482pub async fn virtualization_cluster_types_list(
2483    configuration: &configuration::Configuration,
2484    created: Option<Vec<String>>,
2485    created__empty: Option<Vec<String>>,
2486    created__gt: Option<Vec<String>>,
2487    created__gte: Option<Vec<String>>,
2488    created__lt: Option<Vec<String>>,
2489    created__lte: Option<Vec<String>>,
2490    created__n: Option<Vec<String>>,
2491    created_by_request: Option<&str>,
2492    description: Option<Vec<String>>,
2493    description__empty: Option<bool>,
2494    description__ic: Option<Vec<String>>,
2495    description__ie: Option<Vec<String>>,
2496    description__iew: Option<Vec<String>>,
2497    description__iregex: Option<Vec<String>>,
2498    description__isw: Option<Vec<String>>,
2499    description__n: Option<Vec<String>>,
2500    description__nic: Option<Vec<String>>,
2501    description__nie: Option<Vec<String>>,
2502    description__niew: Option<Vec<String>>,
2503    description__nisw: Option<Vec<String>>,
2504    description__regex: Option<Vec<String>>,
2505    id: Option<Vec<i32>>,
2506    id__empty: Option<bool>,
2507    id__gt: Option<Vec<i32>>,
2508    id__gte: Option<Vec<i32>>,
2509    id__lt: Option<Vec<i32>>,
2510    id__lte: Option<Vec<i32>>,
2511    id__n: Option<Vec<i32>>,
2512    last_updated: Option<Vec<String>>,
2513    last_updated__empty: Option<Vec<String>>,
2514    last_updated__gt: Option<Vec<String>>,
2515    last_updated__gte: Option<Vec<String>>,
2516    last_updated__lt: Option<Vec<String>>,
2517    last_updated__lte: Option<Vec<String>>,
2518    last_updated__n: Option<Vec<String>>,
2519    limit: Option<i32>,
2520    modified_by_request: Option<&str>,
2521    name: Option<Vec<String>>,
2522    name__empty: Option<bool>,
2523    name__ic: Option<Vec<String>>,
2524    name__ie: Option<Vec<String>>,
2525    name__iew: Option<Vec<String>>,
2526    name__iregex: Option<Vec<String>>,
2527    name__isw: Option<Vec<String>>,
2528    name__n: Option<Vec<String>>,
2529    name__nic: Option<Vec<String>>,
2530    name__nie: Option<Vec<String>>,
2531    name__niew: Option<Vec<String>>,
2532    name__nisw: Option<Vec<String>>,
2533    name__regex: Option<Vec<String>>,
2534    offset: Option<i32>,
2535    ordering: Option<&str>,
2536    q: Option<&str>,
2537    slug: Option<Vec<String>>,
2538    slug__empty: Option<bool>,
2539    slug__ic: Option<Vec<String>>,
2540    slug__ie: Option<Vec<String>>,
2541    slug__iew: Option<Vec<String>>,
2542    slug__iregex: Option<Vec<String>>,
2543    slug__isw: Option<Vec<String>>,
2544    slug__n: Option<Vec<String>>,
2545    slug__nic: Option<Vec<String>>,
2546    slug__nie: Option<Vec<String>>,
2547    slug__niew: Option<Vec<String>>,
2548    slug__nisw: Option<Vec<String>>,
2549    slug__regex: Option<Vec<String>>,
2550    tag: Option<Vec<String>>,
2551    tag__n: Option<Vec<String>>,
2552    tag_id: Option<Vec<i32>>,
2553    tag_id__n: Option<Vec<i32>>,
2554    updated_by_request: Option<&str>,
2555) -> Result<crate::models::PaginatedClusterTypeList, Error<VirtualizationClusterTypesListError>> {
2556    let local_var_configuration = configuration;
2557
2558    let local_var_client = &local_var_configuration.client;
2559
2560    let local_var_uri_str = format!(
2561        "{}/api/virtualization/cluster-types/",
2562        local_var_configuration.base_path
2563    );
2564    let mut local_var_req_builder =
2565        local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
2566
2567    if let Some(ref local_var_str) = created {
2568        local_var_req_builder = match "multi" {
2569            "multi" => local_var_req_builder.query(
2570                &local_var_str
2571                    .into_iter()
2572                    .map(|p| ("created".to_owned(), p.to_string()))
2573                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2574            ),
2575            _ => local_var_req_builder.query(&[(
2576                "created",
2577                &local_var_str
2578                    .into_iter()
2579                    .map(|p| p.to_string())
2580                    .collect::<Vec<String>>()
2581                    .join(",")
2582                    .to_string(),
2583            )]),
2584        };
2585    }
2586    if let Some(ref local_var_str) = created__empty {
2587        local_var_req_builder = match "multi" {
2588            "multi" => local_var_req_builder.query(
2589                &local_var_str
2590                    .into_iter()
2591                    .map(|p| ("created__empty".to_owned(), p.to_string()))
2592                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2593            ),
2594            _ => local_var_req_builder.query(&[(
2595                "created__empty",
2596                &local_var_str
2597                    .into_iter()
2598                    .map(|p| p.to_string())
2599                    .collect::<Vec<String>>()
2600                    .join(",")
2601                    .to_string(),
2602            )]),
2603        };
2604    }
2605    if let Some(ref local_var_str) = created__gt {
2606        local_var_req_builder = match "multi" {
2607            "multi" => local_var_req_builder.query(
2608                &local_var_str
2609                    .into_iter()
2610                    .map(|p| ("created__gt".to_owned(), p.to_string()))
2611                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2612            ),
2613            _ => local_var_req_builder.query(&[(
2614                "created__gt",
2615                &local_var_str
2616                    .into_iter()
2617                    .map(|p| p.to_string())
2618                    .collect::<Vec<String>>()
2619                    .join(",")
2620                    .to_string(),
2621            )]),
2622        };
2623    }
2624    if let Some(ref local_var_str) = created__gte {
2625        local_var_req_builder = match "multi" {
2626            "multi" => local_var_req_builder.query(
2627                &local_var_str
2628                    .into_iter()
2629                    .map(|p| ("created__gte".to_owned(), p.to_string()))
2630                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2631            ),
2632            _ => local_var_req_builder.query(&[(
2633                "created__gte",
2634                &local_var_str
2635                    .into_iter()
2636                    .map(|p| p.to_string())
2637                    .collect::<Vec<String>>()
2638                    .join(",")
2639                    .to_string(),
2640            )]),
2641        };
2642    }
2643    if let Some(ref local_var_str) = created__lt {
2644        local_var_req_builder = match "multi" {
2645            "multi" => local_var_req_builder.query(
2646                &local_var_str
2647                    .into_iter()
2648                    .map(|p| ("created__lt".to_owned(), p.to_string()))
2649                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2650            ),
2651            _ => local_var_req_builder.query(&[(
2652                "created__lt",
2653                &local_var_str
2654                    .into_iter()
2655                    .map(|p| p.to_string())
2656                    .collect::<Vec<String>>()
2657                    .join(",")
2658                    .to_string(),
2659            )]),
2660        };
2661    }
2662    if let Some(ref local_var_str) = created__lte {
2663        local_var_req_builder = match "multi" {
2664            "multi" => local_var_req_builder.query(
2665                &local_var_str
2666                    .into_iter()
2667                    .map(|p| ("created__lte".to_owned(), p.to_string()))
2668                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2669            ),
2670            _ => local_var_req_builder.query(&[(
2671                "created__lte",
2672                &local_var_str
2673                    .into_iter()
2674                    .map(|p| p.to_string())
2675                    .collect::<Vec<String>>()
2676                    .join(",")
2677                    .to_string(),
2678            )]),
2679        };
2680    }
2681    if let Some(ref local_var_str) = created__n {
2682        local_var_req_builder = match "multi" {
2683            "multi" => local_var_req_builder.query(
2684                &local_var_str
2685                    .into_iter()
2686                    .map(|p| ("created__n".to_owned(), p.to_string()))
2687                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2688            ),
2689            _ => local_var_req_builder.query(&[(
2690                "created__n",
2691                &local_var_str
2692                    .into_iter()
2693                    .map(|p| p.to_string())
2694                    .collect::<Vec<String>>()
2695                    .join(",")
2696                    .to_string(),
2697            )]),
2698        };
2699    }
2700    if let Some(ref local_var_str) = created_by_request {
2701        local_var_req_builder =
2702            local_var_req_builder.query(&[("created_by_request", &local_var_str.to_string())]);
2703    }
2704    if let Some(ref local_var_str) = description {
2705        local_var_req_builder = match "multi" {
2706            "multi" => local_var_req_builder.query(
2707                &local_var_str
2708                    .into_iter()
2709                    .map(|p| ("description".to_owned(), p.to_string()))
2710                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2711            ),
2712            _ => local_var_req_builder.query(&[(
2713                "description",
2714                &local_var_str
2715                    .into_iter()
2716                    .map(|p| p.to_string())
2717                    .collect::<Vec<String>>()
2718                    .join(",")
2719                    .to_string(),
2720            )]),
2721        };
2722    }
2723    if let Some(ref local_var_str) = description__empty {
2724        local_var_req_builder =
2725            local_var_req_builder.query(&[("description__empty", &local_var_str.to_string())]);
2726    }
2727    if let Some(ref local_var_str) = description__ic {
2728        local_var_req_builder = match "multi" {
2729            "multi" => local_var_req_builder.query(
2730                &local_var_str
2731                    .into_iter()
2732                    .map(|p| ("description__ic".to_owned(), p.to_string()))
2733                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2734            ),
2735            _ => local_var_req_builder.query(&[(
2736                "description__ic",
2737                &local_var_str
2738                    .into_iter()
2739                    .map(|p| p.to_string())
2740                    .collect::<Vec<String>>()
2741                    .join(",")
2742                    .to_string(),
2743            )]),
2744        };
2745    }
2746    if let Some(ref local_var_str) = description__ie {
2747        local_var_req_builder = match "multi" {
2748            "multi" => local_var_req_builder.query(
2749                &local_var_str
2750                    .into_iter()
2751                    .map(|p| ("description__ie".to_owned(), p.to_string()))
2752                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2753            ),
2754            _ => local_var_req_builder.query(&[(
2755                "description__ie",
2756                &local_var_str
2757                    .into_iter()
2758                    .map(|p| p.to_string())
2759                    .collect::<Vec<String>>()
2760                    .join(",")
2761                    .to_string(),
2762            )]),
2763        };
2764    }
2765    if let Some(ref local_var_str) = description__iew {
2766        local_var_req_builder = match "multi" {
2767            "multi" => local_var_req_builder.query(
2768                &local_var_str
2769                    .into_iter()
2770                    .map(|p| ("description__iew".to_owned(), p.to_string()))
2771                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2772            ),
2773            _ => local_var_req_builder.query(&[(
2774                "description__iew",
2775                &local_var_str
2776                    .into_iter()
2777                    .map(|p| p.to_string())
2778                    .collect::<Vec<String>>()
2779                    .join(",")
2780                    .to_string(),
2781            )]),
2782        };
2783    }
2784    if let Some(ref local_var_str) = description__iregex {
2785        local_var_req_builder = match "multi" {
2786            "multi" => local_var_req_builder.query(
2787                &local_var_str
2788                    .into_iter()
2789                    .map(|p| ("description__iregex".to_owned(), p.to_string()))
2790                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2791            ),
2792            _ => local_var_req_builder.query(&[(
2793                "description__iregex",
2794                &local_var_str
2795                    .into_iter()
2796                    .map(|p| p.to_string())
2797                    .collect::<Vec<String>>()
2798                    .join(",")
2799                    .to_string(),
2800            )]),
2801        };
2802    }
2803    if let Some(ref local_var_str) = description__isw {
2804        local_var_req_builder = match "multi" {
2805            "multi" => local_var_req_builder.query(
2806                &local_var_str
2807                    .into_iter()
2808                    .map(|p| ("description__isw".to_owned(), p.to_string()))
2809                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2810            ),
2811            _ => local_var_req_builder.query(&[(
2812                "description__isw",
2813                &local_var_str
2814                    .into_iter()
2815                    .map(|p| p.to_string())
2816                    .collect::<Vec<String>>()
2817                    .join(",")
2818                    .to_string(),
2819            )]),
2820        };
2821    }
2822    if let Some(ref local_var_str) = description__n {
2823        local_var_req_builder = match "multi" {
2824            "multi" => local_var_req_builder.query(
2825                &local_var_str
2826                    .into_iter()
2827                    .map(|p| ("description__n".to_owned(), p.to_string()))
2828                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2829            ),
2830            _ => local_var_req_builder.query(&[(
2831                "description__n",
2832                &local_var_str
2833                    .into_iter()
2834                    .map(|p| p.to_string())
2835                    .collect::<Vec<String>>()
2836                    .join(",")
2837                    .to_string(),
2838            )]),
2839        };
2840    }
2841    if let Some(ref local_var_str) = description__nic {
2842        local_var_req_builder = match "multi" {
2843            "multi" => local_var_req_builder.query(
2844                &local_var_str
2845                    .into_iter()
2846                    .map(|p| ("description__nic".to_owned(), p.to_string()))
2847                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2848            ),
2849            _ => local_var_req_builder.query(&[(
2850                "description__nic",
2851                &local_var_str
2852                    .into_iter()
2853                    .map(|p| p.to_string())
2854                    .collect::<Vec<String>>()
2855                    .join(",")
2856                    .to_string(),
2857            )]),
2858        };
2859    }
2860    if let Some(ref local_var_str) = description__nie {
2861        local_var_req_builder = match "multi" {
2862            "multi" => local_var_req_builder.query(
2863                &local_var_str
2864                    .into_iter()
2865                    .map(|p| ("description__nie".to_owned(), p.to_string()))
2866                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2867            ),
2868            _ => local_var_req_builder.query(&[(
2869                "description__nie",
2870                &local_var_str
2871                    .into_iter()
2872                    .map(|p| p.to_string())
2873                    .collect::<Vec<String>>()
2874                    .join(",")
2875                    .to_string(),
2876            )]),
2877        };
2878    }
2879    if let Some(ref local_var_str) = description__niew {
2880        local_var_req_builder = match "multi" {
2881            "multi" => local_var_req_builder.query(
2882                &local_var_str
2883                    .into_iter()
2884                    .map(|p| ("description__niew".to_owned(), p.to_string()))
2885                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2886            ),
2887            _ => local_var_req_builder.query(&[(
2888                "description__niew",
2889                &local_var_str
2890                    .into_iter()
2891                    .map(|p| p.to_string())
2892                    .collect::<Vec<String>>()
2893                    .join(",")
2894                    .to_string(),
2895            )]),
2896        };
2897    }
2898    if let Some(ref local_var_str) = description__nisw {
2899        local_var_req_builder = match "multi" {
2900            "multi" => local_var_req_builder.query(
2901                &local_var_str
2902                    .into_iter()
2903                    .map(|p| ("description__nisw".to_owned(), p.to_string()))
2904                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2905            ),
2906            _ => local_var_req_builder.query(&[(
2907                "description__nisw",
2908                &local_var_str
2909                    .into_iter()
2910                    .map(|p| p.to_string())
2911                    .collect::<Vec<String>>()
2912                    .join(",")
2913                    .to_string(),
2914            )]),
2915        };
2916    }
2917    if let Some(ref local_var_str) = description__regex {
2918        local_var_req_builder = match "multi" {
2919            "multi" => local_var_req_builder.query(
2920                &local_var_str
2921                    .into_iter()
2922                    .map(|p| ("description__regex".to_owned(), p.to_string()))
2923                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2924            ),
2925            _ => local_var_req_builder.query(&[(
2926                "description__regex",
2927                &local_var_str
2928                    .into_iter()
2929                    .map(|p| p.to_string())
2930                    .collect::<Vec<String>>()
2931                    .join(",")
2932                    .to_string(),
2933            )]),
2934        };
2935    }
2936    if let Some(ref local_var_str) = id {
2937        local_var_req_builder = match "multi" {
2938            "multi" => local_var_req_builder.query(
2939                &local_var_str
2940                    .into_iter()
2941                    .map(|p| ("id".to_owned(), p.to_string()))
2942                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2943            ),
2944            _ => local_var_req_builder.query(&[(
2945                "id",
2946                &local_var_str
2947                    .into_iter()
2948                    .map(|p| p.to_string())
2949                    .collect::<Vec<String>>()
2950                    .join(",")
2951                    .to_string(),
2952            )]),
2953        };
2954    }
2955    if let Some(ref local_var_str) = id__empty {
2956        local_var_req_builder =
2957            local_var_req_builder.query(&[("id__empty", &local_var_str.to_string())]);
2958    }
2959    if let Some(ref local_var_str) = id__gt {
2960        local_var_req_builder = match "multi" {
2961            "multi" => local_var_req_builder.query(
2962                &local_var_str
2963                    .into_iter()
2964                    .map(|p| ("id__gt".to_owned(), p.to_string()))
2965                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2966            ),
2967            _ => local_var_req_builder.query(&[(
2968                "id__gt",
2969                &local_var_str
2970                    .into_iter()
2971                    .map(|p| p.to_string())
2972                    .collect::<Vec<String>>()
2973                    .join(",")
2974                    .to_string(),
2975            )]),
2976        };
2977    }
2978    if let Some(ref local_var_str) = id__gte {
2979        local_var_req_builder = match "multi" {
2980            "multi" => local_var_req_builder.query(
2981                &local_var_str
2982                    .into_iter()
2983                    .map(|p| ("id__gte".to_owned(), p.to_string()))
2984                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2985            ),
2986            _ => local_var_req_builder.query(&[(
2987                "id__gte",
2988                &local_var_str
2989                    .into_iter()
2990                    .map(|p| p.to_string())
2991                    .collect::<Vec<String>>()
2992                    .join(",")
2993                    .to_string(),
2994            )]),
2995        };
2996    }
2997    if let Some(ref local_var_str) = id__lt {
2998        local_var_req_builder = match "multi" {
2999            "multi" => local_var_req_builder.query(
3000                &local_var_str
3001                    .into_iter()
3002                    .map(|p| ("id__lt".to_owned(), p.to_string()))
3003                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3004            ),
3005            _ => local_var_req_builder.query(&[(
3006                "id__lt",
3007                &local_var_str
3008                    .into_iter()
3009                    .map(|p| p.to_string())
3010                    .collect::<Vec<String>>()
3011                    .join(",")
3012                    .to_string(),
3013            )]),
3014        };
3015    }
3016    if let Some(ref local_var_str) = id__lte {
3017        local_var_req_builder = match "multi" {
3018            "multi" => local_var_req_builder.query(
3019                &local_var_str
3020                    .into_iter()
3021                    .map(|p| ("id__lte".to_owned(), p.to_string()))
3022                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3023            ),
3024            _ => local_var_req_builder.query(&[(
3025                "id__lte",
3026                &local_var_str
3027                    .into_iter()
3028                    .map(|p| p.to_string())
3029                    .collect::<Vec<String>>()
3030                    .join(",")
3031                    .to_string(),
3032            )]),
3033        };
3034    }
3035    if let Some(ref local_var_str) = id__n {
3036        local_var_req_builder = match "multi" {
3037            "multi" => local_var_req_builder.query(
3038                &local_var_str
3039                    .into_iter()
3040                    .map(|p| ("id__n".to_owned(), p.to_string()))
3041                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3042            ),
3043            _ => local_var_req_builder.query(&[(
3044                "id__n",
3045                &local_var_str
3046                    .into_iter()
3047                    .map(|p| p.to_string())
3048                    .collect::<Vec<String>>()
3049                    .join(",")
3050                    .to_string(),
3051            )]),
3052        };
3053    }
3054    if let Some(ref local_var_str) = last_updated {
3055        local_var_req_builder = match "multi" {
3056            "multi" => local_var_req_builder.query(
3057                &local_var_str
3058                    .into_iter()
3059                    .map(|p| ("last_updated".to_owned(), p.to_string()))
3060                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3061            ),
3062            _ => local_var_req_builder.query(&[(
3063                "last_updated",
3064                &local_var_str
3065                    .into_iter()
3066                    .map(|p| p.to_string())
3067                    .collect::<Vec<String>>()
3068                    .join(",")
3069                    .to_string(),
3070            )]),
3071        };
3072    }
3073    if let Some(ref local_var_str) = last_updated__empty {
3074        local_var_req_builder = match "multi" {
3075            "multi" => local_var_req_builder.query(
3076                &local_var_str
3077                    .into_iter()
3078                    .map(|p| ("last_updated__empty".to_owned(), p.to_string()))
3079                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3080            ),
3081            _ => local_var_req_builder.query(&[(
3082                "last_updated__empty",
3083                &local_var_str
3084                    .into_iter()
3085                    .map(|p| p.to_string())
3086                    .collect::<Vec<String>>()
3087                    .join(",")
3088                    .to_string(),
3089            )]),
3090        };
3091    }
3092    if let Some(ref local_var_str) = last_updated__gt {
3093        local_var_req_builder = match "multi" {
3094            "multi" => local_var_req_builder.query(
3095                &local_var_str
3096                    .into_iter()
3097                    .map(|p| ("last_updated__gt".to_owned(), p.to_string()))
3098                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3099            ),
3100            _ => local_var_req_builder.query(&[(
3101                "last_updated__gt",
3102                &local_var_str
3103                    .into_iter()
3104                    .map(|p| p.to_string())
3105                    .collect::<Vec<String>>()
3106                    .join(",")
3107                    .to_string(),
3108            )]),
3109        };
3110    }
3111    if let Some(ref local_var_str) = last_updated__gte {
3112        local_var_req_builder = match "multi" {
3113            "multi" => local_var_req_builder.query(
3114                &local_var_str
3115                    .into_iter()
3116                    .map(|p| ("last_updated__gte".to_owned(), p.to_string()))
3117                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3118            ),
3119            _ => local_var_req_builder.query(&[(
3120                "last_updated__gte",
3121                &local_var_str
3122                    .into_iter()
3123                    .map(|p| p.to_string())
3124                    .collect::<Vec<String>>()
3125                    .join(",")
3126                    .to_string(),
3127            )]),
3128        };
3129    }
3130    if let Some(ref local_var_str) = last_updated__lt {
3131        local_var_req_builder = match "multi" {
3132            "multi" => local_var_req_builder.query(
3133                &local_var_str
3134                    .into_iter()
3135                    .map(|p| ("last_updated__lt".to_owned(), p.to_string()))
3136                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3137            ),
3138            _ => local_var_req_builder.query(&[(
3139                "last_updated__lt",
3140                &local_var_str
3141                    .into_iter()
3142                    .map(|p| p.to_string())
3143                    .collect::<Vec<String>>()
3144                    .join(",")
3145                    .to_string(),
3146            )]),
3147        };
3148    }
3149    if let Some(ref local_var_str) = last_updated__lte {
3150        local_var_req_builder = match "multi" {
3151            "multi" => local_var_req_builder.query(
3152                &local_var_str
3153                    .into_iter()
3154                    .map(|p| ("last_updated__lte".to_owned(), p.to_string()))
3155                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3156            ),
3157            _ => local_var_req_builder.query(&[(
3158                "last_updated__lte",
3159                &local_var_str
3160                    .into_iter()
3161                    .map(|p| p.to_string())
3162                    .collect::<Vec<String>>()
3163                    .join(",")
3164                    .to_string(),
3165            )]),
3166        };
3167    }
3168    if let Some(ref local_var_str) = last_updated__n {
3169        local_var_req_builder = match "multi" {
3170            "multi" => local_var_req_builder.query(
3171                &local_var_str
3172                    .into_iter()
3173                    .map(|p| ("last_updated__n".to_owned(), p.to_string()))
3174                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3175            ),
3176            _ => local_var_req_builder.query(&[(
3177                "last_updated__n",
3178                &local_var_str
3179                    .into_iter()
3180                    .map(|p| p.to_string())
3181                    .collect::<Vec<String>>()
3182                    .join(",")
3183                    .to_string(),
3184            )]),
3185        };
3186    }
3187    if let Some(ref local_var_str) = limit {
3188        local_var_req_builder =
3189            local_var_req_builder.query(&[("limit", &local_var_str.to_string())]);
3190    }
3191    if let Some(ref local_var_str) = modified_by_request {
3192        local_var_req_builder =
3193            local_var_req_builder.query(&[("modified_by_request", &local_var_str.to_string())]);
3194    }
3195    if let Some(ref local_var_str) = name {
3196        local_var_req_builder = match "multi" {
3197            "multi" => local_var_req_builder.query(
3198                &local_var_str
3199                    .into_iter()
3200                    .map(|p| ("name".to_owned(), p.to_string()))
3201                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3202            ),
3203            _ => local_var_req_builder.query(&[(
3204                "name",
3205                &local_var_str
3206                    .into_iter()
3207                    .map(|p| p.to_string())
3208                    .collect::<Vec<String>>()
3209                    .join(",")
3210                    .to_string(),
3211            )]),
3212        };
3213    }
3214    if let Some(ref local_var_str) = name__empty {
3215        local_var_req_builder =
3216            local_var_req_builder.query(&[("name__empty", &local_var_str.to_string())]);
3217    }
3218    if let Some(ref local_var_str) = name__ic {
3219        local_var_req_builder = match "multi" {
3220            "multi" => local_var_req_builder.query(
3221                &local_var_str
3222                    .into_iter()
3223                    .map(|p| ("name__ic".to_owned(), p.to_string()))
3224                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3225            ),
3226            _ => local_var_req_builder.query(&[(
3227                "name__ic",
3228                &local_var_str
3229                    .into_iter()
3230                    .map(|p| p.to_string())
3231                    .collect::<Vec<String>>()
3232                    .join(",")
3233                    .to_string(),
3234            )]),
3235        };
3236    }
3237    if let Some(ref local_var_str) = name__ie {
3238        local_var_req_builder = match "multi" {
3239            "multi" => local_var_req_builder.query(
3240                &local_var_str
3241                    .into_iter()
3242                    .map(|p| ("name__ie".to_owned(), p.to_string()))
3243                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3244            ),
3245            _ => local_var_req_builder.query(&[(
3246                "name__ie",
3247                &local_var_str
3248                    .into_iter()
3249                    .map(|p| p.to_string())
3250                    .collect::<Vec<String>>()
3251                    .join(",")
3252                    .to_string(),
3253            )]),
3254        };
3255    }
3256    if let Some(ref local_var_str) = name__iew {
3257        local_var_req_builder = match "multi" {
3258            "multi" => local_var_req_builder.query(
3259                &local_var_str
3260                    .into_iter()
3261                    .map(|p| ("name__iew".to_owned(), p.to_string()))
3262                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3263            ),
3264            _ => local_var_req_builder.query(&[(
3265                "name__iew",
3266                &local_var_str
3267                    .into_iter()
3268                    .map(|p| p.to_string())
3269                    .collect::<Vec<String>>()
3270                    .join(",")
3271                    .to_string(),
3272            )]),
3273        };
3274    }
3275    if let Some(ref local_var_str) = name__iregex {
3276        local_var_req_builder = match "multi" {
3277            "multi" => local_var_req_builder.query(
3278                &local_var_str
3279                    .into_iter()
3280                    .map(|p| ("name__iregex".to_owned(), p.to_string()))
3281                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3282            ),
3283            _ => local_var_req_builder.query(&[(
3284                "name__iregex",
3285                &local_var_str
3286                    .into_iter()
3287                    .map(|p| p.to_string())
3288                    .collect::<Vec<String>>()
3289                    .join(",")
3290                    .to_string(),
3291            )]),
3292        };
3293    }
3294    if let Some(ref local_var_str) = name__isw {
3295        local_var_req_builder = match "multi" {
3296            "multi" => local_var_req_builder.query(
3297                &local_var_str
3298                    .into_iter()
3299                    .map(|p| ("name__isw".to_owned(), p.to_string()))
3300                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3301            ),
3302            _ => local_var_req_builder.query(&[(
3303                "name__isw",
3304                &local_var_str
3305                    .into_iter()
3306                    .map(|p| p.to_string())
3307                    .collect::<Vec<String>>()
3308                    .join(",")
3309                    .to_string(),
3310            )]),
3311        };
3312    }
3313    if let Some(ref local_var_str) = name__n {
3314        local_var_req_builder = match "multi" {
3315            "multi" => local_var_req_builder.query(
3316                &local_var_str
3317                    .into_iter()
3318                    .map(|p| ("name__n".to_owned(), p.to_string()))
3319                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3320            ),
3321            _ => local_var_req_builder.query(&[(
3322                "name__n",
3323                &local_var_str
3324                    .into_iter()
3325                    .map(|p| p.to_string())
3326                    .collect::<Vec<String>>()
3327                    .join(",")
3328                    .to_string(),
3329            )]),
3330        };
3331    }
3332    if let Some(ref local_var_str) = name__nic {
3333        local_var_req_builder = match "multi" {
3334            "multi" => local_var_req_builder.query(
3335                &local_var_str
3336                    .into_iter()
3337                    .map(|p| ("name__nic".to_owned(), p.to_string()))
3338                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3339            ),
3340            _ => local_var_req_builder.query(&[(
3341                "name__nic",
3342                &local_var_str
3343                    .into_iter()
3344                    .map(|p| p.to_string())
3345                    .collect::<Vec<String>>()
3346                    .join(",")
3347                    .to_string(),
3348            )]),
3349        };
3350    }
3351    if let Some(ref local_var_str) = name__nie {
3352        local_var_req_builder = match "multi" {
3353            "multi" => local_var_req_builder.query(
3354                &local_var_str
3355                    .into_iter()
3356                    .map(|p| ("name__nie".to_owned(), p.to_string()))
3357                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3358            ),
3359            _ => local_var_req_builder.query(&[(
3360                "name__nie",
3361                &local_var_str
3362                    .into_iter()
3363                    .map(|p| p.to_string())
3364                    .collect::<Vec<String>>()
3365                    .join(",")
3366                    .to_string(),
3367            )]),
3368        };
3369    }
3370    if let Some(ref local_var_str) = name__niew {
3371        local_var_req_builder = match "multi" {
3372            "multi" => local_var_req_builder.query(
3373                &local_var_str
3374                    .into_iter()
3375                    .map(|p| ("name__niew".to_owned(), p.to_string()))
3376                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3377            ),
3378            _ => local_var_req_builder.query(&[(
3379                "name__niew",
3380                &local_var_str
3381                    .into_iter()
3382                    .map(|p| p.to_string())
3383                    .collect::<Vec<String>>()
3384                    .join(",")
3385                    .to_string(),
3386            )]),
3387        };
3388    }
3389    if let Some(ref local_var_str) = name__nisw {
3390        local_var_req_builder = match "multi" {
3391            "multi" => local_var_req_builder.query(
3392                &local_var_str
3393                    .into_iter()
3394                    .map(|p| ("name__nisw".to_owned(), p.to_string()))
3395                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3396            ),
3397            _ => local_var_req_builder.query(&[(
3398                "name__nisw",
3399                &local_var_str
3400                    .into_iter()
3401                    .map(|p| p.to_string())
3402                    .collect::<Vec<String>>()
3403                    .join(",")
3404                    .to_string(),
3405            )]),
3406        };
3407    }
3408    if let Some(ref local_var_str) = name__regex {
3409        local_var_req_builder = match "multi" {
3410            "multi" => local_var_req_builder.query(
3411                &local_var_str
3412                    .into_iter()
3413                    .map(|p| ("name__regex".to_owned(), p.to_string()))
3414                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3415            ),
3416            _ => local_var_req_builder.query(&[(
3417                "name__regex",
3418                &local_var_str
3419                    .into_iter()
3420                    .map(|p| p.to_string())
3421                    .collect::<Vec<String>>()
3422                    .join(",")
3423                    .to_string(),
3424            )]),
3425        };
3426    }
3427    if let Some(ref local_var_str) = offset {
3428        local_var_req_builder =
3429            local_var_req_builder.query(&[("offset", &local_var_str.to_string())]);
3430    }
3431    if let Some(ref local_var_str) = ordering {
3432        local_var_req_builder =
3433            local_var_req_builder.query(&[("ordering", &local_var_str.to_string())]);
3434    }
3435    if let Some(ref local_var_str) = q {
3436        local_var_req_builder = local_var_req_builder.query(&[("q", &local_var_str.to_string())]);
3437    }
3438    if let Some(ref local_var_str) = slug {
3439        local_var_req_builder = match "multi" {
3440            "multi" => local_var_req_builder.query(
3441                &local_var_str
3442                    .into_iter()
3443                    .map(|p| ("slug".to_owned(), p.to_string()))
3444                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3445            ),
3446            _ => local_var_req_builder.query(&[(
3447                "slug",
3448                &local_var_str
3449                    .into_iter()
3450                    .map(|p| p.to_string())
3451                    .collect::<Vec<String>>()
3452                    .join(",")
3453                    .to_string(),
3454            )]),
3455        };
3456    }
3457    if let Some(ref local_var_str) = slug__empty {
3458        local_var_req_builder =
3459            local_var_req_builder.query(&[("slug__empty", &local_var_str.to_string())]);
3460    }
3461    if let Some(ref local_var_str) = slug__ic {
3462        local_var_req_builder = match "multi" {
3463            "multi" => local_var_req_builder.query(
3464                &local_var_str
3465                    .into_iter()
3466                    .map(|p| ("slug__ic".to_owned(), p.to_string()))
3467                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3468            ),
3469            _ => local_var_req_builder.query(&[(
3470                "slug__ic",
3471                &local_var_str
3472                    .into_iter()
3473                    .map(|p| p.to_string())
3474                    .collect::<Vec<String>>()
3475                    .join(",")
3476                    .to_string(),
3477            )]),
3478        };
3479    }
3480    if let Some(ref local_var_str) = slug__ie {
3481        local_var_req_builder = match "multi" {
3482            "multi" => local_var_req_builder.query(
3483                &local_var_str
3484                    .into_iter()
3485                    .map(|p| ("slug__ie".to_owned(), p.to_string()))
3486                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3487            ),
3488            _ => local_var_req_builder.query(&[(
3489                "slug__ie",
3490                &local_var_str
3491                    .into_iter()
3492                    .map(|p| p.to_string())
3493                    .collect::<Vec<String>>()
3494                    .join(",")
3495                    .to_string(),
3496            )]),
3497        };
3498    }
3499    if let Some(ref local_var_str) = slug__iew {
3500        local_var_req_builder = match "multi" {
3501            "multi" => local_var_req_builder.query(
3502                &local_var_str
3503                    .into_iter()
3504                    .map(|p| ("slug__iew".to_owned(), p.to_string()))
3505                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3506            ),
3507            _ => local_var_req_builder.query(&[(
3508                "slug__iew",
3509                &local_var_str
3510                    .into_iter()
3511                    .map(|p| p.to_string())
3512                    .collect::<Vec<String>>()
3513                    .join(",")
3514                    .to_string(),
3515            )]),
3516        };
3517    }
3518    if let Some(ref local_var_str) = slug__iregex {
3519        local_var_req_builder = match "multi" {
3520            "multi" => local_var_req_builder.query(
3521                &local_var_str
3522                    .into_iter()
3523                    .map(|p| ("slug__iregex".to_owned(), p.to_string()))
3524                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3525            ),
3526            _ => local_var_req_builder.query(&[(
3527                "slug__iregex",
3528                &local_var_str
3529                    .into_iter()
3530                    .map(|p| p.to_string())
3531                    .collect::<Vec<String>>()
3532                    .join(",")
3533                    .to_string(),
3534            )]),
3535        };
3536    }
3537    if let Some(ref local_var_str) = slug__isw {
3538        local_var_req_builder = match "multi" {
3539            "multi" => local_var_req_builder.query(
3540                &local_var_str
3541                    .into_iter()
3542                    .map(|p| ("slug__isw".to_owned(), p.to_string()))
3543                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3544            ),
3545            _ => local_var_req_builder.query(&[(
3546                "slug__isw",
3547                &local_var_str
3548                    .into_iter()
3549                    .map(|p| p.to_string())
3550                    .collect::<Vec<String>>()
3551                    .join(",")
3552                    .to_string(),
3553            )]),
3554        };
3555    }
3556    if let Some(ref local_var_str) = slug__n {
3557        local_var_req_builder = match "multi" {
3558            "multi" => local_var_req_builder.query(
3559                &local_var_str
3560                    .into_iter()
3561                    .map(|p| ("slug__n".to_owned(), p.to_string()))
3562                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3563            ),
3564            _ => local_var_req_builder.query(&[(
3565                "slug__n",
3566                &local_var_str
3567                    .into_iter()
3568                    .map(|p| p.to_string())
3569                    .collect::<Vec<String>>()
3570                    .join(",")
3571                    .to_string(),
3572            )]),
3573        };
3574    }
3575    if let Some(ref local_var_str) = slug__nic {
3576        local_var_req_builder = match "multi" {
3577            "multi" => local_var_req_builder.query(
3578                &local_var_str
3579                    .into_iter()
3580                    .map(|p| ("slug__nic".to_owned(), p.to_string()))
3581                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3582            ),
3583            _ => local_var_req_builder.query(&[(
3584                "slug__nic",
3585                &local_var_str
3586                    .into_iter()
3587                    .map(|p| p.to_string())
3588                    .collect::<Vec<String>>()
3589                    .join(",")
3590                    .to_string(),
3591            )]),
3592        };
3593    }
3594    if let Some(ref local_var_str) = slug__nie {
3595        local_var_req_builder = match "multi" {
3596            "multi" => local_var_req_builder.query(
3597                &local_var_str
3598                    .into_iter()
3599                    .map(|p| ("slug__nie".to_owned(), p.to_string()))
3600                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3601            ),
3602            _ => local_var_req_builder.query(&[(
3603                "slug__nie",
3604                &local_var_str
3605                    .into_iter()
3606                    .map(|p| p.to_string())
3607                    .collect::<Vec<String>>()
3608                    .join(",")
3609                    .to_string(),
3610            )]),
3611        };
3612    }
3613    if let Some(ref local_var_str) = slug__niew {
3614        local_var_req_builder = match "multi" {
3615            "multi" => local_var_req_builder.query(
3616                &local_var_str
3617                    .into_iter()
3618                    .map(|p| ("slug__niew".to_owned(), p.to_string()))
3619                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3620            ),
3621            _ => local_var_req_builder.query(&[(
3622                "slug__niew",
3623                &local_var_str
3624                    .into_iter()
3625                    .map(|p| p.to_string())
3626                    .collect::<Vec<String>>()
3627                    .join(",")
3628                    .to_string(),
3629            )]),
3630        };
3631    }
3632    if let Some(ref local_var_str) = slug__nisw {
3633        local_var_req_builder = match "multi" {
3634            "multi" => local_var_req_builder.query(
3635                &local_var_str
3636                    .into_iter()
3637                    .map(|p| ("slug__nisw".to_owned(), p.to_string()))
3638                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3639            ),
3640            _ => local_var_req_builder.query(&[(
3641                "slug__nisw",
3642                &local_var_str
3643                    .into_iter()
3644                    .map(|p| p.to_string())
3645                    .collect::<Vec<String>>()
3646                    .join(",")
3647                    .to_string(),
3648            )]),
3649        };
3650    }
3651    if let Some(ref local_var_str) = slug__regex {
3652        local_var_req_builder = match "multi" {
3653            "multi" => local_var_req_builder.query(
3654                &local_var_str
3655                    .into_iter()
3656                    .map(|p| ("slug__regex".to_owned(), p.to_string()))
3657                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3658            ),
3659            _ => local_var_req_builder.query(&[(
3660                "slug__regex",
3661                &local_var_str
3662                    .into_iter()
3663                    .map(|p| p.to_string())
3664                    .collect::<Vec<String>>()
3665                    .join(",")
3666                    .to_string(),
3667            )]),
3668        };
3669    }
3670    if let Some(ref local_var_str) = tag {
3671        local_var_req_builder = match "multi" {
3672            "multi" => local_var_req_builder.query(
3673                &local_var_str
3674                    .into_iter()
3675                    .map(|p| ("tag".to_owned(), p.to_string()))
3676                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3677            ),
3678            _ => local_var_req_builder.query(&[(
3679                "tag",
3680                &local_var_str
3681                    .into_iter()
3682                    .map(|p| p.to_string())
3683                    .collect::<Vec<String>>()
3684                    .join(",")
3685                    .to_string(),
3686            )]),
3687        };
3688    }
3689    if let Some(ref local_var_str) = tag__n {
3690        local_var_req_builder = match "multi" {
3691            "multi" => local_var_req_builder.query(
3692                &local_var_str
3693                    .into_iter()
3694                    .map(|p| ("tag__n".to_owned(), p.to_string()))
3695                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3696            ),
3697            _ => local_var_req_builder.query(&[(
3698                "tag__n",
3699                &local_var_str
3700                    .into_iter()
3701                    .map(|p| p.to_string())
3702                    .collect::<Vec<String>>()
3703                    .join(",")
3704                    .to_string(),
3705            )]),
3706        };
3707    }
3708    if let Some(ref local_var_str) = tag_id {
3709        local_var_req_builder = match "multi" {
3710            "multi" => local_var_req_builder.query(
3711                &local_var_str
3712                    .into_iter()
3713                    .map(|p| ("tag_id".to_owned(), p.to_string()))
3714                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3715            ),
3716            _ => local_var_req_builder.query(&[(
3717                "tag_id",
3718                &local_var_str
3719                    .into_iter()
3720                    .map(|p| p.to_string())
3721                    .collect::<Vec<String>>()
3722                    .join(",")
3723                    .to_string(),
3724            )]),
3725        };
3726    }
3727    if let Some(ref local_var_str) = tag_id__n {
3728        local_var_req_builder = match "multi" {
3729            "multi" => local_var_req_builder.query(
3730                &local_var_str
3731                    .into_iter()
3732                    .map(|p| ("tag_id__n".to_owned(), p.to_string()))
3733                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3734            ),
3735            _ => local_var_req_builder.query(&[(
3736                "tag_id__n",
3737                &local_var_str
3738                    .into_iter()
3739                    .map(|p| p.to_string())
3740                    .collect::<Vec<String>>()
3741                    .join(",")
3742                    .to_string(),
3743            )]),
3744        };
3745    }
3746    if let Some(ref local_var_str) = updated_by_request {
3747        local_var_req_builder =
3748            local_var_req_builder.query(&[("updated_by_request", &local_var_str.to_string())]);
3749    }
3750    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
3751        local_var_req_builder =
3752            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
3753    }
3754    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
3755        let local_var_key = local_var_apikey.key.clone();
3756        let local_var_value = match local_var_apikey.prefix {
3757            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
3758            None => local_var_key,
3759        };
3760        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
3761    };
3762
3763    let local_var_req = local_var_req_builder.build()?;
3764    let local_var_resp = local_var_client.execute(local_var_req).await?;
3765
3766    let local_var_status = local_var_resp.status();
3767    let local_var_content = local_var_resp.text().await?;
3768
3769    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
3770        serde_json::from_str(&local_var_content).map_err(Error::from)
3771    } else {
3772        let local_var_entity: Option<VirtualizationClusterTypesListError> =
3773            serde_json::from_str(&local_var_content).ok();
3774        let local_var_error = ResponseContent {
3775            status: local_var_status,
3776            content: local_var_content,
3777            entity: local_var_entity,
3778        };
3779        Err(Error::ResponseError(local_var_error))
3780    }
3781}
3782
3783/// Patch a cluster type object.
3784pub async fn virtualization_cluster_types_partial_update(
3785    configuration: &configuration::Configuration,
3786    id: i32,
3787    patched_cluster_type_request: Option<crate::models::PatchedClusterTypeRequest>,
3788) -> Result<crate::models::ClusterType, Error<VirtualizationClusterTypesPartialUpdateError>> {
3789    let local_var_configuration = configuration;
3790
3791    let local_var_client = &local_var_configuration.client;
3792
3793    let local_var_uri_str = format!(
3794        "{}/api/virtualization/cluster-types/{id}/",
3795        local_var_configuration.base_path,
3796        id = id
3797    );
3798    let mut local_var_req_builder =
3799        local_var_client.request(reqwest::Method::PATCH, local_var_uri_str.as_str());
3800
3801    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
3802        local_var_req_builder =
3803            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
3804    }
3805    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
3806        let local_var_key = local_var_apikey.key.clone();
3807        let local_var_value = match local_var_apikey.prefix {
3808            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
3809            None => local_var_key,
3810        };
3811        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
3812    };
3813    local_var_req_builder = local_var_req_builder.json(&patched_cluster_type_request);
3814
3815    let local_var_req = local_var_req_builder.build()?;
3816    let local_var_resp = local_var_client.execute(local_var_req).await?;
3817
3818    let local_var_status = local_var_resp.status();
3819    let local_var_content = local_var_resp.text().await?;
3820
3821    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
3822        serde_json::from_str(&local_var_content).map_err(Error::from)
3823    } else {
3824        let local_var_entity: Option<VirtualizationClusterTypesPartialUpdateError> =
3825            serde_json::from_str(&local_var_content).ok();
3826        let local_var_error = ResponseContent {
3827            status: local_var_status,
3828            content: local_var_content,
3829            entity: local_var_entity,
3830        };
3831        Err(Error::ResponseError(local_var_error))
3832    }
3833}
3834
3835/// Get a cluster type object.
3836pub async fn virtualization_cluster_types_retrieve(
3837    configuration: &configuration::Configuration,
3838    id: i32,
3839) -> Result<crate::models::ClusterType, Error<VirtualizationClusterTypesRetrieveError>> {
3840    let local_var_configuration = configuration;
3841
3842    let local_var_client = &local_var_configuration.client;
3843
3844    let local_var_uri_str = format!(
3845        "{}/api/virtualization/cluster-types/{id}/",
3846        local_var_configuration.base_path,
3847        id = id
3848    );
3849    let mut local_var_req_builder =
3850        local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
3851
3852    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
3853        local_var_req_builder =
3854            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
3855    }
3856    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
3857        let local_var_key = local_var_apikey.key.clone();
3858        let local_var_value = match local_var_apikey.prefix {
3859            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
3860            None => local_var_key,
3861        };
3862        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
3863    };
3864
3865    let local_var_req = local_var_req_builder.build()?;
3866    let local_var_resp = local_var_client.execute(local_var_req).await?;
3867
3868    let local_var_status = local_var_resp.status();
3869    let local_var_content = local_var_resp.text().await?;
3870
3871    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
3872        serde_json::from_str(&local_var_content).map_err(Error::from)
3873    } else {
3874        let local_var_entity: Option<VirtualizationClusterTypesRetrieveError> =
3875            serde_json::from_str(&local_var_content).ok();
3876        let local_var_error = ResponseContent {
3877            status: local_var_status,
3878            content: local_var_content,
3879            entity: local_var_entity,
3880        };
3881        Err(Error::ResponseError(local_var_error))
3882    }
3883}
3884
3885/// Put a cluster type object.
3886pub async fn virtualization_cluster_types_update(
3887    configuration: &configuration::Configuration,
3888    id: i32,
3889    cluster_type_request: crate::models::ClusterTypeRequest,
3890) -> Result<crate::models::ClusterType, Error<VirtualizationClusterTypesUpdateError>> {
3891    let local_var_configuration = configuration;
3892
3893    let local_var_client = &local_var_configuration.client;
3894
3895    let local_var_uri_str = format!(
3896        "{}/api/virtualization/cluster-types/{id}/",
3897        local_var_configuration.base_path,
3898        id = id
3899    );
3900    let mut local_var_req_builder =
3901        local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());
3902
3903    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
3904        local_var_req_builder =
3905            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
3906    }
3907    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
3908        let local_var_key = local_var_apikey.key.clone();
3909        let local_var_value = match local_var_apikey.prefix {
3910            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
3911            None => local_var_key,
3912        };
3913        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
3914    };
3915    local_var_req_builder = local_var_req_builder.json(&cluster_type_request);
3916
3917    let local_var_req = local_var_req_builder.build()?;
3918    let local_var_resp = local_var_client.execute(local_var_req).await?;
3919
3920    let local_var_status = local_var_resp.status();
3921    let local_var_content = local_var_resp.text().await?;
3922
3923    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
3924        serde_json::from_str(&local_var_content).map_err(Error::from)
3925    } else {
3926        let local_var_entity: Option<VirtualizationClusterTypesUpdateError> =
3927            serde_json::from_str(&local_var_content).ok();
3928        let local_var_error = ResponseContent {
3929            status: local_var_status,
3930            content: local_var_content,
3931            entity: local_var_entity,
3932        };
3933        Err(Error::ResponseError(local_var_error))
3934    }
3935}
3936
3937/// Delete a list of cluster objects.
3938pub async fn virtualization_clusters_bulk_destroy(
3939    configuration: &configuration::Configuration,
3940    cluster_request: Vec<crate::models::ClusterRequest>,
3941) -> Result<(), Error<VirtualizationClustersBulkDestroyError>> {
3942    let local_var_configuration = configuration;
3943
3944    let local_var_client = &local_var_configuration.client;
3945
3946    let local_var_uri_str = format!(
3947        "{}/api/virtualization/clusters/",
3948        local_var_configuration.base_path
3949    );
3950    let mut local_var_req_builder =
3951        local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());
3952
3953    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
3954        local_var_req_builder =
3955            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
3956    }
3957    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
3958        let local_var_key = local_var_apikey.key.clone();
3959        let local_var_value = match local_var_apikey.prefix {
3960            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
3961            None => local_var_key,
3962        };
3963        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
3964    };
3965    local_var_req_builder = local_var_req_builder.json(&cluster_request);
3966
3967    let local_var_req = local_var_req_builder.build()?;
3968    let local_var_resp = local_var_client.execute(local_var_req).await?;
3969
3970    let local_var_status = local_var_resp.status();
3971    let local_var_content = local_var_resp.text().await?;
3972
3973    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
3974        Ok(())
3975    } else {
3976        let local_var_entity: Option<VirtualizationClustersBulkDestroyError> =
3977            serde_json::from_str(&local_var_content).ok();
3978        let local_var_error = ResponseContent {
3979            status: local_var_status,
3980            content: local_var_content,
3981            entity: local_var_entity,
3982        };
3983        Err(Error::ResponseError(local_var_error))
3984    }
3985}
3986
3987/// Patch a list of cluster objects.
3988pub async fn virtualization_clusters_bulk_partial_update(
3989    configuration: &configuration::Configuration,
3990    cluster_request: Vec<crate::models::ClusterRequest>,
3991) -> Result<Vec<crate::models::Cluster>, Error<VirtualizationClustersBulkPartialUpdateError>> {
3992    let local_var_configuration = configuration;
3993
3994    let local_var_client = &local_var_configuration.client;
3995
3996    let local_var_uri_str = format!(
3997        "{}/api/virtualization/clusters/",
3998        local_var_configuration.base_path
3999    );
4000    let mut local_var_req_builder =
4001        local_var_client.request(reqwest::Method::PATCH, local_var_uri_str.as_str());
4002
4003    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
4004        local_var_req_builder =
4005            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
4006    }
4007    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
4008        let local_var_key = local_var_apikey.key.clone();
4009        let local_var_value = match local_var_apikey.prefix {
4010            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
4011            None => local_var_key,
4012        };
4013        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
4014    };
4015    local_var_req_builder = local_var_req_builder.json(&cluster_request);
4016
4017    let local_var_req = local_var_req_builder.build()?;
4018    let local_var_resp = local_var_client.execute(local_var_req).await?;
4019
4020    let local_var_status = local_var_resp.status();
4021    let local_var_content = local_var_resp.text().await?;
4022
4023    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
4024        serde_json::from_str(&local_var_content).map_err(Error::from)
4025    } else {
4026        let local_var_entity: Option<VirtualizationClustersBulkPartialUpdateError> =
4027            serde_json::from_str(&local_var_content).ok();
4028        let local_var_error = ResponseContent {
4029            status: local_var_status,
4030            content: local_var_content,
4031            entity: local_var_entity,
4032        };
4033        Err(Error::ResponseError(local_var_error))
4034    }
4035}
4036
4037/// Put a list of cluster objects.
4038pub async fn virtualization_clusters_bulk_update(
4039    configuration: &configuration::Configuration,
4040    cluster_request: Vec<crate::models::ClusterRequest>,
4041) -> Result<Vec<crate::models::Cluster>, Error<VirtualizationClustersBulkUpdateError>> {
4042    let local_var_configuration = configuration;
4043
4044    let local_var_client = &local_var_configuration.client;
4045
4046    let local_var_uri_str = format!(
4047        "{}/api/virtualization/clusters/",
4048        local_var_configuration.base_path
4049    );
4050    let mut local_var_req_builder =
4051        local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());
4052
4053    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
4054        local_var_req_builder =
4055            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
4056    }
4057    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
4058        let local_var_key = local_var_apikey.key.clone();
4059        let local_var_value = match local_var_apikey.prefix {
4060            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
4061            None => local_var_key,
4062        };
4063        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
4064    };
4065    local_var_req_builder = local_var_req_builder.json(&cluster_request);
4066
4067    let local_var_req = local_var_req_builder.build()?;
4068    let local_var_resp = local_var_client.execute(local_var_req).await?;
4069
4070    let local_var_status = local_var_resp.status();
4071    let local_var_content = local_var_resp.text().await?;
4072
4073    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
4074        serde_json::from_str(&local_var_content).map_err(Error::from)
4075    } else {
4076        let local_var_entity: Option<VirtualizationClustersBulkUpdateError> =
4077            serde_json::from_str(&local_var_content).ok();
4078        let local_var_error = ResponseContent {
4079            status: local_var_status,
4080            content: local_var_content,
4081            entity: local_var_entity,
4082        };
4083        Err(Error::ResponseError(local_var_error))
4084    }
4085}
4086
4087/// Post a list of cluster objects.
4088pub async fn virtualization_clusters_create(
4089    configuration: &configuration::Configuration,
4090    writable_cluster_request: crate::models::WritableClusterRequest,
4091) -> Result<crate::models::Cluster, Error<VirtualizationClustersCreateError>> {
4092    let local_var_configuration = configuration;
4093
4094    let local_var_client = &local_var_configuration.client;
4095
4096    let local_var_uri_str = format!(
4097        "{}/api/virtualization/clusters/",
4098        local_var_configuration.base_path
4099    );
4100    let mut local_var_req_builder =
4101        local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
4102
4103    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
4104        local_var_req_builder =
4105            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
4106    }
4107    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
4108        let local_var_key = local_var_apikey.key.clone();
4109        let local_var_value = match local_var_apikey.prefix {
4110            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
4111            None => local_var_key,
4112        };
4113        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
4114    };
4115    local_var_req_builder = local_var_req_builder.json(&writable_cluster_request);
4116
4117    let local_var_req = local_var_req_builder.build()?;
4118    let local_var_resp = local_var_client.execute(local_var_req).await?;
4119
4120    let local_var_status = local_var_resp.status();
4121    let local_var_content = local_var_resp.text().await?;
4122
4123    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
4124        serde_json::from_str(&local_var_content).map_err(Error::from)
4125    } else {
4126        let local_var_entity: Option<VirtualizationClustersCreateError> =
4127            serde_json::from_str(&local_var_content).ok();
4128        let local_var_error = ResponseContent {
4129            status: local_var_status,
4130            content: local_var_content,
4131            entity: local_var_entity,
4132        };
4133        Err(Error::ResponseError(local_var_error))
4134    }
4135}
4136
4137/// Delete a cluster object.
4138pub async fn virtualization_clusters_destroy(
4139    configuration: &configuration::Configuration,
4140    id: i32,
4141) -> Result<(), Error<VirtualizationClustersDestroyError>> {
4142    let local_var_configuration = configuration;
4143
4144    let local_var_client = &local_var_configuration.client;
4145
4146    let local_var_uri_str = format!(
4147        "{}/api/virtualization/clusters/{id}/",
4148        local_var_configuration.base_path,
4149        id = id
4150    );
4151    let mut local_var_req_builder =
4152        local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());
4153
4154    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
4155        local_var_req_builder =
4156            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
4157    }
4158    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
4159        let local_var_key = local_var_apikey.key.clone();
4160        let local_var_value = match local_var_apikey.prefix {
4161            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
4162            None => local_var_key,
4163        };
4164        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
4165    };
4166
4167    let local_var_req = local_var_req_builder.build()?;
4168    let local_var_resp = local_var_client.execute(local_var_req).await?;
4169
4170    let local_var_status = local_var_resp.status();
4171    let local_var_content = local_var_resp.text().await?;
4172
4173    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
4174        Ok(())
4175    } else {
4176        let local_var_entity: Option<VirtualizationClustersDestroyError> =
4177            serde_json::from_str(&local_var_content).ok();
4178        let local_var_error = ResponseContent {
4179            status: local_var_status,
4180            content: local_var_content,
4181            entity: local_var_entity,
4182        };
4183        Err(Error::ResponseError(local_var_error))
4184    }
4185}
4186
4187/// Get a list of cluster objects.
4188pub async fn virtualization_clusters_list(
4189    configuration: &configuration::Configuration,
4190    contact: Option<Vec<i32>>,
4191    contact__n: Option<Vec<i32>>,
4192    contact_group: Option<Vec<String>>,
4193    contact_group__n: Option<Vec<String>>,
4194    contact_role: Option<Vec<i32>>,
4195    contact_role__n: Option<Vec<i32>>,
4196    created: Option<Vec<String>>,
4197    created__empty: Option<Vec<String>>,
4198    created__gt: Option<Vec<String>>,
4199    created__gte: Option<Vec<String>>,
4200    created__lt: Option<Vec<String>>,
4201    created__lte: Option<Vec<String>>,
4202    created__n: Option<Vec<String>>,
4203    created_by_request: Option<&str>,
4204    description: Option<Vec<String>>,
4205    description__empty: Option<bool>,
4206    description__ic: Option<Vec<String>>,
4207    description__ie: Option<Vec<String>>,
4208    description__iew: Option<Vec<String>>,
4209    description__iregex: Option<Vec<String>>,
4210    description__isw: Option<Vec<String>>,
4211    description__n: Option<Vec<String>>,
4212    description__nic: Option<Vec<String>>,
4213    description__nie: Option<Vec<String>>,
4214    description__niew: Option<Vec<String>>,
4215    description__nisw: Option<Vec<String>>,
4216    description__regex: Option<Vec<String>>,
4217    group: Option<Vec<String>>,
4218    group__n: Option<Vec<String>>,
4219    group_id: Option<Vec<i32>>,
4220    group_id__n: Option<Vec<i32>>,
4221    id: Option<Vec<i32>>,
4222    id__empty: Option<bool>,
4223    id__gt: Option<Vec<i32>>,
4224    id__gte: Option<Vec<i32>>,
4225    id__lt: Option<Vec<i32>>,
4226    id__lte: Option<Vec<i32>>,
4227    id__n: Option<Vec<i32>>,
4228    last_updated: Option<Vec<String>>,
4229    last_updated__empty: Option<Vec<String>>,
4230    last_updated__gt: Option<Vec<String>>,
4231    last_updated__gte: Option<Vec<String>>,
4232    last_updated__lt: Option<Vec<String>>,
4233    last_updated__lte: Option<Vec<String>>,
4234    last_updated__n: Option<Vec<String>>,
4235    limit: Option<i32>,
4236    location: Option<Vec<String>>,
4237    location__n: Option<Vec<String>>,
4238    location_id: Option<Vec<String>>,
4239    location_id__n: Option<Vec<String>>,
4240    modified_by_request: Option<&str>,
4241    name: Option<Vec<String>>,
4242    name__empty: Option<bool>,
4243    name__ic: Option<Vec<String>>,
4244    name__ie: Option<Vec<String>>,
4245    name__iew: Option<Vec<String>>,
4246    name__iregex: Option<Vec<String>>,
4247    name__isw: Option<Vec<String>>,
4248    name__n: Option<Vec<String>>,
4249    name__nic: Option<Vec<String>>,
4250    name__nie: Option<Vec<String>>,
4251    name__niew: Option<Vec<String>>,
4252    name__nisw: Option<Vec<String>>,
4253    name__regex: Option<Vec<String>>,
4254    offset: Option<i32>,
4255    ordering: Option<&str>,
4256    q: Option<&str>,
4257    region: Option<Vec<String>>,
4258    region__n: Option<Vec<String>>,
4259    region_id: Option<Vec<String>>,
4260    region_id__n: Option<Vec<String>>,
4261    scope_id: Option<Vec<i32>>,
4262    scope_id__empty: Option<bool>,
4263    scope_id__gt: Option<Vec<i32>>,
4264    scope_id__gte: Option<Vec<i32>>,
4265    scope_id__lt: Option<Vec<i32>>,
4266    scope_id__lte: Option<Vec<i32>>,
4267    scope_id__n: Option<Vec<i32>>,
4268    scope_type: Option<&str>,
4269    scope_type__n: Option<&str>,
4270    site: Option<Vec<String>>,
4271    site__n: Option<Vec<String>>,
4272    site_group: Option<Vec<String>>,
4273    site_group__n: Option<Vec<String>>,
4274    site_group_id: Option<Vec<String>>,
4275    site_group_id__n: Option<Vec<String>>,
4276    site_id: Option<Vec<i32>>,
4277    site_id__n: Option<Vec<i32>>,
4278    status: Option<Vec<String>>,
4279    status__empty: Option<bool>,
4280    status__ic: Option<Vec<String>>,
4281    status__ie: Option<Vec<String>>,
4282    status__iew: Option<Vec<String>>,
4283    status__iregex: Option<Vec<String>>,
4284    status__isw: Option<Vec<String>>,
4285    status__n: Option<Vec<String>>,
4286    status__nic: Option<Vec<String>>,
4287    status__nie: Option<Vec<String>>,
4288    status__niew: Option<Vec<String>>,
4289    status__nisw: Option<Vec<String>>,
4290    status__regex: Option<Vec<String>>,
4291    tag: Option<Vec<String>>,
4292    tag__n: Option<Vec<String>>,
4293    tag_id: Option<Vec<i32>>,
4294    tag_id__n: Option<Vec<i32>>,
4295    tenant: Option<Vec<String>>,
4296    tenant__n: Option<Vec<String>>,
4297    tenant_group: Option<Vec<String>>,
4298    tenant_group__n: Option<Vec<String>>,
4299    tenant_group_id: Option<Vec<String>>,
4300    tenant_group_id__n: Option<Vec<String>>,
4301    tenant_id: Option<Vec<i32>>,
4302    tenant_id__n: Option<Vec<i32>>,
4303    r#type: Option<Vec<String>>,
4304    type__n: Option<Vec<String>>,
4305    type_id: Option<Vec<i32>>,
4306    type_id__n: Option<Vec<i32>>,
4307    updated_by_request: Option<&str>,
4308) -> Result<crate::models::PaginatedClusterList, Error<VirtualizationClustersListError>> {
4309    let local_var_configuration = configuration;
4310
4311    let local_var_client = &local_var_configuration.client;
4312
4313    let local_var_uri_str = format!(
4314        "{}/api/virtualization/clusters/",
4315        local_var_configuration.base_path
4316    );
4317    let mut local_var_req_builder =
4318        local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
4319
4320    if let Some(ref local_var_str) = contact {
4321        local_var_req_builder = match "multi" {
4322            "multi" => local_var_req_builder.query(
4323                &local_var_str
4324                    .into_iter()
4325                    .map(|p| ("contact".to_owned(), p.to_string()))
4326                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4327            ),
4328            _ => local_var_req_builder.query(&[(
4329                "contact",
4330                &local_var_str
4331                    .into_iter()
4332                    .map(|p| p.to_string())
4333                    .collect::<Vec<String>>()
4334                    .join(",")
4335                    .to_string(),
4336            )]),
4337        };
4338    }
4339    if let Some(ref local_var_str) = contact__n {
4340        local_var_req_builder = match "multi" {
4341            "multi" => local_var_req_builder.query(
4342                &local_var_str
4343                    .into_iter()
4344                    .map(|p| ("contact__n".to_owned(), p.to_string()))
4345                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4346            ),
4347            _ => local_var_req_builder.query(&[(
4348                "contact__n",
4349                &local_var_str
4350                    .into_iter()
4351                    .map(|p| p.to_string())
4352                    .collect::<Vec<String>>()
4353                    .join(",")
4354                    .to_string(),
4355            )]),
4356        };
4357    }
4358    if let Some(ref local_var_str) = contact_group {
4359        local_var_req_builder = match "multi" {
4360            "multi" => local_var_req_builder.query(
4361                &local_var_str
4362                    .into_iter()
4363                    .map(|p| ("contact_group".to_owned(), p.to_string()))
4364                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4365            ),
4366            _ => local_var_req_builder.query(&[(
4367                "contact_group",
4368                &local_var_str
4369                    .into_iter()
4370                    .map(|p| p.to_string())
4371                    .collect::<Vec<String>>()
4372                    .join(",")
4373                    .to_string(),
4374            )]),
4375        };
4376    }
4377    if let Some(ref local_var_str) = contact_group__n {
4378        local_var_req_builder = match "multi" {
4379            "multi" => local_var_req_builder.query(
4380                &local_var_str
4381                    .into_iter()
4382                    .map(|p| ("contact_group__n".to_owned(), p.to_string()))
4383                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4384            ),
4385            _ => local_var_req_builder.query(&[(
4386                "contact_group__n",
4387                &local_var_str
4388                    .into_iter()
4389                    .map(|p| p.to_string())
4390                    .collect::<Vec<String>>()
4391                    .join(",")
4392                    .to_string(),
4393            )]),
4394        };
4395    }
4396    if let Some(ref local_var_str) = contact_role {
4397        local_var_req_builder = match "multi" {
4398            "multi" => local_var_req_builder.query(
4399                &local_var_str
4400                    .into_iter()
4401                    .map(|p| ("contact_role".to_owned(), p.to_string()))
4402                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4403            ),
4404            _ => local_var_req_builder.query(&[(
4405                "contact_role",
4406                &local_var_str
4407                    .into_iter()
4408                    .map(|p| p.to_string())
4409                    .collect::<Vec<String>>()
4410                    .join(",")
4411                    .to_string(),
4412            )]),
4413        };
4414    }
4415    if let Some(ref local_var_str) = contact_role__n {
4416        local_var_req_builder = match "multi" {
4417            "multi" => local_var_req_builder.query(
4418                &local_var_str
4419                    .into_iter()
4420                    .map(|p| ("contact_role__n".to_owned(), p.to_string()))
4421                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4422            ),
4423            _ => local_var_req_builder.query(&[(
4424                "contact_role__n",
4425                &local_var_str
4426                    .into_iter()
4427                    .map(|p| p.to_string())
4428                    .collect::<Vec<String>>()
4429                    .join(",")
4430                    .to_string(),
4431            )]),
4432        };
4433    }
4434    if let Some(ref local_var_str) = created {
4435        local_var_req_builder = match "multi" {
4436            "multi" => local_var_req_builder.query(
4437                &local_var_str
4438                    .into_iter()
4439                    .map(|p| ("created".to_owned(), p.to_string()))
4440                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4441            ),
4442            _ => local_var_req_builder.query(&[(
4443                "created",
4444                &local_var_str
4445                    .into_iter()
4446                    .map(|p| p.to_string())
4447                    .collect::<Vec<String>>()
4448                    .join(",")
4449                    .to_string(),
4450            )]),
4451        };
4452    }
4453    if let Some(ref local_var_str) = created__empty {
4454        local_var_req_builder = match "multi" {
4455            "multi" => local_var_req_builder.query(
4456                &local_var_str
4457                    .into_iter()
4458                    .map(|p| ("created__empty".to_owned(), p.to_string()))
4459                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4460            ),
4461            _ => local_var_req_builder.query(&[(
4462                "created__empty",
4463                &local_var_str
4464                    .into_iter()
4465                    .map(|p| p.to_string())
4466                    .collect::<Vec<String>>()
4467                    .join(",")
4468                    .to_string(),
4469            )]),
4470        };
4471    }
4472    if let Some(ref local_var_str) = created__gt {
4473        local_var_req_builder = match "multi" {
4474            "multi" => local_var_req_builder.query(
4475                &local_var_str
4476                    .into_iter()
4477                    .map(|p| ("created__gt".to_owned(), p.to_string()))
4478                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4479            ),
4480            _ => local_var_req_builder.query(&[(
4481                "created__gt",
4482                &local_var_str
4483                    .into_iter()
4484                    .map(|p| p.to_string())
4485                    .collect::<Vec<String>>()
4486                    .join(",")
4487                    .to_string(),
4488            )]),
4489        };
4490    }
4491    if let Some(ref local_var_str) = created__gte {
4492        local_var_req_builder = match "multi" {
4493            "multi" => local_var_req_builder.query(
4494                &local_var_str
4495                    .into_iter()
4496                    .map(|p| ("created__gte".to_owned(), p.to_string()))
4497                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4498            ),
4499            _ => local_var_req_builder.query(&[(
4500                "created__gte",
4501                &local_var_str
4502                    .into_iter()
4503                    .map(|p| p.to_string())
4504                    .collect::<Vec<String>>()
4505                    .join(",")
4506                    .to_string(),
4507            )]),
4508        };
4509    }
4510    if let Some(ref local_var_str) = created__lt {
4511        local_var_req_builder = match "multi" {
4512            "multi" => local_var_req_builder.query(
4513                &local_var_str
4514                    .into_iter()
4515                    .map(|p| ("created__lt".to_owned(), p.to_string()))
4516                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4517            ),
4518            _ => local_var_req_builder.query(&[(
4519                "created__lt",
4520                &local_var_str
4521                    .into_iter()
4522                    .map(|p| p.to_string())
4523                    .collect::<Vec<String>>()
4524                    .join(",")
4525                    .to_string(),
4526            )]),
4527        };
4528    }
4529    if let Some(ref local_var_str) = created__lte {
4530        local_var_req_builder = match "multi" {
4531            "multi" => local_var_req_builder.query(
4532                &local_var_str
4533                    .into_iter()
4534                    .map(|p| ("created__lte".to_owned(), p.to_string()))
4535                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4536            ),
4537            _ => local_var_req_builder.query(&[(
4538                "created__lte",
4539                &local_var_str
4540                    .into_iter()
4541                    .map(|p| p.to_string())
4542                    .collect::<Vec<String>>()
4543                    .join(",")
4544                    .to_string(),
4545            )]),
4546        };
4547    }
4548    if let Some(ref local_var_str) = created__n {
4549        local_var_req_builder = match "multi" {
4550            "multi" => local_var_req_builder.query(
4551                &local_var_str
4552                    .into_iter()
4553                    .map(|p| ("created__n".to_owned(), p.to_string()))
4554                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4555            ),
4556            _ => local_var_req_builder.query(&[(
4557                "created__n",
4558                &local_var_str
4559                    .into_iter()
4560                    .map(|p| p.to_string())
4561                    .collect::<Vec<String>>()
4562                    .join(",")
4563                    .to_string(),
4564            )]),
4565        };
4566    }
4567    if let Some(ref local_var_str) = created_by_request {
4568        local_var_req_builder =
4569            local_var_req_builder.query(&[("created_by_request", &local_var_str.to_string())]);
4570    }
4571    if let Some(ref local_var_str) = description {
4572        local_var_req_builder = match "multi" {
4573            "multi" => local_var_req_builder.query(
4574                &local_var_str
4575                    .into_iter()
4576                    .map(|p| ("description".to_owned(), p.to_string()))
4577                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4578            ),
4579            _ => local_var_req_builder.query(&[(
4580                "description",
4581                &local_var_str
4582                    .into_iter()
4583                    .map(|p| p.to_string())
4584                    .collect::<Vec<String>>()
4585                    .join(",")
4586                    .to_string(),
4587            )]),
4588        };
4589    }
4590    if let Some(ref local_var_str) = description__empty {
4591        local_var_req_builder =
4592            local_var_req_builder.query(&[("description__empty", &local_var_str.to_string())]);
4593    }
4594    if let Some(ref local_var_str) = description__ic {
4595        local_var_req_builder = match "multi" {
4596            "multi" => local_var_req_builder.query(
4597                &local_var_str
4598                    .into_iter()
4599                    .map(|p| ("description__ic".to_owned(), p.to_string()))
4600                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4601            ),
4602            _ => local_var_req_builder.query(&[(
4603                "description__ic",
4604                &local_var_str
4605                    .into_iter()
4606                    .map(|p| p.to_string())
4607                    .collect::<Vec<String>>()
4608                    .join(",")
4609                    .to_string(),
4610            )]),
4611        };
4612    }
4613    if let Some(ref local_var_str) = description__ie {
4614        local_var_req_builder = match "multi" {
4615            "multi" => local_var_req_builder.query(
4616                &local_var_str
4617                    .into_iter()
4618                    .map(|p| ("description__ie".to_owned(), p.to_string()))
4619                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4620            ),
4621            _ => local_var_req_builder.query(&[(
4622                "description__ie",
4623                &local_var_str
4624                    .into_iter()
4625                    .map(|p| p.to_string())
4626                    .collect::<Vec<String>>()
4627                    .join(",")
4628                    .to_string(),
4629            )]),
4630        };
4631    }
4632    if let Some(ref local_var_str) = description__iew {
4633        local_var_req_builder = match "multi" {
4634            "multi" => local_var_req_builder.query(
4635                &local_var_str
4636                    .into_iter()
4637                    .map(|p| ("description__iew".to_owned(), p.to_string()))
4638                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4639            ),
4640            _ => local_var_req_builder.query(&[(
4641                "description__iew",
4642                &local_var_str
4643                    .into_iter()
4644                    .map(|p| p.to_string())
4645                    .collect::<Vec<String>>()
4646                    .join(",")
4647                    .to_string(),
4648            )]),
4649        };
4650    }
4651    if let Some(ref local_var_str) = description__iregex {
4652        local_var_req_builder = match "multi" {
4653            "multi" => local_var_req_builder.query(
4654                &local_var_str
4655                    .into_iter()
4656                    .map(|p| ("description__iregex".to_owned(), p.to_string()))
4657                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4658            ),
4659            _ => local_var_req_builder.query(&[(
4660                "description__iregex",
4661                &local_var_str
4662                    .into_iter()
4663                    .map(|p| p.to_string())
4664                    .collect::<Vec<String>>()
4665                    .join(",")
4666                    .to_string(),
4667            )]),
4668        };
4669    }
4670    if let Some(ref local_var_str) = description__isw {
4671        local_var_req_builder = match "multi" {
4672            "multi" => local_var_req_builder.query(
4673                &local_var_str
4674                    .into_iter()
4675                    .map(|p| ("description__isw".to_owned(), p.to_string()))
4676                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4677            ),
4678            _ => local_var_req_builder.query(&[(
4679                "description__isw",
4680                &local_var_str
4681                    .into_iter()
4682                    .map(|p| p.to_string())
4683                    .collect::<Vec<String>>()
4684                    .join(",")
4685                    .to_string(),
4686            )]),
4687        };
4688    }
4689    if let Some(ref local_var_str) = description__n {
4690        local_var_req_builder = match "multi" {
4691            "multi" => local_var_req_builder.query(
4692                &local_var_str
4693                    .into_iter()
4694                    .map(|p| ("description__n".to_owned(), p.to_string()))
4695                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4696            ),
4697            _ => local_var_req_builder.query(&[(
4698                "description__n",
4699                &local_var_str
4700                    .into_iter()
4701                    .map(|p| p.to_string())
4702                    .collect::<Vec<String>>()
4703                    .join(",")
4704                    .to_string(),
4705            )]),
4706        };
4707    }
4708    if let Some(ref local_var_str) = description__nic {
4709        local_var_req_builder = match "multi" {
4710            "multi" => local_var_req_builder.query(
4711                &local_var_str
4712                    .into_iter()
4713                    .map(|p| ("description__nic".to_owned(), p.to_string()))
4714                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4715            ),
4716            _ => local_var_req_builder.query(&[(
4717                "description__nic",
4718                &local_var_str
4719                    .into_iter()
4720                    .map(|p| p.to_string())
4721                    .collect::<Vec<String>>()
4722                    .join(",")
4723                    .to_string(),
4724            )]),
4725        };
4726    }
4727    if let Some(ref local_var_str) = description__nie {
4728        local_var_req_builder = match "multi" {
4729            "multi" => local_var_req_builder.query(
4730                &local_var_str
4731                    .into_iter()
4732                    .map(|p| ("description__nie".to_owned(), p.to_string()))
4733                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4734            ),
4735            _ => local_var_req_builder.query(&[(
4736                "description__nie",
4737                &local_var_str
4738                    .into_iter()
4739                    .map(|p| p.to_string())
4740                    .collect::<Vec<String>>()
4741                    .join(",")
4742                    .to_string(),
4743            )]),
4744        };
4745    }
4746    if let Some(ref local_var_str) = description__niew {
4747        local_var_req_builder = match "multi" {
4748            "multi" => local_var_req_builder.query(
4749                &local_var_str
4750                    .into_iter()
4751                    .map(|p| ("description__niew".to_owned(), p.to_string()))
4752                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4753            ),
4754            _ => local_var_req_builder.query(&[(
4755                "description__niew",
4756                &local_var_str
4757                    .into_iter()
4758                    .map(|p| p.to_string())
4759                    .collect::<Vec<String>>()
4760                    .join(",")
4761                    .to_string(),
4762            )]),
4763        };
4764    }
4765    if let Some(ref local_var_str) = description__nisw {
4766        local_var_req_builder = match "multi" {
4767            "multi" => local_var_req_builder.query(
4768                &local_var_str
4769                    .into_iter()
4770                    .map(|p| ("description__nisw".to_owned(), p.to_string()))
4771                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4772            ),
4773            _ => local_var_req_builder.query(&[(
4774                "description__nisw",
4775                &local_var_str
4776                    .into_iter()
4777                    .map(|p| p.to_string())
4778                    .collect::<Vec<String>>()
4779                    .join(",")
4780                    .to_string(),
4781            )]),
4782        };
4783    }
4784    if let Some(ref local_var_str) = description__regex {
4785        local_var_req_builder = match "multi" {
4786            "multi" => local_var_req_builder.query(
4787                &local_var_str
4788                    .into_iter()
4789                    .map(|p| ("description__regex".to_owned(), p.to_string()))
4790                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4791            ),
4792            _ => local_var_req_builder.query(&[(
4793                "description__regex",
4794                &local_var_str
4795                    .into_iter()
4796                    .map(|p| p.to_string())
4797                    .collect::<Vec<String>>()
4798                    .join(",")
4799                    .to_string(),
4800            )]),
4801        };
4802    }
4803    if let Some(ref local_var_str) = group {
4804        local_var_req_builder = match "multi" {
4805            "multi" => local_var_req_builder.query(
4806                &local_var_str
4807                    .into_iter()
4808                    .map(|p| ("group".to_owned(), p.to_string()))
4809                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4810            ),
4811            _ => local_var_req_builder.query(&[(
4812                "group",
4813                &local_var_str
4814                    .into_iter()
4815                    .map(|p| p.to_string())
4816                    .collect::<Vec<String>>()
4817                    .join(",")
4818                    .to_string(),
4819            )]),
4820        };
4821    }
4822    if let Some(ref local_var_str) = group__n {
4823        local_var_req_builder = match "multi" {
4824            "multi" => local_var_req_builder.query(
4825                &local_var_str
4826                    .into_iter()
4827                    .map(|p| ("group__n".to_owned(), p.to_string()))
4828                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4829            ),
4830            _ => local_var_req_builder.query(&[(
4831                "group__n",
4832                &local_var_str
4833                    .into_iter()
4834                    .map(|p| p.to_string())
4835                    .collect::<Vec<String>>()
4836                    .join(",")
4837                    .to_string(),
4838            )]),
4839        };
4840    }
4841    if let Some(ref local_var_str) = group_id {
4842        local_var_req_builder = match "multi" {
4843            "multi" => local_var_req_builder.query(
4844                &local_var_str
4845                    .into_iter()
4846                    .map(|p| ("group_id".to_owned(), p.to_string()))
4847                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4848            ),
4849            _ => local_var_req_builder.query(&[(
4850                "group_id",
4851                &local_var_str
4852                    .into_iter()
4853                    .map(|p| p.to_string())
4854                    .collect::<Vec<String>>()
4855                    .join(",")
4856                    .to_string(),
4857            )]),
4858        };
4859    }
4860    if let Some(ref local_var_str) = group_id__n {
4861        local_var_req_builder = match "multi" {
4862            "multi" => local_var_req_builder.query(
4863                &local_var_str
4864                    .into_iter()
4865                    .map(|p| ("group_id__n".to_owned(), p.to_string()))
4866                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4867            ),
4868            _ => local_var_req_builder.query(&[(
4869                "group_id__n",
4870                &local_var_str
4871                    .into_iter()
4872                    .map(|p| p.to_string())
4873                    .collect::<Vec<String>>()
4874                    .join(",")
4875                    .to_string(),
4876            )]),
4877        };
4878    }
4879    if let Some(ref local_var_str) = id {
4880        local_var_req_builder = match "multi" {
4881            "multi" => local_var_req_builder.query(
4882                &local_var_str
4883                    .into_iter()
4884                    .map(|p| ("id".to_owned(), p.to_string()))
4885                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4886            ),
4887            _ => local_var_req_builder.query(&[(
4888                "id",
4889                &local_var_str
4890                    .into_iter()
4891                    .map(|p| p.to_string())
4892                    .collect::<Vec<String>>()
4893                    .join(",")
4894                    .to_string(),
4895            )]),
4896        };
4897    }
4898    if let Some(ref local_var_str) = id__empty {
4899        local_var_req_builder =
4900            local_var_req_builder.query(&[("id__empty", &local_var_str.to_string())]);
4901    }
4902    if let Some(ref local_var_str) = id__gt {
4903        local_var_req_builder = match "multi" {
4904            "multi" => local_var_req_builder.query(
4905                &local_var_str
4906                    .into_iter()
4907                    .map(|p| ("id__gt".to_owned(), p.to_string()))
4908                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4909            ),
4910            _ => local_var_req_builder.query(&[(
4911                "id__gt",
4912                &local_var_str
4913                    .into_iter()
4914                    .map(|p| p.to_string())
4915                    .collect::<Vec<String>>()
4916                    .join(",")
4917                    .to_string(),
4918            )]),
4919        };
4920    }
4921    if let Some(ref local_var_str) = id__gte {
4922        local_var_req_builder = match "multi" {
4923            "multi" => local_var_req_builder.query(
4924                &local_var_str
4925                    .into_iter()
4926                    .map(|p| ("id__gte".to_owned(), p.to_string()))
4927                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4928            ),
4929            _ => local_var_req_builder.query(&[(
4930                "id__gte",
4931                &local_var_str
4932                    .into_iter()
4933                    .map(|p| p.to_string())
4934                    .collect::<Vec<String>>()
4935                    .join(",")
4936                    .to_string(),
4937            )]),
4938        };
4939    }
4940    if let Some(ref local_var_str) = id__lt {
4941        local_var_req_builder = match "multi" {
4942            "multi" => local_var_req_builder.query(
4943                &local_var_str
4944                    .into_iter()
4945                    .map(|p| ("id__lt".to_owned(), p.to_string()))
4946                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4947            ),
4948            _ => local_var_req_builder.query(&[(
4949                "id__lt",
4950                &local_var_str
4951                    .into_iter()
4952                    .map(|p| p.to_string())
4953                    .collect::<Vec<String>>()
4954                    .join(",")
4955                    .to_string(),
4956            )]),
4957        };
4958    }
4959    if let Some(ref local_var_str) = id__lte {
4960        local_var_req_builder = match "multi" {
4961            "multi" => local_var_req_builder.query(
4962                &local_var_str
4963                    .into_iter()
4964                    .map(|p| ("id__lte".to_owned(), p.to_string()))
4965                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4966            ),
4967            _ => local_var_req_builder.query(&[(
4968                "id__lte",
4969                &local_var_str
4970                    .into_iter()
4971                    .map(|p| p.to_string())
4972                    .collect::<Vec<String>>()
4973                    .join(",")
4974                    .to_string(),
4975            )]),
4976        };
4977    }
4978    if let Some(ref local_var_str) = id__n {
4979        local_var_req_builder = match "multi" {
4980            "multi" => local_var_req_builder.query(
4981                &local_var_str
4982                    .into_iter()
4983                    .map(|p| ("id__n".to_owned(), p.to_string()))
4984                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4985            ),
4986            _ => local_var_req_builder.query(&[(
4987                "id__n",
4988                &local_var_str
4989                    .into_iter()
4990                    .map(|p| p.to_string())
4991                    .collect::<Vec<String>>()
4992                    .join(",")
4993                    .to_string(),
4994            )]),
4995        };
4996    }
4997    if let Some(ref local_var_str) = last_updated {
4998        local_var_req_builder = match "multi" {
4999            "multi" => local_var_req_builder.query(
5000                &local_var_str
5001                    .into_iter()
5002                    .map(|p| ("last_updated".to_owned(), p.to_string()))
5003                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5004            ),
5005            _ => local_var_req_builder.query(&[(
5006                "last_updated",
5007                &local_var_str
5008                    .into_iter()
5009                    .map(|p| p.to_string())
5010                    .collect::<Vec<String>>()
5011                    .join(",")
5012                    .to_string(),
5013            )]),
5014        };
5015    }
5016    if let Some(ref local_var_str) = last_updated__empty {
5017        local_var_req_builder = match "multi" {
5018            "multi" => local_var_req_builder.query(
5019                &local_var_str
5020                    .into_iter()
5021                    .map(|p| ("last_updated__empty".to_owned(), p.to_string()))
5022                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5023            ),
5024            _ => local_var_req_builder.query(&[(
5025                "last_updated__empty",
5026                &local_var_str
5027                    .into_iter()
5028                    .map(|p| p.to_string())
5029                    .collect::<Vec<String>>()
5030                    .join(",")
5031                    .to_string(),
5032            )]),
5033        };
5034    }
5035    if let Some(ref local_var_str) = last_updated__gt {
5036        local_var_req_builder = match "multi" {
5037            "multi" => local_var_req_builder.query(
5038                &local_var_str
5039                    .into_iter()
5040                    .map(|p| ("last_updated__gt".to_owned(), p.to_string()))
5041                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5042            ),
5043            _ => local_var_req_builder.query(&[(
5044                "last_updated__gt",
5045                &local_var_str
5046                    .into_iter()
5047                    .map(|p| p.to_string())
5048                    .collect::<Vec<String>>()
5049                    .join(",")
5050                    .to_string(),
5051            )]),
5052        };
5053    }
5054    if let Some(ref local_var_str) = last_updated__gte {
5055        local_var_req_builder = match "multi" {
5056            "multi" => local_var_req_builder.query(
5057                &local_var_str
5058                    .into_iter()
5059                    .map(|p| ("last_updated__gte".to_owned(), p.to_string()))
5060                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5061            ),
5062            _ => local_var_req_builder.query(&[(
5063                "last_updated__gte",
5064                &local_var_str
5065                    .into_iter()
5066                    .map(|p| p.to_string())
5067                    .collect::<Vec<String>>()
5068                    .join(",")
5069                    .to_string(),
5070            )]),
5071        };
5072    }
5073    if let Some(ref local_var_str) = last_updated__lt {
5074        local_var_req_builder = match "multi" {
5075            "multi" => local_var_req_builder.query(
5076                &local_var_str
5077                    .into_iter()
5078                    .map(|p| ("last_updated__lt".to_owned(), p.to_string()))
5079                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5080            ),
5081            _ => local_var_req_builder.query(&[(
5082                "last_updated__lt",
5083                &local_var_str
5084                    .into_iter()
5085                    .map(|p| p.to_string())
5086                    .collect::<Vec<String>>()
5087                    .join(",")
5088                    .to_string(),
5089            )]),
5090        };
5091    }
5092    if let Some(ref local_var_str) = last_updated__lte {
5093        local_var_req_builder = match "multi" {
5094            "multi" => local_var_req_builder.query(
5095                &local_var_str
5096                    .into_iter()
5097                    .map(|p| ("last_updated__lte".to_owned(), p.to_string()))
5098                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5099            ),
5100            _ => local_var_req_builder.query(&[(
5101                "last_updated__lte",
5102                &local_var_str
5103                    .into_iter()
5104                    .map(|p| p.to_string())
5105                    .collect::<Vec<String>>()
5106                    .join(",")
5107                    .to_string(),
5108            )]),
5109        };
5110    }
5111    if let Some(ref local_var_str) = last_updated__n {
5112        local_var_req_builder = match "multi" {
5113            "multi" => local_var_req_builder.query(
5114                &local_var_str
5115                    .into_iter()
5116                    .map(|p| ("last_updated__n".to_owned(), p.to_string()))
5117                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5118            ),
5119            _ => local_var_req_builder.query(&[(
5120                "last_updated__n",
5121                &local_var_str
5122                    .into_iter()
5123                    .map(|p| p.to_string())
5124                    .collect::<Vec<String>>()
5125                    .join(",")
5126                    .to_string(),
5127            )]),
5128        };
5129    }
5130    if let Some(ref local_var_str) = limit {
5131        local_var_req_builder =
5132            local_var_req_builder.query(&[("limit", &local_var_str.to_string())]);
5133    }
5134    if let Some(ref local_var_str) = location {
5135        local_var_req_builder = match "multi" {
5136            "multi" => local_var_req_builder.query(
5137                &local_var_str
5138                    .into_iter()
5139                    .map(|p| ("location".to_owned(), p.to_string()))
5140                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5141            ),
5142            _ => local_var_req_builder.query(&[(
5143                "location",
5144                &local_var_str
5145                    .into_iter()
5146                    .map(|p| p.to_string())
5147                    .collect::<Vec<String>>()
5148                    .join(",")
5149                    .to_string(),
5150            )]),
5151        };
5152    }
5153    if let Some(ref local_var_str) = location__n {
5154        local_var_req_builder = match "multi" {
5155            "multi" => local_var_req_builder.query(
5156                &local_var_str
5157                    .into_iter()
5158                    .map(|p| ("location__n".to_owned(), p.to_string()))
5159                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5160            ),
5161            _ => local_var_req_builder.query(&[(
5162                "location__n",
5163                &local_var_str
5164                    .into_iter()
5165                    .map(|p| p.to_string())
5166                    .collect::<Vec<String>>()
5167                    .join(",")
5168                    .to_string(),
5169            )]),
5170        };
5171    }
5172    if let Some(ref local_var_str) = location_id {
5173        local_var_req_builder = match "multi" {
5174            "multi" => local_var_req_builder.query(
5175                &local_var_str
5176                    .into_iter()
5177                    .map(|p| ("location_id".to_owned(), p.to_string()))
5178                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5179            ),
5180            _ => local_var_req_builder.query(&[(
5181                "location_id",
5182                &local_var_str
5183                    .into_iter()
5184                    .map(|p| p.to_string())
5185                    .collect::<Vec<String>>()
5186                    .join(",")
5187                    .to_string(),
5188            )]),
5189        };
5190    }
5191    if let Some(ref local_var_str) = location_id__n {
5192        local_var_req_builder = match "multi" {
5193            "multi" => local_var_req_builder.query(
5194                &local_var_str
5195                    .into_iter()
5196                    .map(|p| ("location_id__n".to_owned(), p.to_string()))
5197                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5198            ),
5199            _ => local_var_req_builder.query(&[(
5200                "location_id__n",
5201                &local_var_str
5202                    .into_iter()
5203                    .map(|p| p.to_string())
5204                    .collect::<Vec<String>>()
5205                    .join(",")
5206                    .to_string(),
5207            )]),
5208        };
5209    }
5210    if let Some(ref local_var_str) = modified_by_request {
5211        local_var_req_builder =
5212            local_var_req_builder.query(&[("modified_by_request", &local_var_str.to_string())]);
5213    }
5214    if let Some(ref local_var_str) = name {
5215        local_var_req_builder = match "multi" {
5216            "multi" => local_var_req_builder.query(
5217                &local_var_str
5218                    .into_iter()
5219                    .map(|p| ("name".to_owned(), p.to_string()))
5220                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5221            ),
5222            _ => local_var_req_builder.query(&[(
5223                "name",
5224                &local_var_str
5225                    .into_iter()
5226                    .map(|p| p.to_string())
5227                    .collect::<Vec<String>>()
5228                    .join(",")
5229                    .to_string(),
5230            )]),
5231        };
5232    }
5233    if let Some(ref local_var_str) = name__empty {
5234        local_var_req_builder =
5235            local_var_req_builder.query(&[("name__empty", &local_var_str.to_string())]);
5236    }
5237    if let Some(ref local_var_str) = name__ic {
5238        local_var_req_builder = match "multi" {
5239            "multi" => local_var_req_builder.query(
5240                &local_var_str
5241                    .into_iter()
5242                    .map(|p| ("name__ic".to_owned(), p.to_string()))
5243                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5244            ),
5245            _ => local_var_req_builder.query(&[(
5246                "name__ic",
5247                &local_var_str
5248                    .into_iter()
5249                    .map(|p| p.to_string())
5250                    .collect::<Vec<String>>()
5251                    .join(",")
5252                    .to_string(),
5253            )]),
5254        };
5255    }
5256    if let Some(ref local_var_str) = name__ie {
5257        local_var_req_builder = match "multi" {
5258            "multi" => local_var_req_builder.query(
5259                &local_var_str
5260                    .into_iter()
5261                    .map(|p| ("name__ie".to_owned(), p.to_string()))
5262                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5263            ),
5264            _ => local_var_req_builder.query(&[(
5265                "name__ie",
5266                &local_var_str
5267                    .into_iter()
5268                    .map(|p| p.to_string())
5269                    .collect::<Vec<String>>()
5270                    .join(",")
5271                    .to_string(),
5272            )]),
5273        };
5274    }
5275    if let Some(ref local_var_str) = name__iew {
5276        local_var_req_builder = match "multi" {
5277            "multi" => local_var_req_builder.query(
5278                &local_var_str
5279                    .into_iter()
5280                    .map(|p| ("name__iew".to_owned(), p.to_string()))
5281                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5282            ),
5283            _ => local_var_req_builder.query(&[(
5284                "name__iew",
5285                &local_var_str
5286                    .into_iter()
5287                    .map(|p| p.to_string())
5288                    .collect::<Vec<String>>()
5289                    .join(",")
5290                    .to_string(),
5291            )]),
5292        };
5293    }
5294    if let Some(ref local_var_str) = name__iregex {
5295        local_var_req_builder = match "multi" {
5296            "multi" => local_var_req_builder.query(
5297                &local_var_str
5298                    .into_iter()
5299                    .map(|p| ("name__iregex".to_owned(), p.to_string()))
5300                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5301            ),
5302            _ => local_var_req_builder.query(&[(
5303                "name__iregex",
5304                &local_var_str
5305                    .into_iter()
5306                    .map(|p| p.to_string())
5307                    .collect::<Vec<String>>()
5308                    .join(",")
5309                    .to_string(),
5310            )]),
5311        };
5312    }
5313    if let Some(ref local_var_str) = name__isw {
5314        local_var_req_builder = match "multi" {
5315            "multi" => local_var_req_builder.query(
5316                &local_var_str
5317                    .into_iter()
5318                    .map(|p| ("name__isw".to_owned(), p.to_string()))
5319                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5320            ),
5321            _ => local_var_req_builder.query(&[(
5322                "name__isw",
5323                &local_var_str
5324                    .into_iter()
5325                    .map(|p| p.to_string())
5326                    .collect::<Vec<String>>()
5327                    .join(",")
5328                    .to_string(),
5329            )]),
5330        };
5331    }
5332    if let Some(ref local_var_str) = name__n {
5333        local_var_req_builder = match "multi" {
5334            "multi" => local_var_req_builder.query(
5335                &local_var_str
5336                    .into_iter()
5337                    .map(|p| ("name__n".to_owned(), p.to_string()))
5338                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5339            ),
5340            _ => local_var_req_builder.query(&[(
5341                "name__n",
5342                &local_var_str
5343                    .into_iter()
5344                    .map(|p| p.to_string())
5345                    .collect::<Vec<String>>()
5346                    .join(",")
5347                    .to_string(),
5348            )]),
5349        };
5350    }
5351    if let Some(ref local_var_str) = name__nic {
5352        local_var_req_builder = match "multi" {
5353            "multi" => local_var_req_builder.query(
5354                &local_var_str
5355                    .into_iter()
5356                    .map(|p| ("name__nic".to_owned(), p.to_string()))
5357                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5358            ),
5359            _ => local_var_req_builder.query(&[(
5360                "name__nic",
5361                &local_var_str
5362                    .into_iter()
5363                    .map(|p| p.to_string())
5364                    .collect::<Vec<String>>()
5365                    .join(",")
5366                    .to_string(),
5367            )]),
5368        };
5369    }
5370    if let Some(ref local_var_str) = name__nie {
5371        local_var_req_builder = match "multi" {
5372            "multi" => local_var_req_builder.query(
5373                &local_var_str
5374                    .into_iter()
5375                    .map(|p| ("name__nie".to_owned(), p.to_string()))
5376                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5377            ),
5378            _ => local_var_req_builder.query(&[(
5379                "name__nie",
5380                &local_var_str
5381                    .into_iter()
5382                    .map(|p| p.to_string())
5383                    .collect::<Vec<String>>()
5384                    .join(",")
5385                    .to_string(),
5386            )]),
5387        };
5388    }
5389    if let Some(ref local_var_str) = name__niew {
5390        local_var_req_builder = match "multi" {
5391            "multi" => local_var_req_builder.query(
5392                &local_var_str
5393                    .into_iter()
5394                    .map(|p| ("name__niew".to_owned(), p.to_string()))
5395                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5396            ),
5397            _ => local_var_req_builder.query(&[(
5398                "name__niew",
5399                &local_var_str
5400                    .into_iter()
5401                    .map(|p| p.to_string())
5402                    .collect::<Vec<String>>()
5403                    .join(",")
5404                    .to_string(),
5405            )]),
5406        };
5407    }
5408    if let Some(ref local_var_str) = name__nisw {
5409        local_var_req_builder = match "multi" {
5410            "multi" => local_var_req_builder.query(
5411                &local_var_str
5412                    .into_iter()
5413                    .map(|p| ("name__nisw".to_owned(), p.to_string()))
5414                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5415            ),
5416            _ => local_var_req_builder.query(&[(
5417                "name__nisw",
5418                &local_var_str
5419                    .into_iter()
5420                    .map(|p| p.to_string())
5421                    .collect::<Vec<String>>()
5422                    .join(",")
5423                    .to_string(),
5424            )]),
5425        };
5426    }
5427    if let Some(ref local_var_str) = name__regex {
5428        local_var_req_builder = match "multi" {
5429            "multi" => local_var_req_builder.query(
5430                &local_var_str
5431                    .into_iter()
5432                    .map(|p| ("name__regex".to_owned(), p.to_string()))
5433                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5434            ),
5435            _ => local_var_req_builder.query(&[(
5436                "name__regex",
5437                &local_var_str
5438                    .into_iter()
5439                    .map(|p| p.to_string())
5440                    .collect::<Vec<String>>()
5441                    .join(",")
5442                    .to_string(),
5443            )]),
5444        };
5445    }
5446    if let Some(ref local_var_str) = offset {
5447        local_var_req_builder =
5448            local_var_req_builder.query(&[("offset", &local_var_str.to_string())]);
5449    }
5450    if let Some(ref local_var_str) = ordering {
5451        local_var_req_builder =
5452            local_var_req_builder.query(&[("ordering", &local_var_str.to_string())]);
5453    }
5454    if let Some(ref local_var_str) = q {
5455        local_var_req_builder = local_var_req_builder.query(&[("q", &local_var_str.to_string())]);
5456    }
5457    if let Some(ref local_var_str) = region {
5458        local_var_req_builder = match "multi" {
5459            "multi" => local_var_req_builder.query(
5460                &local_var_str
5461                    .into_iter()
5462                    .map(|p| ("region".to_owned(), p.to_string()))
5463                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5464            ),
5465            _ => local_var_req_builder.query(&[(
5466                "region",
5467                &local_var_str
5468                    .into_iter()
5469                    .map(|p| p.to_string())
5470                    .collect::<Vec<String>>()
5471                    .join(",")
5472                    .to_string(),
5473            )]),
5474        };
5475    }
5476    if let Some(ref local_var_str) = region__n {
5477        local_var_req_builder = match "multi" {
5478            "multi" => local_var_req_builder.query(
5479                &local_var_str
5480                    .into_iter()
5481                    .map(|p| ("region__n".to_owned(), p.to_string()))
5482                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5483            ),
5484            _ => local_var_req_builder.query(&[(
5485                "region__n",
5486                &local_var_str
5487                    .into_iter()
5488                    .map(|p| p.to_string())
5489                    .collect::<Vec<String>>()
5490                    .join(",")
5491                    .to_string(),
5492            )]),
5493        };
5494    }
5495    if let Some(ref local_var_str) = region_id {
5496        local_var_req_builder = match "multi" {
5497            "multi" => local_var_req_builder.query(
5498                &local_var_str
5499                    .into_iter()
5500                    .map(|p| ("region_id".to_owned(), p.to_string()))
5501                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5502            ),
5503            _ => local_var_req_builder.query(&[(
5504                "region_id",
5505                &local_var_str
5506                    .into_iter()
5507                    .map(|p| p.to_string())
5508                    .collect::<Vec<String>>()
5509                    .join(",")
5510                    .to_string(),
5511            )]),
5512        };
5513    }
5514    if let Some(ref local_var_str) = region_id__n {
5515        local_var_req_builder = match "multi" {
5516            "multi" => local_var_req_builder.query(
5517                &local_var_str
5518                    .into_iter()
5519                    .map(|p| ("region_id__n".to_owned(), p.to_string()))
5520                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5521            ),
5522            _ => local_var_req_builder.query(&[(
5523                "region_id__n",
5524                &local_var_str
5525                    .into_iter()
5526                    .map(|p| p.to_string())
5527                    .collect::<Vec<String>>()
5528                    .join(",")
5529                    .to_string(),
5530            )]),
5531        };
5532    }
5533    if let Some(ref local_var_str) = scope_id {
5534        local_var_req_builder = match "multi" {
5535            "multi" => local_var_req_builder.query(
5536                &local_var_str
5537                    .into_iter()
5538                    .map(|p| ("scope_id".to_owned(), p.to_string()))
5539                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5540            ),
5541            _ => local_var_req_builder.query(&[(
5542                "scope_id",
5543                &local_var_str
5544                    .into_iter()
5545                    .map(|p| p.to_string())
5546                    .collect::<Vec<String>>()
5547                    .join(",")
5548                    .to_string(),
5549            )]),
5550        };
5551    }
5552    if let Some(ref local_var_str) = scope_id__empty {
5553        local_var_req_builder =
5554            local_var_req_builder.query(&[("scope_id__empty", &local_var_str.to_string())]);
5555    }
5556    if let Some(ref local_var_str) = scope_id__gt {
5557        local_var_req_builder = match "multi" {
5558            "multi" => local_var_req_builder.query(
5559                &local_var_str
5560                    .into_iter()
5561                    .map(|p| ("scope_id__gt".to_owned(), p.to_string()))
5562                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5563            ),
5564            _ => local_var_req_builder.query(&[(
5565                "scope_id__gt",
5566                &local_var_str
5567                    .into_iter()
5568                    .map(|p| p.to_string())
5569                    .collect::<Vec<String>>()
5570                    .join(",")
5571                    .to_string(),
5572            )]),
5573        };
5574    }
5575    if let Some(ref local_var_str) = scope_id__gte {
5576        local_var_req_builder = match "multi" {
5577            "multi" => local_var_req_builder.query(
5578                &local_var_str
5579                    .into_iter()
5580                    .map(|p| ("scope_id__gte".to_owned(), p.to_string()))
5581                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5582            ),
5583            _ => local_var_req_builder.query(&[(
5584                "scope_id__gte",
5585                &local_var_str
5586                    .into_iter()
5587                    .map(|p| p.to_string())
5588                    .collect::<Vec<String>>()
5589                    .join(",")
5590                    .to_string(),
5591            )]),
5592        };
5593    }
5594    if let Some(ref local_var_str) = scope_id__lt {
5595        local_var_req_builder = match "multi" {
5596            "multi" => local_var_req_builder.query(
5597                &local_var_str
5598                    .into_iter()
5599                    .map(|p| ("scope_id__lt".to_owned(), p.to_string()))
5600                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5601            ),
5602            _ => local_var_req_builder.query(&[(
5603                "scope_id__lt",
5604                &local_var_str
5605                    .into_iter()
5606                    .map(|p| p.to_string())
5607                    .collect::<Vec<String>>()
5608                    .join(",")
5609                    .to_string(),
5610            )]),
5611        };
5612    }
5613    if let Some(ref local_var_str) = scope_id__lte {
5614        local_var_req_builder = match "multi" {
5615            "multi" => local_var_req_builder.query(
5616                &local_var_str
5617                    .into_iter()
5618                    .map(|p| ("scope_id__lte".to_owned(), p.to_string()))
5619                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5620            ),
5621            _ => local_var_req_builder.query(&[(
5622                "scope_id__lte",
5623                &local_var_str
5624                    .into_iter()
5625                    .map(|p| p.to_string())
5626                    .collect::<Vec<String>>()
5627                    .join(",")
5628                    .to_string(),
5629            )]),
5630        };
5631    }
5632    if let Some(ref local_var_str) = scope_id__n {
5633        local_var_req_builder = match "multi" {
5634            "multi" => local_var_req_builder.query(
5635                &local_var_str
5636                    .into_iter()
5637                    .map(|p| ("scope_id__n".to_owned(), p.to_string()))
5638                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5639            ),
5640            _ => local_var_req_builder.query(&[(
5641                "scope_id__n",
5642                &local_var_str
5643                    .into_iter()
5644                    .map(|p| p.to_string())
5645                    .collect::<Vec<String>>()
5646                    .join(",")
5647                    .to_string(),
5648            )]),
5649        };
5650    }
5651    if let Some(ref local_var_str) = scope_type {
5652        local_var_req_builder =
5653            local_var_req_builder.query(&[("scope_type", &local_var_str.to_string())]);
5654    }
5655    if let Some(ref local_var_str) = scope_type__n {
5656        local_var_req_builder =
5657            local_var_req_builder.query(&[("scope_type__n", &local_var_str.to_string())]);
5658    }
5659    if let Some(ref local_var_str) = site {
5660        local_var_req_builder = match "multi" {
5661            "multi" => local_var_req_builder.query(
5662                &local_var_str
5663                    .into_iter()
5664                    .map(|p| ("site".to_owned(), p.to_string()))
5665                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5666            ),
5667            _ => local_var_req_builder.query(&[(
5668                "site",
5669                &local_var_str
5670                    .into_iter()
5671                    .map(|p| p.to_string())
5672                    .collect::<Vec<String>>()
5673                    .join(",")
5674                    .to_string(),
5675            )]),
5676        };
5677    }
5678    if let Some(ref local_var_str) = site__n {
5679        local_var_req_builder = match "multi" {
5680            "multi" => local_var_req_builder.query(
5681                &local_var_str
5682                    .into_iter()
5683                    .map(|p| ("site__n".to_owned(), p.to_string()))
5684                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5685            ),
5686            _ => local_var_req_builder.query(&[(
5687                "site__n",
5688                &local_var_str
5689                    .into_iter()
5690                    .map(|p| p.to_string())
5691                    .collect::<Vec<String>>()
5692                    .join(",")
5693                    .to_string(),
5694            )]),
5695        };
5696    }
5697    if let Some(ref local_var_str) = site_group {
5698        local_var_req_builder = match "multi" {
5699            "multi" => local_var_req_builder.query(
5700                &local_var_str
5701                    .into_iter()
5702                    .map(|p| ("site_group".to_owned(), p.to_string()))
5703                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5704            ),
5705            _ => local_var_req_builder.query(&[(
5706                "site_group",
5707                &local_var_str
5708                    .into_iter()
5709                    .map(|p| p.to_string())
5710                    .collect::<Vec<String>>()
5711                    .join(",")
5712                    .to_string(),
5713            )]),
5714        };
5715    }
5716    if let Some(ref local_var_str) = site_group__n {
5717        local_var_req_builder = match "multi" {
5718            "multi" => local_var_req_builder.query(
5719                &local_var_str
5720                    .into_iter()
5721                    .map(|p| ("site_group__n".to_owned(), p.to_string()))
5722                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5723            ),
5724            _ => local_var_req_builder.query(&[(
5725                "site_group__n",
5726                &local_var_str
5727                    .into_iter()
5728                    .map(|p| p.to_string())
5729                    .collect::<Vec<String>>()
5730                    .join(",")
5731                    .to_string(),
5732            )]),
5733        };
5734    }
5735    if let Some(ref local_var_str) = site_group_id {
5736        local_var_req_builder = match "multi" {
5737            "multi" => local_var_req_builder.query(
5738                &local_var_str
5739                    .into_iter()
5740                    .map(|p| ("site_group_id".to_owned(), p.to_string()))
5741                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5742            ),
5743            _ => local_var_req_builder.query(&[(
5744                "site_group_id",
5745                &local_var_str
5746                    .into_iter()
5747                    .map(|p| p.to_string())
5748                    .collect::<Vec<String>>()
5749                    .join(",")
5750                    .to_string(),
5751            )]),
5752        };
5753    }
5754    if let Some(ref local_var_str) = site_group_id__n {
5755        local_var_req_builder = match "multi" {
5756            "multi" => local_var_req_builder.query(
5757                &local_var_str
5758                    .into_iter()
5759                    .map(|p| ("site_group_id__n".to_owned(), p.to_string()))
5760                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5761            ),
5762            _ => local_var_req_builder.query(&[(
5763                "site_group_id__n",
5764                &local_var_str
5765                    .into_iter()
5766                    .map(|p| p.to_string())
5767                    .collect::<Vec<String>>()
5768                    .join(",")
5769                    .to_string(),
5770            )]),
5771        };
5772    }
5773    if let Some(ref local_var_str) = site_id {
5774        local_var_req_builder = match "multi" {
5775            "multi" => local_var_req_builder.query(
5776                &local_var_str
5777                    .into_iter()
5778                    .map(|p| ("site_id".to_owned(), p.to_string()))
5779                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5780            ),
5781            _ => local_var_req_builder.query(&[(
5782                "site_id",
5783                &local_var_str
5784                    .into_iter()
5785                    .map(|p| p.to_string())
5786                    .collect::<Vec<String>>()
5787                    .join(",")
5788                    .to_string(),
5789            )]),
5790        };
5791    }
5792    if let Some(ref local_var_str) = site_id__n {
5793        local_var_req_builder = match "multi" {
5794            "multi" => local_var_req_builder.query(
5795                &local_var_str
5796                    .into_iter()
5797                    .map(|p| ("site_id__n".to_owned(), p.to_string()))
5798                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5799            ),
5800            _ => local_var_req_builder.query(&[(
5801                "site_id__n",
5802                &local_var_str
5803                    .into_iter()
5804                    .map(|p| p.to_string())
5805                    .collect::<Vec<String>>()
5806                    .join(",")
5807                    .to_string(),
5808            )]),
5809        };
5810    }
5811    if let Some(ref local_var_str) = status {
5812        local_var_req_builder = match "multi" {
5813            "multi" => local_var_req_builder.query(
5814                &local_var_str
5815                    .into_iter()
5816                    .map(|p| ("status".to_owned(), p.to_string()))
5817                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5818            ),
5819            _ => local_var_req_builder.query(&[(
5820                "status",
5821                &local_var_str
5822                    .into_iter()
5823                    .map(|p| p.to_string())
5824                    .collect::<Vec<String>>()
5825                    .join(",")
5826                    .to_string(),
5827            )]),
5828        };
5829    }
5830    if let Some(ref local_var_str) = status__empty {
5831        local_var_req_builder =
5832            local_var_req_builder.query(&[("status__empty", &local_var_str.to_string())]);
5833    }
5834    if let Some(ref local_var_str) = status__ic {
5835        local_var_req_builder = match "multi" {
5836            "multi" => local_var_req_builder.query(
5837                &local_var_str
5838                    .into_iter()
5839                    .map(|p| ("status__ic".to_owned(), p.to_string()))
5840                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5841            ),
5842            _ => local_var_req_builder.query(&[(
5843                "status__ic",
5844                &local_var_str
5845                    .into_iter()
5846                    .map(|p| p.to_string())
5847                    .collect::<Vec<String>>()
5848                    .join(",")
5849                    .to_string(),
5850            )]),
5851        };
5852    }
5853    if let Some(ref local_var_str) = status__ie {
5854        local_var_req_builder = match "multi" {
5855            "multi" => local_var_req_builder.query(
5856                &local_var_str
5857                    .into_iter()
5858                    .map(|p| ("status__ie".to_owned(), p.to_string()))
5859                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5860            ),
5861            _ => local_var_req_builder.query(&[(
5862                "status__ie",
5863                &local_var_str
5864                    .into_iter()
5865                    .map(|p| p.to_string())
5866                    .collect::<Vec<String>>()
5867                    .join(",")
5868                    .to_string(),
5869            )]),
5870        };
5871    }
5872    if let Some(ref local_var_str) = status__iew {
5873        local_var_req_builder = match "multi" {
5874            "multi" => local_var_req_builder.query(
5875                &local_var_str
5876                    .into_iter()
5877                    .map(|p| ("status__iew".to_owned(), p.to_string()))
5878                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5879            ),
5880            _ => local_var_req_builder.query(&[(
5881                "status__iew",
5882                &local_var_str
5883                    .into_iter()
5884                    .map(|p| p.to_string())
5885                    .collect::<Vec<String>>()
5886                    .join(",")
5887                    .to_string(),
5888            )]),
5889        };
5890    }
5891    if let Some(ref local_var_str) = status__iregex {
5892        local_var_req_builder = match "multi" {
5893            "multi" => local_var_req_builder.query(
5894                &local_var_str
5895                    .into_iter()
5896                    .map(|p| ("status__iregex".to_owned(), p.to_string()))
5897                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5898            ),
5899            _ => local_var_req_builder.query(&[(
5900                "status__iregex",
5901                &local_var_str
5902                    .into_iter()
5903                    .map(|p| p.to_string())
5904                    .collect::<Vec<String>>()
5905                    .join(",")
5906                    .to_string(),
5907            )]),
5908        };
5909    }
5910    if let Some(ref local_var_str) = status__isw {
5911        local_var_req_builder = match "multi" {
5912            "multi" => local_var_req_builder.query(
5913                &local_var_str
5914                    .into_iter()
5915                    .map(|p| ("status__isw".to_owned(), p.to_string()))
5916                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5917            ),
5918            _ => local_var_req_builder.query(&[(
5919                "status__isw",
5920                &local_var_str
5921                    .into_iter()
5922                    .map(|p| p.to_string())
5923                    .collect::<Vec<String>>()
5924                    .join(",")
5925                    .to_string(),
5926            )]),
5927        };
5928    }
5929    if let Some(ref local_var_str) = status__n {
5930        local_var_req_builder = match "multi" {
5931            "multi" => local_var_req_builder.query(
5932                &local_var_str
5933                    .into_iter()
5934                    .map(|p| ("status__n".to_owned(), p.to_string()))
5935                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5936            ),
5937            _ => local_var_req_builder.query(&[(
5938                "status__n",
5939                &local_var_str
5940                    .into_iter()
5941                    .map(|p| p.to_string())
5942                    .collect::<Vec<String>>()
5943                    .join(",")
5944                    .to_string(),
5945            )]),
5946        };
5947    }
5948    if let Some(ref local_var_str) = status__nic {
5949        local_var_req_builder = match "multi" {
5950            "multi" => local_var_req_builder.query(
5951                &local_var_str
5952                    .into_iter()
5953                    .map(|p| ("status__nic".to_owned(), p.to_string()))
5954                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5955            ),
5956            _ => local_var_req_builder.query(&[(
5957                "status__nic",
5958                &local_var_str
5959                    .into_iter()
5960                    .map(|p| p.to_string())
5961                    .collect::<Vec<String>>()
5962                    .join(",")
5963                    .to_string(),
5964            )]),
5965        };
5966    }
5967    if let Some(ref local_var_str) = status__nie {
5968        local_var_req_builder = match "multi" {
5969            "multi" => local_var_req_builder.query(
5970                &local_var_str
5971                    .into_iter()
5972                    .map(|p| ("status__nie".to_owned(), p.to_string()))
5973                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5974            ),
5975            _ => local_var_req_builder.query(&[(
5976                "status__nie",
5977                &local_var_str
5978                    .into_iter()
5979                    .map(|p| p.to_string())
5980                    .collect::<Vec<String>>()
5981                    .join(",")
5982                    .to_string(),
5983            )]),
5984        };
5985    }
5986    if let Some(ref local_var_str) = status__niew {
5987        local_var_req_builder = match "multi" {
5988            "multi" => local_var_req_builder.query(
5989                &local_var_str
5990                    .into_iter()
5991                    .map(|p| ("status__niew".to_owned(), p.to_string()))
5992                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5993            ),
5994            _ => local_var_req_builder.query(&[(
5995                "status__niew",
5996                &local_var_str
5997                    .into_iter()
5998                    .map(|p| p.to_string())
5999                    .collect::<Vec<String>>()
6000                    .join(",")
6001                    .to_string(),
6002            )]),
6003        };
6004    }
6005    if let Some(ref local_var_str) = status__nisw {
6006        local_var_req_builder = match "multi" {
6007            "multi" => local_var_req_builder.query(
6008                &local_var_str
6009                    .into_iter()
6010                    .map(|p| ("status__nisw".to_owned(), p.to_string()))
6011                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6012            ),
6013            _ => local_var_req_builder.query(&[(
6014                "status__nisw",
6015                &local_var_str
6016                    .into_iter()
6017                    .map(|p| p.to_string())
6018                    .collect::<Vec<String>>()
6019                    .join(",")
6020                    .to_string(),
6021            )]),
6022        };
6023    }
6024    if let Some(ref local_var_str) = status__regex {
6025        local_var_req_builder = match "multi" {
6026            "multi" => local_var_req_builder.query(
6027                &local_var_str
6028                    .into_iter()
6029                    .map(|p| ("status__regex".to_owned(), p.to_string()))
6030                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6031            ),
6032            _ => local_var_req_builder.query(&[(
6033                "status__regex",
6034                &local_var_str
6035                    .into_iter()
6036                    .map(|p| p.to_string())
6037                    .collect::<Vec<String>>()
6038                    .join(",")
6039                    .to_string(),
6040            )]),
6041        };
6042    }
6043    if let Some(ref local_var_str) = tag {
6044        local_var_req_builder = match "multi" {
6045            "multi" => local_var_req_builder.query(
6046                &local_var_str
6047                    .into_iter()
6048                    .map(|p| ("tag".to_owned(), p.to_string()))
6049                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6050            ),
6051            _ => local_var_req_builder.query(&[(
6052                "tag",
6053                &local_var_str
6054                    .into_iter()
6055                    .map(|p| p.to_string())
6056                    .collect::<Vec<String>>()
6057                    .join(",")
6058                    .to_string(),
6059            )]),
6060        };
6061    }
6062    if let Some(ref local_var_str) = tag__n {
6063        local_var_req_builder = match "multi" {
6064            "multi" => local_var_req_builder.query(
6065                &local_var_str
6066                    .into_iter()
6067                    .map(|p| ("tag__n".to_owned(), p.to_string()))
6068                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6069            ),
6070            _ => local_var_req_builder.query(&[(
6071                "tag__n",
6072                &local_var_str
6073                    .into_iter()
6074                    .map(|p| p.to_string())
6075                    .collect::<Vec<String>>()
6076                    .join(",")
6077                    .to_string(),
6078            )]),
6079        };
6080    }
6081    if let Some(ref local_var_str) = tag_id {
6082        local_var_req_builder = match "multi" {
6083            "multi" => local_var_req_builder.query(
6084                &local_var_str
6085                    .into_iter()
6086                    .map(|p| ("tag_id".to_owned(), p.to_string()))
6087                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6088            ),
6089            _ => local_var_req_builder.query(&[(
6090                "tag_id",
6091                &local_var_str
6092                    .into_iter()
6093                    .map(|p| p.to_string())
6094                    .collect::<Vec<String>>()
6095                    .join(",")
6096                    .to_string(),
6097            )]),
6098        };
6099    }
6100    if let Some(ref local_var_str) = tag_id__n {
6101        local_var_req_builder = match "multi" {
6102            "multi" => local_var_req_builder.query(
6103                &local_var_str
6104                    .into_iter()
6105                    .map(|p| ("tag_id__n".to_owned(), p.to_string()))
6106                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6107            ),
6108            _ => local_var_req_builder.query(&[(
6109                "tag_id__n",
6110                &local_var_str
6111                    .into_iter()
6112                    .map(|p| p.to_string())
6113                    .collect::<Vec<String>>()
6114                    .join(",")
6115                    .to_string(),
6116            )]),
6117        };
6118    }
6119    if let Some(ref local_var_str) = tenant {
6120        local_var_req_builder = match "multi" {
6121            "multi" => local_var_req_builder.query(
6122                &local_var_str
6123                    .into_iter()
6124                    .map(|p| ("tenant".to_owned(), p.to_string()))
6125                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6126            ),
6127            _ => local_var_req_builder.query(&[(
6128                "tenant",
6129                &local_var_str
6130                    .into_iter()
6131                    .map(|p| p.to_string())
6132                    .collect::<Vec<String>>()
6133                    .join(",")
6134                    .to_string(),
6135            )]),
6136        };
6137    }
6138    if let Some(ref local_var_str) = tenant__n {
6139        local_var_req_builder = match "multi" {
6140            "multi" => local_var_req_builder.query(
6141                &local_var_str
6142                    .into_iter()
6143                    .map(|p| ("tenant__n".to_owned(), p.to_string()))
6144                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6145            ),
6146            _ => local_var_req_builder.query(&[(
6147                "tenant__n",
6148                &local_var_str
6149                    .into_iter()
6150                    .map(|p| p.to_string())
6151                    .collect::<Vec<String>>()
6152                    .join(",")
6153                    .to_string(),
6154            )]),
6155        };
6156    }
6157    if let Some(ref local_var_str) = tenant_group {
6158        local_var_req_builder = match "multi" {
6159            "multi" => local_var_req_builder.query(
6160                &local_var_str
6161                    .into_iter()
6162                    .map(|p| ("tenant_group".to_owned(), p.to_string()))
6163                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6164            ),
6165            _ => local_var_req_builder.query(&[(
6166                "tenant_group",
6167                &local_var_str
6168                    .into_iter()
6169                    .map(|p| p.to_string())
6170                    .collect::<Vec<String>>()
6171                    .join(",")
6172                    .to_string(),
6173            )]),
6174        };
6175    }
6176    if let Some(ref local_var_str) = tenant_group__n {
6177        local_var_req_builder = match "multi" {
6178            "multi" => local_var_req_builder.query(
6179                &local_var_str
6180                    .into_iter()
6181                    .map(|p| ("tenant_group__n".to_owned(), p.to_string()))
6182                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6183            ),
6184            _ => local_var_req_builder.query(&[(
6185                "tenant_group__n",
6186                &local_var_str
6187                    .into_iter()
6188                    .map(|p| p.to_string())
6189                    .collect::<Vec<String>>()
6190                    .join(",")
6191                    .to_string(),
6192            )]),
6193        };
6194    }
6195    if let Some(ref local_var_str) = tenant_group_id {
6196        local_var_req_builder = match "multi" {
6197            "multi" => local_var_req_builder.query(
6198                &local_var_str
6199                    .into_iter()
6200                    .map(|p| ("tenant_group_id".to_owned(), p.to_string()))
6201                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6202            ),
6203            _ => local_var_req_builder.query(&[(
6204                "tenant_group_id",
6205                &local_var_str
6206                    .into_iter()
6207                    .map(|p| p.to_string())
6208                    .collect::<Vec<String>>()
6209                    .join(",")
6210                    .to_string(),
6211            )]),
6212        };
6213    }
6214    if let Some(ref local_var_str) = tenant_group_id__n {
6215        local_var_req_builder = match "multi" {
6216            "multi" => local_var_req_builder.query(
6217                &local_var_str
6218                    .into_iter()
6219                    .map(|p| ("tenant_group_id__n".to_owned(), p.to_string()))
6220                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6221            ),
6222            _ => local_var_req_builder.query(&[(
6223                "tenant_group_id__n",
6224                &local_var_str
6225                    .into_iter()
6226                    .map(|p| p.to_string())
6227                    .collect::<Vec<String>>()
6228                    .join(",")
6229                    .to_string(),
6230            )]),
6231        };
6232    }
6233    if let Some(ref local_var_str) = tenant_id {
6234        local_var_req_builder = match "multi" {
6235            "multi" => local_var_req_builder.query(
6236                &local_var_str
6237                    .into_iter()
6238                    .map(|p| ("tenant_id".to_owned(), p.to_string()))
6239                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6240            ),
6241            _ => local_var_req_builder.query(&[(
6242                "tenant_id",
6243                &local_var_str
6244                    .into_iter()
6245                    .map(|p| p.to_string())
6246                    .collect::<Vec<String>>()
6247                    .join(",")
6248                    .to_string(),
6249            )]),
6250        };
6251    }
6252    if let Some(ref local_var_str) = tenant_id__n {
6253        local_var_req_builder = match "multi" {
6254            "multi" => local_var_req_builder.query(
6255                &local_var_str
6256                    .into_iter()
6257                    .map(|p| ("tenant_id__n".to_owned(), p.to_string()))
6258                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6259            ),
6260            _ => local_var_req_builder.query(&[(
6261                "tenant_id__n",
6262                &local_var_str
6263                    .into_iter()
6264                    .map(|p| p.to_string())
6265                    .collect::<Vec<String>>()
6266                    .join(",")
6267                    .to_string(),
6268            )]),
6269        };
6270    }
6271    if let Some(ref local_var_str) = r#type {
6272        local_var_req_builder = match "multi" {
6273            "multi" => local_var_req_builder.query(
6274                &local_var_str
6275                    .into_iter()
6276                    .map(|p| ("type".to_owned(), p.to_string()))
6277                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6278            ),
6279            _ => local_var_req_builder.query(&[(
6280                "type",
6281                &local_var_str
6282                    .into_iter()
6283                    .map(|p| p.to_string())
6284                    .collect::<Vec<String>>()
6285                    .join(",")
6286                    .to_string(),
6287            )]),
6288        };
6289    }
6290    if let Some(ref local_var_str) = type__n {
6291        local_var_req_builder = match "multi" {
6292            "multi" => local_var_req_builder.query(
6293                &local_var_str
6294                    .into_iter()
6295                    .map(|p| ("type__n".to_owned(), p.to_string()))
6296                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6297            ),
6298            _ => local_var_req_builder.query(&[(
6299                "type__n",
6300                &local_var_str
6301                    .into_iter()
6302                    .map(|p| p.to_string())
6303                    .collect::<Vec<String>>()
6304                    .join(",")
6305                    .to_string(),
6306            )]),
6307        };
6308    }
6309    if let Some(ref local_var_str) = type_id {
6310        local_var_req_builder = match "multi" {
6311            "multi" => local_var_req_builder.query(
6312                &local_var_str
6313                    .into_iter()
6314                    .map(|p| ("type_id".to_owned(), p.to_string()))
6315                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6316            ),
6317            _ => local_var_req_builder.query(&[(
6318                "type_id",
6319                &local_var_str
6320                    .into_iter()
6321                    .map(|p| p.to_string())
6322                    .collect::<Vec<String>>()
6323                    .join(",")
6324                    .to_string(),
6325            )]),
6326        };
6327    }
6328    if let Some(ref local_var_str) = type_id__n {
6329        local_var_req_builder = match "multi" {
6330            "multi" => local_var_req_builder.query(
6331                &local_var_str
6332                    .into_iter()
6333                    .map(|p| ("type_id__n".to_owned(), p.to_string()))
6334                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6335            ),
6336            _ => local_var_req_builder.query(&[(
6337                "type_id__n",
6338                &local_var_str
6339                    .into_iter()
6340                    .map(|p| p.to_string())
6341                    .collect::<Vec<String>>()
6342                    .join(",")
6343                    .to_string(),
6344            )]),
6345        };
6346    }
6347    if let Some(ref local_var_str) = updated_by_request {
6348        local_var_req_builder =
6349            local_var_req_builder.query(&[("updated_by_request", &local_var_str.to_string())]);
6350    }
6351    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
6352        local_var_req_builder =
6353            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
6354    }
6355    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
6356        let local_var_key = local_var_apikey.key.clone();
6357        let local_var_value = match local_var_apikey.prefix {
6358            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
6359            None => local_var_key,
6360        };
6361        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
6362    };
6363
6364    let local_var_req = local_var_req_builder.build()?;
6365    let local_var_resp = local_var_client.execute(local_var_req).await?;
6366
6367    let local_var_status = local_var_resp.status();
6368    let local_var_content = local_var_resp.text().await?;
6369
6370    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
6371        serde_json::from_str(&local_var_content).map_err(Error::from)
6372    } else {
6373        let local_var_entity: Option<VirtualizationClustersListError> =
6374            serde_json::from_str(&local_var_content).ok();
6375        let local_var_error = ResponseContent {
6376            status: local_var_status,
6377            content: local_var_content,
6378            entity: local_var_entity,
6379        };
6380        Err(Error::ResponseError(local_var_error))
6381    }
6382}
6383
6384/// Patch a cluster object.
6385pub async fn virtualization_clusters_partial_update(
6386    configuration: &configuration::Configuration,
6387    id: i32,
6388    patched_writable_cluster_request: Option<crate::models::PatchedWritableClusterRequest>,
6389) -> Result<crate::models::Cluster, Error<VirtualizationClustersPartialUpdateError>> {
6390    let local_var_configuration = configuration;
6391
6392    let local_var_client = &local_var_configuration.client;
6393
6394    let local_var_uri_str = format!(
6395        "{}/api/virtualization/clusters/{id}/",
6396        local_var_configuration.base_path,
6397        id = id
6398    );
6399    let mut local_var_req_builder =
6400        local_var_client.request(reqwest::Method::PATCH, local_var_uri_str.as_str());
6401
6402    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
6403        local_var_req_builder =
6404            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
6405    }
6406    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
6407        let local_var_key = local_var_apikey.key.clone();
6408        let local_var_value = match local_var_apikey.prefix {
6409            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
6410            None => local_var_key,
6411        };
6412        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
6413    };
6414    local_var_req_builder = local_var_req_builder.json(&patched_writable_cluster_request);
6415
6416    let local_var_req = local_var_req_builder.build()?;
6417    let local_var_resp = local_var_client.execute(local_var_req).await?;
6418
6419    let local_var_status = local_var_resp.status();
6420    let local_var_content = local_var_resp.text().await?;
6421
6422    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
6423        serde_json::from_str(&local_var_content).map_err(Error::from)
6424    } else {
6425        let local_var_entity: Option<VirtualizationClustersPartialUpdateError> =
6426            serde_json::from_str(&local_var_content).ok();
6427        let local_var_error = ResponseContent {
6428            status: local_var_status,
6429            content: local_var_content,
6430            entity: local_var_entity,
6431        };
6432        Err(Error::ResponseError(local_var_error))
6433    }
6434}
6435
6436/// Get a cluster object.
6437pub async fn virtualization_clusters_retrieve(
6438    configuration: &configuration::Configuration,
6439    id: i32,
6440) -> Result<crate::models::Cluster, Error<VirtualizationClustersRetrieveError>> {
6441    let local_var_configuration = configuration;
6442
6443    let local_var_client = &local_var_configuration.client;
6444
6445    let local_var_uri_str = format!(
6446        "{}/api/virtualization/clusters/{id}/",
6447        local_var_configuration.base_path,
6448        id = id
6449    );
6450    let mut local_var_req_builder =
6451        local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
6452
6453    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
6454        local_var_req_builder =
6455            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
6456    }
6457    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
6458        let local_var_key = local_var_apikey.key.clone();
6459        let local_var_value = match local_var_apikey.prefix {
6460            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
6461            None => local_var_key,
6462        };
6463        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
6464    };
6465
6466    let local_var_req = local_var_req_builder.build()?;
6467    let local_var_resp = local_var_client.execute(local_var_req).await?;
6468
6469    let local_var_status = local_var_resp.status();
6470    let local_var_content = local_var_resp.text().await?;
6471
6472    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
6473        serde_json::from_str(&local_var_content).map_err(Error::from)
6474    } else {
6475        let local_var_entity: Option<VirtualizationClustersRetrieveError> =
6476            serde_json::from_str(&local_var_content).ok();
6477        let local_var_error = ResponseContent {
6478            status: local_var_status,
6479            content: local_var_content,
6480            entity: local_var_entity,
6481        };
6482        Err(Error::ResponseError(local_var_error))
6483    }
6484}
6485
6486/// Put a cluster object.
6487pub async fn virtualization_clusters_update(
6488    configuration: &configuration::Configuration,
6489    id: i32,
6490    writable_cluster_request: crate::models::WritableClusterRequest,
6491) -> Result<crate::models::Cluster, Error<VirtualizationClustersUpdateError>> {
6492    let local_var_configuration = configuration;
6493
6494    let local_var_client = &local_var_configuration.client;
6495
6496    let local_var_uri_str = format!(
6497        "{}/api/virtualization/clusters/{id}/",
6498        local_var_configuration.base_path,
6499        id = id
6500    );
6501    let mut local_var_req_builder =
6502        local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());
6503
6504    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
6505        local_var_req_builder =
6506            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
6507    }
6508    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
6509        let local_var_key = local_var_apikey.key.clone();
6510        let local_var_value = match local_var_apikey.prefix {
6511            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
6512            None => local_var_key,
6513        };
6514        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
6515    };
6516    local_var_req_builder = local_var_req_builder.json(&writable_cluster_request);
6517
6518    let local_var_req = local_var_req_builder.build()?;
6519    let local_var_resp = local_var_client.execute(local_var_req).await?;
6520
6521    let local_var_status = local_var_resp.status();
6522    let local_var_content = local_var_resp.text().await?;
6523
6524    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
6525        serde_json::from_str(&local_var_content).map_err(Error::from)
6526    } else {
6527        let local_var_entity: Option<VirtualizationClustersUpdateError> =
6528            serde_json::from_str(&local_var_content).ok();
6529        let local_var_error = ResponseContent {
6530            status: local_var_status,
6531            content: local_var_content,
6532            entity: local_var_entity,
6533        };
6534        Err(Error::ResponseError(local_var_error))
6535    }
6536}
6537
6538/// Delete a list of interface objects.
6539pub async fn virtualization_interfaces_bulk_destroy(
6540    configuration: &configuration::Configuration,
6541    vm_interface_request: Vec<crate::models::VmInterfaceRequest>,
6542) -> Result<(), Error<VirtualizationInterfacesBulkDestroyError>> {
6543    let local_var_configuration = configuration;
6544
6545    let local_var_client = &local_var_configuration.client;
6546
6547    let local_var_uri_str = format!(
6548        "{}/api/virtualization/interfaces/",
6549        local_var_configuration.base_path
6550    );
6551    let mut local_var_req_builder =
6552        local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());
6553
6554    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
6555        local_var_req_builder =
6556            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
6557    }
6558    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
6559        let local_var_key = local_var_apikey.key.clone();
6560        let local_var_value = match local_var_apikey.prefix {
6561            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
6562            None => local_var_key,
6563        };
6564        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
6565    };
6566    local_var_req_builder = local_var_req_builder.json(&vm_interface_request);
6567
6568    let local_var_req = local_var_req_builder.build()?;
6569    let local_var_resp = local_var_client.execute(local_var_req).await?;
6570
6571    let local_var_status = local_var_resp.status();
6572    let local_var_content = local_var_resp.text().await?;
6573
6574    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
6575        Ok(())
6576    } else {
6577        let local_var_entity: Option<VirtualizationInterfacesBulkDestroyError> =
6578            serde_json::from_str(&local_var_content).ok();
6579        let local_var_error = ResponseContent {
6580            status: local_var_status,
6581            content: local_var_content,
6582            entity: local_var_entity,
6583        };
6584        Err(Error::ResponseError(local_var_error))
6585    }
6586}
6587
6588/// Patch a list of interface objects.
6589pub async fn virtualization_interfaces_bulk_partial_update(
6590    configuration: &configuration::Configuration,
6591    vm_interface_request: Vec<crate::models::VmInterfaceRequest>,
6592) -> Result<Vec<crate::models::VmInterface>, Error<VirtualizationInterfacesBulkPartialUpdateError>>
6593{
6594    let local_var_configuration = configuration;
6595
6596    let local_var_client = &local_var_configuration.client;
6597
6598    let local_var_uri_str = format!(
6599        "{}/api/virtualization/interfaces/",
6600        local_var_configuration.base_path
6601    );
6602    let mut local_var_req_builder =
6603        local_var_client.request(reqwest::Method::PATCH, local_var_uri_str.as_str());
6604
6605    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
6606        local_var_req_builder =
6607            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
6608    }
6609    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
6610        let local_var_key = local_var_apikey.key.clone();
6611        let local_var_value = match local_var_apikey.prefix {
6612            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
6613            None => local_var_key,
6614        };
6615        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
6616    };
6617    local_var_req_builder = local_var_req_builder.json(&vm_interface_request);
6618
6619    let local_var_req = local_var_req_builder.build()?;
6620    let local_var_resp = local_var_client.execute(local_var_req).await?;
6621
6622    let local_var_status = local_var_resp.status();
6623    let local_var_content = local_var_resp.text().await?;
6624
6625    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
6626        serde_json::from_str(&local_var_content).map_err(Error::from)
6627    } else {
6628        let local_var_entity: Option<VirtualizationInterfacesBulkPartialUpdateError> =
6629            serde_json::from_str(&local_var_content).ok();
6630        let local_var_error = ResponseContent {
6631            status: local_var_status,
6632            content: local_var_content,
6633            entity: local_var_entity,
6634        };
6635        Err(Error::ResponseError(local_var_error))
6636    }
6637}
6638
6639/// Put a list of interface objects.
6640pub async fn virtualization_interfaces_bulk_update(
6641    configuration: &configuration::Configuration,
6642    vm_interface_request: Vec<crate::models::VmInterfaceRequest>,
6643) -> Result<Vec<crate::models::VmInterface>, Error<VirtualizationInterfacesBulkUpdateError>> {
6644    let local_var_configuration = configuration;
6645
6646    let local_var_client = &local_var_configuration.client;
6647
6648    let local_var_uri_str = format!(
6649        "{}/api/virtualization/interfaces/",
6650        local_var_configuration.base_path
6651    );
6652    let mut local_var_req_builder =
6653        local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());
6654
6655    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
6656        local_var_req_builder =
6657            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
6658    }
6659    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
6660        let local_var_key = local_var_apikey.key.clone();
6661        let local_var_value = match local_var_apikey.prefix {
6662            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
6663            None => local_var_key,
6664        };
6665        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
6666    };
6667    local_var_req_builder = local_var_req_builder.json(&vm_interface_request);
6668
6669    let local_var_req = local_var_req_builder.build()?;
6670    let local_var_resp = local_var_client.execute(local_var_req).await?;
6671
6672    let local_var_status = local_var_resp.status();
6673    let local_var_content = local_var_resp.text().await?;
6674
6675    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
6676        serde_json::from_str(&local_var_content).map_err(Error::from)
6677    } else {
6678        let local_var_entity: Option<VirtualizationInterfacesBulkUpdateError> =
6679            serde_json::from_str(&local_var_content).ok();
6680        let local_var_error = ResponseContent {
6681            status: local_var_status,
6682            content: local_var_content,
6683            entity: local_var_entity,
6684        };
6685        Err(Error::ResponseError(local_var_error))
6686    }
6687}
6688
6689/// Post a list of interface objects.
6690pub async fn virtualization_interfaces_create(
6691    configuration: &configuration::Configuration,
6692    writable_vm_interface_request: crate::models::WritableVmInterfaceRequest,
6693) -> Result<crate::models::VmInterface, Error<VirtualizationInterfacesCreateError>> {
6694    let local_var_configuration = configuration;
6695
6696    let local_var_client = &local_var_configuration.client;
6697
6698    let local_var_uri_str = format!(
6699        "{}/api/virtualization/interfaces/",
6700        local_var_configuration.base_path
6701    );
6702    let mut local_var_req_builder =
6703        local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
6704
6705    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
6706        local_var_req_builder =
6707            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
6708    }
6709    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
6710        let local_var_key = local_var_apikey.key.clone();
6711        let local_var_value = match local_var_apikey.prefix {
6712            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
6713            None => local_var_key,
6714        };
6715        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
6716    };
6717    local_var_req_builder = local_var_req_builder.json(&writable_vm_interface_request);
6718
6719    let local_var_req = local_var_req_builder.build()?;
6720    let local_var_resp = local_var_client.execute(local_var_req).await?;
6721
6722    let local_var_status = local_var_resp.status();
6723    let local_var_content = local_var_resp.text().await?;
6724
6725    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
6726        serde_json::from_str(&local_var_content).map_err(Error::from)
6727    } else {
6728        let local_var_entity: Option<VirtualizationInterfacesCreateError> =
6729            serde_json::from_str(&local_var_content).ok();
6730        let local_var_error = ResponseContent {
6731            status: local_var_status,
6732            content: local_var_content,
6733            entity: local_var_entity,
6734        };
6735        Err(Error::ResponseError(local_var_error))
6736    }
6737}
6738
6739/// Delete a interface object.
6740pub async fn virtualization_interfaces_destroy(
6741    configuration: &configuration::Configuration,
6742    id: i32,
6743) -> Result<(), Error<VirtualizationInterfacesDestroyError>> {
6744    let local_var_configuration = configuration;
6745
6746    let local_var_client = &local_var_configuration.client;
6747
6748    let local_var_uri_str = format!(
6749        "{}/api/virtualization/interfaces/{id}/",
6750        local_var_configuration.base_path,
6751        id = id
6752    );
6753    let mut local_var_req_builder =
6754        local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());
6755
6756    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
6757        local_var_req_builder =
6758            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
6759    }
6760    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
6761        let local_var_key = local_var_apikey.key.clone();
6762        let local_var_value = match local_var_apikey.prefix {
6763            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
6764            None => local_var_key,
6765        };
6766        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
6767    };
6768
6769    let local_var_req = local_var_req_builder.build()?;
6770    let local_var_resp = local_var_client.execute(local_var_req).await?;
6771
6772    let local_var_status = local_var_resp.status();
6773    let local_var_content = local_var_resp.text().await?;
6774
6775    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
6776        Ok(())
6777    } else {
6778        let local_var_entity: Option<VirtualizationInterfacesDestroyError> =
6779            serde_json::from_str(&local_var_content).ok();
6780        let local_var_error = ResponseContent {
6781            status: local_var_status,
6782            content: local_var_content,
6783            entity: local_var_entity,
6784        };
6785        Err(Error::ResponseError(local_var_error))
6786    }
6787}
6788
6789/// Get a list of interface objects.
6790pub async fn virtualization_interfaces_list(
6791    configuration: &configuration::Configuration,
6792    bridge_id: Option<Vec<i32>>,
6793    bridge_id__n: Option<Vec<i32>>,
6794    cluster: Option<Vec<String>>,
6795    cluster__n: Option<Vec<String>>,
6796    cluster_id: Option<Vec<i32>>,
6797    cluster_id__n: Option<Vec<i32>>,
6798    created: Option<Vec<String>>,
6799    created__empty: Option<Vec<String>>,
6800    created__gt: Option<Vec<String>>,
6801    created__gte: Option<Vec<String>>,
6802    created__lt: Option<Vec<String>>,
6803    created__lte: Option<Vec<String>>,
6804    created__n: Option<Vec<String>>,
6805    created_by_request: Option<&str>,
6806    description: Option<Vec<String>>,
6807    description__empty: Option<bool>,
6808    description__ic: Option<Vec<String>>,
6809    description__ie: Option<Vec<String>>,
6810    description__iew: Option<Vec<String>>,
6811    description__iregex: Option<Vec<String>>,
6812    description__isw: Option<Vec<String>>,
6813    description__n: Option<Vec<String>>,
6814    description__nic: Option<Vec<String>>,
6815    description__nie: Option<Vec<String>>,
6816    description__niew: Option<Vec<String>>,
6817    description__nisw: Option<Vec<String>>,
6818    description__regex: Option<Vec<String>>,
6819    enabled: Option<bool>,
6820    id: Option<Vec<i32>>,
6821    id__empty: Option<bool>,
6822    id__gt: Option<Vec<i32>>,
6823    id__gte: Option<Vec<i32>>,
6824    id__lt: Option<Vec<i32>>,
6825    id__lte: Option<Vec<i32>>,
6826    id__n: Option<Vec<i32>>,
6827    l2vpn: Option<Vec<i64>>,
6828    l2vpn__n: Option<Vec<i64>>,
6829    l2vpn_id: Option<Vec<i32>>,
6830    l2vpn_id__n: Option<Vec<i32>>,
6831    last_updated: Option<Vec<String>>,
6832    last_updated__empty: Option<Vec<String>>,
6833    last_updated__gt: Option<Vec<String>>,
6834    last_updated__gte: Option<Vec<String>>,
6835    last_updated__lt: Option<Vec<String>>,
6836    last_updated__lte: Option<Vec<String>>,
6837    last_updated__n: Option<Vec<String>>,
6838    limit: Option<i32>,
6839    mac_address: Option<Vec<String>>,
6840    mac_address__ic: Option<Vec<String>>,
6841    mac_address__ie: Option<Vec<String>>,
6842    mac_address__iew: Option<Vec<String>>,
6843    mac_address__iregex: Option<Vec<String>>,
6844    mac_address__isw: Option<Vec<String>>,
6845    mac_address__n: Option<Vec<String>>,
6846    mac_address__nic: Option<Vec<String>>,
6847    mac_address__nie: Option<Vec<String>>,
6848    mac_address__niew: Option<Vec<String>>,
6849    mac_address__nisw: Option<Vec<String>>,
6850    mac_address__regex: Option<Vec<String>>,
6851    mode: Option<Vec<String>>,
6852    mode__empty: Option<bool>,
6853    mode__ic: Option<Vec<String>>,
6854    mode__ie: Option<Vec<String>>,
6855    mode__iew: Option<Vec<String>>,
6856    mode__iregex: Option<Vec<String>>,
6857    mode__isw: Option<Vec<String>>,
6858    mode__n: Option<Vec<String>>,
6859    mode__nic: Option<Vec<String>>,
6860    mode__nie: Option<Vec<String>>,
6861    mode__niew: Option<Vec<String>>,
6862    mode__nisw: Option<Vec<String>>,
6863    mode__regex: Option<Vec<String>>,
6864    modified_by_request: Option<&str>,
6865    mtu: Option<Vec<i32>>,
6866    mtu__empty: Option<bool>,
6867    mtu__gt: Option<Vec<i32>>,
6868    mtu__gte: Option<Vec<i32>>,
6869    mtu__lt: Option<Vec<i32>>,
6870    mtu__lte: Option<Vec<i32>>,
6871    mtu__n: Option<Vec<i32>>,
6872    name: Option<Vec<String>>,
6873    name__empty: Option<bool>,
6874    name__ic: Option<Vec<String>>,
6875    name__ie: Option<Vec<String>>,
6876    name__iew: Option<Vec<String>>,
6877    name__iregex: Option<Vec<String>>,
6878    name__isw: Option<Vec<String>>,
6879    name__n: Option<Vec<String>>,
6880    name__nic: Option<Vec<String>>,
6881    name__nie: Option<Vec<String>>,
6882    name__niew: Option<Vec<String>>,
6883    name__nisw: Option<Vec<String>>,
6884    name__regex: Option<Vec<String>>,
6885    offset: Option<i32>,
6886    ordering: Option<&str>,
6887    parent_id: Option<Vec<i32>>,
6888    parent_id__n: Option<Vec<i32>>,
6889    primary_mac_address: Option<Vec<String>>,
6890    primary_mac_address__n: Option<Vec<String>>,
6891    primary_mac_address_id: Option<Vec<i32>>,
6892    primary_mac_address_id__n: Option<Vec<i32>>,
6893    q: Option<&str>,
6894    tag: Option<Vec<String>>,
6895    tag__n: Option<Vec<String>>,
6896    tag_id: Option<Vec<i32>>,
6897    tag_id__n: Option<Vec<i32>>,
6898    updated_by_request: Option<&str>,
6899    virtual_machine: Option<Vec<String>>,
6900    virtual_machine__n: Option<Vec<String>>,
6901    virtual_machine_id: Option<Vec<i32>>,
6902    virtual_machine_id__n: Option<Vec<i32>>,
6903    vlan: Option<&str>,
6904    vlan_id: Option<&str>,
6905    vlan_translation_policy: Option<Vec<String>>,
6906    vlan_translation_policy__n: Option<Vec<String>>,
6907    vlan_translation_policy_id: Option<Vec<i32>>,
6908    vlan_translation_policy_id__n: Option<Vec<i32>>,
6909    vrf: Option<Vec<String>>,
6910    vrf__n: Option<Vec<String>>,
6911    vrf_id: Option<Vec<i32>>,
6912    vrf_id__n: Option<Vec<i32>>,
6913) -> Result<crate::models::PaginatedVmInterfaceList, Error<VirtualizationInterfacesListError>> {
6914    let local_var_configuration = configuration;
6915
6916    let local_var_client = &local_var_configuration.client;
6917
6918    let local_var_uri_str = format!(
6919        "{}/api/virtualization/interfaces/",
6920        local_var_configuration.base_path
6921    );
6922    let mut local_var_req_builder =
6923        local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
6924
6925    if let Some(ref local_var_str) = bridge_id {
6926        local_var_req_builder = match "multi" {
6927            "multi" => local_var_req_builder.query(
6928                &local_var_str
6929                    .into_iter()
6930                    .map(|p| ("bridge_id".to_owned(), p.to_string()))
6931                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6932            ),
6933            _ => local_var_req_builder.query(&[(
6934                "bridge_id",
6935                &local_var_str
6936                    .into_iter()
6937                    .map(|p| p.to_string())
6938                    .collect::<Vec<String>>()
6939                    .join(",")
6940                    .to_string(),
6941            )]),
6942        };
6943    }
6944    if let Some(ref local_var_str) = bridge_id__n {
6945        local_var_req_builder = match "multi" {
6946            "multi" => local_var_req_builder.query(
6947                &local_var_str
6948                    .into_iter()
6949                    .map(|p| ("bridge_id__n".to_owned(), p.to_string()))
6950                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6951            ),
6952            _ => local_var_req_builder.query(&[(
6953                "bridge_id__n",
6954                &local_var_str
6955                    .into_iter()
6956                    .map(|p| p.to_string())
6957                    .collect::<Vec<String>>()
6958                    .join(",")
6959                    .to_string(),
6960            )]),
6961        };
6962    }
6963    if let Some(ref local_var_str) = cluster {
6964        local_var_req_builder = match "multi" {
6965            "multi" => local_var_req_builder.query(
6966                &local_var_str
6967                    .into_iter()
6968                    .map(|p| ("cluster".to_owned(), p.to_string()))
6969                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6970            ),
6971            _ => local_var_req_builder.query(&[(
6972                "cluster",
6973                &local_var_str
6974                    .into_iter()
6975                    .map(|p| p.to_string())
6976                    .collect::<Vec<String>>()
6977                    .join(",")
6978                    .to_string(),
6979            )]),
6980        };
6981    }
6982    if let Some(ref local_var_str) = cluster__n {
6983        local_var_req_builder = match "multi" {
6984            "multi" => local_var_req_builder.query(
6985                &local_var_str
6986                    .into_iter()
6987                    .map(|p| ("cluster__n".to_owned(), p.to_string()))
6988                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6989            ),
6990            _ => local_var_req_builder.query(&[(
6991                "cluster__n",
6992                &local_var_str
6993                    .into_iter()
6994                    .map(|p| p.to_string())
6995                    .collect::<Vec<String>>()
6996                    .join(",")
6997                    .to_string(),
6998            )]),
6999        };
7000    }
7001    if let Some(ref local_var_str) = cluster_id {
7002        local_var_req_builder = match "multi" {
7003            "multi" => local_var_req_builder.query(
7004                &local_var_str
7005                    .into_iter()
7006                    .map(|p| ("cluster_id".to_owned(), p.to_string()))
7007                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7008            ),
7009            _ => local_var_req_builder.query(&[(
7010                "cluster_id",
7011                &local_var_str
7012                    .into_iter()
7013                    .map(|p| p.to_string())
7014                    .collect::<Vec<String>>()
7015                    .join(",")
7016                    .to_string(),
7017            )]),
7018        };
7019    }
7020    if let Some(ref local_var_str) = cluster_id__n {
7021        local_var_req_builder = match "multi" {
7022            "multi" => local_var_req_builder.query(
7023                &local_var_str
7024                    .into_iter()
7025                    .map(|p| ("cluster_id__n".to_owned(), p.to_string()))
7026                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7027            ),
7028            _ => local_var_req_builder.query(&[(
7029                "cluster_id__n",
7030                &local_var_str
7031                    .into_iter()
7032                    .map(|p| p.to_string())
7033                    .collect::<Vec<String>>()
7034                    .join(",")
7035                    .to_string(),
7036            )]),
7037        };
7038    }
7039    if let Some(ref local_var_str) = created {
7040        local_var_req_builder = match "multi" {
7041            "multi" => local_var_req_builder.query(
7042                &local_var_str
7043                    .into_iter()
7044                    .map(|p| ("created".to_owned(), p.to_string()))
7045                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7046            ),
7047            _ => local_var_req_builder.query(&[(
7048                "created",
7049                &local_var_str
7050                    .into_iter()
7051                    .map(|p| p.to_string())
7052                    .collect::<Vec<String>>()
7053                    .join(",")
7054                    .to_string(),
7055            )]),
7056        };
7057    }
7058    if let Some(ref local_var_str) = created__empty {
7059        local_var_req_builder = match "multi" {
7060            "multi" => local_var_req_builder.query(
7061                &local_var_str
7062                    .into_iter()
7063                    .map(|p| ("created__empty".to_owned(), p.to_string()))
7064                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7065            ),
7066            _ => local_var_req_builder.query(&[(
7067                "created__empty",
7068                &local_var_str
7069                    .into_iter()
7070                    .map(|p| p.to_string())
7071                    .collect::<Vec<String>>()
7072                    .join(",")
7073                    .to_string(),
7074            )]),
7075        };
7076    }
7077    if let Some(ref local_var_str) = created__gt {
7078        local_var_req_builder = match "multi" {
7079            "multi" => local_var_req_builder.query(
7080                &local_var_str
7081                    .into_iter()
7082                    .map(|p| ("created__gt".to_owned(), p.to_string()))
7083                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7084            ),
7085            _ => local_var_req_builder.query(&[(
7086                "created__gt",
7087                &local_var_str
7088                    .into_iter()
7089                    .map(|p| p.to_string())
7090                    .collect::<Vec<String>>()
7091                    .join(",")
7092                    .to_string(),
7093            )]),
7094        };
7095    }
7096    if let Some(ref local_var_str) = created__gte {
7097        local_var_req_builder = match "multi" {
7098            "multi" => local_var_req_builder.query(
7099                &local_var_str
7100                    .into_iter()
7101                    .map(|p| ("created__gte".to_owned(), p.to_string()))
7102                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7103            ),
7104            _ => local_var_req_builder.query(&[(
7105                "created__gte",
7106                &local_var_str
7107                    .into_iter()
7108                    .map(|p| p.to_string())
7109                    .collect::<Vec<String>>()
7110                    .join(",")
7111                    .to_string(),
7112            )]),
7113        };
7114    }
7115    if let Some(ref local_var_str) = created__lt {
7116        local_var_req_builder = match "multi" {
7117            "multi" => local_var_req_builder.query(
7118                &local_var_str
7119                    .into_iter()
7120                    .map(|p| ("created__lt".to_owned(), p.to_string()))
7121                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7122            ),
7123            _ => local_var_req_builder.query(&[(
7124                "created__lt",
7125                &local_var_str
7126                    .into_iter()
7127                    .map(|p| p.to_string())
7128                    .collect::<Vec<String>>()
7129                    .join(",")
7130                    .to_string(),
7131            )]),
7132        };
7133    }
7134    if let Some(ref local_var_str) = created__lte {
7135        local_var_req_builder = match "multi" {
7136            "multi" => local_var_req_builder.query(
7137                &local_var_str
7138                    .into_iter()
7139                    .map(|p| ("created__lte".to_owned(), p.to_string()))
7140                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7141            ),
7142            _ => local_var_req_builder.query(&[(
7143                "created__lte",
7144                &local_var_str
7145                    .into_iter()
7146                    .map(|p| p.to_string())
7147                    .collect::<Vec<String>>()
7148                    .join(",")
7149                    .to_string(),
7150            )]),
7151        };
7152    }
7153    if let Some(ref local_var_str) = created__n {
7154        local_var_req_builder = match "multi" {
7155            "multi" => local_var_req_builder.query(
7156                &local_var_str
7157                    .into_iter()
7158                    .map(|p| ("created__n".to_owned(), p.to_string()))
7159                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7160            ),
7161            _ => local_var_req_builder.query(&[(
7162                "created__n",
7163                &local_var_str
7164                    .into_iter()
7165                    .map(|p| p.to_string())
7166                    .collect::<Vec<String>>()
7167                    .join(",")
7168                    .to_string(),
7169            )]),
7170        };
7171    }
7172    if let Some(ref local_var_str) = created_by_request {
7173        local_var_req_builder =
7174            local_var_req_builder.query(&[("created_by_request", &local_var_str.to_string())]);
7175    }
7176    if let Some(ref local_var_str) = description {
7177        local_var_req_builder = match "multi" {
7178            "multi" => local_var_req_builder.query(
7179                &local_var_str
7180                    .into_iter()
7181                    .map(|p| ("description".to_owned(), p.to_string()))
7182                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7183            ),
7184            _ => local_var_req_builder.query(&[(
7185                "description",
7186                &local_var_str
7187                    .into_iter()
7188                    .map(|p| p.to_string())
7189                    .collect::<Vec<String>>()
7190                    .join(",")
7191                    .to_string(),
7192            )]),
7193        };
7194    }
7195    if let Some(ref local_var_str) = description__empty {
7196        local_var_req_builder =
7197            local_var_req_builder.query(&[("description__empty", &local_var_str.to_string())]);
7198    }
7199    if let Some(ref local_var_str) = description__ic {
7200        local_var_req_builder = match "multi" {
7201            "multi" => local_var_req_builder.query(
7202                &local_var_str
7203                    .into_iter()
7204                    .map(|p| ("description__ic".to_owned(), p.to_string()))
7205                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7206            ),
7207            _ => local_var_req_builder.query(&[(
7208                "description__ic",
7209                &local_var_str
7210                    .into_iter()
7211                    .map(|p| p.to_string())
7212                    .collect::<Vec<String>>()
7213                    .join(",")
7214                    .to_string(),
7215            )]),
7216        };
7217    }
7218    if let Some(ref local_var_str) = description__ie {
7219        local_var_req_builder = match "multi" {
7220            "multi" => local_var_req_builder.query(
7221                &local_var_str
7222                    .into_iter()
7223                    .map(|p| ("description__ie".to_owned(), p.to_string()))
7224                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7225            ),
7226            _ => local_var_req_builder.query(&[(
7227                "description__ie",
7228                &local_var_str
7229                    .into_iter()
7230                    .map(|p| p.to_string())
7231                    .collect::<Vec<String>>()
7232                    .join(",")
7233                    .to_string(),
7234            )]),
7235        };
7236    }
7237    if let Some(ref local_var_str) = description__iew {
7238        local_var_req_builder = match "multi" {
7239            "multi" => local_var_req_builder.query(
7240                &local_var_str
7241                    .into_iter()
7242                    .map(|p| ("description__iew".to_owned(), p.to_string()))
7243                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7244            ),
7245            _ => local_var_req_builder.query(&[(
7246                "description__iew",
7247                &local_var_str
7248                    .into_iter()
7249                    .map(|p| p.to_string())
7250                    .collect::<Vec<String>>()
7251                    .join(",")
7252                    .to_string(),
7253            )]),
7254        };
7255    }
7256    if let Some(ref local_var_str) = description__iregex {
7257        local_var_req_builder = match "multi" {
7258            "multi" => local_var_req_builder.query(
7259                &local_var_str
7260                    .into_iter()
7261                    .map(|p| ("description__iregex".to_owned(), p.to_string()))
7262                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7263            ),
7264            _ => local_var_req_builder.query(&[(
7265                "description__iregex",
7266                &local_var_str
7267                    .into_iter()
7268                    .map(|p| p.to_string())
7269                    .collect::<Vec<String>>()
7270                    .join(",")
7271                    .to_string(),
7272            )]),
7273        };
7274    }
7275    if let Some(ref local_var_str) = description__isw {
7276        local_var_req_builder = match "multi" {
7277            "multi" => local_var_req_builder.query(
7278                &local_var_str
7279                    .into_iter()
7280                    .map(|p| ("description__isw".to_owned(), p.to_string()))
7281                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7282            ),
7283            _ => local_var_req_builder.query(&[(
7284                "description__isw",
7285                &local_var_str
7286                    .into_iter()
7287                    .map(|p| p.to_string())
7288                    .collect::<Vec<String>>()
7289                    .join(",")
7290                    .to_string(),
7291            )]),
7292        };
7293    }
7294    if let Some(ref local_var_str) = description__n {
7295        local_var_req_builder = match "multi" {
7296            "multi" => local_var_req_builder.query(
7297                &local_var_str
7298                    .into_iter()
7299                    .map(|p| ("description__n".to_owned(), p.to_string()))
7300                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7301            ),
7302            _ => local_var_req_builder.query(&[(
7303                "description__n",
7304                &local_var_str
7305                    .into_iter()
7306                    .map(|p| p.to_string())
7307                    .collect::<Vec<String>>()
7308                    .join(",")
7309                    .to_string(),
7310            )]),
7311        };
7312    }
7313    if let Some(ref local_var_str) = description__nic {
7314        local_var_req_builder = match "multi" {
7315            "multi" => local_var_req_builder.query(
7316                &local_var_str
7317                    .into_iter()
7318                    .map(|p| ("description__nic".to_owned(), p.to_string()))
7319                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7320            ),
7321            _ => local_var_req_builder.query(&[(
7322                "description__nic",
7323                &local_var_str
7324                    .into_iter()
7325                    .map(|p| p.to_string())
7326                    .collect::<Vec<String>>()
7327                    .join(",")
7328                    .to_string(),
7329            )]),
7330        };
7331    }
7332    if let Some(ref local_var_str) = description__nie {
7333        local_var_req_builder = match "multi" {
7334            "multi" => local_var_req_builder.query(
7335                &local_var_str
7336                    .into_iter()
7337                    .map(|p| ("description__nie".to_owned(), p.to_string()))
7338                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7339            ),
7340            _ => local_var_req_builder.query(&[(
7341                "description__nie",
7342                &local_var_str
7343                    .into_iter()
7344                    .map(|p| p.to_string())
7345                    .collect::<Vec<String>>()
7346                    .join(",")
7347                    .to_string(),
7348            )]),
7349        };
7350    }
7351    if let Some(ref local_var_str) = description__niew {
7352        local_var_req_builder = match "multi" {
7353            "multi" => local_var_req_builder.query(
7354                &local_var_str
7355                    .into_iter()
7356                    .map(|p| ("description__niew".to_owned(), p.to_string()))
7357                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7358            ),
7359            _ => local_var_req_builder.query(&[(
7360                "description__niew",
7361                &local_var_str
7362                    .into_iter()
7363                    .map(|p| p.to_string())
7364                    .collect::<Vec<String>>()
7365                    .join(",")
7366                    .to_string(),
7367            )]),
7368        };
7369    }
7370    if let Some(ref local_var_str) = description__nisw {
7371        local_var_req_builder = match "multi" {
7372            "multi" => local_var_req_builder.query(
7373                &local_var_str
7374                    .into_iter()
7375                    .map(|p| ("description__nisw".to_owned(), p.to_string()))
7376                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7377            ),
7378            _ => local_var_req_builder.query(&[(
7379                "description__nisw",
7380                &local_var_str
7381                    .into_iter()
7382                    .map(|p| p.to_string())
7383                    .collect::<Vec<String>>()
7384                    .join(",")
7385                    .to_string(),
7386            )]),
7387        };
7388    }
7389    if let Some(ref local_var_str) = description__regex {
7390        local_var_req_builder = match "multi" {
7391            "multi" => local_var_req_builder.query(
7392                &local_var_str
7393                    .into_iter()
7394                    .map(|p| ("description__regex".to_owned(), p.to_string()))
7395                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7396            ),
7397            _ => local_var_req_builder.query(&[(
7398                "description__regex",
7399                &local_var_str
7400                    .into_iter()
7401                    .map(|p| p.to_string())
7402                    .collect::<Vec<String>>()
7403                    .join(",")
7404                    .to_string(),
7405            )]),
7406        };
7407    }
7408    if let Some(ref local_var_str) = enabled {
7409        local_var_req_builder =
7410            local_var_req_builder.query(&[("enabled", &local_var_str.to_string())]);
7411    }
7412    if let Some(ref local_var_str) = id {
7413        local_var_req_builder = match "multi" {
7414            "multi" => local_var_req_builder.query(
7415                &local_var_str
7416                    .into_iter()
7417                    .map(|p| ("id".to_owned(), p.to_string()))
7418                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7419            ),
7420            _ => local_var_req_builder.query(&[(
7421                "id",
7422                &local_var_str
7423                    .into_iter()
7424                    .map(|p| p.to_string())
7425                    .collect::<Vec<String>>()
7426                    .join(",")
7427                    .to_string(),
7428            )]),
7429        };
7430    }
7431    if let Some(ref local_var_str) = id__empty {
7432        local_var_req_builder =
7433            local_var_req_builder.query(&[("id__empty", &local_var_str.to_string())]);
7434    }
7435    if let Some(ref local_var_str) = id__gt {
7436        local_var_req_builder = match "multi" {
7437            "multi" => local_var_req_builder.query(
7438                &local_var_str
7439                    .into_iter()
7440                    .map(|p| ("id__gt".to_owned(), p.to_string()))
7441                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7442            ),
7443            _ => local_var_req_builder.query(&[(
7444                "id__gt",
7445                &local_var_str
7446                    .into_iter()
7447                    .map(|p| p.to_string())
7448                    .collect::<Vec<String>>()
7449                    .join(",")
7450                    .to_string(),
7451            )]),
7452        };
7453    }
7454    if let Some(ref local_var_str) = id__gte {
7455        local_var_req_builder = match "multi" {
7456            "multi" => local_var_req_builder.query(
7457                &local_var_str
7458                    .into_iter()
7459                    .map(|p| ("id__gte".to_owned(), p.to_string()))
7460                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7461            ),
7462            _ => local_var_req_builder.query(&[(
7463                "id__gte",
7464                &local_var_str
7465                    .into_iter()
7466                    .map(|p| p.to_string())
7467                    .collect::<Vec<String>>()
7468                    .join(",")
7469                    .to_string(),
7470            )]),
7471        };
7472    }
7473    if let Some(ref local_var_str) = id__lt {
7474        local_var_req_builder = match "multi" {
7475            "multi" => local_var_req_builder.query(
7476                &local_var_str
7477                    .into_iter()
7478                    .map(|p| ("id__lt".to_owned(), p.to_string()))
7479                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7480            ),
7481            _ => local_var_req_builder.query(&[(
7482                "id__lt",
7483                &local_var_str
7484                    .into_iter()
7485                    .map(|p| p.to_string())
7486                    .collect::<Vec<String>>()
7487                    .join(",")
7488                    .to_string(),
7489            )]),
7490        };
7491    }
7492    if let Some(ref local_var_str) = id__lte {
7493        local_var_req_builder = match "multi" {
7494            "multi" => local_var_req_builder.query(
7495                &local_var_str
7496                    .into_iter()
7497                    .map(|p| ("id__lte".to_owned(), p.to_string()))
7498                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7499            ),
7500            _ => local_var_req_builder.query(&[(
7501                "id__lte",
7502                &local_var_str
7503                    .into_iter()
7504                    .map(|p| p.to_string())
7505                    .collect::<Vec<String>>()
7506                    .join(",")
7507                    .to_string(),
7508            )]),
7509        };
7510    }
7511    if let Some(ref local_var_str) = id__n {
7512        local_var_req_builder = match "multi" {
7513            "multi" => local_var_req_builder.query(
7514                &local_var_str
7515                    .into_iter()
7516                    .map(|p| ("id__n".to_owned(), p.to_string()))
7517                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7518            ),
7519            _ => local_var_req_builder.query(&[(
7520                "id__n",
7521                &local_var_str
7522                    .into_iter()
7523                    .map(|p| p.to_string())
7524                    .collect::<Vec<String>>()
7525                    .join(",")
7526                    .to_string(),
7527            )]),
7528        };
7529    }
7530    if let Some(ref local_var_str) = l2vpn {
7531        local_var_req_builder = match "multi" {
7532            "multi" => local_var_req_builder.query(
7533                &local_var_str
7534                    .into_iter()
7535                    .map(|p| ("l2vpn".to_owned(), p.to_string()))
7536                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7537            ),
7538            _ => local_var_req_builder.query(&[(
7539                "l2vpn",
7540                &local_var_str
7541                    .into_iter()
7542                    .map(|p| p.to_string())
7543                    .collect::<Vec<String>>()
7544                    .join(",")
7545                    .to_string(),
7546            )]),
7547        };
7548    }
7549    if let Some(ref local_var_str) = l2vpn__n {
7550        local_var_req_builder = match "multi" {
7551            "multi" => local_var_req_builder.query(
7552                &local_var_str
7553                    .into_iter()
7554                    .map(|p| ("l2vpn__n".to_owned(), p.to_string()))
7555                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7556            ),
7557            _ => local_var_req_builder.query(&[(
7558                "l2vpn__n",
7559                &local_var_str
7560                    .into_iter()
7561                    .map(|p| p.to_string())
7562                    .collect::<Vec<String>>()
7563                    .join(",")
7564                    .to_string(),
7565            )]),
7566        };
7567    }
7568    if let Some(ref local_var_str) = l2vpn_id {
7569        local_var_req_builder = match "multi" {
7570            "multi" => local_var_req_builder.query(
7571                &local_var_str
7572                    .into_iter()
7573                    .map(|p| ("l2vpn_id".to_owned(), p.to_string()))
7574                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7575            ),
7576            _ => local_var_req_builder.query(&[(
7577                "l2vpn_id",
7578                &local_var_str
7579                    .into_iter()
7580                    .map(|p| p.to_string())
7581                    .collect::<Vec<String>>()
7582                    .join(",")
7583                    .to_string(),
7584            )]),
7585        };
7586    }
7587    if let Some(ref local_var_str) = l2vpn_id__n {
7588        local_var_req_builder = match "multi" {
7589            "multi" => local_var_req_builder.query(
7590                &local_var_str
7591                    .into_iter()
7592                    .map(|p| ("l2vpn_id__n".to_owned(), p.to_string()))
7593                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7594            ),
7595            _ => local_var_req_builder.query(&[(
7596                "l2vpn_id__n",
7597                &local_var_str
7598                    .into_iter()
7599                    .map(|p| p.to_string())
7600                    .collect::<Vec<String>>()
7601                    .join(",")
7602                    .to_string(),
7603            )]),
7604        };
7605    }
7606    if let Some(ref local_var_str) = last_updated {
7607        local_var_req_builder = match "multi" {
7608            "multi" => local_var_req_builder.query(
7609                &local_var_str
7610                    .into_iter()
7611                    .map(|p| ("last_updated".to_owned(), p.to_string()))
7612                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7613            ),
7614            _ => local_var_req_builder.query(&[(
7615                "last_updated",
7616                &local_var_str
7617                    .into_iter()
7618                    .map(|p| p.to_string())
7619                    .collect::<Vec<String>>()
7620                    .join(",")
7621                    .to_string(),
7622            )]),
7623        };
7624    }
7625    if let Some(ref local_var_str) = last_updated__empty {
7626        local_var_req_builder = match "multi" {
7627            "multi" => local_var_req_builder.query(
7628                &local_var_str
7629                    .into_iter()
7630                    .map(|p| ("last_updated__empty".to_owned(), p.to_string()))
7631                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7632            ),
7633            _ => local_var_req_builder.query(&[(
7634                "last_updated__empty",
7635                &local_var_str
7636                    .into_iter()
7637                    .map(|p| p.to_string())
7638                    .collect::<Vec<String>>()
7639                    .join(",")
7640                    .to_string(),
7641            )]),
7642        };
7643    }
7644    if let Some(ref local_var_str) = last_updated__gt {
7645        local_var_req_builder = match "multi" {
7646            "multi" => local_var_req_builder.query(
7647                &local_var_str
7648                    .into_iter()
7649                    .map(|p| ("last_updated__gt".to_owned(), p.to_string()))
7650                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7651            ),
7652            _ => local_var_req_builder.query(&[(
7653                "last_updated__gt",
7654                &local_var_str
7655                    .into_iter()
7656                    .map(|p| p.to_string())
7657                    .collect::<Vec<String>>()
7658                    .join(",")
7659                    .to_string(),
7660            )]),
7661        };
7662    }
7663    if let Some(ref local_var_str) = last_updated__gte {
7664        local_var_req_builder = match "multi" {
7665            "multi" => local_var_req_builder.query(
7666                &local_var_str
7667                    .into_iter()
7668                    .map(|p| ("last_updated__gte".to_owned(), p.to_string()))
7669                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7670            ),
7671            _ => local_var_req_builder.query(&[(
7672                "last_updated__gte",
7673                &local_var_str
7674                    .into_iter()
7675                    .map(|p| p.to_string())
7676                    .collect::<Vec<String>>()
7677                    .join(",")
7678                    .to_string(),
7679            )]),
7680        };
7681    }
7682    if let Some(ref local_var_str) = last_updated__lt {
7683        local_var_req_builder = match "multi" {
7684            "multi" => local_var_req_builder.query(
7685                &local_var_str
7686                    .into_iter()
7687                    .map(|p| ("last_updated__lt".to_owned(), p.to_string()))
7688                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7689            ),
7690            _ => local_var_req_builder.query(&[(
7691                "last_updated__lt",
7692                &local_var_str
7693                    .into_iter()
7694                    .map(|p| p.to_string())
7695                    .collect::<Vec<String>>()
7696                    .join(",")
7697                    .to_string(),
7698            )]),
7699        };
7700    }
7701    if let Some(ref local_var_str) = last_updated__lte {
7702        local_var_req_builder = match "multi" {
7703            "multi" => local_var_req_builder.query(
7704                &local_var_str
7705                    .into_iter()
7706                    .map(|p| ("last_updated__lte".to_owned(), p.to_string()))
7707                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7708            ),
7709            _ => local_var_req_builder.query(&[(
7710                "last_updated__lte",
7711                &local_var_str
7712                    .into_iter()
7713                    .map(|p| p.to_string())
7714                    .collect::<Vec<String>>()
7715                    .join(",")
7716                    .to_string(),
7717            )]),
7718        };
7719    }
7720    if let Some(ref local_var_str) = last_updated__n {
7721        local_var_req_builder = match "multi" {
7722            "multi" => local_var_req_builder.query(
7723                &local_var_str
7724                    .into_iter()
7725                    .map(|p| ("last_updated__n".to_owned(), p.to_string()))
7726                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7727            ),
7728            _ => local_var_req_builder.query(&[(
7729                "last_updated__n",
7730                &local_var_str
7731                    .into_iter()
7732                    .map(|p| p.to_string())
7733                    .collect::<Vec<String>>()
7734                    .join(",")
7735                    .to_string(),
7736            )]),
7737        };
7738    }
7739    if let Some(ref local_var_str) = limit {
7740        local_var_req_builder =
7741            local_var_req_builder.query(&[("limit", &local_var_str.to_string())]);
7742    }
7743    if let Some(ref local_var_str) = mac_address {
7744        local_var_req_builder = match "multi" {
7745            "multi" => local_var_req_builder.query(
7746                &local_var_str
7747                    .into_iter()
7748                    .map(|p| ("mac_address".to_owned(), p.to_string()))
7749                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7750            ),
7751            _ => local_var_req_builder.query(&[(
7752                "mac_address",
7753                &local_var_str
7754                    .into_iter()
7755                    .map(|p| p.to_string())
7756                    .collect::<Vec<String>>()
7757                    .join(",")
7758                    .to_string(),
7759            )]),
7760        };
7761    }
7762    if let Some(ref local_var_str) = mac_address__ic {
7763        local_var_req_builder = match "multi" {
7764            "multi" => local_var_req_builder.query(
7765                &local_var_str
7766                    .into_iter()
7767                    .map(|p| ("mac_address__ic".to_owned(), p.to_string()))
7768                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7769            ),
7770            _ => local_var_req_builder.query(&[(
7771                "mac_address__ic",
7772                &local_var_str
7773                    .into_iter()
7774                    .map(|p| p.to_string())
7775                    .collect::<Vec<String>>()
7776                    .join(",")
7777                    .to_string(),
7778            )]),
7779        };
7780    }
7781    if let Some(ref local_var_str) = mac_address__ie {
7782        local_var_req_builder = match "multi" {
7783            "multi" => local_var_req_builder.query(
7784                &local_var_str
7785                    .into_iter()
7786                    .map(|p| ("mac_address__ie".to_owned(), p.to_string()))
7787                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7788            ),
7789            _ => local_var_req_builder.query(&[(
7790                "mac_address__ie",
7791                &local_var_str
7792                    .into_iter()
7793                    .map(|p| p.to_string())
7794                    .collect::<Vec<String>>()
7795                    .join(",")
7796                    .to_string(),
7797            )]),
7798        };
7799    }
7800    if let Some(ref local_var_str) = mac_address__iew {
7801        local_var_req_builder = match "multi" {
7802            "multi" => local_var_req_builder.query(
7803                &local_var_str
7804                    .into_iter()
7805                    .map(|p| ("mac_address__iew".to_owned(), p.to_string()))
7806                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7807            ),
7808            _ => local_var_req_builder.query(&[(
7809                "mac_address__iew",
7810                &local_var_str
7811                    .into_iter()
7812                    .map(|p| p.to_string())
7813                    .collect::<Vec<String>>()
7814                    .join(",")
7815                    .to_string(),
7816            )]),
7817        };
7818    }
7819    if let Some(ref local_var_str) = mac_address__iregex {
7820        local_var_req_builder = match "multi" {
7821            "multi" => local_var_req_builder.query(
7822                &local_var_str
7823                    .into_iter()
7824                    .map(|p| ("mac_address__iregex".to_owned(), p.to_string()))
7825                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7826            ),
7827            _ => local_var_req_builder.query(&[(
7828                "mac_address__iregex",
7829                &local_var_str
7830                    .into_iter()
7831                    .map(|p| p.to_string())
7832                    .collect::<Vec<String>>()
7833                    .join(",")
7834                    .to_string(),
7835            )]),
7836        };
7837    }
7838    if let Some(ref local_var_str) = mac_address__isw {
7839        local_var_req_builder = match "multi" {
7840            "multi" => local_var_req_builder.query(
7841                &local_var_str
7842                    .into_iter()
7843                    .map(|p| ("mac_address__isw".to_owned(), p.to_string()))
7844                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7845            ),
7846            _ => local_var_req_builder.query(&[(
7847                "mac_address__isw",
7848                &local_var_str
7849                    .into_iter()
7850                    .map(|p| p.to_string())
7851                    .collect::<Vec<String>>()
7852                    .join(",")
7853                    .to_string(),
7854            )]),
7855        };
7856    }
7857    if let Some(ref local_var_str) = mac_address__n {
7858        local_var_req_builder = match "multi" {
7859            "multi" => local_var_req_builder.query(
7860                &local_var_str
7861                    .into_iter()
7862                    .map(|p| ("mac_address__n".to_owned(), p.to_string()))
7863                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7864            ),
7865            _ => local_var_req_builder.query(&[(
7866                "mac_address__n",
7867                &local_var_str
7868                    .into_iter()
7869                    .map(|p| p.to_string())
7870                    .collect::<Vec<String>>()
7871                    .join(",")
7872                    .to_string(),
7873            )]),
7874        };
7875    }
7876    if let Some(ref local_var_str) = mac_address__nic {
7877        local_var_req_builder = match "multi" {
7878            "multi" => local_var_req_builder.query(
7879                &local_var_str
7880                    .into_iter()
7881                    .map(|p| ("mac_address__nic".to_owned(), p.to_string()))
7882                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7883            ),
7884            _ => local_var_req_builder.query(&[(
7885                "mac_address__nic",
7886                &local_var_str
7887                    .into_iter()
7888                    .map(|p| p.to_string())
7889                    .collect::<Vec<String>>()
7890                    .join(",")
7891                    .to_string(),
7892            )]),
7893        };
7894    }
7895    if let Some(ref local_var_str) = mac_address__nie {
7896        local_var_req_builder = match "multi" {
7897            "multi" => local_var_req_builder.query(
7898                &local_var_str
7899                    .into_iter()
7900                    .map(|p| ("mac_address__nie".to_owned(), p.to_string()))
7901                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7902            ),
7903            _ => local_var_req_builder.query(&[(
7904                "mac_address__nie",
7905                &local_var_str
7906                    .into_iter()
7907                    .map(|p| p.to_string())
7908                    .collect::<Vec<String>>()
7909                    .join(",")
7910                    .to_string(),
7911            )]),
7912        };
7913    }
7914    if let Some(ref local_var_str) = mac_address__niew {
7915        local_var_req_builder = match "multi" {
7916            "multi" => local_var_req_builder.query(
7917                &local_var_str
7918                    .into_iter()
7919                    .map(|p| ("mac_address__niew".to_owned(), p.to_string()))
7920                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7921            ),
7922            _ => local_var_req_builder.query(&[(
7923                "mac_address__niew",
7924                &local_var_str
7925                    .into_iter()
7926                    .map(|p| p.to_string())
7927                    .collect::<Vec<String>>()
7928                    .join(",")
7929                    .to_string(),
7930            )]),
7931        };
7932    }
7933    if let Some(ref local_var_str) = mac_address__nisw {
7934        local_var_req_builder = match "multi" {
7935            "multi" => local_var_req_builder.query(
7936                &local_var_str
7937                    .into_iter()
7938                    .map(|p| ("mac_address__nisw".to_owned(), p.to_string()))
7939                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7940            ),
7941            _ => local_var_req_builder.query(&[(
7942                "mac_address__nisw",
7943                &local_var_str
7944                    .into_iter()
7945                    .map(|p| p.to_string())
7946                    .collect::<Vec<String>>()
7947                    .join(",")
7948                    .to_string(),
7949            )]),
7950        };
7951    }
7952    if let Some(ref local_var_str) = mac_address__regex {
7953        local_var_req_builder = match "multi" {
7954            "multi" => local_var_req_builder.query(
7955                &local_var_str
7956                    .into_iter()
7957                    .map(|p| ("mac_address__regex".to_owned(), p.to_string()))
7958                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7959            ),
7960            _ => local_var_req_builder.query(&[(
7961                "mac_address__regex",
7962                &local_var_str
7963                    .into_iter()
7964                    .map(|p| p.to_string())
7965                    .collect::<Vec<String>>()
7966                    .join(",")
7967                    .to_string(),
7968            )]),
7969        };
7970    }
7971    if let Some(ref local_var_str) = mode {
7972        local_var_req_builder = match "multi" {
7973            "multi" => local_var_req_builder.query(
7974                &local_var_str
7975                    .into_iter()
7976                    .map(|p| ("mode".to_owned(), p.to_string()))
7977                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7978            ),
7979            _ => local_var_req_builder.query(&[(
7980                "mode",
7981                &local_var_str
7982                    .into_iter()
7983                    .map(|p| p.to_string())
7984                    .collect::<Vec<String>>()
7985                    .join(",")
7986                    .to_string(),
7987            )]),
7988        };
7989    }
7990    if let Some(ref local_var_str) = mode__empty {
7991        local_var_req_builder =
7992            local_var_req_builder.query(&[("mode__empty", &local_var_str.to_string())]);
7993    }
7994    if let Some(ref local_var_str) = mode__ic {
7995        local_var_req_builder = match "multi" {
7996            "multi" => local_var_req_builder.query(
7997                &local_var_str
7998                    .into_iter()
7999                    .map(|p| ("mode__ic".to_owned(), p.to_string()))
8000                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8001            ),
8002            _ => local_var_req_builder.query(&[(
8003                "mode__ic",
8004                &local_var_str
8005                    .into_iter()
8006                    .map(|p| p.to_string())
8007                    .collect::<Vec<String>>()
8008                    .join(",")
8009                    .to_string(),
8010            )]),
8011        };
8012    }
8013    if let Some(ref local_var_str) = mode__ie {
8014        local_var_req_builder = match "multi" {
8015            "multi" => local_var_req_builder.query(
8016                &local_var_str
8017                    .into_iter()
8018                    .map(|p| ("mode__ie".to_owned(), p.to_string()))
8019                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8020            ),
8021            _ => local_var_req_builder.query(&[(
8022                "mode__ie",
8023                &local_var_str
8024                    .into_iter()
8025                    .map(|p| p.to_string())
8026                    .collect::<Vec<String>>()
8027                    .join(",")
8028                    .to_string(),
8029            )]),
8030        };
8031    }
8032    if let Some(ref local_var_str) = mode__iew {
8033        local_var_req_builder = match "multi" {
8034            "multi" => local_var_req_builder.query(
8035                &local_var_str
8036                    .into_iter()
8037                    .map(|p| ("mode__iew".to_owned(), p.to_string()))
8038                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8039            ),
8040            _ => local_var_req_builder.query(&[(
8041                "mode__iew",
8042                &local_var_str
8043                    .into_iter()
8044                    .map(|p| p.to_string())
8045                    .collect::<Vec<String>>()
8046                    .join(",")
8047                    .to_string(),
8048            )]),
8049        };
8050    }
8051    if let Some(ref local_var_str) = mode__iregex {
8052        local_var_req_builder = match "multi" {
8053            "multi" => local_var_req_builder.query(
8054                &local_var_str
8055                    .into_iter()
8056                    .map(|p| ("mode__iregex".to_owned(), p.to_string()))
8057                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8058            ),
8059            _ => local_var_req_builder.query(&[(
8060                "mode__iregex",
8061                &local_var_str
8062                    .into_iter()
8063                    .map(|p| p.to_string())
8064                    .collect::<Vec<String>>()
8065                    .join(",")
8066                    .to_string(),
8067            )]),
8068        };
8069    }
8070    if let Some(ref local_var_str) = mode__isw {
8071        local_var_req_builder = match "multi" {
8072            "multi" => local_var_req_builder.query(
8073                &local_var_str
8074                    .into_iter()
8075                    .map(|p| ("mode__isw".to_owned(), p.to_string()))
8076                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8077            ),
8078            _ => local_var_req_builder.query(&[(
8079                "mode__isw",
8080                &local_var_str
8081                    .into_iter()
8082                    .map(|p| p.to_string())
8083                    .collect::<Vec<String>>()
8084                    .join(",")
8085                    .to_string(),
8086            )]),
8087        };
8088    }
8089    if let Some(ref local_var_str) = mode__n {
8090        local_var_req_builder = match "multi" {
8091            "multi" => local_var_req_builder.query(
8092                &local_var_str
8093                    .into_iter()
8094                    .map(|p| ("mode__n".to_owned(), p.to_string()))
8095                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8096            ),
8097            _ => local_var_req_builder.query(&[(
8098                "mode__n",
8099                &local_var_str
8100                    .into_iter()
8101                    .map(|p| p.to_string())
8102                    .collect::<Vec<String>>()
8103                    .join(",")
8104                    .to_string(),
8105            )]),
8106        };
8107    }
8108    if let Some(ref local_var_str) = mode__nic {
8109        local_var_req_builder = match "multi" {
8110            "multi" => local_var_req_builder.query(
8111                &local_var_str
8112                    .into_iter()
8113                    .map(|p| ("mode__nic".to_owned(), p.to_string()))
8114                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8115            ),
8116            _ => local_var_req_builder.query(&[(
8117                "mode__nic",
8118                &local_var_str
8119                    .into_iter()
8120                    .map(|p| p.to_string())
8121                    .collect::<Vec<String>>()
8122                    .join(",")
8123                    .to_string(),
8124            )]),
8125        };
8126    }
8127    if let Some(ref local_var_str) = mode__nie {
8128        local_var_req_builder = match "multi" {
8129            "multi" => local_var_req_builder.query(
8130                &local_var_str
8131                    .into_iter()
8132                    .map(|p| ("mode__nie".to_owned(), p.to_string()))
8133                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8134            ),
8135            _ => local_var_req_builder.query(&[(
8136                "mode__nie",
8137                &local_var_str
8138                    .into_iter()
8139                    .map(|p| p.to_string())
8140                    .collect::<Vec<String>>()
8141                    .join(",")
8142                    .to_string(),
8143            )]),
8144        };
8145    }
8146    if let Some(ref local_var_str) = mode__niew {
8147        local_var_req_builder = match "multi" {
8148            "multi" => local_var_req_builder.query(
8149                &local_var_str
8150                    .into_iter()
8151                    .map(|p| ("mode__niew".to_owned(), p.to_string()))
8152                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8153            ),
8154            _ => local_var_req_builder.query(&[(
8155                "mode__niew",
8156                &local_var_str
8157                    .into_iter()
8158                    .map(|p| p.to_string())
8159                    .collect::<Vec<String>>()
8160                    .join(",")
8161                    .to_string(),
8162            )]),
8163        };
8164    }
8165    if let Some(ref local_var_str) = mode__nisw {
8166        local_var_req_builder = match "multi" {
8167            "multi" => local_var_req_builder.query(
8168                &local_var_str
8169                    .into_iter()
8170                    .map(|p| ("mode__nisw".to_owned(), p.to_string()))
8171                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8172            ),
8173            _ => local_var_req_builder.query(&[(
8174                "mode__nisw",
8175                &local_var_str
8176                    .into_iter()
8177                    .map(|p| p.to_string())
8178                    .collect::<Vec<String>>()
8179                    .join(",")
8180                    .to_string(),
8181            )]),
8182        };
8183    }
8184    if let Some(ref local_var_str) = mode__regex {
8185        local_var_req_builder = match "multi" {
8186            "multi" => local_var_req_builder.query(
8187                &local_var_str
8188                    .into_iter()
8189                    .map(|p| ("mode__regex".to_owned(), p.to_string()))
8190                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8191            ),
8192            _ => local_var_req_builder.query(&[(
8193                "mode__regex",
8194                &local_var_str
8195                    .into_iter()
8196                    .map(|p| p.to_string())
8197                    .collect::<Vec<String>>()
8198                    .join(",")
8199                    .to_string(),
8200            )]),
8201        };
8202    }
8203    if let Some(ref local_var_str) = modified_by_request {
8204        local_var_req_builder =
8205            local_var_req_builder.query(&[("modified_by_request", &local_var_str.to_string())]);
8206    }
8207    if let Some(ref local_var_str) = mtu {
8208        local_var_req_builder = match "multi" {
8209            "multi" => local_var_req_builder.query(
8210                &local_var_str
8211                    .into_iter()
8212                    .map(|p| ("mtu".to_owned(), p.to_string()))
8213                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8214            ),
8215            _ => local_var_req_builder.query(&[(
8216                "mtu",
8217                &local_var_str
8218                    .into_iter()
8219                    .map(|p| p.to_string())
8220                    .collect::<Vec<String>>()
8221                    .join(",")
8222                    .to_string(),
8223            )]),
8224        };
8225    }
8226    if let Some(ref local_var_str) = mtu__empty {
8227        local_var_req_builder =
8228            local_var_req_builder.query(&[("mtu__empty", &local_var_str.to_string())]);
8229    }
8230    if let Some(ref local_var_str) = mtu__gt {
8231        local_var_req_builder = match "multi" {
8232            "multi" => local_var_req_builder.query(
8233                &local_var_str
8234                    .into_iter()
8235                    .map(|p| ("mtu__gt".to_owned(), p.to_string()))
8236                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8237            ),
8238            _ => local_var_req_builder.query(&[(
8239                "mtu__gt",
8240                &local_var_str
8241                    .into_iter()
8242                    .map(|p| p.to_string())
8243                    .collect::<Vec<String>>()
8244                    .join(",")
8245                    .to_string(),
8246            )]),
8247        };
8248    }
8249    if let Some(ref local_var_str) = mtu__gte {
8250        local_var_req_builder = match "multi" {
8251            "multi" => local_var_req_builder.query(
8252                &local_var_str
8253                    .into_iter()
8254                    .map(|p| ("mtu__gte".to_owned(), p.to_string()))
8255                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8256            ),
8257            _ => local_var_req_builder.query(&[(
8258                "mtu__gte",
8259                &local_var_str
8260                    .into_iter()
8261                    .map(|p| p.to_string())
8262                    .collect::<Vec<String>>()
8263                    .join(",")
8264                    .to_string(),
8265            )]),
8266        };
8267    }
8268    if let Some(ref local_var_str) = mtu__lt {
8269        local_var_req_builder = match "multi" {
8270            "multi" => local_var_req_builder.query(
8271                &local_var_str
8272                    .into_iter()
8273                    .map(|p| ("mtu__lt".to_owned(), p.to_string()))
8274                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8275            ),
8276            _ => local_var_req_builder.query(&[(
8277                "mtu__lt",
8278                &local_var_str
8279                    .into_iter()
8280                    .map(|p| p.to_string())
8281                    .collect::<Vec<String>>()
8282                    .join(",")
8283                    .to_string(),
8284            )]),
8285        };
8286    }
8287    if let Some(ref local_var_str) = mtu__lte {
8288        local_var_req_builder = match "multi" {
8289            "multi" => local_var_req_builder.query(
8290                &local_var_str
8291                    .into_iter()
8292                    .map(|p| ("mtu__lte".to_owned(), p.to_string()))
8293                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8294            ),
8295            _ => local_var_req_builder.query(&[(
8296                "mtu__lte",
8297                &local_var_str
8298                    .into_iter()
8299                    .map(|p| p.to_string())
8300                    .collect::<Vec<String>>()
8301                    .join(",")
8302                    .to_string(),
8303            )]),
8304        };
8305    }
8306    if let Some(ref local_var_str) = mtu__n {
8307        local_var_req_builder = match "multi" {
8308            "multi" => local_var_req_builder.query(
8309                &local_var_str
8310                    .into_iter()
8311                    .map(|p| ("mtu__n".to_owned(), p.to_string()))
8312                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8313            ),
8314            _ => local_var_req_builder.query(&[(
8315                "mtu__n",
8316                &local_var_str
8317                    .into_iter()
8318                    .map(|p| p.to_string())
8319                    .collect::<Vec<String>>()
8320                    .join(",")
8321                    .to_string(),
8322            )]),
8323        };
8324    }
8325    if let Some(ref local_var_str) = name {
8326        local_var_req_builder = match "multi" {
8327            "multi" => local_var_req_builder.query(
8328                &local_var_str
8329                    .into_iter()
8330                    .map(|p| ("name".to_owned(), p.to_string()))
8331                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8332            ),
8333            _ => local_var_req_builder.query(&[(
8334                "name",
8335                &local_var_str
8336                    .into_iter()
8337                    .map(|p| p.to_string())
8338                    .collect::<Vec<String>>()
8339                    .join(",")
8340                    .to_string(),
8341            )]),
8342        };
8343    }
8344    if let Some(ref local_var_str) = name__empty {
8345        local_var_req_builder =
8346            local_var_req_builder.query(&[("name__empty", &local_var_str.to_string())]);
8347    }
8348    if let Some(ref local_var_str) = name__ic {
8349        local_var_req_builder = match "multi" {
8350            "multi" => local_var_req_builder.query(
8351                &local_var_str
8352                    .into_iter()
8353                    .map(|p| ("name__ic".to_owned(), p.to_string()))
8354                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8355            ),
8356            _ => local_var_req_builder.query(&[(
8357                "name__ic",
8358                &local_var_str
8359                    .into_iter()
8360                    .map(|p| p.to_string())
8361                    .collect::<Vec<String>>()
8362                    .join(",")
8363                    .to_string(),
8364            )]),
8365        };
8366    }
8367    if let Some(ref local_var_str) = name__ie {
8368        local_var_req_builder = match "multi" {
8369            "multi" => local_var_req_builder.query(
8370                &local_var_str
8371                    .into_iter()
8372                    .map(|p| ("name__ie".to_owned(), p.to_string()))
8373                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8374            ),
8375            _ => local_var_req_builder.query(&[(
8376                "name__ie",
8377                &local_var_str
8378                    .into_iter()
8379                    .map(|p| p.to_string())
8380                    .collect::<Vec<String>>()
8381                    .join(",")
8382                    .to_string(),
8383            )]),
8384        };
8385    }
8386    if let Some(ref local_var_str) = name__iew {
8387        local_var_req_builder = match "multi" {
8388            "multi" => local_var_req_builder.query(
8389                &local_var_str
8390                    .into_iter()
8391                    .map(|p| ("name__iew".to_owned(), p.to_string()))
8392                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8393            ),
8394            _ => local_var_req_builder.query(&[(
8395                "name__iew",
8396                &local_var_str
8397                    .into_iter()
8398                    .map(|p| p.to_string())
8399                    .collect::<Vec<String>>()
8400                    .join(",")
8401                    .to_string(),
8402            )]),
8403        };
8404    }
8405    if let Some(ref local_var_str) = name__iregex {
8406        local_var_req_builder = match "multi" {
8407            "multi" => local_var_req_builder.query(
8408                &local_var_str
8409                    .into_iter()
8410                    .map(|p| ("name__iregex".to_owned(), p.to_string()))
8411                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8412            ),
8413            _ => local_var_req_builder.query(&[(
8414                "name__iregex",
8415                &local_var_str
8416                    .into_iter()
8417                    .map(|p| p.to_string())
8418                    .collect::<Vec<String>>()
8419                    .join(",")
8420                    .to_string(),
8421            )]),
8422        };
8423    }
8424    if let Some(ref local_var_str) = name__isw {
8425        local_var_req_builder = match "multi" {
8426            "multi" => local_var_req_builder.query(
8427                &local_var_str
8428                    .into_iter()
8429                    .map(|p| ("name__isw".to_owned(), p.to_string()))
8430                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8431            ),
8432            _ => local_var_req_builder.query(&[(
8433                "name__isw",
8434                &local_var_str
8435                    .into_iter()
8436                    .map(|p| p.to_string())
8437                    .collect::<Vec<String>>()
8438                    .join(",")
8439                    .to_string(),
8440            )]),
8441        };
8442    }
8443    if let Some(ref local_var_str) = name__n {
8444        local_var_req_builder = match "multi" {
8445            "multi" => local_var_req_builder.query(
8446                &local_var_str
8447                    .into_iter()
8448                    .map(|p| ("name__n".to_owned(), p.to_string()))
8449                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8450            ),
8451            _ => local_var_req_builder.query(&[(
8452                "name__n",
8453                &local_var_str
8454                    .into_iter()
8455                    .map(|p| p.to_string())
8456                    .collect::<Vec<String>>()
8457                    .join(",")
8458                    .to_string(),
8459            )]),
8460        };
8461    }
8462    if let Some(ref local_var_str) = name__nic {
8463        local_var_req_builder = match "multi" {
8464            "multi" => local_var_req_builder.query(
8465                &local_var_str
8466                    .into_iter()
8467                    .map(|p| ("name__nic".to_owned(), p.to_string()))
8468                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8469            ),
8470            _ => local_var_req_builder.query(&[(
8471                "name__nic",
8472                &local_var_str
8473                    .into_iter()
8474                    .map(|p| p.to_string())
8475                    .collect::<Vec<String>>()
8476                    .join(",")
8477                    .to_string(),
8478            )]),
8479        };
8480    }
8481    if let Some(ref local_var_str) = name__nie {
8482        local_var_req_builder = match "multi" {
8483            "multi" => local_var_req_builder.query(
8484                &local_var_str
8485                    .into_iter()
8486                    .map(|p| ("name__nie".to_owned(), p.to_string()))
8487                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8488            ),
8489            _ => local_var_req_builder.query(&[(
8490                "name__nie",
8491                &local_var_str
8492                    .into_iter()
8493                    .map(|p| p.to_string())
8494                    .collect::<Vec<String>>()
8495                    .join(",")
8496                    .to_string(),
8497            )]),
8498        };
8499    }
8500    if let Some(ref local_var_str) = name__niew {
8501        local_var_req_builder = match "multi" {
8502            "multi" => local_var_req_builder.query(
8503                &local_var_str
8504                    .into_iter()
8505                    .map(|p| ("name__niew".to_owned(), p.to_string()))
8506                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8507            ),
8508            _ => local_var_req_builder.query(&[(
8509                "name__niew",
8510                &local_var_str
8511                    .into_iter()
8512                    .map(|p| p.to_string())
8513                    .collect::<Vec<String>>()
8514                    .join(",")
8515                    .to_string(),
8516            )]),
8517        };
8518    }
8519    if let Some(ref local_var_str) = name__nisw {
8520        local_var_req_builder = match "multi" {
8521            "multi" => local_var_req_builder.query(
8522                &local_var_str
8523                    .into_iter()
8524                    .map(|p| ("name__nisw".to_owned(), p.to_string()))
8525                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8526            ),
8527            _ => local_var_req_builder.query(&[(
8528                "name__nisw",
8529                &local_var_str
8530                    .into_iter()
8531                    .map(|p| p.to_string())
8532                    .collect::<Vec<String>>()
8533                    .join(",")
8534                    .to_string(),
8535            )]),
8536        };
8537    }
8538    if let Some(ref local_var_str) = name__regex {
8539        local_var_req_builder = match "multi" {
8540            "multi" => local_var_req_builder.query(
8541                &local_var_str
8542                    .into_iter()
8543                    .map(|p| ("name__regex".to_owned(), p.to_string()))
8544                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8545            ),
8546            _ => local_var_req_builder.query(&[(
8547                "name__regex",
8548                &local_var_str
8549                    .into_iter()
8550                    .map(|p| p.to_string())
8551                    .collect::<Vec<String>>()
8552                    .join(",")
8553                    .to_string(),
8554            )]),
8555        };
8556    }
8557    if let Some(ref local_var_str) = offset {
8558        local_var_req_builder =
8559            local_var_req_builder.query(&[("offset", &local_var_str.to_string())]);
8560    }
8561    if let Some(ref local_var_str) = ordering {
8562        local_var_req_builder =
8563            local_var_req_builder.query(&[("ordering", &local_var_str.to_string())]);
8564    }
8565    if let Some(ref local_var_str) = parent_id {
8566        local_var_req_builder = match "multi" {
8567            "multi" => local_var_req_builder.query(
8568                &local_var_str
8569                    .into_iter()
8570                    .map(|p| ("parent_id".to_owned(), p.to_string()))
8571                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8572            ),
8573            _ => local_var_req_builder.query(&[(
8574                "parent_id",
8575                &local_var_str
8576                    .into_iter()
8577                    .map(|p| p.to_string())
8578                    .collect::<Vec<String>>()
8579                    .join(",")
8580                    .to_string(),
8581            )]),
8582        };
8583    }
8584    if let Some(ref local_var_str) = parent_id__n {
8585        local_var_req_builder = match "multi" {
8586            "multi" => local_var_req_builder.query(
8587                &local_var_str
8588                    .into_iter()
8589                    .map(|p| ("parent_id__n".to_owned(), p.to_string()))
8590                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8591            ),
8592            _ => local_var_req_builder.query(&[(
8593                "parent_id__n",
8594                &local_var_str
8595                    .into_iter()
8596                    .map(|p| p.to_string())
8597                    .collect::<Vec<String>>()
8598                    .join(",")
8599                    .to_string(),
8600            )]),
8601        };
8602    }
8603    if let Some(ref local_var_str) = primary_mac_address {
8604        local_var_req_builder = match "multi" {
8605            "multi" => local_var_req_builder.query(
8606                &local_var_str
8607                    .into_iter()
8608                    .map(|p| ("primary_mac_address".to_owned(), p.to_string()))
8609                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8610            ),
8611            _ => local_var_req_builder.query(&[(
8612                "primary_mac_address",
8613                &local_var_str
8614                    .into_iter()
8615                    .map(|p| p.to_string())
8616                    .collect::<Vec<String>>()
8617                    .join(",")
8618                    .to_string(),
8619            )]),
8620        };
8621    }
8622    if let Some(ref local_var_str) = primary_mac_address__n {
8623        local_var_req_builder = match "multi" {
8624            "multi" => local_var_req_builder.query(
8625                &local_var_str
8626                    .into_iter()
8627                    .map(|p| ("primary_mac_address__n".to_owned(), p.to_string()))
8628                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8629            ),
8630            _ => local_var_req_builder.query(&[(
8631                "primary_mac_address__n",
8632                &local_var_str
8633                    .into_iter()
8634                    .map(|p| p.to_string())
8635                    .collect::<Vec<String>>()
8636                    .join(",")
8637                    .to_string(),
8638            )]),
8639        };
8640    }
8641    if let Some(ref local_var_str) = primary_mac_address_id {
8642        local_var_req_builder = match "multi" {
8643            "multi" => local_var_req_builder.query(
8644                &local_var_str
8645                    .into_iter()
8646                    .map(|p| ("primary_mac_address_id".to_owned(), p.to_string()))
8647                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8648            ),
8649            _ => local_var_req_builder.query(&[(
8650                "primary_mac_address_id",
8651                &local_var_str
8652                    .into_iter()
8653                    .map(|p| p.to_string())
8654                    .collect::<Vec<String>>()
8655                    .join(",")
8656                    .to_string(),
8657            )]),
8658        };
8659    }
8660    if let Some(ref local_var_str) = primary_mac_address_id__n {
8661        local_var_req_builder = match "multi" {
8662            "multi" => local_var_req_builder.query(
8663                &local_var_str
8664                    .into_iter()
8665                    .map(|p| ("primary_mac_address_id__n".to_owned(), p.to_string()))
8666                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8667            ),
8668            _ => local_var_req_builder.query(&[(
8669                "primary_mac_address_id__n",
8670                &local_var_str
8671                    .into_iter()
8672                    .map(|p| p.to_string())
8673                    .collect::<Vec<String>>()
8674                    .join(",")
8675                    .to_string(),
8676            )]),
8677        };
8678    }
8679    if let Some(ref local_var_str) = q {
8680        local_var_req_builder = local_var_req_builder.query(&[("q", &local_var_str.to_string())]);
8681    }
8682    if let Some(ref local_var_str) = tag {
8683        local_var_req_builder = match "multi" {
8684            "multi" => local_var_req_builder.query(
8685                &local_var_str
8686                    .into_iter()
8687                    .map(|p| ("tag".to_owned(), p.to_string()))
8688                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8689            ),
8690            _ => local_var_req_builder.query(&[(
8691                "tag",
8692                &local_var_str
8693                    .into_iter()
8694                    .map(|p| p.to_string())
8695                    .collect::<Vec<String>>()
8696                    .join(",")
8697                    .to_string(),
8698            )]),
8699        };
8700    }
8701    if let Some(ref local_var_str) = tag__n {
8702        local_var_req_builder = match "multi" {
8703            "multi" => local_var_req_builder.query(
8704                &local_var_str
8705                    .into_iter()
8706                    .map(|p| ("tag__n".to_owned(), p.to_string()))
8707                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8708            ),
8709            _ => local_var_req_builder.query(&[(
8710                "tag__n",
8711                &local_var_str
8712                    .into_iter()
8713                    .map(|p| p.to_string())
8714                    .collect::<Vec<String>>()
8715                    .join(",")
8716                    .to_string(),
8717            )]),
8718        };
8719    }
8720    if let Some(ref local_var_str) = tag_id {
8721        local_var_req_builder = match "multi" {
8722            "multi" => local_var_req_builder.query(
8723                &local_var_str
8724                    .into_iter()
8725                    .map(|p| ("tag_id".to_owned(), p.to_string()))
8726                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8727            ),
8728            _ => local_var_req_builder.query(&[(
8729                "tag_id",
8730                &local_var_str
8731                    .into_iter()
8732                    .map(|p| p.to_string())
8733                    .collect::<Vec<String>>()
8734                    .join(",")
8735                    .to_string(),
8736            )]),
8737        };
8738    }
8739    if let Some(ref local_var_str) = tag_id__n {
8740        local_var_req_builder = match "multi" {
8741            "multi" => local_var_req_builder.query(
8742                &local_var_str
8743                    .into_iter()
8744                    .map(|p| ("tag_id__n".to_owned(), p.to_string()))
8745                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8746            ),
8747            _ => local_var_req_builder.query(&[(
8748                "tag_id__n",
8749                &local_var_str
8750                    .into_iter()
8751                    .map(|p| p.to_string())
8752                    .collect::<Vec<String>>()
8753                    .join(",")
8754                    .to_string(),
8755            )]),
8756        };
8757    }
8758    if let Some(ref local_var_str) = updated_by_request {
8759        local_var_req_builder =
8760            local_var_req_builder.query(&[("updated_by_request", &local_var_str.to_string())]);
8761    }
8762    if let Some(ref local_var_str) = virtual_machine {
8763        local_var_req_builder = match "multi" {
8764            "multi" => local_var_req_builder.query(
8765                &local_var_str
8766                    .into_iter()
8767                    .map(|p| ("virtual_machine".to_owned(), p.to_string()))
8768                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8769            ),
8770            _ => local_var_req_builder.query(&[(
8771                "virtual_machine",
8772                &local_var_str
8773                    .into_iter()
8774                    .map(|p| p.to_string())
8775                    .collect::<Vec<String>>()
8776                    .join(",")
8777                    .to_string(),
8778            )]),
8779        };
8780    }
8781    if let Some(ref local_var_str) = virtual_machine__n {
8782        local_var_req_builder = match "multi" {
8783            "multi" => local_var_req_builder.query(
8784                &local_var_str
8785                    .into_iter()
8786                    .map(|p| ("virtual_machine__n".to_owned(), p.to_string()))
8787                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8788            ),
8789            _ => local_var_req_builder.query(&[(
8790                "virtual_machine__n",
8791                &local_var_str
8792                    .into_iter()
8793                    .map(|p| p.to_string())
8794                    .collect::<Vec<String>>()
8795                    .join(",")
8796                    .to_string(),
8797            )]),
8798        };
8799    }
8800    if let Some(ref local_var_str) = virtual_machine_id {
8801        local_var_req_builder = match "multi" {
8802            "multi" => local_var_req_builder.query(
8803                &local_var_str
8804                    .into_iter()
8805                    .map(|p| ("virtual_machine_id".to_owned(), p.to_string()))
8806                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8807            ),
8808            _ => local_var_req_builder.query(&[(
8809                "virtual_machine_id",
8810                &local_var_str
8811                    .into_iter()
8812                    .map(|p| p.to_string())
8813                    .collect::<Vec<String>>()
8814                    .join(",")
8815                    .to_string(),
8816            )]),
8817        };
8818    }
8819    if let Some(ref local_var_str) = virtual_machine_id__n {
8820        local_var_req_builder = match "multi" {
8821            "multi" => local_var_req_builder.query(
8822                &local_var_str
8823                    .into_iter()
8824                    .map(|p| ("virtual_machine_id__n".to_owned(), p.to_string()))
8825                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8826            ),
8827            _ => local_var_req_builder.query(&[(
8828                "virtual_machine_id__n",
8829                &local_var_str
8830                    .into_iter()
8831                    .map(|p| p.to_string())
8832                    .collect::<Vec<String>>()
8833                    .join(",")
8834                    .to_string(),
8835            )]),
8836        };
8837    }
8838    if let Some(ref local_var_str) = vlan {
8839        local_var_req_builder =
8840            local_var_req_builder.query(&[("vlan", &local_var_str.to_string())]);
8841    }
8842    if let Some(ref local_var_str) = vlan_id {
8843        local_var_req_builder =
8844            local_var_req_builder.query(&[("vlan_id", &local_var_str.to_string())]);
8845    }
8846    if let Some(ref local_var_str) = vlan_translation_policy {
8847        local_var_req_builder = match "multi" {
8848            "multi" => local_var_req_builder.query(
8849                &local_var_str
8850                    .into_iter()
8851                    .map(|p| ("vlan_translation_policy".to_owned(), p.to_string()))
8852                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8853            ),
8854            _ => local_var_req_builder.query(&[(
8855                "vlan_translation_policy",
8856                &local_var_str
8857                    .into_iter()
8858                    .map(|p| p.to_string())
8859                    .collect::<Vec<String>>()
8860                    .join(",")
8861                    .to_string(),
8862            )]),
8863        };
8864    }
8865    if let Some(ref local_var_str) = vlan_translation_policy__n {
8866        local_var_req_builder = match "multi" {
8867            "multi" => local_var_req_builder.query(
8868                &local_var_str
8869                    .into_iter()
8870                    .map(|p| ("vlan_translation_policy__n".to_owned(), p.to_string()))
8871                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8872            ),
8873            _ => local_var_req_builder.query(&[(
8874                "vlan_translation_policy__n",
8875                &local_var_str
8876                    .into_iter()
8877                    .map(|p| p.to_string())
8878                    .collect::<Vec<String>>()
8879                    .join(",")
8880                    .to_string(),
8881            )]),
8882        };
8883    }
8884    if let Some(ref local_var_str) = vlan_translation_policy_id {
8885        local_var_req_builder = match "multi" {
8886            "multi" => local_var_req_builder.query(
8887                &local_var_str
8888                    .into_iter()
8889                    .map(|p| ("vlan_translation_policy_id".to_owned(), p.to_string()))
8890                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8891            ),
8892            _ => local_var_req_builder.query(&[(
8893                "vlan_translation_policy_id",
8894                &local_var_str
8895                    .into_iter()
8896                    .map(|p| p.to_string())
8897                    .collect::<Vec<String>>()
8898                    .join(",")
8899                    .to_string(),
8900            )]),
8901        };
8902    }
8903    if let Some(ref local_var_str) = vlan_translation_policy_id__n {
8904        local_var_req_builder = match "multi" {
8905            "multi" => local_var_req_builder.query(
8906                &local_var_str
8907                    .into_iter()
8908                    .map(|p| ("vlan_translation_policy_id__n".to_owned(), p.to_string()))
8909                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8910            ),
8911            _ => local_var_req_builder.query(&[(
8912                "vlan_translation_policy_id__n",
8913                &local_var_str
8914                    .into_iter()
8915                    .map(|p| p.to_string())
8916                    .collect::<Vec<String>>()
8917                    .join(",")
8918                    .to_string(),
8919            )]),
8920        };
8921    }
8922    if let Some(ref local_var_str) = vrf {
8923        local_var_req_builder = match "multi" {
8924            "multi" => local_var_req_builder.query(
8925                &local_var_str
8926                    .into_iter()
8927                    .map(|p| ("vrf".to_owned(), p.to_string()))
8928                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8929            ),
8930            _ => local_var_req_builder.query(&[(
8931                "vrf",
8932                &local_var_str
8933                    .into_iter()
8934                    .map(|p| p.to_string())
8935                    .collect::<Vec<String>>()
8936                    .join(",")
8937                    .to_string(),
8938            )]),
8939        };
8940    }
8941    if let Some(ref local_var_str) = vrf__n {
8942        local_var_req_builder = match "multi" {
8943            "multi" => local_var_req_builder.query(
8944                &local_var_str
8945                    .into_iter()
8946                    .map(|p| ("vrf__n".to_owned(), p.to_string()))
8947                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8948            ),
8949            _ => local_var_req_builder.query(&[(
8950                "vrf__n",
8951                &local_var_str
8952                    .into_iter()
8953                    .map(|p| p.to_string())
8954                    .collect::<Vec<String>>()
8955                    .join(",")
8956                    .to_string(),
8957            )]),
8958        };
8959    }
8960    if let Some(ref local_var_str) = vrf_id {
8961        local_var_req_builder = match "multi" {
8962            "multi" => local_var_req_builder.query(
8963                &local_var_str
8964                    .into_iter()
8965                    .map(|p| ("vrf_id".to_owned(), p.to_string()))
8966                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8967            ),
8968            _ => local_var_req_builder.query(&[(
8969                "vrf_id",
8970                &local_var_str
8971                    .into_iter()
8972                    .map(|p| p.to_string())
8973                    .collect::<Vec<String>>()
8974                    .join(",")
8975                    .to_string(),
8976            )]),
8977        };
8978    }
8979    if let Some(ref local_var_str) = vrf_id__n {
8980        local_var_req_builder = match "multi" {
8981            "multi" => local_var_req_builder.query(
8982                &local_var_str
8983                    .into_iter()
8984                    .map(|p| ("vrf_id__n".to_owned(), p.to_string()))
8985                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8986            ),
8987            _ => local_var_req_builder.query(&[(
8988                "vrf_id__n",
8989                &local_var_str
8990                    .into_iter()
8991                    .map(|p| p.to_string())
8992                    .collect::<Vec<String>>()
8993                    .join(",")
8994                    .to_string(),
8995            )]),
8996        };
8997    }
8998    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
8999        local_var_req_builder =
9000            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
9001    }
9002    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
9003        let local_var_key = local_var_apikey.key.clone();
9004        let local_var_value = match local_var_apikey.prefix {
9005            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
9006            None => local_var_key,
9007        };
9008        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
9009    };
9010
9011    let local_var_req = local_var_req_builder.build()?;
9012    let local_var_resp = local_var_client.execute(local_var_req).await?;
9013
9014    let local_var_status = local_var_resp.status();
9015    let local_var_content = local_var_resp.text().await?;
9016
9017    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
9018        serde_json::from_str(&local_var_content).map_err(Error::from)
9019    } else {
9020        let local_var_entity: Option<VirtualizationInterfacesListError> =
9021            serde_json::from_str(&local_var_content).ok();
9022        let local_var_error = ResponseContent {
9023            status: local_var_status,
9024            content: local_var_content,
9025            entity: local_var_entity,
9026        };
9027        Err(Error::ResponseError(local_var_error))
9028    }
9029}
9030
9031/// Patch a interface object.
9032pub async fn virtualization_interfaces_partial_update(
9033    configuration: &configuration::Configuration,
9034    id: i32,
9035    patched_writable_vm_interface_request: Option<crate::models::PatchedWritableVmInterfaceRequest>,
9036) -> Result<crate::models::VmInterface, Error<VirtualizationInterfacesPartialUpdateError>> {
9037    let local_var_configuration = configuration;
9038
9039    let local_var_client = &local_var_configuration.client;
9040
9041    let local_var_uri_str = format!(
9042        "{}/api/virtualization/interfaces/{id}/",
9043        local_var_configuration.base_path,
9044        id = id
9045    );
9046    let mut local_var_req_builder =
9047        local_var_client.request(reqwest::Method::PATCH, local_var_uri_str.as_str());
9048
9049    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
9050        local_var_req_builder =
9051            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
9052    }
9053    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
9054        let local_var_key = local_var_apikey.key.clone();
9055        let local_var_value = match local_var_apikey.prefix {
9056            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
9057            None => local_var_key,
9058        };
9059        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
9060    };
9061    local_var_req_builder = local_var_req_builder.json(&patched_writable_vm_interface_request);
9062
9063    let local_var_req = local_var_req_builder.build()?;
9064    let local_var_resp = local_var_client.execute(local_var_req).await?;
9065
9066    let local_var_status = local_var_resp.status();
9067    let local_var_content = local_var_resp.text().await?;
9068
9069    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
9070        serde_json::from_str(&local_var_content).map_err(Error::from)
9071    } else {
9072        let local_var_entity: Option<VirtualizationInterfacesPartialUpdateError> =
9073            serde_json::from_str(&local_var_content).ok();
9074        let local_var_error = ResponseContent {
9075            status: local_var_status,
9076            content: local_var_content,
9077            entity: local_var_entity,
9078        };
9079        Err(Error::ResponseError(local_var_error))
9080    }
9081}
9082
9083/// Get a interface object.
9084pub async fn virtualization_interfaces_retrieve(
9085    configuration: &configuration::Configuration,
9086    id: i32,
9087) -> Result<crate::models::VmInterface, Error<VirtualizationInterfacesRetrieveError>> {
9088    let local_var_configuration = configuration;
9089
9090    let local_var_client = &local_var_configuration.client;
9091
9092    let local_var_uri_str = format!(
9093        "{}/api/virtualization/interfaces/{id}/",
9094        local_var_configuration.base_path,
9095        id = id
9096    );
9097    let mut local_var_req_builder =
9098        local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
9099
9100    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
9101        local_var_req_builder =
9102            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
9103    }
9104    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
9105        let local_var_key = local_var_apikey.key.clone();
9106        let local_var_value = match local_var_apikey.prefix {
9107            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
9108            None => local_var_key,
9109        };
9110        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
9111    };
9112
9113    let local_var_req = local_var_req_builder.build()?;
9114    let local_var_resp = local_var_client.execute(local_var_req).await?;
9115
9116    let local_var_status = local_var_resp.status();
9117    let local_var_content = local_var_resp.text().await?;
9118
9119    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
9120        serde_json::from_str(&local_var_content).map_err(Error::from)
9121    } else {
9122        let local_var_entity: Option<VirtualizationInterfacesRetrieveError> =
9123            serde_json::from_str(&local_var_content).ok();
9124        let local_var_error = ResponseContent {
9125            status: local_var_status,
9126            content: local_var_content,
9127            entity: local_var_entity,
9128        };
9129        Err(Error::ResponseError(local_var_error))
9130    }
9131}
9132
9133/// Put a interface object.
9134pub async fn virtualization_interfaces_update(
9135    configuration: &configuration::Configuration,
9136    id: i32,
9137    writable_vm_interface_request: crate::models::WritableVmInterfaceRequest,
9138) -> Result<crate::models::VmInterface, Error<VirtualizationInterfacesUpdateError>> {
9139    let local_var_configuration = configuration;
9140
9141    let local_var_client = &local_var_configuration.client;
9142
9143    let local_var_uri_str = format!(
9144        "{}/api/virtualization/interfaces/{id}/",
9145        local_var_configuration.base_path,
9146        id = id
9147    );
9148    let mut local_var_req_builder =
9149        local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());
9150
9151    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
9152        local_var_req_builder =
9153            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
9154    }
9155    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
9156        let local_var_key = local_var_apikey.key.clone();
9157        let local_var_value = match local_var_apikey.prefix {
9158            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
9159            None => local_var_key,
9160        };
9161        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
9162    };
9163    local_var_req_builder = local_var_req_builder.json(&writable_vm_interface_request);
9164
9165    let local_var_req = local_var_req_builder.build()?;
9166    let local_var_resp = local_var_client.execute(local_var_req).await?;
9167
9168    let local_var_status = local_var_resp.status();
9169    let local_var_content = local_var_resp.text().await?;
9170
9171    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
9172        serde_json::from_str(&local_var_content).map_err(Error::from)
9173    } else {
9174        let local_var_entity: Option<VirtualizationInterfacesUpdateError> =
9175            serde_json::from_str(&local_var_content).ok();
9176        let local_var_error = ResponseContent {
9177            status: local_var_status,
9178            content: local_var_content,
9179            entity: local_var_entity,
9180        };
9181        Err(Error::ResponseError(local_var_error))
9182    }
9183}
9184
9185/// Delete a list of virtual disk objects.
9186pub async fn virtualization_virtual_disks_bulk_destroy(
9187    configuration: &configuration::Configuration,
9188    virtual_disk_request: Vec<crate::models::VirtualDiskRequest>,
9189) -> Result<(), Error<VirtualizationVirtualDisksBulkDestroyError>> {
9190    let local_var_configuration = configuration;
9191
9192    let local_var_client = &local_var_configuration.client;
9193
9194    let local_var_uri_str = format!(
9195        "{}/api/virtualization/virtual-disks/",
9196        local_var_configuration.base_path
9197    );
9198    let mut local_var_req_builder =
9199        local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());
9200
9201    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
9202        local_var_req_builder =
9203            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
9204    }
9205    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
9206        let local_var_key = local_var_apikey.key.clone();
9207        let local_var_value = match local_var_apikey.prefix {
9208            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
9209            None => local_var_key,
9210        };
9211        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
9212    };
9213    local_var_req_builder = local_var_req_builder.json(&virtual_disk_request);
9214
9215    let local_var_req = local_var_req_builder.build()?;
9216    let local_var_resp = local_var_client.execute(local_var_req).await?;
9217
9218    let local_var_status = local_var_resp.status();
9219    let local_var_content = local_var_resp.text().await?;
9220
9221    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
9222        Ok(())
9223    } else {
9224        let local_var_entity: Option<VirtualizationVirtualDisksBulkDestroyError> =
9225            serde_json::from_str(&local_var_content).ok();
9226        let local_var_error = ResponseContent {
9227            status: local_var_status,
9228            content: local_var_content,
9229            entity: local_var_entity,
9230        };
9231        Err(Error::ResponseError(local_var_error))
9232    }
9233}
9234
9235/// Patch a list of virtual disk objects.
9236pub async fn virtualization_virtual_disks_bulk_partial_update(
9237    configuration: &configuration::Configuration,
9238    virtual_disk_request: Vec<crate::models::VirtualDiskRequest>,
9239) -> Result<Vec<crate::models::VirtualDisk>, Error<VirtualizationVirtualDisksBulkPartialUpdateError>>
9240{
9241    let local_var_configuration = configuration;
9242
9243    let local_var_client = &local_var_configuration.client;
9244
9245    let local_var_uri_str = format!(
9246        "{}/api/virtualization/virtual-disks/",
9247        local_var_configuration.base_path
9248    );
9249    let mut local_var_req_builder =
9250        local_var_client.request(reqwest::Method::PATCH, local_var_uri_str.as_str());
9251
9252    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
9253        local_var_req_builder =
9254            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
9255    }
9256    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
9257        let local_var_key = local_var_apikey.key.clone();
9258        let local_var_value = match local_var_apikey.prefix {
9259            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
9260            None => local_var_key,
9261        };
9262        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
9263    };
9264    local_var_req_builder = local_var_req_builder.json(&virtual_disk_request);
9265
9266    let local_var_req = local_var_req_builder.build()?;
9267    let local_var_resp = local_var_client.execute(local_var_req).await?;
9268
9269    let local_var_status = local_var_resp.status();
9270    let local_var_content = local_var_resp.text().await?;
9271
9272    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
9273        serde_json::from_str(&local_var_content).map_err(Error::from)
9274    } else {
9275        let local_var_entity: Option<VirtualizationVirtualDisksBulkPartialUpdateError> =
9276            serde_json::from_str(&local_var_content).ok();
9277        let local_var_error = ResponseContent {
9278            status: local_var_status,
9279            content: local_var_content,
9280            entity: local_var_entity,
9281        };
9282        Err(Error::ResponseError(local_var_error))
9283    }
9284}
9285
9286/// Put a list of virtual disk objects.
9287pub async fn virtualization_virtual_disks_bulk_update(
9288    configuration: &configuration::Configuration,
9289    virtual_disk_request: Vec<crate::models::VirtualDiskRequest>,
9290) -> Result<Vec<crate::models::VirtualDisk>, Error<VirtualizationVirtualDisksBulkUpdateError>> {
9291    let local_var_configuration = configuration;
9292
9293    let local_var_client = &local_var_configuration.client;
9294
9295    let local_var_uri_str = format!(
9296        "{}/api/virtualization/virtual-disks/",
9297        local_var_configuration.base_path
9298    );
9299    let mut local_var_req_builder =
9300        local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());
9301
9302    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
9303        local_var_req_builder =
9304            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
9305    }
9306    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
9307        let local_var_key = local_var_apikey.key.clone();
9308        let local_var_value = match local_var_apikey.prefix {
9309            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
9310            None => local_var_key,
9311        };
9312        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
9313    };
9314    local_var_req_builder = local_var_req_builder.json(&virtual_disk_request);
9315
9316    let local_var_req = local_var_req_builder.build()?;
9317    let local_var_resp = local_var_client.execute(local_var_req).await?;
9318
9319    let local_var_status = local_var_resp.status();
9320    let local_var_content = local_var_resp.text().await?;
9321
9322    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
9323        serde_json::from_str(&local_var_content).map_err(Error::from)
9324    } else {
9325        let local_var_entity: Option<VirtualizationVirtualDisksBulkUpdateError> =
9326            serde_json::from_str(&local_var_content).ok();
9327        let local_var_error = ResponseContent {
9328            status: local_var_status,
9329            content: local_var_content,
9330            entity: local_var_entity,
9331        };
9332        Err(Error::ResponseError(local_var_error))
9333    }
9334}
9335
9336/// Post a list of virtual disk objects.
9337pub async fn virtualization_virtual_disks_create(
9338    configuration: &configuration::Configuration,
9339    virtual_disk_request: crate::models::VirtualDiskRequest,
9340) -> Result<crate::models::VirtualDisk, Error<VirtualizationVirtualDisksCreateError>> {
9341    let local_var_configuration = configuration;
9342
9343    let local_var_client = &local_var_configuration.client;
9344
9345    let local_var_uri_str = format!(
9346        "{}/api/virtualization/virtual-disks/",
9347        local_var_configuration.base_path
9348    );
9349    let mut local_var_req_builder =
9350        local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
9351
9352    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
9353        local_var_req_builder =
9354            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
9355    }
9356    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
9357        let local_var_key = local_var_apikey.key.clone();
9358        let local_var_value = match local_var_apikey.prefix {
9359            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
9360            None => local_var_key,
9361        };
9362        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
9363    };
9364    local_var_req_builder = local_var_req_builder.json(&virtual_disk_request);
9365
9366    let local_var_req = local_var_req_builder.build()?;
9367    let local_var_resp = local_var_client.execute(local_var_req).await?;
9368
9369    let local_var_status = local_var_resp.status();
9370    let local_var_content = local_var_resp.text().await?;
9371
9372    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
9373        serde_json::from_str(&local_var_content).map_err(Error::from)
9374    } else {
9375        let local_var_entity: Option<VirtualizationVirtualDisksCreateError> =
9376            serde_json::from_str(&local_var_content).ok();
9377        let local_var_error = ResponseContent {
9378            status: local_var_status,
9379            content: local_var_content,
9380            entity: local_var_entity,
9381        };
9382        Err(Error::ResponseError(local_var_error))
9383    }
9384}
9385
9386/// Delete a virtual disk object.
9387pub async fn virtualization_virtual_disks_destroy(
9388    configuration: &configuration::Configuration,
9389    id: i32,
9390) -> Result<(), Error<VirtualizationVirtualDisksDestroyError>> {
9391    let local_var_configuration = configuration;
9392
9393    let local_var_client = &local_var_configuration.client;
9394
9395    let local_var_uri_str = format!(
9396        "{}/api/virtualization/virtual-disks/{id}/",
9397        local_var_configuration.base_path,
9398        id = id
9399    );
9400    let mut local_var_req_builder =
9401        local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());
9402
9403    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
9404        local_var_req_builder =
9405            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
9406    }
9407    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
9408        let local_var_key = local_var_apikey.key.clone();
9409        let local_var_value = match local_var_apikey.prefix {
9410            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
9411            None => local_var_key,
9412        };
9413        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
9414    };
9415
9416    let local_var_req = local_var_req_builder.build()?;
9417    let local_var_resp = local_var_client.execute(local_var_req).await?;
9418
9419    let local_var_status = local_var_resp.status();
9420    let local_var_content = local_var_resp.text().await?;
9421
9422    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
9423        Ok(())
9424    } else {
9425        let local_var_entity: Option<VirtualizationVirtualDisksDestroyError> =
9426            serde_json::from_str(&local_var_content).ok();
9427        let local_var_error = ResponseContent {
9428            status: local_var_status,
9429            content: local_var_content,
9430            entity: local_var_entity,
9431        };
9432        Err(Error::ResponseError(local_var_error))
9433    }
9434}
9435
9436/// Get a list of virtual disk objects.
9437pub async fn virtualization_virtual_disks_list(
9438    configuration: &configuration::Configuration,
9439    created: Option<Vec<String>>,
9440    created__empty: Option<Vec<String>>,
9441    created__gt: Option<Vec<String>>,
9442    created__gte: Option<Vec<String>>,
9443    created__lt: Option<Vec<String>>,
9444    created__lte: Option<Vec<String>>,
9445    created__n: Option<Vec<String>>,
9446    created_by_request: Option<&str>,
9447    description: Option<Vec<String>>,
9448    description__empty: Option<bool>,
9449    description__ic: Option<Vec<String>>,
9450    description__ie: Option<Vec<String>>,
9451    description__iew: Option<Vec<String>>,
9452    description__iregex: Option<Vec<String>>,
9453    description__isw: Option<Vec<String>>,
9454    description__n: Option<Vec<String>>,
9455    description__nic: Option<Vec<String>>,
9456    description__nie: Option<Vec<String>>,
9457    description__niew: Option<Vec<String>>,
9458    description__nisw: Option<Vec<String>>,
9459    description__regex: Option<Vec<String>>,
9460    id: Option<Vec<i32>>,
9461    id__empty: Option<bool>,
9462    id__gt: Option<Vec<i32>>,
9463    id__gte: Option<Vec<i32>>,
9464    id__lt: Option<Vec<i32>>,
9465    id__lte: Option<Vec<i32>>,
9466    id__n: Option<Vec<i32>>,
9467    last_updated: Option<Vec<String>>,
9468    last_updated__empty: Option<Vec<String>>,
9469    last_updated__gt: Option<Vec<String>>,
9470    last_updated__gte: Option<Vec<String>>,
9471    last_updated__lt: Option<Vec<String>>,
9472    last_updated__lte: Option<Vec<String>>,
9473    last_updated__n: Option<Vec<String>>,
9474    limit: Option<i32>,
9475    modified_by_request: Option<&str>,
9476    name: Option<Vec<String>>,
9477    name__empty: Option<bool>,
9478    name__ic: Option<Vec<String>>,
9479    name__ie: Option<Vec<String>>,
9480    name__iew: Option<Vec<String>>,
9481    name__iregex: Option<Vec<String>>,
9482    name__isw: Option<Vec<String>>,
9483    name__n: Option<Vec<String>>,
9484    name__nic: Option<Vec<String>>,
9485    name__nie: Option<Vec<String>>,
9486    name__niew: Option<Vec<String>>,
9487    name__nisw: Option<Vec<String>>,
9488    name__regex: Option<Vec<String>>,
9489    offset: Option<i32>,
9490    ordering: Option<&str>,
9491    q: Option<&str>,
9492    size: Option<Vec<i32>>,
9493    size__empty: Option<bool>,
9494    size__gt: Option<Vec<i32>>,
9495    size__gte: Option<Vec<i32>>,
9496    size__lt: Option<Vec<i32>>,
9497    size__lte: Option<Vec<i32>>,
9498    size__n: Option<Vec<i32>>,
9499    tag: Option<Vec<String>>,
9500    tag__n: Option<Vec<String>>,
9501    tag_id: Option<Vec<i32>>,
9502    tag_id__n: Option<Vec<i32>>,
9503    updated_by_request: Option<&str>,
9504    virtual_machine: Option<Vec<String>>,
9505    virtual_machine__n: Option<Vec<String>>,
9506    virtual_machine_id: Option<Vec<i32>>,
9507    virtual_machine_id__n: Option<Vec<i32>>,
9508) -> Result<crate::models::PaginatedVirtualDiskList, Error<VirtualizationVirtualDisksListError>> {
9509    let local_var_configuration = configuration;
9510
9511    let local_var_client = &local_var_configuration.client;
9512
9513    let local_var_uri_str = format!(
9514        "{}/api/virtualization/virtual-disks/",
9515        local_var_configuration.base_path
9516    );
9517    let mut local_var_req_builder =
9518        local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
9519
9520    if let Some(ref local_var_str) = created {
9521        local_var_req_builder = match "multi" {
9522            "multi" => local_var_req_builder.query(
9523                &local_var_str
9524                    .into_iter()
9525                    .map(|p| ("created".to_owned(), p.to_string()))
9526                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9527            ),
9528            _ => local_var_req_builder.query(&[(
9529                "created",
9530                &local_var_str
9531                    .into_iter()
9532                    .map(|p| p.to_string())
9533                    .collect::<Vec<String>>()
9534                    .join(",")
9535                    .to_string(),
9536            )]),
9537        };
9538    }
9539    if let Some(ref local_var_str) = created__empty {
9540        local_var_req_builder = match "multi" {
9541            "multi" => local_var_req_builder.query(
9542                &local_var_str
9543                    .into_iter()
9544                    .map(|p| ("created__empty".to_owned(), p.to_string()))
9545                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9546            ),
9547            _ => local_var_req_builder.query(&[(
9548                "created__empty",
9549                &local_var_str
9550                    .into_iter()
9551                    .map(|p| p.to_string())
9552                    .collect::<Vec<String>>()
9553                    .join(",")
9554                    .to_string(),
9555            )]),
9556        };
9557    }
9558    if let Some(ref local_var_str) = created__gt {
9559        local_var_req_builder = match "multi" {
9560            "multi" => local_var_req_builder.query(
9561                &local_var_str
9562                    .into_iter()
9563                    .map(|p| ("created__gt".to_owned(), p.to_string()))
9564                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9565            ),
9566            _ => local_var_req_builder.query(&[(
9567                "created__gt",
9568                &local_var_str
9569                    .into_iter()
9570                    .map(|p| p.to_string())
9571                    .collect::<Vec<String>>()
9572                    .join(",")
9573                    .to_string(),
9574            )]),
9575        };
9576    }
9577    if let Some(ref local_var_str) = created__gte {
9578        local_var_req_builder = match "multi" {
9579            "multi" => local_var_req_builder.query(
9580                &local_var_str
9581                    .into_iter()
9582                    .map(|p| ("created__gte".to_owned(), p.to_string()))
9583                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9584            ),
9585            _ => local_var_req_builder.query(&[(
9586                "created__gte",
9587                &local_var_str
9588                    .into_iter()
9589                    .map(|p| p.to_string())
9590                    .collect::<Vec<String>>()
9591                    .join(",")
9592                    .to_string(),
9593            )]),
9594        };
9595    }
9596    if let Some(ref local_var_str) = created__lt {
9597        local_var_req_builder = match "multi" {
9598            "multi" => local_var_req_builder.query(
9599                &local_var_str
9600                    .into_iter()
9601                    .map(|p| ("created__lt".to_owned(), p.to_string()))
9602                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9603            ),
9604            _ => local_var_req_builder.query(&[(
9605                "created__lt",
9606                &local_var_str
9607                    .into_iter()
9608                    .map(|p| p.to_string())
9609                    .collect::<Vec<String>>()
9610                    .join(",")
9611                    .to_string(),
9612            )]),
9613        };
9614    }
9615    if let Some(ref local_var_str) = created__lte {
9616        local_var_req_builder = match "multi" {
9617            "multi" => local_var_req_builder.query(
9618                &local_var_str
9619                    .into_iter()
9620                    .map(|p| ("created__lte".to_owned(), p.to_string()))
9621                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9622            ),
9623            _ => local_var_req_builder.query(&[(
9624                "created__lte",
9625                &local_var_str
9626                    .into_iter()
9627                    .map(|p| p.to_string())
9628                    .collect::<Vec<String>>()
9629                    .join(",")
9630                    .to_string(),
9631            )]),
9632        };
9633    }
9634    if let Some(ref local_var_str) = created__n {
9635        local_var_req_builder = match "multi" {
9636            "multi" => local_var_req_builder.query(
9637                &local_var_str
9638                    .into_iter()
9639                    .map(|p| ("created__n".to_owned(), p.to_string()))
9640                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9641            ),
9642            _ => local_var_req_builder.query(&[(
9643                "created__n",
9644                &local_var_str
9645                    .into_iter()
9646                    .map(|p| p.to_string())
9647                    .collect::<Vec<String>>()
9648                    .join(",")
9649                    .to_string(),
9650            )]),
9651        };
9652    }
9653    if let Some(ref local_var_str) = created_by_request {
9654        local_var_req_builder =
9655            local_var_req_builder.query(&[("created_by_request", &local_var_str.to_string())]);
9656    }
9657    if let Some(ref local_var_str) = description {
9658        local_var_req_builder = match "multi" {
9659            "multi" => local_var_req_builder.query(
9660                &local_var_str
9661                    .into_iter()
9662                    .map(|p| ("description".to_owned(), p.to_string()))
9663                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9664            ),
9665            _ => local_var_req_builder.query(&[(
9666                "description",
9667                &local_var_str
9668                    .into_iter()
9669                    .map(|p| p.to_string())
9670                    .collect::<Vec<String>>()
9671                    .join(",")
9672                    .to_string(),
9673            )]),
9674        };
9675    }
9676    if let Some(ref local_var_str) = description__empty {
9677        local_var_req_builder =
9678            local_var_req_builder.query(&[("description__empty", &local_var_str.to_string())]);
9679    }
9680    if let Some(ref local_var_str) = description__ic {
9681        local_var_req_builder = match "multi" {
9682            "multi" => local_var_req_builder.query(
9683                &local_var_str
9684                    .into_iter()
9685                    .map(|p| ("description__ic".to_owned(), p.to_string()))
9686                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9687            ),
9688            _ => local_var_req_builder.query(&[(
9689                "description__ic",
9690                &local_var_str
9691                    .into_iter()
9692                    .map(|p| p.to_string())
9693                    .collect::<Vec<String>>()
9694                    .join(",")
9695                    .to_string(),
9696            )]),
9697        };
9698    }
9699    if let Some(ref local_var_str) = description__ie {
9700        local_var_req_builder = match "multi" {
9701            "multi" => local_var_req_builder.query(
9702                &local_var_str
9703                    .into_iter()
9704                    .map(|p| ("description__ie".to_owned(), p.to_string()))
9705                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9706            ),
9707            _ => local_var_req_builder.query(&[(
9708                "description__ie",
9709                &local_var_str
9710                    .into_iter()
9711                    .map(|p| p.to_string())
9712                    .collect::<Vec<String>>()
9713                    .join(",")
9714                    .to_string(),
9715            )]),
9716        };
9717    }
9718    if let Some(ref local_var_str) = description__iew {
9719        local_var_req_builder = match "multi" {
9720            "multi" => local_var_req_builder.query(
9721                &local_var_str
9722                    .into_iter()
9723                    .map(|p| ("description__iew".to_owned(), p.to_string()))
9724                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9725            ),
9726            _ => local_var_req_builder.query(&[(
9727                "description__iew",
9728                &local_var_str
9729                    .into_iter()
9730                    .map(|p| p.to_string())
9731                    .collect::<Vec<String>>()
9732                    .join(",")
9733                    .to_string(),
9734            )]),
9735        };
9736    }
9737    if let Some(ref local_var_str) = description__iregex {
9738        local_var_req_builder = match "multi" {
9739            "multi" => local_var_req_builder.query(
9740                &local_var_str
9741                    .into_iter()
9742                    .map(|p| ("description__iregex".to_owned(), p.to_string()))
9743                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9744            ),
9745            _ => local_var_req_builder.query(&[(
9746                "description__iregex",
9747                &local_var_str
9748                    .into_iter()
9749                    .map(|p| p.to_string())
9750                    .collect::<Vec<String>>()
9751                    .join(",")
9752                    .to_string(),
9753            )]),
9754        };
9755    }
9756    if let Some(ref local_var_str) = description__isw {
9757        local_var_req_builder = match "multi" {
9758            "multi" => local_var_req_builder.query(
9759                &local_var_str
9760                    .into_iter()
9761                    .map(|p| ("description__isw".to_owned(), p.to_string()))
9762                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9763            ),
9764            _ => local_var_req_builder.query(&[(
9765                "description__isw",
9766                &local_var_str
9767                    .into_iter()
9768                    .map(|p| p.to_string())
9769                    .collect::<Vec<String>>()
9770                    .join(",")
9771                    .to_string(),
9772            )]),
9773        };
9774    }
9775    if let Some(ref local_var_str) = description__n {
9776        local_var_req_builder = match "multi" {
9777            "multi" => local_var_req_builder.query(
9778                &local_var_str
9779                    .into_iter()
9780                    .map(|p| ("description__n".to_owned(), p.to_string()))
9781                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9782            ),
9783            _ => local_var_req_builder.query(&[(
9784                "description__n",
9785                &local_var_str
9786                    .into_iter()
9787                    .map(|p| p.to_string())
9788                    .collect::<Vec<String>>()
9789                    .join(",")
9790                    .to_string(),
9791            )]),
9792        };
9793    }
9794    if let Some(ref local_var_str) = description__nic {
9795        local_var_req_builder = match "multi" {
9796            "multi" => local_var_req_builder.query(
9797                &local_var_str
9798                    .into_iter()
9799                    .map(|p| ("description__nic".to_owned(), p.to_string()))
9800                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9801            ),
9802            _ => local_var_req_builder.query(&[(
9803                "description__nic",
9804                &local_var_str
9805                    .into_iter()
9806                    .map(|p| p.to_string())
9807                    .collect::<Vec<String>>()
9808                    .join(",")
9809                    .to_string(),
9810            )]),
9811        };
9812    }
9813    if let Some(ref local_var_str) = description__nie {
9814        local_var_req_builder = match "multi" {
9815            "multi" => local_var_req_builder.query(
9816                &local_var_str
9817                    .into_iter()
9818                    .map(|p| ("description__nie".to_owned(), p.to_string()))
9819                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9820            ),
9821            _ => local_var_req_builder.query(&[(
9822                "description__nie",
9823                &local_var_str
9824                    .into_iter()
9825                    .map(|p| p.to_string())
9826                    .collect::<Vec<String>>()
9827                    .join(",")
9828                    .to_string(),
9829            )]),
9830        };
9831    }
9832    if let Some(ref local_var_str) = description__niew {
9833        local_var_req_builder = match "multi" {
9834            "multi" => local_var_req_builder.query(
9835                &local_var_str
9836                    .into_iter()
9837                    .map(|p| ("description__niew".to_owned(), p.to_string()))
9838                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9839            ),
9840            _ => local_var_req_builder.query(&[(
9841                "description__niew",
9842                &local_var_str
9843                    .into_iter()
9844                    .map(|p| p.to_string())
9845                    .collect::<Vec<String>>()
9846                    .join(",")
9847                    .to_string(),
9848            )]),
9849        };
9850    }
9851    if let Some(ref local_var_str) = description__nisw {
9852        local_var_req_builder = match "multi" {
9853            "multi" => local_var_req_builder.query(
9854                &local_var_str
9855                    .into_iter()
9856                    .map(|p| ("description__nisw".to_owned(), p.to_string()))
9857                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9858            ),
9859            _ => local_var_req_builder.query(&[(
9860                "description__nisw",
9861                &local_var_str
9862                    .into_iter()
9863                    .map(|p| p.to_string())
9864                    .collect::<Vec<String>>()
9865                    .join(",")
9866                    .to_string(),
9867            )]),
9868        };
9869    }
9870    if let Some(ref local_var_str) = description__regex {
9871        local_var_req_builder = match "multi" {
9872            "multi" => local_var_req_builder.query(
9873                &local_var_str
9874                    .into_iter()
9875                    .map(|p| ("description__regex".to_owned(), p.to_string()))
9876                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9877            ),
9878            _ => local_var_req_builder.query(&[(
9879                "description__regex",
9880                &local_var_str
9881                    .into_iter()
9882                    .map(|p| p.to_string())
9883                    .collect::<Vec<String>>()
9884                    .join(",")
9885                    .to_string(),
9886            )]),
9887        };
9888    }
9889    if let Some(ref local_var_str) = id {
9890        local_var_req_builder = match "multi" {
9891            "multi" => local_var_req_builder.query(
9892                &local_var_str
9893                    .into_iter()
9894                    .map(|p| ("id".to_owned(), p.to_string()))
9895                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9896            ),
9897            _ => local_var_req_builder.query(&[(
9898                "id",
9899                &local_var_str
9900                    .into_iter()
9901                    .map(|p| p.to_string())
9902                    .collect::<Vec<String>>()
9903                    .join(",")
9904                    .to_string(),
9905            )]),
9906        };
9907    }
9908    if let Some(ref local_var_str) = id__empty {
9909        local_var_req_builder =
9910            local_var_req_builder.query(&[("id__empty", &local_var_str.to_string())]);
9911    }
9912    if let Some(ref local_var_str) = id__gt {
9913        local_var_req_builder = match "multi" {
9914            "multi" => local_var_req_builder.query(
9915                &local_var_str
9916                    .into_iter()
9917                    .map(|p| ("id__gt".to_owned(), p.to_string()))
9918                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9919            ),
9920            _ => local_var_req_builder.query(&[(
9921                "id__gt",
9922                &local_var_str
9923                    .into_iter()
9924                    .map(|p| p.to_string())
9925                    .collect::<Vec<String>>()
9926                    .join(",")
9927                    .to_string(),
9928            )]),
9929        };
9930    }
9931    if let Some(ref local_var_str) = id__gte {
9932        local_var_req_builder = match "multi" {
9933            "multi" => local_var_req_builder.query(
9934                &local_var_str
9935                    .into_iter()
9936                    .map(|p| ("id__gte".to_owned(), p.to_string()))
9937                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9938            ),
9939            _ => local_var_req_builder.query(&[(
9940                "id__gte",
9941                &local_var_str
9942                    .into_iter()
9943                    .map(|p| p.to_string())
9944                    .collect::<Vec<String>>()
9945                    .join(",")
9946                    .to_string(),
9947            )]),
9948        };
9949    }
9950    if let Some(ref local_var_str) = id__lt {
9951        local_var_req_builder = match "multi" {
9952            "multi" => local_var_req_builder.query(
9953                &local_var_str
9954                    .into_iter()
9955                    .map(|p| ("id__lt".to_owned(), p.to_string()))
9956                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9957            ),
9958            _ => local_var_req_builder.query(&[(
9959                "id__lt",
9960                &local_var_str
9961                    .into_iter()
9962                    .map(|p| p.to_string())
9963                    .collect::<Vec<String>>()
9964                    .join(",")
9965                    .to_string(),
9966            )]),
9967        };
9968    }
9969    if let Some(ref local_var_str) = id__lte {
9970        local_var_req_builder = match "multi" {
9971            "multi" => local_var_req_builder.query(
9972                &local_var_str
9973                    .into_iter()
9974                    .map(|p| ("id__lte".to_owned(), p.to_string()))
9975                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9976            ),
9977            _ => local_var_req_builder.query(&[(
9978                "id__lte",
9979                &local_var_str
9980                    .into_iter()
9981                    .map(|p| p.to_string())
9982                    .collect::<Vec<String>>()
9983                    .join(",")
9984                    .to_string(),
9985            )]),
9986        };
9987    }
9988    if let Some(ref local_var_str) = id__n {
9989        local_var_req_builder = match "multi" {
9990            "multi" => local_var_req_builder.query(
9991                &local_var_str
9992                    .into_iter()
9993                    .map(|p| ("id__n".to_owned(), p.to_string()))
9994                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9995            ),
9996            _ => local_var_req_builder.query(&[(
9997                "id__n",
9998                &local_var_str
9999                    .into_iter()
10000                    .map(|p| p.to_string())
10001                    .collect::<Vec<String>>()
10002                    .join(",")
10003                    .to_string(),
10004            )]),
10005        };
10006    }
10007    if let Some(ref local_var_str) = last_updated {
10008        local_var_req_builder = match "multi" {
10009            "multi" => local_var_req_builder.query(
10010                &local_var_str
10011                    .into_iter()
10012                    .map(|p| ("last_updated".to_owned(), p.to_string()))
10013                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10014            ),
10015            _ => local_var_req_builder.query(&[(
10016                "last_updated",
10017                &local_var_str
10018                    .into_iter()
10019                    .map(|p| p.to_string())
10020                    .collect::<Vec<String>>()
10021                    .join(",")
10022                    .to_string(),
10023            )]),
10024        };
10025    }
10026    if let Some(ref local_var_str) = last_updated__empty {
10027        local_var_req_builder = match "multi" {
10028            "multi" => local_var_req_builder.query(
10029                &local_var_str
10030                    .into_iter()
10031                    .map(|p| ("last_updated__empty".to_owned(), p.to_string()))
10032                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10033            ),
10034            _ => local_var_req_builder.query(&[(
10035                "last_updated__empty",
10036                &local_var_str
10037                    .into_iter()
10038                    .map(|p| p.to_string())
10039                    .collect::<Vec<String>>()
10040                    .join(",")
10041                    .to_string(),
10042            )]),
10043        };
10044    }
10045    if let Some(ref local_var_str) = last_updated__gt {
10046        local_var_req_builder = match "multi" {
10047            "multi" => local_var_req_builder.query(
10048                &local_var_str
10049                    .into_iter()
10050                    .map(|p| ("last_updated__gt".to_owned(), p.to_string()))
10051                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10052            ),
10053            _ => local_var_req_builder.query(&[(
10054                "last_updated__gt",
10055                &local_var_str
10056                    .into_iter()
10057                    .map(|p| p.to_string())
10058                    .collect::<Vec<String>>()
10059                    .join(",")
10060                    .to_string(),
10061            )]),
10062        };
10063    }
10064    if let Some(ref local_var_str) = last_updated__gte {
10065        local_var_req_builder = match "multi" {
10066            "multi" => local_var_req_builder.query(
10067                &local_var_str
10068                    .into_iter()
10069                    .map(|p| ("last_updated__gte".to_owned(), p.to_string()))
10070                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10071            ),
10072            _ => local_var_req_builder.query(&[(
10073                "last_updated__gte",
10074                &local_var_str
10075                    .into_iter()
10076                    .map(|p| p.to_string())
10077                    .collect::<Vec<String>>()
10078                    .join(",")
10079                    .to_string(),
10080            )]),
10081        };
10082    }
10083    if let Some(ref local_var_str) = last_updated__lt {
10084        local_var_req_builder = match "multi" {
10085            "multi" => local_var_req_builder.query(
10086                &local_var_str
10087                    .into_iter()
10088                    .map(|p| ("last_updated__lt".to_owned(), p.to_string()))
10089                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10090            ),
10091            _ => local_var_req_builder.query(&[(
10092                "last_updated__lt",
10093                &local_var_str
10094                    .into_iter()
10095                    .map(|p| p.to_string())
10096                    .collect::<Vec<String>>()
10097                    .join(",")
10098                    .to_string(),
10099            )]),
10100        };
10101    }
10102    if let Some(ref local_var_str) = last_updated__lte {
10103        local_var_req_builder = match "multi" {
10104            "multi" => local_var_req_builder.query(
10105                &local_var_str
10106                    .into_iter()
10107                    .map(|p| ("last_updated__lte".to_owned(), p.to_string()))
10108                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10109            ),
10110            _ => local_var_req_builder.query(&[(
10111                "last_updated__lte",
10112                &local_var_str
10113                    .into_iter()
10114                    .map(|p| p.to_string())
10115                    .collect::<Vec<String>>()
10116                    .join(",")
10117                    .to_string(),
10118            )]),
10119        };
10120    }
10121    if let Some(ref local_var_str) = last_updated__n {
10122        local_var_req_builder = match "multi" {
10123            "multi" => local_var_req_builder.query(
10124                &local_var_str
10125                    .into_iter()
10126                    .map(|p| ("last_updated__n".to_owned(), p.to_string()))
10127                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10128            ),
10129            _ => local_var_req_builder.query(&[(
10130                "last_updated__n",
10131                &local_var_str
10132                    .into_iter()
10133                    .map(|p| p.to_string())
10134                    .collect::<Vec<String>>()
10135                    .join(",")
10136                    .to_string(),
10137            )]),
10138        };
10139    }
10140    if let Some(ref local_var_str) = limit {
10141        local_var_req_builder =
10142            local_var_req_builder.query(&[("limit", &local_var_str.to_string())]);
10143    }
10144    if let Some(ref local_var_str) = modified_by_request {
10145        local_var_req_builder =
10146            local_var_req_builder.query(&[("modified_by_request", &local_var_str.to_string())]);
10147    }
10148    if let Some(ref local_var_str) = name {
10149        local_var_req_builder = match "multi" {
10150            "multi" => local_var_req_builder.query(
10151                &local_var_str
10152                    .into_iter()
10153                    .map(|p| ("name".to_owned(), p.to_string()))
10154                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10155            ),
10156            _ => local_var_req_builder.query(&[(
10157                "name",
10158                &local_var_str
10159                    .into_iter()
10160                    .map(|p| p.to_string())
10161                    .collect::<Vec<String>>()
10162                    .join(",")
10163                    .to_string(),
10164            )]),
10165        };
10166    }
10167    if let Some(ref local_var_str) = name__empty {
10168        local_var_req_builder =
10169            local_var_req_builder.query(&[("name__empty", &local_var_str.to_string())]);
10170    }
10171    if let Some(ref local_var_str) = name__ic {
10172        local_var_req_builder = match "multi" {
10173            "multi" => local_var_req_builder.query(
10174                &local_var_str
10175                    .into_iter()
10176                    .map(|p| ("name__ic".to_owned(), p.to_string()))
10177                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10178            ),
10179            _ => local_var_req_builder.query(&[(
10180                "name__ic",
10181                &local_var_str
10182                    .into_iter()
10183                    .map(|p| p.to_string())
10184                    .collect::<Vec<String>>()
10185                    .join(",")
10186                    .to_string(),
10187            )]),
10188        };
10189    }
10190    if let Some(ref local_var_str) = name__ie {
10191        local_var_req_builder = match "multi" {
10192            "multi" => local_var_req_builder.query(
10193                &local_var_str
10194                    .into_iter()
10195                    .map(|p| ("name__ie".to_owned(), p.to_string()))
10196                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10197            ),
10198            _ => local_var_req_builder.query(&[(
10199                "name__ie",
10200                &local_var_str
10201                    .into_iter()
10202                    .map(|p| p.to_string())
10203                    .collect::<Vec<String>>()
10204                    .join(",")
10205                    .to_string(),
10206            )]),
10207        };
10208    }
10209    if let Some(ref local_var_str) = name__iew {
10210        local_var_req_builder = match "multi" {
10211            "multi" => local_var_req_builder.query(
10212                &local_var_str
10213                    .into_iter()
10214                    .map(|p| ("name__iew".to_owned(), p.to_string()))
10215                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10216            ),
10217            _ => local_var_req_builder.query(&[(
10218                "name__iew",
10219                &local_var_str
10220                    .into_iter()
10221                    .map(|p| p.to_string())
10222                    .collect::<Vec<String>>()
10223                    .join(",")
10224                    .to_string(),
10225            )]),
10226        };
10227    }
10228    if let Some(ref local_var_str) = name__iregex {
10229        local_var_req_builder = match "multi" {
10230            "multi" => local_var_req_builder.query(
10231                &local_var_str
10232                    .into_iter()
10233                    .map(|p| ("name__iregex".to_owned(), p.to_string()))
10234                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10235            ),
10236            _ => local_var_req_builder.query(&[(
10237                "name__iregex",
10238                &local_var_str
10239                    .into_iter()
10240                    .map(|p| p.to_string())
10241                    .collect::<Vec<String>>()
10242                    .join(",")
10243                    .to_string(),
10244            )]),
10245        };
10246    }
10247    if let Some(ref local_var_str) = name__isw {
10248        local_var_req_builder = match "multi" {
10249            "multi" => local_var_req_builder.query(
10250                &local_var_str
10251                    .into_iter()
10252                    .map(|p| ("name__isw".to_owned(), p.to_string()))
10253                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10254            ),
10255            _ => local_var_req_builder.query(&[(
10256                "name__isw",
10257                &local_var_str
10258                    .into_iter()
10259                    .map(|p| p.to_string())
10260                    .collect::<Vec<String>>()
10261                    .join(",")
10262                    .to_string(),
10263            )]),
10264        };
10265    }
10266    if let Some(ref local_var_str) = name__n {
10267        local_var_req_builder = match "multi" {
10268            "multi" => local_var_req_builder.query(
10269                &local_var_str
10270                    .into_iter()
10271                    .map(|p| ("name__n".to_owned(), p.to_string()))
10272                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10273            ),
10274            _ => local_var_req_builder.query(&[(
10275                "name__n",
10276                &local_var_str
10277                    .into_iter()
10278                    .map(|p| p.to_string())
10279                    .collect::<Vec<String>>()
10280                    .join(",")
10281                    .to_string(),
10282            )]),
10283        };
10284    }
10285    if let Some(ref local_var_str) = name__nic {
10286        local_var_req_builder = match "multi" {
10287            "multi" => local_var_req_builder.query(
10288                &local_var_str
10289                    .into_iter()
10290                    .map(|p| ("name__nic".to_owned(), p.to_string()))
10291                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10292            ),
10293            _ => local_var_req_builder.query(&[(
10294                "name__nic",
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) = name__nie {
10305        local_var_req_builder = match "multi" {
10306            "multi" => local_var_req_builder.query(
10307                &local_var_str
10308                    .into_iter()
10309                    .map(|p| ("name__nie".to_owned(), p.to_string()))
10310                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10311            ),
10312            _ => local_var_req_builder.query(&[(
10313                "name__nie",
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) = name__niew {
10324        local_var_req_builder = match "multi" {
10325            "multi" => local_var_req_builder.query(
10326                &local_var_str
10327                    .into_iter()
10328                    .map(|p| ("name__niew".to_owned(), p.to_string()))
10329                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10330            ),
10331            _ => local_var_req_builder.query(&[(
10332                "name__niew",
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) = name__nisw {
10343        local_var_req_builder = match "multi" {
10344            "multi" => local_var_req_builder.query(
10345                &local_var_str
10346                    .into_iter()
10347                    .map(|p| ("name__nisw".to_owned(), p.to_string()))
10348                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10349            ),
10350            _ => local_var_req_builder.query(&[(
10351                "name__nisw",
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) = name__regex {
10362        local_var_req_builder = match "multi" {
10363            "multi" => local_var_req_builder.query(
10364                &local_var_str
10365                    .into_iter()
10366                    .map(|p| ("name__regex".to_owned(), p.to_string()))
10367                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10368            ),
10369            _ => local_var_req_builder.query(&[(
10370                "name__regex",
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) = offset {
10381        local_var_req_builder =
10382            local_var_req_builder.query(&[("offset", &local_var_str.to_string())]);
10383    }
10384    if let Some(ref local_var_str) = ordering {
10385        local_var_req_builder =
10386            local_var_req_builder.query(&[("ordering", &local_var_str.to_string())]);
10387    }
10388    if let Some(ref local_var_str) = q {
10389        local_var_req_builder = local_var_req_builder.query(&[("q", &local_var_str.to_string())]);
10390    }
10391    if let Some(ref local_var_str) = size {
10392        local_var_req_builder = match "multi" {
10393            "multi" => local_var_req_builder.query(
10394                &local_var_str
10395                    .into_iter()
10396                    .map(|p| ("size".to_owned(), p.to_string()))
10397                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10398            ),
10399            _ => local_var_req_builder.query(&[(
10400                "size",
10401                &local_var_str
10402                    .into_iter()
10403                    .map(|p| p.to_string())
10404                    .collect::<Vec<String>>()
10405                    .join(",")
10406                    .to_string(),
10407            )]),
10408        };
10409    }
10410    if let Some(ref local_var_str) = size__empty {
10411        local_var_req_builder =
10412            local_var_req_builder.query(&[("size__empty", &local_var_str.to_string())]);
10413    }
10414    if let Some(ref local_var_str) = size__gt {
10415        local_var_req_builder = match "multi" {
10416            "multi" => local_var_req_builder.query(
10417                &local_var_str
10418                    .into_iter()
10419                    .map(|p| ("size__gt".to_owned(), p.to_string()))
10420                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10421            ),
10422            _ => local_var_req_builder.query(&[(
10423                "size__gt",
10424                &local_var_str
10425                    .into_iter()
10426                    .map(|p| p.to_string())
10427                    .collect::<Vec<String>>()
10428                    .join(",")
10429                    .to_string(),
10430            )]),
10431        };
10432    }
10433    if let Some(ref local_var_str) = size__gte {
10434        local_var_req_builder = match "multi" {
10435            "multi" => local_var_req_builder.query(
10436                &local_var_str
10437                    .into_iter()
10438                    .map(|p| ("size__gte".to_owned(), p.to_string()))
10439                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10440            ),
10441            _ => local_var_req_builder.query(&[(
10442                "size__gte",
10443                &local_var_str
10444                    .into_iter()
10445                    .map(|p| p.to_string())
10446                    .collect::<Vec<String>>()
10447                    .join(",")
10448                    .to_string(),
10449            )]),
10450        };
10451    }
10452    if let Some(ref local_var_str) = size__lt {
10453        local_var_req_builder = match "multi" {
10454            "multi" => local_var_req_builder.query(
10455                &local_var_str
10456                    .into_iter()
10457                    .map(|p| ("size__lt".to_owned(), p.to_string()))
10458                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10459            ),
10460            _ => local_var_req_builder.query(&[(
10461                "size__lt",
10462                &local_var_str
10463                    .into_iter()
10464                    .map(|p| p.to_string())
10465                    .collect::<Vec<String>>()
10466                    .join(",")
10467                    .to_string(),
10468            )]),
10469        };
10470    }
10471    if let Some(ref local_var_str) = size__lte {
10472        local_var_req_builder = match "multi" {
10473            "multi" => local_var_req_builder.query(
10474                &local_var_str
10475                    .into_iter()
10476                    .map(|p| ("size__lte".to_owned(), p.to_string()))
10477                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10478            ),
10479            _ => local_var_req_builder.query(&[(
10480                "size__lte",
10481                &local_var_str
10482                    .into_iter()
10483                    .map(|p| p.to_string())
10484                    .collect::<Vec<String>>()
10485                    .join(",")
10486                    .to_string(),
10487            )]),
10488        };
10489    }
10490    if let Some(ref local_var_str) = size__n {
10491        local_var_req_builder = match "multi" {
10492            "multi" => local_var_req_builder.query(
10493                &local_var_str
10494                    .into_iter()
10495                    .map(|p| ("size__n".to_owned(), p.to_string()))
10496                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10497            ),
10498            _ => local_var_req_builder.query(&[(
10499                "size__n",
10500                &local_var_str
10501                    .into_iter()
10502                    .map(|p| p.to_string())
10503                    .collect::<Vec<String>>()
10504                    .join(",")
10505                    .to_string(),
10506            )]),
10507        };
10508    }
10509    if let Some(ref local_var_str) = tag {
10510        local_var_req_builder = match "multi" {
10511            "multi" => local_var_req_builder.query(
10512                &local_var_str
10513                    .into_iter()
10514                    .map(|p| ("tag".to_owned(), p.to_string()))
10515                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10516            ),
10517            _ => local_var_req_builder.query(&[(
10518                "tag",
10519                &local_var_str
10520                    .into_iter()
10521                    .map(|p| p.to_string())
10522                    .collect::<Vec<String>>()
10523                    .join(",")
10524                    .to_string(),
10525            )]),
10526        };
10527    }
10528    if let Some(ref local_var_str) = tag__n {
10529        local_var_req_builder = match "multi" {
10530            "multi" => local_var_req_builder.query(
10531                &local_var_str
10532                    .into_iter()
10533                    .map(|p| ("tag__n".to_owned(), p.to_string()))
10534                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10535            ),
10536            _ => local_var_req_builder.query(&[(
10537                "tag__n",
10538                &local_var_str
10539                    .into_iter()
10540                    .map(|p| p.to_string())
10541                    .collect::<Vec<String>>()
10542                    .join(",")
10543                    .to_string(),
10544            )]),
10545        };
10546    }
10547    if let Some(ref local_var_str) = tag_id {
10548        local_var_req_builder = match "multi" {
10549            "multi" => local_var_req_builder.query(
10550                &local_var_str
10551                    .into_iter()
10552                    .map(|p| ("tag_id".to_owned(), p.to_string()))
10553                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10554            ),
10555            _ => local_var_req_builder.query(&[(
10556                "tag_id",
10557                &local_var_str
10558                    .into_iter()
10559                    .map(|p| p.to_string())
10560                    .collect::<Vec<String>>()
10561                    .join(",")
10562                    .to_string(),
10563            )]),
10564        };
10565    }
10566    if let Some(ref local_var_str) = tag_id__n {
10567        local_var_req_builder = match "multi" {
10568            "multi" => local_var_req_builder.query(
10569                &local_var_str
10570                    .into_iter()
10571                    .map(|p| ("tag_id__n".to_owned(), p.to_string()))
10572                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10573            ),
10574            _ => local_var_req_builder.query(&[(
10575                "tag_id__n",
10576                &local_var_str
10577                    .into_iter()
10578                    .map(|p| p.to_string())
10579                    .collect::<Vec<String>>()
10580                    .join(",")
10581                    .to_string(),
10582            )]),
10583        };
10584    }
10585    if let Some(ref local_var_str) = updated_by_request {
10586        local_var_req_builder =
10587            local_var_req_builder.query(&[("updated_by_request", &local_var_str.to_string())]);
10588    }
10589    if let Some(ref local_var_str) = virtual_machine {
10590        local_var_req_builder = match "multi" {
10591            "multi" => local_var_req_builder.query(
10592                &local_var_str
10593                    .into_iter()
10594                    .map(|p| ("virtual_machine".to_owned(), p.to_string()))
10595                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10596            ),
10597            _ => local_var_req_builder.query(&[(
10598                "virtual_machine",
10599                &local_var_str
10600                    .into_iter()
10601                    .map(|p| p.to_string())
10602                    .collect::<Vec<String>>()
10603                    .join(",")
10604                    .to_string(),
10605            )]),
10606        };
10607    }
10608    if let Some(ref local_var_str) = virtual_machine__n {
10609        local_var_req_builder = match "multi" {
10610            "multi" => local_var_req_builder.query(
10611                &local_var_str
10612                    .into_iter()
10613                    .map(|p| ("virtual_machine__n".to_owned(), p.to_string()))
10614                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10615            ),
10616            _ => local_var_req_builder.query(&[(
10617                "virtual_machine__n",
10618                &local_var_str
10619                    .into_iter()
10620                    .map(|p| p.to_string())
10621                    .collect::<Vec<String>>()
10622                    .join(",")
10623                    .to_string(),
10624            )]),
10625        };
10626    }
10627    if let Some(ref local_var_str) = virtual_machine_id {
10628        local_var_req_builder = match "multi" {
10629            "multi" => local_var_req_builder.query(
10630                &local_var_str
10631                    .into_iter()
10632                    .map(|p| ("virtual_machine_id".to_owned(), p.to_string()))
10633                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10634            ),
10635            _ => local_var_req_builder.query(&[(
10636                "virtual_machine_id",
10637                &local_var_str
10638                    .into_iter()
10639                    .map(|p| p.to_string())
10640                    .collect::<Vec<String>>()
10641                    .join(",")
10642                    .to_string(),
10643            )]),
10644        };
10645    }
10646    if let Some(ref local_var_str) = virtual_machine_id__n {
10647        local_var_req_builder = match "multi" {
10648            "multi" => local_var_req_builder.query(
10649                &local_var_str
10650                    .into_iter()
10651                    .map(|p| ("virtual_machine_id__n".to_owned(), p.to_string()))
10652                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10653            ),
10654            _ => local_var_req_builder.query(&[(
10655                "virtual_machine_id__n",
10656                &local_var_str
10657                    .into_iter()
10658                    .map(|p| p.to_string())
10659                    .collect::<Vec<String>>()
10660                    .join(",")
10661                    .to_string(),
10662            )]),
10663        };
10664    }
10665    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
10666        local_var_req_builder =
10667            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
10668    }
10669    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
10670        let local_var_key = local_var_apikey.key.clone();
10671        let local_var_value = match local_var_apikey.prefix {
10672            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
10673            None => local_var_key,
10674        };
10675        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
10676    };
10677
10678    let local_var_req = local_var_req_builder.build()?;
10679    let local_var_resp = local_var_client.execute(local_var_req).await?;
10680
10681    let local_var_status = local_var_resp.status();
10682    let local_var_content = local_var_resp.text().await?;
10683
10684    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
10685        serde_json::from_str(&local_var_content).map_err(Error::from)
10686    } else {
10687        let local_var_entity: Option<VirtualizationVirtualDisksListError> =
10688            serde_json::from_str(&local_var_content).ok();
10689        let local_var_error = ResponseContent {
10690            status: local_var_status,
10691            content: local_var_content,
10692            entity: local_var_entity,
10693        };
10694        Err(Error::ResponseError(local_var_error))
10695    }
10696}
10697
10698/// Patch a virtual disk object.
10699pub async fn virtualization_virtual_disks_partial_update(
10700    configuration: &configuration::Configuration,
10701    id: i32,
10702    patched_virtual_disk_request: Option<crate::models::PatchedVirtualDiskRequest>,
10703) -> Result<crate::models::VirtualDisk, Error<VirtualizationVirtualDisksPartialUpdateError>> {
10704    let local_var_configuration = configuration;
10705
10706    let local_var_client = &local_var_configuration.client;
10707
10708    let local_var_uri_str = format!(
10709        "{}/api/virtualization/virtual-disks/{id}/",
10710        local_var_configuration.base_path,
10711        id = id
10712    );
10713    let mut local_var_req_builder =
10714        local_var_client.request(reqwest::Method::PATCH, local_var_uri_str.as_str());
10715
10716    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
10717        local_var_req_builder =
10718            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
10719    }
10720    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
10721        let local_var_key = local_var_apikey.key.clone();
10722        let local_var_value = match local_var_apikey.prefix {
10723            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
10724            None => local_var_key,
10725        };
10726        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
10727    };
10728    local_var_req_builder = local_var_req_builder.json(&patched_virtual_disk_request);
10729
10730    let local_var_req = local_var_req_builder.build()?;
10731    let local_var_resp = local_var_client.execute(local_var_req).await?;
10732
10733    let local_var_status = local_var_resp.status();
10734    let local_var_content = local_var_resp.text().await?;
10735
10736    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
10737        serde_json::from_str(&local_var_content).map_err(Error::from)
10738    } else {
10739        let local_var_entity: Option<VirtualizationVirtualDisksPartialUpdateError> =
10740            serde_json::from_str(&local_var_content).ok();
10741        let local_var_error = ResponseContent {
10742            status: local_var_status,
10743            content: local_var_content,
10744            entity: local_var_entity,
10745        };
10746        Err(Error::ResponseError(local_var_error))
10747    }
10748}
10749
10750/// Get a virtual disk object.
10751pub async fn virtualization_virtual_disks_retrieve(
10752    configuration: &configuration::Configuration,
10753    id: i32,
10754) -> Result<crate::models::VirtualDisk, Error<VirtualizationVirtualDisksRetrieveError>> {
10755    let local_var_configuration = configuration;
10756
10757    let local_var_client = &local_var_configuration.client;
10758
10759    let local_var_uri_str = format!(
10760        "{}/api/virtualization/virtual-disks/{id}/",
10761        local_var_configuration.base_path,
10762        id = id
10763    );
10764    let mut local_var_req_builder =
10765        local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
10766
10767    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
10768        local_var_req_builder =
10769            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
10770    }
10771    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
10772        let local_var_key = local_var_apikey.key.clone();
10773        let local_var_value = match local_var_apikey.prefix {
10774            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
10775            None => local_var_key,
10776        };
10777        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
10778    };
10779
10780    let local_var_req = local_var_req_builder.build()?;
10781    let local_var_resp = local_var_client.execute(local_var_req).await?;
10782
10783    let local_var_status = local_var_resp.status();
10784    let local_var_content = local_var_resp.text().await?;
10785
10786    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
10787        serde_json::from_str(&local_var_content).map_err(Error::from)
10788    } else {
10789        let local_var_entity: Option<VirtualizationVirtualDisksRetrieveError> =
10790            serde_json::from_str(&local_var_content).ok();
10791        let local_var_error = ResponseContent {
10792            status: local_var_status,
10793            content: local_var_content,
10794            entity: local_var_entity,
10795        };
10796        Err(Error::ResponseError(local_var_error))
10797    }
10798}
10799
10800/// Put a virtual disk object.
10801pub async fn virtualization_virtual_disks_update(
10802    configuration: &configuration::Configuration,
10803    id: i32,
10804    virtual_disk_request: crate::models::VirtualDiskRequest,
10805) -> Result<crate::models::VirtualDisk, Error<VirtualizationVirtualDisksUpdateError>> {
10806    let local_var_configuration = configuration;
10807
10808    let local_var_client = &local_var_configuration.client;
10809
10810    let local_var_uri_str = format!(
10811        "{}/api/virtualization/virtual-disks/{id}/",
10812        local_var_configuration.base_path,
10813        id = id
10814    );
10815    let mut local_var_req_builder =
10816        local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());
10817
10818    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
10819        local_var_req_builder =
10820            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
10821    }
10822    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
10823        let local_var_key = local_var_apikey.key.clone();
10824        let local_var_value = match local_var_apikey.prefix {
10825            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
10826            None => local_var_key,
10827        };
10828        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
10829    };
10830    local_var_req_builder = local_var_req_builder.json(&virtual_disk_request);
10831
10832    let local_var_req = local_var_req_builder.build()?;
10833    let local_var_resp = local_var_client.execute(local_var_req).await?;
10834
10835    let local_var_status = local_var_resp.status();
10836    let local_var_content = local_var_resp.text().await?;
10837
10838    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
10839        serde_json::from_str(&local_var_content).map_err(Error::from)
10840    } else {
10841        let local_var_entity: Option<VirtualizationVirtualDisksUpdateError> =
10842            serde_json::from_str(&local_var_content).ok();
10843        let local_var_error = ResponseContent {
10844            status: local_var_status,
10845            content: local_var_content,
10846            entity: local_var_entity,
10847        };
10848        Err(Error::ResponseError(local_var_error))
10849    }
10850}
10851
10852/// Delete a list of virtual machine objects.
10853pub async fn virtualization_virtual_machines_bulk_destroy(
10854    configuration: &configuration::Configuration,
10855    virtual_machine_with_config_context_request: Vec<
10856        crate::models::VirtualMachineWithConfigContextRequest,
10857    >,
10858) -> Result<(), Error<VirtualizationVirtualMachinesBulkDestroyError>> {
10859    let local_var_configuration = configuration;
10860
10861    let local_var_client = &local_var_configuration.client;
10862
10863    let local_var_uri_str = format!(
10864        "{}/api/virtualization/virtual-machines/",
10865        local_var_configuration.base_path
10866    );
10867    let mut local_var_req_builder =
10868        local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());
10869
10870    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
10871        local_var_req_builder =
10872            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
10873    }
10874    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
10875        let local_var_key = local_var_apikey.key.clone();
10876        let local_var_value = match local_var_apikey.prefix {
10877            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
10878            None => local_var_key,
10879        };
10880        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
10881    };
10882    local_var_req_builder =
10883        local_var_req_builder.json(&virtual_machine_with_config_context_request);
10884
10885    let local_var_req = local_var_req_builder.build()?;
10886    let local_var_resp = local_var_client.execute(local_var_req).await?;
10887
10888    let local_var_status = local_var_resp.status();
10889    let local_var_content = local_var_resp.text().await?;
10890
10891    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
10892        Ok(())
10893    } else {
10894        let local_var_entity: Option<VirtualizationVirtualMachinesBulkDestroyError> =
10895            serde_json::from_str(&local_var_content).ok();
10896        let local_var_error = ResponseContent {
10897            status: local_var_status,
10898            content: local_var_content,
10899            entity: local_var_entity,
10900        };
10901        Err(Error::ResponseError(local_var_error))
10902    }
10903}
10904
10905/// Patch a list of virtual machine objects.
10906pub async fn virtualization_virtual_machines_bulk_partial_update(
10907    configuration: &configuration::Configuration,
10908    virtual_machine_with_config_context_request: Vec<
10909        crate::models::VirtualMachineWithConfigContextRequest,
10910    >,
10911) -> Result<
10912    Vec<crate::models::VirtualMachineWithConfigContext>,
10913    Error<VirtualizationVirtualMachinesBulkPartialUpdateError>,
10914> {
10915    let local_var_configuration = configuration;
10916
10917    let local_var_client = &local_var_configuration.client;
10918
10919    let local_var_uri_str = format!(
10920        "{}/api/virtualization/virtual-machines/",
10921        local_var_configuration.base_path
10922    );
10923    let mut local_var_req_builder =
10924        local_var_client.request(reqwest::Method::PATCH, local_var_uri_str.as_str());
10925
10926    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
10927        local_var_req_builder =
10928            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
10929    }
10930    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
10931        let local_var_key = local_var_apikey.key.clone();
10932        let local_var_value = match local_var_apikey.prefix {
10933            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
10934            None => local_var_key,
10935        };
10936        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
10937    };
10938    local_var_req_builder =
10939        local_var_req_builder.json(&virtual_machine_with_config_context_request);
10940
10941    let local_var_req = local_var_req_builder.build()?;
10942    let local_var_resp = local_var_client.execute(local_var_req).await?;
10943
10944    let local_var_status = local_var_resp.status();
10945    let local_var_content = local_var_resp.text().await?;
10946
10947    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
10948        serde_json::from_str(&local_var_content).map_err(Error::from)
10949    } else {
10950        let local_var_entity: Option<VirtualizationVirtualMachinesBulkPartialUpdateError> =
10951            serde_json::from_str(&local_var_content).ok();
10952        let local_var_error = ResponseContent {
10953            status: local_var_status,
10954            content: local_var_content,
10955            entity: local_var_entity,
10956        };
10957        Err(Error::ResponseError(local_var_error))
10958    }
10959}
10960
10961/// Put a list of virtual machine objects.
10962pub async fn virtualization_virtual_machines_bulk_update(
10963    configuration: &configuration::Configuration,
10964    virtual_machine_with_config_context_request: Vec<
10965        crate::models::VirtualMachineWithConfigContextRequest,
10966    >,
10967) -> Result<
10968    Vec<crate::models::VirtualMachineWithConfigContext>,
10969    Error<VirtualizationVirtualMachinesBulkUpdateError>,
10970> {
10971    let local_var_configuration = configuration;
10972
10973    let local_var_client = &local_var_configuration.client;
10974
10975    let local_var_uri_str = format!(
10976        "{}/api/virtualization/virtual-machines/",
10977        local_var_configuration.base_path
10978    );
10979    let mut local_var_req_builder =
10980        local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());
10981
10982    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
10983        local_var_req_builder =
10984            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
10985    }
10986    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
10987        let local_var_key = local_var_apikey.key.clone();
10988        let local_var_value = match local_var_apikey.prefix {
10989            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
10990            None => local_var_key,
10991        };
10992        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
10993    };
10994    local_var_req_builder =
10995        local_var_req_builder.json(&virtual_machine_with_config_context_request);
10996
10997    let local_var_req = local_var_req_builder.build()?;
10998    let local_var_resp = local_var_client.execute(local_var_req).await?;
10999
11000    let local_var_status = local_var_resp.status();
11001    let local_var_content = local_var_resp.text().await?;
11002
11003    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
11004        serde_json::from_str(&local_var_content).map_err(Error::from)
11005    } else {
11006        let local_var_entity: Option<VirtualizationVirtualMachinesBulkUpdateError> =
11007            serde_json::from_str(&local_var_content).ok();
11008        let local_var_error = ResponseContent {
11009            status: local_var_status,
11010            content: local_var_content,
11011            entity: local_var_entity,
11012        };
11013        Err(Error::ResponseError(local_var_error))
11014    }
11015}
11016
11017/// Post a list of virtual machine objects.
11018pub async fn virtualization_virtual_machines_create(
11019    configuration: &configuration::Configuration,
11020    writable_virtual_machine_with_config_context_request: crate::models::WritableVirtualMachineWithConfigContextRequest,
11021) -> Result<
11022    crate::models::VirtualMachineWithConfigContext,
11023    Error<VirtualizationVirtualMachinesCreateError>,
11024> {
11025    let local_var_configuration = configuration;
11026
11027    let local_var_client = &local_var_configuration.client;
11028
11029    let local_var_uri_str = format!(
11030        "{}/api/virtualization/virtual-machines/",
11031        local_var_configuration.base_path
11032    );
11033    let mut local_var_req_builder =
11034        local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
11035
11036    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
11037        local_var_req_builder =
11038            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
11039    }
11040    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
11041        let local_var_key = local_var_apikey.key.clone();
11042        let local_var_value = match local_var_apikey.prefix {
11043            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
11044            None => local_var_key,
11045        };
11046        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
11047    };
11048    local_var_req_builder =
11049        local_var_req_builder.json(&writable_virtual_machine_with_config_context_request);
11050
11051    let local_var_req = local_var_req_builder.build()?;
11052    let local_var_resp = local_var_client.execute(local_var_req).await?;
11053
11054    let local_var_status = local_var_resp.status();
11055    let local_var_content = local_var_resp.text().await?;
11056
11057    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
11058        serde_json::from_str(&local_var_content).map_err(Error::from)
11059    } else {
11060        let local_var_entity: Option<VirtualizationVirtualMachinesCreateError> =
11061            serde_json::from_str(&local_var_content).ok();
11062        let local_var_error = ResponseContent {
11063            status: local_var_status,
11064            content: local_var_content,
11065            entity: local_var_entity,
11066        };
11067        Err(Error::ResponseError(local_var_error))
11068    }
11069}
11070
11071/// Delete a virtual machine object.
11072pub async fn virtualization_virtual_machines_destroy(
11073    configuration: &configuration::Configuration,
11074    id: i32,
11075) -> Result<(), Error<VirtualizationVirtualMachinesDestroyError>> {
11076    let local_var_configuration = configuration;
11077
11078    let local_var_client = &local_var_configuration.client;
11079
11080    let local_var_uri_str = format!(
11081        "{}/api/virtualization/virtual-machines/{id}/",
11082        local_var_configuration.base_path,
11083        id = id
11084    );
11085    let mut local_var_req_builder =
11086        local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());
11087
11088    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
11089        local_var_req_builder =
11090            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
11091    }
11092    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
11093        let local_var_key = local_var_apikey.key.clone();
11094        let local_var_value = match local_var_apikey.prefix {
11095            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
11096            None => local_var_key,
11097        };
11098        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
11099    };
11100
11101    let local_var_req = local_var_req_builder.build()?;
11102    let local_var_resp = local_var_client.execute(local_var_req).await?;
11103
11104    let local_var_status = local_var_resp.status();
11105    let local_var_content = local_var_resp.text().await?;
11106
11107    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
11108        Ok(())
11109    } else {
11110        let local_var_entity: Option<VirtualizationVirtualMachinesDestroyError> =
11111            serde_json::from_str(&local_var_content).ok();
11112        let local_var_error = ResponseContent {
11113            status: local_var_status,
11114            content: local_var_content,
11115            entity: local_var_entity,
11116        };
11117        Err(Error::ResponseError(local_var_error))
11118    }
11119}
11120
11121/// Get a list of virtual machine objects.
11122pub async fn virtualization_virtual_machines_list(
11123    configuration: &configuration::Configuration,
11124    cluster: Option<Vec<String>>,
11125    cluster__n: Option<Vec<String>>,
11126    cluster_group: Option<Vec<String>>,
11127    cluster_group__n: Option<Vec<String>>,
11128    cluster_group_id: Option<Vec<i32>>,
11129    cluster_group_id__n: Option<Vec<i32>>,
11130    cluster_id: Option<Vec<i32>>,
11131    cluster_id__n: Option<Vec<i32>>,
11132    cluster_type: Option<Vec<String>>,
11133    cluster_type__n: Option<Vec<String>>,
11134    cluster_type_id: Option<Vec<i32>>,
11135    cluster_type_id__n: Option<Vec<i32>>,
11136    config_template_id: Option<Vec<i32>>,
11137    config_template_id__n: Option<Vec<i32>>,
11138    contact: Option<Vec<i32>>,
11139    contact__n: Option<Vec<i32>>,
11140    contact_group: Option<Vec<String>>,
11141    contact_group__n: Option<Vec<String>>,
11142    contact_role: Option<Vec<i32>>,
11143    contact_role__n: Option<Vec<i32>>,
11144    created: Option<Vec<String>>,
11145    created__empty: Option<Vec<String>>,
11146    created__gt: Option<Vec<String>>,
11147    created__gte: Option<Vec<String>>,
11148    created__lt: Option<Vec<String>>,
11149    created__lte: Option<Vec<String>>,
11150    created__n: Option<Vec<String>>,
11151    created_by_request: Option<&str>,
11152    description: Option<Vec<String>>,
11153    description__empty: Option<bool>,
11154    description__ic: Option<Vec<String>>,
11155    description__ie: Option<Vec<String>>,
11156    description__iew: Option<Vec<String>>,
11157    description__iregex: Option<Vec<String>>,
11158    description__isw: Option<Vec<String>>,
11159    description__n: Option<Vec<String>>,
11160    description__nic: Option<Vec<String>>,
11161    description__nie: Option<Vec<String>>,
11162    description__niew: Option<Vec<String>>,
11163    description__nisw: Option<Vec<String>>,
11164    description__regex: Option<Vec<String>>,
11165    device: Option<Vec<String>>,
11166    device__n: Option<Vec<String>>,
11167    device_id: Option<Vec<i32>>,
11168    device_id__n: Option<Vec<i32>>,
11169    disk: Option<Vec<i32>>,
11170    disk__empty: Option<bool>,
11171    disk__gt: Option<Vec<i32>>,
11172    disk__gte: Option<Vec<i32>>,
11173    disk__lt: Option<Vec<i32>>,
11174    disk__lte: Option<Vec<i32>>,
11175    disk__n: Option<Vec<i32>>,
11176    has_primary_ip: Option<bool>,
11177    id: Option<Vec<i32>>,
11178    id__empty: Option<bool>,
11179    id__gt: Option<Vec<i32>>,
11180    id__gte: Option<Vec<i32>>,
11181    id__lt: Option<Vec<i32>>,
11182    id__lte: Option<Vec<i32>>,
11183    id__n: Option<Vec<i32>>,
11184    interface_count: Option<Vec<i32>>,
11185    interface_count__empty: Option<bool>,
11186    interface_count__gt: Option<Vec<i32>>,
11187    interface_count__gte: Option<Vec<i32>>,
11188    interface_count__lt: Option<Vec<i32>>,
11189    interface_count__lte: Option<Vec<i32>>,
11190    interface_count__n: Option<Vec<i32>>,
11191    last_updated: Option<Vec<String>>,
11192    last_updated__empty: Option<Vec<String>>,
11193    last_updated__gt: Option<Vec<String>>,
11194    last_updated__gte: Option<Vec<String>>,
11195    last_updated__lt: Option<Vec<String>>,
11196    last_updated__lte: Option<Vec<String>>,
11197    last_updated__n: Option<Vec<String>>,
11198    limit: Option<i32>,
11199    local_context_data: Option<bool>,
11200    mac_address: Option<Vec<String>>,
11201    mac_address__ic: Option<Vec<String>>,
11202    mac_address__ie: Option<Vec<String>>,
11203    mac_address__iew: Option<Vec<String>>,
11204    mac_address__iregex: Option<Vec<String>>,
11205    mac_address__isw: Option<Vec<String>>,
11206    mac_address__n: Option<Vec<String>>,
11207    mac_address__nic: Option<Vec<String>>,
11208    mac_address__nie: Option<Vec<String>>,
11209    mac_address__niew: Option<Vec<String>>,
11210    mac_address__nisw: Option<Vec<String>>,
11211    mac_address__regex: Option<Vec<String>>,
11212    memory: Option<Vec<i32>>,
11213    memory__empty: Option<bool>,
11214    memory__gt: Option<Vec<i32>>,
11215    memory__gte: Option<Vec<i32>>,
11216    memory__lt: Option<Vec<i32>>,
11217    memory__lte: Option<Vec<i32>>,
11218    memory__n: Option<Vec<i32>>,
11219    modified_by_request: Option<&str>,
11220    name: Option<Vec<String>>,
11221    name__empty: Option<bool>,
11222    name__ic: Option<Vec<String>>,
11223    name__ie: Option<Vec<String>>,
11224    name__iew: Option<Vec<String>>,
11225    name__iregex: Option<Vec<String>>,
11226    name__isw: Option<Vec<String>>,
11227    name__n: Option<Vec<String>>,
11228    name__nic: Option<Vec<String>>,
11229    name__nie: Option<Vec<String>>,
11230    name__niew: Option<Vec<String>>,
11231    name__nisw: Option<Vec<String>>,
11232    name__regex: Option<Vec<String>>,
11233    offset: Option<i32>,
11234    ordering: Option<&str>,
11235    platform: Option<Vec<String>>,
11236    platform__n: Option<Vec<String>>,
11237    platform_id: Option<Vec<String>>,
11238    platform_id__n: Option<Vec<String>>,
11239    primary_ip4: Option<Vec<String>>,
11240    primary_ip4__n: Option<Vec<String>>,
11241    primary_ip4_id: Option<Vec<i32>>,
11242    primary_ip4_id__n: Option<Vec<i32>>,
11243    primary_ip6: Option<Vec<String>>,
11244    primary_ip6__n: Option<Vec<String>>,
11245    primary_ip6_id: Option<Vec<i32>>,
11246    primary_ip6_id__n: Option<Vec<i32>>,
11247    q: Option<&str>,
11248    region: Option<Vec<String>>,
11249    region__n: Option<Vec<String>>,
11250    region_id: Option<Vec<String>>,
11251    region_id__n: Option<Vec<String>>,
11252    role: Option<Vec<String>>,
11253    role__n: Option<Vec<String>>,
11254    role_id: Option<Vec<String>>,
11255    role_id__n: Option<Vec<String>>,
11256    serial: Option<Vec<String>>,
11257    serial__empty: Option<bool>,
11258    serial__ic: Option<Vec<String>>,
11259    serial__ie: Option<Vec<String>>,
11260    serial__iew: Option<Vec<String>>,
11261    serial__iregex: Option<Vec<String>>,
11262    serial__isw: Option<Vec<String>>,
11263    serial__n: Option<Vec<String>>,
11264    serial__nic: Option<Vec<String>>,
11265    serial__nie: Option<Vec<String>>,
11266    serial__niew: Option<Vec<String>>,
11267    serial__nisw: Option<Vec<String>>,
11268    serial__regex: Option<Vec<String>>,
11269    site: Option<Vec<String>>,
11270    site__n: Option<Vec<String>>,
11271    site_group: Option<Vec<String>>,
11272    site_group__n: Option<Vec<String>>,
11273    site_group_id: Option<Vec<String>>,
11274    site_group_id__n: Option<Vec<String>>,
11275    site_id: Option<Vec<i32>>,
11276    site_id__n: Option<Vec<i32>>,
11277    status: Option<Vec<String>>,
11278    status__empty: Option<bool>,
11279    status__ic: Option<Vec<String>>,
11280    status__ie: Option<Vec<String>>,
11281    status__iew: Option<Vec<String>>,
11282    status__iregex: Option<Vec<String>>,
11283    status__isw: Option<Vec<String>>,
11284    status__n: Option<Vec<String>>,
11285    status__nic: Option<Vec<String>>,
11286    status__nie: Option<Vec<String>>,
11287    status__niew: Option<Vec<String>>,
11288    status__nisw: Option<Vec<String>>,
11289    status__regex: Option<Vec<String>>,
11290    tag: Option<Vec<String>>,
11291    tag__n: Option<Vec<String>>,
11292    tag_id: Option<Vec<i32>>,
11293    tag_id__n: Option<Vec<i32>>,
11294    tenant: Option<Vec<String>>,
11295    tenant__n: Option<Vec<String>>,
11296    tenant_group: Option<Vec<String>>,
11297    tenant_group__n: Option<Vec<String>>,
11298    tenant_group_id: Option<Vec<String>>,
11299    tenant_group_id__n: Option<Vec<String>>,
11300    tenant_id: Option<Vec<i32>>,
11301    tenant_id__n: Option<Vec<i32>>,
11302    updated_by_request: Option<&str>,
11303    vcpus: Option<Vec<f64>>,
11304    vcpus__empty: Option<bool>,
11305    vcpus__gt: Option<Vec<f64>>,
11306    vcpus__gte: Option<Vec<f64>>,
11307    vcpus__lt: Option<Vec<f64>>,
11308    vcpus__lte: Option<Vec<f64>>,
11309    vcpus__n: Option<Vec<f64>>,
11310    virtual_disk_count: Option<Vec<i32>>,
11311    virtual_disk_count__empty: Option<bool>,
11312    virtual_disk_count__gt: Option<Vec<i32>>,
11313    virtual_disk_count__gte: Option<Vec<i32>>,
11314    virtual_disk_count__lt: Option<Vec<i32>>,
11315    virtual_disk_count__lte: Option<Vec<i32>>,
11316    virtual_disk_count__n: Option<Vec<i32>>,
11317) -> Result<
11318    crate::models::PaginatedVirtualMachineWithConfigContextList,
11319    Error<VirtualizationVirtualMachinesListError>,
11320> {
11321    let local_var_configuration = configuration;
11322
11323    let local_var_client = &local_var_configuration.client;
11324
11325    let local_var_uri_str = format!(
11326        "{}/api/virtualization/virtual-machines/",
11327        local_var_configuration.base_path
11328    );
11329    let mut local_var_req_builder =
11330        local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
11331
11332    if let Some(ref local_var_str) = cluster {
11333        local_var_req_builder = match "multi" {
11334            "multi" => local_var_req_builder.query(
11335                &local_var_str
11336                    .into_iter()
11337                    .map(|p| ("cluster".to_owned(), p.to_string()))
11338                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11339            ),
11340            _ => local_var_req_builder.query(&[(
11341                "cluster",
11342                &local_var_str
11343                    .into_iter()
11344                    .map(|p| p.to_string())
11345                    .collect::<Vec<String>>()
11346                    .join(",")
11347                    .to_string(),
11348            )]),
11349        };
11350    }
11351    if let Some(ref local_var_str) = cluster__n {
11352        local_var_req_builder = match "multi" {
11353            "multi" => local_var_req_builder.query(
11354                &local_var_str
11355                    .into_iter()
11356                    .map(|p| ("cluster__n".to_owned(), p.to_string()))
11357                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11358            ),
11359            _ => local_var_req_builder.query(&[(
11360                "cluster__n",
11361                &local_var_str
11362                    .into_iter()
11363                    .map(|p| p.to_string())
11364                    .collect::<Vec<String>>()
11365                    .join(",")
11366                    .to_string(),
11367            )]),
11368        };
11369    }
11370    if let Some(ref local_var_str) = cluster_group {
11371        local_var_req_builder = match "multi" {
11372            "multi" => local_var_req_builder.query(
11373                &local_var_str
11374                    .into_iter()
11375                    .map(|p| ("cluster_group".to_owned(), p.to_string()))
11376                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11377            ),
11378            _ => local_var_req_builder.query(&[(
11379                "cluster_group",
11380                &local_var_str
11381                    .into_iter()
11382                    .map(|p| p.to_string())
11383                    .collect::<Vec<String>>()
11384                    .join(",")
11385                    .to_string(),
11386            )]),
11387        };
11388    }
11389    if let Some(ref local_var_str) = cluster_group__n {
11390        local_var_req_builder = match "multi" {
11391            "multi" => local_var_req_builder.query(
11392                &local_var_str
11393                    .into_iter()
11394                    .map(|p| ("cluster_group__n".to_owned(), p.to_string()))
11395                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11396            ),
11397            _ => local_var_req_builder.query(&[(
11398                "cluster_group__n",
11399                &local_var_str
11400                    .into_iter()
11401                    .map(|p| p.to_string())
11402                    .collect::<Vec<String>>()
11403                    .join(",")
11404                    .to_string(),
11405            )]),
11406        };
11407    }
11408    if let Some(ref local_var_str) = cluster_group_id {
11409        local_var_req_builder = match "multi" {
11410            "multi" => local_var_req_builder.query(
11411                &local_var_str
11412                    .into_iter()
11413                    .map(|p| ("cluster_group_id".to_owned(), p.to_string()))
11414                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11415            ),
11416            _ => local_var_req_builder.query(&[(
11417                "cluster_group_id",
11418                &local_var_str
11419                    .into_iter()
11420                    .map(|p| p.to_string())
11421                    .collect::<Vec<String>>()
11422                    .join(",")
11423                    .to_string(),
11424            )]),
11425        };
11426    }
11427    if let Some(ref local_var_str) = cluster_group_id__n {
11428        local_var_req_builder = match "multi" {
11429            "multi" => local_var_req_builder.query(
11430                &local_var_str
11431                    .into_iter()
11432                    .map(|p| ("cluster_group_id__n".to_owned(), p.to_string()))
11433                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11434            ),
11435            _ => local_var_req_builder.query(&[(
11436                "cluster_group_id__n",
11437                &local_var_str
11438                    .into_iter()
11439                    .map(|p| p.to_string())
11440                    .collect::<Vec<String>>()
11441                    .join(",")
11442                    .to_string(),
11443            )]),
11444        };
11445    }
11446    if let Some(ref local_var_str) = cluster_id {
11447        local_var_req_builder = match "multi" {
11448            "multi" => local_var_req_builder.query(
11449                &local_var_str
11450                    .into_iter()
11451                    .map(|p| ("cluster_id".to_owned(), p.to_string()))
11452                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11453            ),
11454            _ => local_var_req_builder.query(&[(
11455                "cluster_id",
11456                &local_var_str
11457                    .into_iter()
11458                    .map(|p| p.to_string())
11459                    .collect::<Vec<String>>()
11460                    .join(",")
11461                    .to_string(),
11462            )]),
11463        };
11464    }
11465    if let Some(ref local_var_str) = cluster_id__n {
11466        local_var_req_builder = match "multi" {
11467            "multi" => local_var_req_builder.query(
11468                &local_var_str
11469                    .into_iter()
11470                    .map(|p| ("cluster_id__n".to_owned(), p.to_string()))
11471                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11472            ),
11473            _ => local_var_req_builder.query(&[(
11474                "cluster_id__n",
11475                &local_var_str
11476                    .into_iter()
11477                    .map(|p| p.to_string())
11478                    .collect::<Vec<String>>()
11479                    .join(",")
11480                    .to_string(),
11481            )]),
11482        };
11483    }
11484    if let Some(ref local_var_str) = cluster_type {
11485        local_var_req_builder = match "multi" {
11486            "multi" => local_var_req_builder.query(
11487                &local_var_str
11488                    .into_iter()
11489                    .map(|p| ("cluster_type".to_owned(), p.to_string()))
11490                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11491            ),
11492            _ => local_var_req_builder.query(&[(
11493                "cluster_type",
11494                &local_var_str
11495                    .into_iter()
11496                    .map(|p| p.to_string())
11497                    .collect::<Vec<String>>()
11498                    .join(",")
11499                    .to_string(),
11500            )]),
11501        };
11502    }
11503    if let Some(ref local_var_str) = cluster_type__n {
11504        local_var_req_builder = match "multi" {
11505            "multi" => local_var_req_builder.query(
11506                &local_var_str
11507                    .into_iter()
11508                    .map(|p| ("cluster_type__n".to_owned(), p.to_string()))
11509                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11510            ),
11511            _ => local_var_req_builder.query(&[(
11512                "cluster_type__n",
11513                &local_var_str
11514                    .into_iter()
11515                    .map(|p| p.to_string())
11516                    .collect::<Vec<String>>()
11517                    .join(",")
11518                    .to_string(),
11519            )]),
11520        };
11521    }
11522    if let Some(ref local_var_str) = cluster_type_id {
11523        local_var_req_builder = match "multi" {
11524            "multi" => local_var_req_builder.query(
11525                &local_var_str
11526                    .into_iter()
11527                    .map(|p| ("cluster_type_id".to_owned(), p.to_string()))
11528                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11529            ),
11530            _ => local_var_req_builder.query(&[(
11531                "cluster_type_id",
11532                &local_var_str
11533                    .into_iter()
11534                    .map(|p| p.to_string())
11535                    .collect::<Vec<String>>()
11536                    .join(",")
11537                    .to_string(),
11538            )]),
11539        };
11540    }
11541    if let Some(ref local_var_str) = cluster_type_id__n {
11542        local_var_req_builder = match "multi" {
11543            "multi" => local_var_req_builder.query(
11544                &local_var_str
11545                    .into_iter()
11546                    .map(|p| ("cluster_type_id__n".to_owned(), p.to_string()))
11547                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11548            ),
11549            _ => local_var_req_builder.query(&[(
11550                "cluster_type_id__n",
11551                &local_var_str
11552                    .into_iter()
11553                    .map(|p| p.to_string())
11554                    .collect::<Vec<String>>()
11555                    .join(",")
11556                    .to_string(),
11557            )]),
11558        };
11559    }
11560    if let Some(ref local_var_str) = config_template_id {
11561        local_var_req_builder = match "multi" {
11562            "multi" => local_var_req_builder.query(
11563                &local_var_str
11564                    .into_iter()
11565                    .map(|p| ("config_template_id".to_owned(), p.to_string()))
11566                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11567            ),
11568            _ => local_var_req_builder.query(&[(
11569                "config_template_id",
11570                &local_var_str
11571                    .into_iter()
11572                    .map(|p| p.to_string())
11573                    .collect::<Vec<String>>()
11574                    .join(",")
11575                    .to_string(),
11576            )]),
11577        };
11578    }
11579    if let Some(ref local_var_str) = config_template_id__n {
11580        local_var_req_builder = match "multi" {
11581            "multi" => local_var_req_builder.query(
11582                &local_var_str
11583                    .into_iter()
11584                    .map(|p| ("config_template_id__n".to_owned(), p.to_string()))
11585                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11586            ),
11587            _ => local_var_req_builder.query(&[(
11588                "config_template_id__n",
11589                &local_var_str
11590                    .into_iter()
11591                    .map(|p| p.to_string())
11592                    .collect::<Vec<String>>()
11593                    .join(",")
11594                    .to_string(),
11595            )]),
11596        };
11597    }
11598    if let Some(ref local_var_str) = contact {
11599        local_var_req_builder = match "multi" {
11600            "multi" => local_var_req_builder.query(
11601                &local_var_str
11602                    .into_iter()
11603                    .map(|p| ("contact".to_owned(), p.to_string()))
11604                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11605            ),
11606            _ => local_var_req_builder.query(&[(
11607                "contact",
11608                &local_var_str
11609                    .into_iter()
11610                    .map(|p| p.to_string())
11611                    .collect::<Vec<String>>()
11612                    .join(",")
11613                    .to_string(),
11614            )]),
11615        };
11616    }
11617    if let Some(ref local_var_str) = contact__n {
11618        local_var_req_builder = match "multi" {
11619            "multi" => local_var_req_builder.query(
11620                &local_var_str
11621                    .into_iter()
11622                    .map(|p| ("contact__n".to_owned(), p.to_string()))
11623                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11624            ),
11625            _ => local_var_req_builder.query(&[(
11626                "contact__n",
11627                &local_var_str
11628                    .into_iter()
11629                    .map(|p| p.to_string())
11630                    .collect::<Vec<String>>()
11631                    .join(",")
11632                    .to_string(),
11633            )]),
11634        };
11635    }
11636    if let Some(ref local_var_str) = contact_group {
11637        local_var_req_builder = match "multi" {
11638            "multi" => local_var_req_builder.query(
11639                &local_var_str
11640                    .into_iter()
11641                    .map(|p| ("contact_group".to_owned(), p.to_string()))
11642                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11643            ),
11644            _ => local_var_req_builder.query(&[(
11645                "contact_group",
11646                &local_var_str
11647                    .into_iter()
11648                    .map(|p| p.to_string())
11649                    .collect::<Vec<String>>()
11650                    .join(",")
11651                    .to_string(),
11652            )]),
11653        };
11654    }
11655    if let Some(ref local_var_str) = contact_group__n {
11656        local_var_req_builder = match "multi" {
11657            "multi" => local_var_req_builder.query(
11658                &local_var_str
11659                    .into_iter()
11660                    .map(|p| ("contact_group__n".to_owned(), p.to_string()))
11661                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11662            ),
11663            _ => local_var_req_builder.query(&[(
11664                "contact_group__n",
11665                &local_var_str
11666                    .into_iter()
11667                    .map(|p| p.to_string())
11668                    .collect::<Vec<String>>()
11669                    .join(",")
11670                    .to_string(),
11671            )]),
11672        };
11673    }
11674    if let Some(ref local_var_str) = contact_role {
11675        local_var_req_builder = match "multi" {
11676            "multi" => local_var_req_builder.query(
11677                &local_var_str
11678                    .into_iter()
11679                    .map(|p| ("contact_role".to_owned(), p.to_string()))
11680                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11681            ),
11682            _ => local_var_req_builder.query(&[(
11683                "contact_role",
11684                &local_var_str
11685                    .into_iter()
11686                    .map(|p| p.to_string())
11687                    .collect::<Vec<String>>()
11688                    .join(",")
11689                    .to_string(),
11690            )]),
11691        };
11692    }
11693    if let Some(ref local_var_str) = contact_role__n {
11694        local_var_req_builder = match "multi" {
11695            "multi" => local_var_req_builder.query(
11696                &local_var_str
11697                    .into_iter()
11698                    .map(|p| ("contact_role__n".to_owned(), p.to_string()))
11699                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11700            ),
11701            _ => local_var_req_builder.query(&[(
11702                "contact_role__n",
11703                &local_var_str
11704                    .into_iter()
11705                    .map(|p| p.to_string())
11706                    .collect::<Vec<String>>()
11707                    .join(",")
11708                    .to_string(),
11709            )]),
11710        };
11711    }
11712    if let Some(ref local_var_str) = created {
11713        local_var_req_builder = match "multi" {
11714            "multi" => local_var_req_builder.query(
11715                &local_var_str
11716                    .into_iter()
11717                    .map(|p| ("created".to_owned(), p.to_string()))
11718                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11719            ),
11720            _ => local_var_req_builder.query(&[(
11721                "created",
11722                &local_var_str
11723                    .into_iter()
11724                    .map(|p| p.to_string())
11725                    .collect::<Vec<String>>()
11726                    .join(",")
11727                    .to_string(),
11728            )]),
11729        };
11730    }
11731    if let Some(ref local_var_str) = created__empty {
11732        local_var_req_builder = match "multi" {
11733            "multi" => local_var_req_builder.query(
11734                &local_var_str
11735                    .into_iter()
11736                    .map(|p| ("created__empty".to_owned(), p.to_string()))
11737                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11738            ),
11739            _ => local_var_req_builder.query(&[(
11740                "created__empty",
11741                &local_var_str
11742                    .into_iter()
11743                    .map(|p| p.to_string())
11744                    .collect::<Vec<String>>()
11745                    .join(",")
11746                    .to_string(),
11747            )]),
11748        };
11749    }
11750    if let Some(ref local_var_str) = created__gt {
11751        local_var_req_builder = match "multi" {
11752            "multi" => local_var_req_builder.query(
11753                &local_var_str
11754                    .into_iter()
11755                    .map(|p| ("created__gt".to_owned(), p.to_string()))
11756                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11757            ),
11758            _ => local_var_req_builder.query(&[(
11759                "created__gt",
11760                &local_var_str
11761                    .into_iter()
11762                    .map(|p| p.to_string())
11763                    .collect::<Vec<String>>()
11764                    .join(",")
11765                    .to_string(),
11766            )]),
11767        };
11768    }
11769    if let Some(ref local_var_str) = created__gte {
11770        local_var_req_builder = match "multi" {
11771            "multi" => local_var_req_builder.query(
11772                &local_var_str
11773                    .into_iter()
11774                    .map(|p| ("created__gte".to_owned(), p.to_string()))
11775                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11776            ),
11777            _ => local_var_req_builder.query(&[(
11778                "created__gte",
11779                &local_var_str
11780                    .into_iter()
11781                    .map(|p| p.to_string())
11782                    .collect::<Vec<String>>()
11783                    .join(",")
11784                    .to_string(),
11785            )]),
11786        };
11787    }
11788    if let Some(ref local_var_str) = created__lt {
11789        local_var_req_builder = match "multi" {
11790            "multi" => local_var_req_builder.query(
11791                &local_var_str
11792                    .into_iter()
11793                    .map(|p| ("created__lt".to_owned(), p.to_string()))
11794                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11795            ),
11796            _ => local_var_req_builder.query(&[(
11797                "created__lt",
11798                &local_var_str
11799                    .into_iter()
11800                    .map(|p| p.to_string())
11801                    .collect::<Vec<String>>()
11802                    .join(",")
11803                    .to_string(),
11804            )]),
11805        };
11806    }
11807    if let Some(ref local_var_str) = created__lte {
11808        local_var_req_builder = match "multi" {
11809            "multi" => local_var_req_builder.query(
11810                &local_var_str
11811                    .into_iter()
11812                    .map(|p| ("created__lte".to_owned(), p.to_string()))
11813                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11814            ),
11815            _ => local_var_req_builder.query(&[(
11816                "created__lte",
11817                &local_var_str
11818                    .into_iter()
11819                    .map(|p| p.to_string())
11820                    .collect::<Vec<String>>()
11821                    .join(",")
11822                    .to_string(),
11823            )]),
11824        };
11825    }
11826    if let Some(ref local_var_str) = created__n {
11827        local_var_req_builder = match "multi" {
11828            "multi" => local_var_req_builder.query(
11829                &local_var_str
11830                    .into_iter()
11831                    .map(|p| ("created__n".to_owned(), p.to_string()))
11832                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11833            ),
11834            _ => local_var_req_builder.query(&[(
11835                "created__n",
11836                &local_var_str
11837                    .into_iter()
11838                    .map(|p| p.to_string())
11839                    .collect::<Vec<String>>()
11840                    .join(",")
11841                    .to_string(),
11842            )]),
11843        };
11844    }
11845    if let Some(ref local_var_str) = created_by_request {
11846        local_var_req_builder =
11847            local_var_req_builder.query(&[("created_by_request", &local_var_str.to_string())]);
11848    }
11849    if let Some(ref local_var_str) = description {
11850        local_var_req_builder = match "multi" {
11851            "multi" => local_var_req_builder.query(
11852                &local_var_str
11853                    .into_iter()
11854                    .map(|p| ("description".to_owned(), p.to_string()))
11855                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11856            ),
11857            _ => local_var_req_builder.query(&[(
11858                "description",
11859                &local_var_str
11860                    .into_iter()
11861                    .map(|p| p.to_string())
11862                    .collect::<Vec<String>>()
11863                    .join(",")
11864                    .to_string(),
11865            )]),
11866        };
11867    }
11868    if let Some(ref local_var_str) = description__empty {
11869        local_var_req_builder =
11870            local_var_req_builder.query(&[("description__empty", &local_var_str.to_string())]);
11871    }
11872    if let Some(ref local_var_str) = description__ic {
11873        local_var_req_builder = match "multi" {
11874            "multi" => local_var_req_builder.query(
11875                &local_var_str
11876                    .into_iter()
11877                    .map(|p| ("description__ic".to_owned(), p.to_string()))
11878                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11879            ),
11880            _ => local_var_req_builder.query(&[(
11881                "description__ic",
11882                &local_var_str
11883                    .into_iter()
11884                    .map(|p| p.to_string())
11885                    .collect::<Vec<String>>()
11886                    .join(",")
11887                    .to_string(),
11888            )]),
11889        };
11890    }
11891    if let Some(ref local_var_str) = description__ie {
11892        local_var_req_builder = match "multi" {
11893            "multi" => local_var_req_builder.query(
11894                &local_var_str
11895                    .into_iter()
11896                    .map(|p| ("description__ie".to_owned(), p.to_string()))
11897                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11898            ),
11899            _ => local_var_req_builder.query(&[(
11900                "description__ie",
11901                &local_var_str
11902                    .into_iter()
11903                    .map(|p| p.to_string())
11904                    .collect::<Vec<String>>()
11905                    .join(",")
11906                    .to_string(),
11907            )]),
11908        };
11909    }
11910    if let Some(ref local_var_str) = description__iew {
11911        local_var_req_builder = match "multi" {
11912            "multi" => local_var_req_builder.query(
11913                &local_var_str
11914                    .into_iter()
11915                    .map(|p| ("description__iew".to_owned(), p.to_string()))
11916                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11917            ),
11918            _ => local_var_req_builder.query(&[(
11919                "description__iew",
11920                &local_var_str
11921                    .into_iter()
11922                    .map(|p| p.to_string())
11923                    .collect::<Vec<String>>()
11924                    .join(",")
11925                    .to_string(),
11926            )]),
11927        };
11928    }
11929    if let Some(ref local_var_str) = description__iregex {
11930        local_var_req_builder = match "multi" {
11931            "multi" => local_var_req_builder.query(
11932                &local_var_str
11933                    .into_iter()
11934                    .map(|p| ("description__iregex".to_owned(), p.to_string()))
11935                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11936            ),
11937            _ => local_var_req_builder.query(&[(
11938                "description__iregex",
11939                &local_var_str
11940                    .into_iter()
11941                    .map(|p| p.to_string())
11942                    .collect::<Vec<String>>()
11943                    .join(",")
11944                    .to_string(),
11945            )]),
11946        };
11947    }
11948    if let Some(ref local_var_str) = description__isw {
11949        local_var_req_builder = match "multi" {
11950            "multi" => local_var_req_builder.query(
11951                &local_var_str
11952                    .into_iter()
11953                    .map(|p| ("description__isw".to_owned(), p.to_string()))
11954                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11955            ),
11956            _ => local_var_req_builder.query(&[(
11957                "description__isw",
11958                &local_var_str
11959                    .into_iter()
11960                    .map(|p| p.to_string())
11961                    .collect::<Vec<String>>()
11962                    .join(",")
11963                    .to_string(),
11964            )]),
11965        };
11966    }
11967    if let Some(ref local_var_str) = description__n {
11968        local_var_req_builder = match "multi" {
11969            "multi" => local_var_req_builder.query(
11970                &local_var_str
11971                    .into_iter()
11972                    .map(|p| ("description__n".to_owned(), p.to_string()))
11973                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11974            ),
11975            _ => local_var_req_builder.query(&[(
11976                "description__n",
11977                &local_var_str
11978                    .into_iter()
11979                    .map(|p| p.to_string())
11980                    .collect::<Vec<String>>()
11981                    .join(",")
11982                    .to_string(),
11983            )]),
11984        };
11985    }
11986    if let Some(ref local_var_str) = description__nic {
11987        local_var_req_builder = match "multi" {
11988            "multi" => local_var_req_builder.query(
11989                &local_var_str
11990                    .into_iter()
11991                    .map(|p| ("description__nic".to_owned(), p.to_string()))
11992                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11993            ),
11994            _ => local_var_req_builder.query(&[(
11995                "description__nic",
11996                &local_var_str
11997                    .into_iter()
11998                    .map(|p| p.to_string())
11999                    .collect::<Vec<String>>()
12000                    .join(",")
12001                    .to_string(),
12002            )]),
12003        };
12004    }
12005    if let Some(ref local_var_str) = description__nie {
12006        local_var_req_builder = match "multi" {
12007            "multi" => local_var_req_builder.query(
12008                &local_var_str
12009                    .into_iter()
12010                    .map(|p| ("description__nie".to_owned(), p.to_string()))
12011                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12012            ),
12013            _ => local_var_req_builder.query(&[(
12014                "description__nie",
12015                &local_var_str
12016                    .into_iter()
12017                    .map(|p| p.to_string())
12018                    .collect::<Vec<String>>()
12019                    .join(",")
12020                    .to_string(),
12021            )]),
12022        };
12023    }
12024    if let Some(ref local_var_str) = description__niew {
12025        local_var_req_builder = match "multi" {
12026            "multi" => local_var_req_builder.query(
12027                &local_var_str
12028                    .into_iter()
12029                    .map(|p| ("description__niew".to_owned(), p.to_string()))
12030                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12031            ),
12032            _ => local_var_req_builder.query(&[(
12033                "description__niew",
12034                &local_var_str
12035                    .into_iter()
12036                    .map(|p| p.to_string())
12037                    .collect::<Vec<String>>()
12038                    .join(",")
12039                    .to_string(),
12040            )]),
12041        };
12042    }
12043    if let Some(ref local_var_str) = description__nisw {
12044        local_var_req_builder = match "multi" {
12045            "multi" => local_var_req_builder.query(
12046                &local_var_str
12047                    .into_iter()
12048                    .map(|p| ("description__nisw".to_owned(), p.to_string()))
12049                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12050            ),
12051            _ => local_var_req_builder.query(&[(
12052                "description__nisw",
12053                &local_var_str
12054                    .into_iter()
12055                    .map(|p| p.to_string())
12056                    .collect::<Vec<String>>()
12057                    .join(",")
12058                    .to_string(),
12059            )]),
12060        };
12061    }
12062    if let Some(ref local_var_str) = description__regex {
12063        local_var_req_builder = match "multi" {
12064            "multi" => local_var_req_builder.query(
12065                &local_var_str
12066                    .into_iter()
12067                    .map(|p| ("description__regex".to_owned(), p.to_string()))
12068                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12069            ),
12070            _ => local_var_req_builder.query(&[(
12071                "description__regex",
12072                &local_var_str
12073                    .into_iter()
12074                    .map(|p| p.to_string())
12075                    .collect::<Vec<String>>()
12076                    .join(",")
12077                    .to_string(),
12078            )]),
12079        };
12080    }
12081    if let Some(ref local_var_str) = device {
12082        local_var_req_builder = match "multi" {
12083            "multi" => local_var_req_builder.query(
12084                &local_var_str
12085                    .into_iter()
12086                    .map(|p| ("device".to_owned(), p.to_string()))
12087                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12088            ),
12089            _ => local_var_req_builder.query(&[(
12090                "device",
12091                &local_var_str
12092                    .into_iter()
12093                    .map(|p| p.to_string())
12094                    .collect::<Vec<String>>()
12095                    .join(",")
12096                    .to_string(),
12097            )]),
12098        };
12099    }
12100    if let Some(ref local_var_str) = device__n {
12101        local_var_req_builder = match "multi" {
12102            "multi" => local_var_req_builder.query(
12103                &local_var_str
12104                    .into_iter()
12105                    .map(|p| ("device__n".to_owned(), p.to_string()))
12106                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12107            ),
12108            _ => local_var_req_builder.query(&[(
12109                "device__n",
12110                &local_var_str
12111                    .into_iter()
12112                    .map(|p| p.to_string())
12113                    .collect::<Vec<String>>()
12114                    .join(",")
12115                    .to_string(),
12116            )]),
12117        };
12118    }
12119    if let Some(ref local_var_str) = device_id {
12120        local_var_req_builder = match "multi" {
12121            "multi" => local_var_req_builder.query(
12122                &local_var_str
12123                    .into_iter()
12124                    .map(|p| ("device_id".to_owned(), p.to_string()))
12125                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12126            ),
12127            _ => local_var_req_builder.query(&[(
12128                "device_id",
12129                &local_var_str
12130                    .into_iter()
12131                    .map(|p| p.to_string())
12132                    .collect::<Vec<String>>()
12133                    .join(",")
12134                    .to_string(),
12135            )]),
12136        };
12137    }
12138    if let Some(ref local_var_str) = device_id__n {
12139        local_var_req_builder = match "multi" {
12140            "multi" => local_var_req_builder.query(
12141                &local_var_str
12142                    .into_iter()
12143                    .map(|p| ("device_id__n".to_owned(), p.to_string()))
12144                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12145            ),
12146            _ => local_var_req_builder.query(&[(
12147                "device_id__n",
12148                &local_var_str
12149                    .into_iter()
12150                    .map(|p| p.to_string())
12151                    .collect::<Vec<String>>()
12152                    .join(",")
12153                    .to_string(),
12154            )]),
12155        };
12156    }
12157    if let Some(ref local_var_str) = disk {
12158        local_var_req_builder = match "multi" {
12159            "multi" => local_var_req_builder.query(
12160                &local_var_str
12161                    .into_iter()
12162                    .map(|p| ("disk".to_owned(), p.to_string()))
12163                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12164            ),
12165            _ => local_var_req_builder.query(&[(
12166                "disk",
12167                &local_var_str
12168                    .into_iter()
12169                    .map(|p| p.to_string())
12170                    .collect::<Vec<String>>()
12171                    .join(",")
12172                    .to_string(),
12173            )]),
12174        };
12175    }
12176    if let Some(ref local_var_str) = disk__empty {
12177        local_var_req_builder =
12178            local_var_req_builder.query(&[("disk__empty", &local_var_str.to_string())]);
12179    }
12180    if let Some(ref local_var_str) = disk__gt {
12181        local_var_req_builder = match "multi" {
12182            "multi" => local_var_req_builder.query(
12183                &local_var_str
12184                    .into_iter()
12185                    .map(|p| ("disk__gt".to_owned(), p.to_string()))
12186                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12187            ),
12188            _ => local_var_req_builder.query(&[(
12189                "disk__gt",
12190                &local_var_str
12191                    .into_iter()
12192                    .map(|p| p.to_string())
12193                    .collect::<Vec<String>>()
12194                    .join(",")
12195                    .to_string(),
12196            )]),
12197        };
12198    }
12199    if let Some(ref local_var_str) = disk__gte {
12200        local_var_req_builder = match "multi" {
12201            "multi" => local_var_req_builder.query(
12202                &local_var_str
12203                    .into_iter()
12204                    .map(|p| ("disk__gte".to_owned(), p.to_string()))
12205                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12206            ),
12207            _ => local_var_req_builder.query(&[(
12208                "disk__gte",
12209                &local_var_str
12210                    .into_iter()
12211                    .map(|p| p.to_string())
12212                    .collect::<Vec<String>>()
12213                    .join(",")
12214                    .to_string(),
12215            )]),
12216        };
12217    }
12218    if let Some(ref local_var_str) = disk__lt {
12219        local_var_req_builder = match "multi" {
12220            "multi" => local_var_req_builder.query(
12221                &local_var_str
12222                    .into_iter()
12223                    .map(|p| ("disk__lt".to_owned(), p.to_string()))
12224                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12225            ),
12226            _ => local_var_req_builder.query(&[(
12227                "disk__lt",
12228                &local_var_str
12229                    .into_iter()
12230                    .map(|p| p.to_string())
12231                    .collect::<Vec<String>>()
12232                    .join(",")
12233                    .to_string(),
12234            )]),
12235        };
12236    }
12237    if let Some(ref local_var_str) = disk__lte {
12238        local_var_req_builder = match "multi" {
12239            "multi" => local_var_req_builder.query(
12240                &local_var_str
12241                    .into_iter()
12242                    .map(|p| ("disk__lte".to_owned(), p.to_string()))
12243                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12244            ),
12245            _ => local_var_req_builder.query(&[(
12246                "disk__lte",
12247                &local_var_str
12248                    .into_iter()
12249                    .map(|p| p.to_string())
12250                    .collect::<Vec<String>>()
12251                    .join(",")
12252                    .to_string(),
12253            )]),
12254        };
12255    }
12256    if let Some(ref local_var_str) = disk__n {
12257        local_var_req_builder = match "multi" {
12258            "multi" => local_var_req_builder.query(
12259                &local_var_str
12260                    .into_iter()
12261                    .map(|p| ("disk__n".to_owned(), p.to_string()))
12262                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12263            ),
12264            _ => local_var_req_builder.query(&[(
12265                "disk__n",
12266                &local_var_str
12267                    .into_iter()
12268                    .map(|p| p.to_string())
12269                    .collect::<Vec<String>>()
12270                    .join(",")
12271                    .to_string(),
12272            )]),
12273        };
12274    }
12275    if let Some(ref local_var_str) = has_primary_ip {
12276        local_var_req_builder =
12277            local_var_req_builder.query(&[("has_primary_ip", &local_var_str.to_string())]);
12278    }
12279    if let Some(ref local_var_str) = id {
12280        local_var_req_builder = match "multi" {
12281            "multi" => local_var_req_builder.query(
12282                &local_var_str
12283                    .into_iter()
12284                    .map(|p| ("id".to_owned(), p.to_string()))
12285                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12286            ),
12287            _ => local_var_req_builder.query(&[(
12288                "id",
12289                &local_var_str
12290                    .into_iter()
12291                    .map(|p| p.to_string())
12292                    .collect::<Vec<String>>()
12293                    .join(",")
12294                    .to_string(),
12295            )]),
12296        };
12297    }
12298    if let Some(ref local_var_str) = id__empty {
12299        local_var_req_builder =
12300            local_var_req_builder.query(&[("id__empty", &local_var_str.to_string())]);
12301    }
12302    if let Some(ref local_var_str) = id__gt {
12303        local_var_req_builder = match "multi" {
12304            "multi" => local_var_req_builder.query(
12305                &local_var_str
12306                    .into_iter()
12307                    .map(|p| ("id__gt".to_owned(), p.to_string()))
12308                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12309            ),
12310            _ => local_var_req_builder.query(&[(
12311                "id__gt",
12312                &local_var_str
12313                    .into_iter()
12314                    .map(|p| p.to_string())
12315                    .collect::<Vec<String>>()
12316                    .join(",")
12317                    .to_string(),
12318            )]),
12319        };
12320    }
12321    if let Some(ref local_var_str) = id__gte {
12322        local_var_req_builder = match "multi" {
12323            "multi" => local_var_req_builder.query(
12324                &local_var_str
12325                    .into_iter()
12326                    .map(|p| ("id__gte".to_owned(), p.to_string()))
12327                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12328            ),
12329            _ => local_var_req_builder.query(&[(
12330                "id__gte",
12331                &local_var_str
12332                    .into_iter()
12333                    .map(|p| p.to_string())
12334                    .collect::<Vec<String>>()
12335                    .join(",")
12336                    .to_string(),
12337            )]),
12338        };
12339    }
12340    if let Some(ref local_var_str) = id__lt {
12341        local_var_req_builder = match "multi" {
12342            "multi" => local_var_req_builder.query(
12343                &local_var_str
12344                    .into_iter()
12345                    .map(|p| ("id__lt".to_owned(), p.to_string()))
12346                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12347            ),
12348            _ => local_var_req_builder.query(&[(
12349                "id__lt",
12350                &local_var_str
12351                    .into_iter()
12352                    .map(|p| p.to_string())
12353                    .collect::<Vec<String>>()
12354                    .join(",")
12355                    .to_string(),
12356            )]),
12357        };
12358    }
12359    if let Some(ref local_var_str) = id__lte {
12360        local_var_req_builder = match "multi" {
12361            "multi" => local_var_req_builder.query(
12362                &local_var_str
12363                    .into_iter()
12364                    .map(|p| ("id__lte".to_owned(), p.to_string()))
12365                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12366            ),
12367            _ => local_var_req_builder.query(&[(
12368                "id__lte",
12369                &local_var_str
12370                    .into_iter()
12371                    .map(|p| p.to_string())
12372                    .collect::<Vec<String>>()
12373                    .join(",")
12374                    .to_string(),
12375            )]),
12376        };
12377    }
12378    if let Some(ref local_var_str) = id__n {
12379        local_var_req_builder = match "multi" {
12380            "multi" => local_var_req_builder.query(
12381                &local_var_str
12382                    .into_iter()
12383                    .map(|p| ("id__n".to_owned(), p.to_string()))
12384                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12385            ),
12386            _ => local_var_req_builder.query(&[(
12387                "id__n",
12388                &local_var_str
12389                    .into_iter()
12390                    .map(|p| p.to_string())
12391                    .collect::<Vec<String>>()
12392                    .join(",")
12393                    .to_string(),
12394            )]),
12395        };
12396    }
12397    if let Some(ref local_var_str) = interface_count {
12398        local_var_req_builder = match "multi" {
12399            "multi" => local_var_req_builder.query(
12400                &local_var_str
12401                    .into_iter()
12402                    .map(|p| ("interface_count".to_owned(), p.to_string()))
12403                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12404            ),
12405            _ => local_var_req_builder.query(&[(
12406                "interface_count",
12407                &local_var_str
12408                    .into_iter()
12409                    .map(|p| p.to_string())
12410                    .collect::<Vec<String>>()
12411                    .join(",")
12412                    .to_string(),
12413            )]),
12414        };
12415    }
12416    if let Some(ref local_var_str) = interface_count__empty {
12417        local_var_req_builder =
12418            local_var_req_builder.query(&[("interface_count__empty", &local_var_str.to_string())]);
12419    }
12420    if let Some(ref local_var_str) = interface_count__gt {
12421        local_var_req_builder = match "multi" {
12422            "multi" => local_var_req_builder.query(
12423                &local_var_str
12424                    .into_iter()
12425                    .map(|p| ("interface_count__gt".to_owned(), p.to_string()))
12426                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12427            ),
12428            _ => local_var_req_builder.query(&[(
12429                "interface_count__gt",
12430                &local_var_str
12431                    .into_iter()
12432                    .map(|p| p.to_string())
12433                    .collect::<Vec<String>>()
12434                    .join(",")
12435                    .to_string(),
12436            )]),
12437        };
12438    }
12439    if let Some(ref local_var_str) = interface_count__gte {
12440        local_var_req_builder = match "multi" {
12441            "multi" => local_var_req_builder.query(
12442                &local_var_str
12443                    .into_iter()
12444                    .map(|p| ("interface_count__gte".to_owned(), p.to_string()))
12445                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12446            ),
12447            _ => local_var_req_builder.query(&[(
12448                "interface_count__gte",
12449                &local_var_str
12450                    .into_iter()
12451                    .map(|p| p.to_string())
12452                    .collect::<Vec<String>>()
12453                    .join(",")
12454                    .to_string(),
12455            )]),
12456        };
12457    }
12458    if let Some(ref local_var_str) = interface_count__lt {
12459        local_var_req_builder = match "multi" {
12460            "multi" => local_var_req_builder.query(
12461                &local_var_str
12462                    .into_iter()
12463                    .map(|p| ("interface_count__lt".to_owned(), p.to_string()))
12464                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12465            ),
12466            _ => local_var_req_builder.query(&[(
12467                "interface_count__lt",
12468                &local_var_str
12469                    .into_iter()
12470                    .map(|p| p.to_string())
12471                    .collect::<Vec<String>>()
12472                    .join(",")
12473                    .to_string(),
12474            )]),
12475        };
12476    }
12477    if let Some(ref local_var_str) = interface_count__lte {
12478        local_var_req_builder = match "multi" {
12479            "multi" => local_var_req_builder.query(
12480                &local_var_str
12481                    .into_iter()
12482                    .map(|p| ("interface_count__lte".to_owned(), p.to_string()))
12483                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12484            ),
12485            _ => local_var_req_builder.query(&[(
12486                "interface_count__lte",
12487                &local_var_str
12488                    .into_iter()
12489                    .map(|p| p.to_string())
12490                    .collect::<Vec<String>>()
12491                    .join(",")
12492                    .to_string(),
12493            )]),
12494        };
12495    }
12496    if let Some(ref local_var_str) = interface_count__n {
12497        local_var_req_builder = match "multi" {
12498            "multi" => local_var_req_builder.query(
12499                &local_var_str
12500                    .into_iter()
12501                    .map(|p| ("interface_count__n".to_owned(), p.to_string()))
12502                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12503            ),
12504            _ => local_var_req_builder.query(&[(
12505                "interface_count__n",
12506                &local_var_str
12507                    .into_iter()
12508                    .map(|p| p.to_string())
12509                    .collect::<Vec<String>>()
12510                    .join(",")
12511                    .to_string(),
12512            )]),
12513        };
12514    }
12515    if let Some(ref local_var_str) = last_updated {
12516        local_var_req_builder = match "multi" {
12517            "multi" => local_var_req_builder.query(
12518                &local_var_str
12519                    .into_iter()
12520                    .map(|p| ("last_updated".to_owned(), p.to_string()))
12521                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12522            ),
12523            _ => local_var_req_builder.query(&[(
12524                "last_updated",
12525                &local_var_str
12526                    .into_iter()
12527                    .map(|p| p.to_string())
12528                    .collect::<Vec<String>>()
12529                    .join(",")
12530                    .to_string(),
12531            )]),
12532        };
12533    }
12534    if let Some(ref local_var_str) = last_updated__empty {
12535        local_var_req_builder = match "multi" {
12536            "multi" => local_var_req_builder.query(
12537                &local_var_str
12538                    .into_iter()
12539                    .map(|p| ("last_updated__empty".to_owned(), p.to_string()))
12540                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12541            ),
12542            _ => local_var_req_builder.query(&[(
12543                "last_updated__empty",
12544                &local_var_str
12545                    .into_iter()
12546                    .map(|p| p.to_string())
12547                    .collect::<Vec<String>>()
12548                    .join(",")
12549                    .to_string(),
12550            )]),
12551        };
12552    }
12553    if let Some(ref local_var_str) = last_updated__gt {
12554        local_var_req_builder = match "multi" {
12555            "multi" => local_var_req_builder.query(
12556                &local_var_str
12557                    .into_iter()
12558                    .map(|p| ("last_updated__gt".to_owned(), p.to_string()))
12559                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12560            ),
12561            _ => local_var_req_builder.query(&[(
12562                "last_updated__gt",
12563                &local_var_str
12564                    .into_iter()
12565                    .map(|p| p.to_string())
12566                    .collect::<Vec<String>>()
12567                    .join(",")
12568                    .to_string(),
12569            )]),
12570        };
12571    }
12572    if let Some(ref local_var_str) = last_updated__gte {
12573        local_var_req_builder = match "multi" {
12574            "multi" => local_var_req_builder.query(
12575                &local_var_str
12576                    .into_iter()
12577                    .map(|p| ("last_updated__gte".to_owned(), p.to_string()))
12578                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12579            ),
12580            _ => local_var_req_builder.query(&[(
12581                "last_updated__gte",
12582                &local_var_str
12583                    .into_iter()
12584                    .map(|p| p.to_string())
12585                    .collect::<Vec<String>>()
12586                    .join(",")
12587                    .to_string(),
12588            )]),
12589        };
12590    }
12591    if let Some(ref local_var_str) = last_updated__lt {
12592        local_var_req_builder = match "multi" {
12593            "multi" => local_var_req_builder.query(
12594                &local_var_str
12595                    .into_iter()
12596                    .map(|p| ("last_updated__lt".to_owned(), p.to_string()))
12597                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12598            ),
12599            _ => local_var_req_builder.query(&[(
12600                "last_updated__lt",
12601                &local_var_str
12602                    .into_iter()
12603                    .map(|p| p.to_string())
12604                    .collect::<Vec<String>>()
12605                    .join(",")
12606                    .to_string(),
12607            )]),
12608        };
12609    }
12610    if let Some(ref local_var_str) = last_updated__lte {
12611        local_var_req_builder = match "multi" {
12612            "multi" => local_var_req_builder.query(
12613                &local_var_str
12614                    .into_iter()
12615                    .map(|p| ("last_updated__lte".to_owned(), p.to_string()))
12616                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12617            ),
12618            _ => local_var_req_builder.query(&[(
12619                "last_updated__lte",
12620                &local_var_str
12621                    .into_iter()
12622                    .map(|p| p.to_string())
12623                    .collect::<Vec<String>>()
12624                    .join(",")
12625                    .to_string(),
12626            )]),
12627        };
12628    }
12629    if let Some(ref local_var_str) = last_updated__n {
12630        local_var_req_builder = match "multi" {
12631            "multi" => local_var_req_builder.query(
12632                &local_var_str
12633                    .into_iter()
12634                    .map(|p| ("last_updated__n".to_owned(), p.to_string()))
12635                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12636            ),
12637            _ => local_var_req_builder.query(&[(
12638                "last_updated__n",
12639                &local_var_str
12640                    .into_iter()
12641                    .map(|p| p.to_string())
12642                    .collect::<Vec<String>>()
12643                    .join(",")
12644                    .to_string(),
12645            )]),
12646        };
12647    }
12648    if let Some(ref local_var_str) = limit {
12649        local_var_req_builder =
12650            local_var_req_builder.query(&[("limit", &local_var_str.to_string())]);
12651    }
12652    if let Some(ref local_var_str) = local_context_data {
12653        local_var_req_builder =
12654            local_var_req_builder.query(&[("local_context_data", &local_var_str.to_string())]);
12655    }
12656    if let Some(ref local_var_str) = mac_address {
12657        local_var_req_builder = match "multi" {
12658            "multi" => local_var_req_builder.query(
12659                &local_var_str
12660                    .into_iter()
12661                    .map(|p| ("mac_address".to_owned(), p.to_string()))
12662                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12663            ),
12664            _ => local_var_req_builder.query(&[(
12665                "mac_address",
12666                &local_var_str
12667                    .into_iter()
12668                    .map(|p| p.to_string())
12669                    .collect::<Vec<String>>()
12670                    .join(",")
12671                    .to_string(),
12672            )]),
12673        };
12674    }
12675    if let Some(ref local_var_str) = mac_address__ic {
12676        local_var_req_builder = match "multi" {
12677            "multi" => local_var_req_builder.query(
12678                &local_var_str
12679                    .into_iter()
12680                    .map(|p| ("mac_address__ic".to_owned(), p.to_string()))
12681                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12682            ),
12683            _ => local_var_req_builder.query(&[(
12684                "mac_address__ic",
12685                &local_var_str
12686                    .into_iter()
12687                    .map(|p| p.to_string())
12688                    .collect::<Vec<String>>()
12689                    .join(",")
12690                    .to_string(),
12691            )]),
12692        };
12693    }
12694    if let Some(ref local_var_str) = mac_address__ie {
12695        local_var_req_builder = match "multi" {
12696            "multi" => local_var_req_builder.query(
12697                &local_var_str
12698                    .into_iter()
12699                    .map(|p| ("mac_address__ie".to_owned(), p.to_string()))
12700                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12701            ),
12702            _ => local_var_req_builder.query(&[(
12703                "mac_address__ie",
12704                &local_var_str
12705                    .into_iter()
12706                    .map(|p| p.to_string())
12707                    .collect::<Vec<String>>()
12708                    .join(",")
12709                    .to_string(),
12710            )]),
12711        };
12712    }
12713    if let Some(ref local_var_str) = mac_address__iew {
12714        local_var_req_builder = match "multi" {
12715            "multi" => local_var_req_builder.query(
12716                &local_var_str
12717                    .into_iter()
12718                    .map(|p| ("mac_address__iew".to_owned(), p.to_string()))
12719                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12720            ),
12721            _ => local_var_req_builder.query(&[(
12722                "mac_address__iew",
12723                &local_var_str
12724                    .into_iter()
12725                    .map(|p| p.to_string())
12726                    .collect::<Vec<String>>()
12727                    .join(",")
12728                    .to_string(),
12729            )]),
12730        };
12731    }
12732    if let Some(ref local_var_str) = mac_address__iregex {
12733        local_var_req_builder = match "multi" {
12734            "multi" => local_var_req_builder.query(
12735                &local_var_str
12736                    .into_iter()
12737                    .map(|p| ("mac_address__iregex".to_owned(), p.to_string()))
12738                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12739            ),
12740            _ => local_var_req_builder.query(&[(
12741                "mac_address__iregex",
12742                &local_var_str
12743                    .into_iter()
12744                    .map(|p| p.to_string())
12745                    .collect::<Vec<String>>()
12746                    .join(",")
12747                    .to_string(),
12748            )]),
12749        };
12750    }
12751    if let Some(ref local_var_str) = mac_address__isw {
12752        local_var_req_builder = match "multi" {
12753            "multi" => local_var_req_builder.query(
12754                &local_var_str
12755                    .into_iter()
12756                    .map(|p| ("mac_address__isw".to_owned(), p.to_string()))
12757                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12758            ),
12759            _ => local_var_req_builder.query(&[(
12760                "mac_address__isw",
12761                &local_var_str
12762                    .into_iter()
12763                    .map(|p| p.to_string())
12764                    .collect::<Vec<String>>()
12765                    .join(",")
12766                    .to_string(),
12767            )]),
12768        };
12769    }
12770    if let Some(ref local_var_str) = mac_address__n {
12771        local_var_req_builder = match "multi" {
12772            "multi" => local_var_req_builder.query(
12773                &local_var_str
12774                    .into_iter()
12775                    .map(|p| ("mac_address__n".to_owned(), p.to_string()))
12776                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12777            ),
12778            _ => local_var_req_builder.query(&[(
12779                "mac_address__n",
12780                &local_var_str
12781                    .into_iter()
12782                    .map(|p| p.to_string())
12783                    .collect::<Vec<String>>()
12784                    .join(",")
12785                    .to_string(),
12786            )]),
12787        };
12788    }
12789    if let Some(ref local_var_str) = mac_address__nic {
12790        local_var_req_builder = match "multi" {
12791            "multi" => local_var_req_builder.query(
12792                &local_var_str
12793                    .into_iter()
12794                    .map(|p| ("mac_address__nic".to_owned(), p.to_string()))
12795                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12796            ),
12797            _ => local_var_req_builder.query(&[(
12798                "mac_address__nic",
12799                &local_var_str
12800                    .into_iter()
12801                    .map(|p| p.to_string())
12802                    .collect::<Vec<String>>()
12803                    .join(",")
12804                    .to_string(),
12805            )]),
12806        };
12807    }
12808    if let Some(ref local_var_str) = mac_address__nie {
12809        local_var_req_builder = match "multi" {
12810            "multi" => local_var_req_builder.query(
12811                &local_var_str
12812                    .into_iter()
12813                    .map(|p| ("mac_address__nie".to_owned(), p.to_string()))
12814                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12815            ),
12816            _ => local_var_req_builder.query(&[(
12817                "mac_address__nie",
12818                &local_var_str
12819                    .into_iter()
12820                    .map(|p| p.to_string())
12821                    .collect::<Vec<String>>()
12822                    .join(",")
12823                    .to_string(),
12824            )]),
12825        };
12826    }
12827    if let Some(ref local_var_str) = mac_address__niew {
12828        local_var_req_builder = match "multi" {
12829            "multi" => local_var_req_builder.query(
12830                &local_var_str
12831                    .into_iter()
12832                    .map(|p| ("mac_address__niew".to_owned(), p.to_string()))
12833                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12834            ),
12835            _ => local_var_req_builder.query(&[(
12836                "mac_address__niew",
12837                &local_var_str
12838                    .into_iter()
12839                    .map(|p| p.to_string())
12840                    .collect::<Vec<String>>()
12841                    .join(",")
12842                    .to_string(),
12843            )]),
12844        };
12845    }
12846    if let Some(ref local_var_str) = mac_address__nisw {
12847        local_var_req_builder = match "multi" {
12848            "multi" => local_var_req_builder.query(
12849                &local_var_str
12850                    .into_iter()
12851                    .map(|p| ("mac_address__nisw".to_owned(), p.to_string()))
12852                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12853            ),
12854            _ => local_var_req_builder.query(&[(
12855                "mac_address__nisw",
12856                &local_var_str
12857                    .into_iter()
12858                    .map(|p| p.to_string())
12859                    .collect::<Vec<String>>()
12860                    .join(",")
12861                    .to_string(),
12862            )]),
12863        };
12864    }
12865    if let Some(ref local_var_str) = mac_address__regex {
12866        local_var_req_builder = match "multi" {
12867            "multi" => local_var_req_builder.query(
12868                &local_var_str
12869                    .into_iter()
12870                    .map(|p| ("mac_address__regex".to_owned(), p.to_string()))
12871                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12872            ),
12873            _ => local_var_req_builder.query(&[(
12874                "mac_address__regex",
12875                &local_var_str
12876                    .into_iter()
12877                    .map(|p| p.to_string())
12878                    .collect::<Vec<String>>()
12879                    .join(",")
12880                    .to_string(),
12881            )]),
12882        };
12883    }
12884    if let Some(ref local_var_str) = memory {
12885        local_var_req_builder = match "multi" {
12886            "multi" => local_var_req_builder.query(
12887                &local_var_str
12888                    .into_iter()
12889                    .map(|p| ("memory".to_owned(), p.to_string()))
12890                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12891            ),
12892            _ => local_var_req_builder.query(&[(
12893                "memory",
12894                &local_var_str
12895                    .into_iter()
12896                    .map(|p| p.to_string())
12897                    .collect::<Vec<String>>()
12898                    .join(",")
12899                    .to_string(),
12900            )]),
12901        };
12902    }
12903    if let Some(ref local_var_str) = memory__empty {
12904        local_var_req_builder =
12905            local_var_req_builder.query(&[("memory__empty", &local_var_str.to_string())]);
12906    }
12907    if let Some(ref local_var_str) = memory__gt {
12908        local_var_req_builder = match "multi" {
12909            "multi" => local_var_req_builder.query(
12910                &local_var_str
12911                    .into_iter()
12912                    .map(|p| ("memory__gt".to_owned(), p.to_string()))
12913                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12914            ),
12915            _ => local_var_req_builder.query(&[(
12916                "memory__gt",
12917                &local_var_str
12918                    .into_iter()
12919                    .map(|p| p.to_string())
12920                    .collect::<Vec<String>>()
12921                    .join(",")
12922                    .to_string(),
12923            )]),
12924        };
12925    }
12926    if let Some(ref local_var_str) = memory__gte {
12927        local_var_req_builder = match "multi" {
12928            "multi" => local_var_req_builder.query(
12929                &local_var_str
12930                    .into_iter()
12931                    .map(|p| ("memory__gte".to_owned(), p.to_string()))
12932                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12933            ),
12934            _ => local_var_req_builder.query(&[(
12935                "memory__gte",
12936                &local_var_str
12937                    .into_iter()
12938                    .map(|p| p.to_string())
12939                    .collect::<Vec<String>>()
12940                    .join(",")
12941                    .to_string(),
12942            )]),
12943        };
12944    }
12945    if let Some(ref local_var_str) = memory__lt {
12946        local_var_req_builder = match "multi" {
12947            "multi" => local_var_req_builder.query(
12948                &local_var_str
12949                    .into_iter()
12950                    .map(|p| ("memory__lt".to_owned(), p.to_string()))
12951                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12952            ),
12953            _ => local_var_req_builder.query(&[(
12954                "memory__lt",
12955                &local_var_str
12956                    .into_iter()
12957                    .map(|p| p.to_string())
12958                    .collect::<Vec<String>>()
12959                    .join(",")
12960                    .to_string(),
12961            )]),
12962        };
12963    }
12964    if let Some(ref local_var_str) = memory__lte {
12965        local_var_req_builder = match "multi" {
12966            "multi" => local_var_req_builder.query(
12967                &local_var_str
12968                    .into_iter()
12969                    .map(|p| ("memory__lte".to_owned(), p.to_string()))
12970                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12971            ),
12972            _ => local_var_req_builder.query(&[(
12973                "memory__lte",
12974                &local_var_str
12975                    .into_iter()
12976                    .map(|p| p.to_string())
12977                    .collect::<Vec<String>>()
12978                    .join(",")
12979                    .to_string(),
12980            )]),
12981        };
12982    }
12983    if let Some(ref local_var_str) = memory__n {
12984        local_var_req_builder = match "multi" {
12985            "multi" => local_var_req_builder.query(
12986                &local_var_str
12987                    .into_iter()
12988                    .map(|p| ("memory__n".to_owned(), p.to_string()))
12989                    .collect::<Vec<(std::string::String, std::string::String)>>(),
12990            ),
12991            _ => local_var_req_builder.query(&[(
12992                "memory__n",
12993                &local_var_str
12994                    .into_iter()
12995                    .map(|p| p.to_string())
12996                    .collect::<Vec<String>>()
12997                    .join(",")
12998                    .to_string(),
12999            )]),
13000        };
13001    }
13002    if let Some(ref local_var_str) = modified_by_request {
13003        local_var_req_builder =
13004            local_var_req_builder.query(&[("modified_by_request", &local_var_str.to_string())]);
13005    }
13006    if let Some(ref local_var_str) = name {
13007        local_var_req_builder = match "multi" {
13008            "multi" => local_var_req_builder.query(
13009                &local_var_str
13010                    .into_iter()
13011                    .map(|p| ("name".to_owned(), p.to_string()))
13012                    .collect::<Vec<(std::string::String, std::string::String)>>(),
13013            ),
13014            _ => local_var_req_builder.query(&[(
13015                "name",
13016                &local_var_str
13017                    .into_iter()
13018                    .map(|p| p.to_string())
13019                    .collect::<Vec<String>>()
13020                    .join(",")
13021                    .to_string(),
13022            )]),
13023        };
13024    }
13025    if let Some(ref local_var_str) = name__empty {
13026        local_var_req_builder =
13027            local_var_req_builder.query(&[("name__empty", &local_var_str.to_string())]);
13028    }
13029    if let Some(ref local_var_str) = name__ic {
13030        local_var_req_builder = match "multi" {
13031            "multi" => local_var_req_builder.query(
13032                &local_var_str
13033                    .into_iter()
13034                    .map(|p| ("name__ic".to_owned(), p.to_string()))
13035                    .collect::<Vec<(std::string::String, std::string::String)>>(),
13036            ),
13037            _ => local_var_req_builder.query(&[(
13038                "name__ic",
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) = name__ie {
13049        local_var_req_builder = match "multi" {
13050            "multi" => local_var_req_builder.query(
13051                &local_var_str
13052                    .into_iter()
13053                    .map(|p| ("name__ie".to_owned(), p.to_string()))
13054                    .collect::<Vec<(std::string::String, std::string::String)>>(),
13055            ),
13056            _ => local_var_req_builder.query(&[(
13057                "name__ie",
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) = name__iew {
13068        local_var_req_builder = match "multi" {
13069            "multi" => local_var_req_builder.query(
13070                &local_var_str
13071                    .into_iter()
13072                    .map(|p| ("name__iew".to_owned(), p.to_string()))
13073                    .collect::<Vec<(std::string::String, std::string::String)>>(),
13074            ),
13075            _ => local_var_req_builder.query(&[(
13076                "name__iew",
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) = name__iregex {
13087        local_var_req_builder = match "multi" {
13088            "multi" => local_var_req_builder.query(
13089                &local_var_str
13090                    .into_iter()
13091                    .map(|p| ("name__iregex".to_owned(), p.to_string()))
13092                    .collect::<Vec<(std::string::String, std::string::String)>>(),
13093            ),
13094            _ => local_var_req_builder.query(&[(
13095                "name__iregex",
13096                &local_var_str
13097                    .into_iter()
13098                    .map(|p| p.to_string())
13099                    .collect::<Vec<String>>()
13100                    .join(",")
13101                    .to_string(),
13102            )]),
13103        };
13104    }
13105    if let Some(ref local_var_str) = name__isw {
13106        local_var_req_builder = match "multi" {
13107            "multi" => local_var_req_builder.query(
13108                &local_var_str
13109                    .into_iter()
13110                    .map(|p| ("name__isw".to_owned(), p.to_string()))
13111                    .collect::<Vec<(std::string::String, std::string::String)>>(),
13112            ),
13113            _ => local_var_req_builder.query(&[(
13114                "name__isw",
13115                &local_var_str
13116                    .into_iter()
13117                    .map(|p| p.to_string())
13118                    .collect::<Vec<String>>()
13119                    .join(",")
13120                    .to_string(),
13121            )]),
13122        };
13123    }
13124    if let Some(ref local_var_str) = name__n {
13125        local_var_req_builder = match "multi" {
13126            "multi" => local_var_req_builder.query(
13127                &local_var_str
13128                    .into_iter()
13129                    .map(|p| ("name__n".to_owned(), p.to_string()))
13130                    .collect::<Vec<(std::string::String, std::string::String)>>(),
13131            ),
13132            _ => local_var_req_builder.query(&[(
13133                "name__n",
13134                &local_var_str
13135                    .into_iter()
13136                    .map(|p| p.to_string())
13137                    .collect::<Vec<String>>()
13138                    .join(",")
13139                    .to_string(),
13140            )]),
13141        };
13142    }
13143    if let Some(ref local_var_str) = name__nic {
13144        local_var_req_builder = match "multi" {
13145            "multi" => local_var_req_builder.query(
13146                &local_var_str
13147                    .into_iter()
13148                    .map(|p| ("name__nic".to_owned(), p.to_string()))
13149                    .collect::<Vec<(std::string::String, std::string::String)>>(),
13150            ),
13151            _ => local_var_req_builder.query(&[(
13152                "name__nic",
13153                &local_var_str
13154                    .into_iter()
13155                    .map(|p| p.to_string())
13156                    .collect::<Vec<String>>()
13157                    .join(",")
13158                    .to_string(),
13159            )]),
13160        };
13161    }
13162    if let Some(ref local_var_str) = name__nie {
13163        local_var_req_builder = match "multi" {
13164            "multi" => local_var_req_builder.query(
13165                &local_var_str
13166                    .into_iter()
13167                    .map(|p| ("name__nie".to_owned(), p.to_string()))
13168                    .collect::<Vec<(std::string::String, std::string::String)>>(),
13169            ),
13170            _ => local_var_req_builder.query(&[(
13171                "name__nie",
13172                &local_var_str
13173                    .into_iter()
13174                    .map(|p| p.to_string())
13175                    .collect::<Vec<String>>()
13176                    .join(",")
13177                    .to_string(),
13178            )]),
13179        };
13180    }
13181    if let Some(ref local_var_str) = name__niew {
13182        local_var_req_builder = match "multi" {
13183            "multi" => local_var_req_builder.query(
13184                &local_var_str
13185                    .into_iter()
13186                    .map(|p| ("name__niew".to_owned(), p.to_string()))
13187                    .collect::<Vec<(std::string::String, std::string::String)>>(),
13188            ),
13189            _ => local_var_req_builder.query(&[(
13190                "name__niew",
13191                &local_var_str
13192                    .into_iter()
13193                    .map(|p| p.to_string())
13194                    .collect::<Vec<String>>()
13195                    .join(",")
13196                    .to_string(),
13197            )]),
13198        };
13199    }
13200    if let Some(ref local_var_str) = name__nisw {
13201        local_var_req_builder = match "multi" {
13202            "multi" => local_var_req_builder.query(
13203                &local_var_str
13204                    .into_iter()
13205                    .map(|p| ("name__nisw".to_owned(), p.to_string()))
13206                    .collect::<Vec<(std::string::String, std::string::String)>>(),
13207            ),
13208            _ => local_var_req_builder.query(&[(
13209                "name__nisw",
13210                &local_var_str
13211                    .into_iter()
13212                    .map(|p| p.to_string())
13213                    .collect::<Vec<String>>()
13214                    .join(",")
13215                    .to_string(),
13216            )]),
13217        };
13218    }
13219    if let Some(ref local_var_str) = name__regex {
13220        local_var_req_builder = match "multi" {
13221            "multi" => local_var_req_builder.query(
13222                &local_var_str
13223                    .into_iter()
13224                    .map(|p| ("name__regex".to_owned(), p.to_string()))
13225                    .collect::<Vec<(std::string::String, std::string::String)>>(),
13226            ),
13227            _ => local_var_req_builder.query(&[(
13228                "name__regex",
13229                &local_var_str
13230                    .into_iter()
13231                    .map(|p| p.to_string())
13232                    .collect::<Vec<String>>()
13233                    .join(",")
13234                    .to_string(),
13235            )]),
13236        };
13237    }
13238    if let Some(ref local_var_str) = offset {
13239        local_var_req_builder =
13240            local_var_req_builder.query(&[("offset", &local_var_str.to_string())]);
13241    }
13242    if let Some(ref local_var_str) = ordering {
13243        local_var_req_builder =
13244            local_var_req_builder.query(&[("ordering", &local_var_str.to_string())]);
13245    }
13246    if let Some(ref local_var_str) = platform {
13247        local_var_req_builder = match "multi" {
13248            "multi" => local_var_req_builder.query(
13249                &local_var_str
13250                    .into_iter()
13251                    .map(|p| ("platform".to_owned(), p.to_string()))
13252                    .collect::<Vec<(std::string::String, std::string::String)>>(),
13253            ),
13254            _ => local_var_req_builder.query(&[(
13255                "platform",
13256                &local_var_str
13257                    .into_iter()
13258                    .map(|p| p.to_string())
13259                    .collect::<Vec<String>>()
13260                    .join(",")
13261                    .to_string(),
13262            )]),
13263        };
13264    }
13265    if let Some(ref local_var_str) = platform__n {
13266        local_var_req_builder = match "multi" {
13267            "multi" => local_var_req_builder.query(
13268                &local_var_str
13269                    .into_iter()
13270                    .map(|p| ("platform__n".to_owned(), p.to_string()))
13271                    .collect::<Vec<(std::string::String, std::string::String)>>(),
13272            ),
13273            _ => local_var_req_builder.query(&[(
13274                "platform__n",
13275                &local_var_str
13276                    .into_iter()
13277                    .map(|p| p.to_string())
13278                    .collect::<Vec<String>>()
13279                    .join(",")
13280                    .to_string(),
13281            )]),
13282        };
13283    }
13284    if let Some(ref local_var_str) = platform_id {
13285        local_var_req_builder = match "multi" {
13286            "multi" => local_var_req_builder.query(
13287                &local_var_str
13288                    .into_iter()
13289                    .map(|p| ("platform_id".to_owned(), p.to_string()))
13290                    .collect::<Vec<(std::string::String, std::string::String)>>(),
13291            ),
13292            _ => local_var_req_builder.query(&[(
13293                "platform_id",
13294                &local_var_str
13295                    .into_iter()
13296                    .map(|p| p.to_string())
13297                    .collect::<Vec<String>>()
13298                    .join(",")
13299                    .to_string(),
13300            )]),
13301        };
13302    }
13303    if let Some(ref local_var_str) = platform_id__n {
13304        local_var_req_builder = match "multi" {
13305            "multi" => local_var_req_builder.query(
13306                &local_var_str
13307                    .into_iter()
13308                    .map(|p| ("platform_id__n".to_owned(), p.to_string()))
13309                    .collect::<Vec<(std::string::String, std::string::String)>>(),
13310            ),
13311            _ => local_var_req_builder.query(&[(
13312                "platform_id__n",
13313                &local_var_str
13314                    .into_iter()
13315                    .map(|p| p.to_string())
13316                    .collect::<Vec<String>>()
13317                    .join(",")
13318                    .to_string(),
13319            )]),
13320        };
13321    }
13322    if let Some(ref local_var_str) = primary_ip4 {
13323        local_var_req_builder = match "multi" {
13324            "multi" => local_var_req_builder.query(
13325                &local_var_str
13326                    .into_iter()
13327                    .map(|p| ("primary_ip4".to_owned(), p.to_string()))
13328                    .collect::<Vec<(std::string::String, std::string::String)>>(),
13329            ),
13330            _ => local_var_req_builder.query(&[(
13331                "primary_ip4",
13332                &local_var_str
13333                    .into_iter()
13334                    .map(|p| p.to_string())
13335                    .collect::<Vec<String>>()
13336                    .join(",")
13337                    .to_string(),
13338            )]),
13339        };
13340    }
13341    if let Some(ref local_var_str) = primary_ip4__n {
13342        local_var_req_builder = match "multi" {
13343            "multi" => local_var_req_builder.query(
13344                &local_var_str
13345                    .into_iter()
13346                    .map(|p| ("primary_ip4__n".to_owned(), p.to_string()))
13347                    .collect::<Vec<(std::string::String, std::string::String)>>(),
13348            ),
13349            _ => local_var_req_builder.query(&[(
13350                "primary_ip4__n",
13351                &local_var_str
13352                    .into_iter()
13353                    .map(|p| p.to_string())
13354                    .collect::<Vec<String>>()
13355                    .join(",")
13356                    .to_string(),
13357            )]),
13358        };
13359    }
13360    if let Some(ref local_var_str) = primary_ip4_id {
13361        local_var_req_builder = match "multi" {
13362            "multi" => local_var_req_builder.query(
13363                &local_var_str
13364                    .into_iter()
13365                    .map(|p| ("primary_ip4_id".to_owned(), p.to_string()))
13366                    .collect::<Vec<(std::string::String, std::string::String)>>(),
13367            ),
13368            _ => local_var_req_builder.query(&[(
13369                "primary_ip4_id",
13370                &local_var_str
13371                    .into_iter()
13372                    .map(|p| p.to_string())
13373                    .collect::<Vec<String>>()
13374                    .join(",")
13375                    .to_string(),
13376            )]),
13377        };
13378    }
13379    if let Some(ref local_var_str) = primary_ip4_id__n {
13380        local_var_req_builder = match "multi" {
13381            "multi" => local_var_req_builder.query(
13382                &local_var_str
13383                    .into_iter()
13384                    .map(|p| ("primary_ip4_id__n".to_owned(), p.to_string()))
13385                    .collect::<Vec<(std::string::String, std::string::String)>>(),
13386            ),
13387            _ => local_var_req_builder.query(&[(
13388                "primary_ip4_id__n",
13389                &local_var_str
13390                    .into_iter()
13391                    .map(|p| p.to_string())
13392                    .collect::<Vec<String>>()
13393                    .join(",")
13394                    .to_string(),
13395            )]),
13396        };
13397    }
13398    if let Some(ref local_var_str) = primary_ip6 {
13399        local_var_req_builder = match "multi" {
13400            "multi" => local_var_req_builder.query(
13401                &local_var_str
13402                    .into_iter()
13403                    .map(|p| ("primary_ip6".to_owned(), p.to_string()))
13404                    .collect::<Vec<(std::string::String, std::string::String)>>(),
13405            ),
13406            _ => local_var_req_builder.query(&[(
13407                "primary_ip6",
13408                &local_var_str
13409                    .into_iter()
13410                    .map(|p| p.to_string())
13411                    .collect::<Vec<String>>()
13412                    .join(",")
13413                    .to_string(),
13414            )]),
13415        };
13416    }
13417    if let Some(ref local_var_str) = primary_ip6__n {
13418        local_var_req_builder = match "multi" {
13419            "multi" => local_var_req_builder.query(
13420                &local_var_str
13421                    .into_iter()
13422                    .map(|p| ("primary_ip6__n".to_owned(), p.to_string()))
13423                    .collect::<Vec<(std::string::String, std::string::String)>>(),
13424            ),
13425            _ => local_var_req_builder.query(&[(
13426                "primary_ip6__n",
13427                &local_var_str
13428                    .into_iter()
13429                    .map(|p| p.to_string())
13430                    .collect::<Vec<String>>()
13431                    .join(",")
13432                    .to_string(),
13433            )]),
13434        };
13435    }
13436    if let Some(ref local_var_str) = primary_ip6_id {
13437        local_var_req_builder = match "multi" {
13438            "multi" => local_var_req_builder.query(
13439                &local_var_str
13440                    .into_iter()
13441                    .map(|p| ("primary_ip6_id".to_owned(), p.to_string()))
13442                    .collect::<Vec<(std::string::String, std::string::String)>>(),
13443            ),
13444            _ => local_var_req_builder.query(&[(
13445                "primary_ip6_id",
13446                &local_var_str
13447                    .into_iter()
13448                    .map(|p| p.to_string())
13449                    .collect::<Vec<String>>()
13450                    .join(",")
13451                    .to_string(),
13452            )]),
13453        };
13454    }
13455    if let Some(ref local_var_str) = primary_ip6_id__n {
13456        local_var_req_builder = match "multi" {
13457            "multi" => local_var_req_builder.query(
13458                &local_var_str
13459                    .into_iter()
13460                    .map(|p| ("primary_ip6_id__n".to_owned(), p.to_string()))
13461                    .collect::<Vec<(std::string::String, std::string::String)>>(),
13462            ),
13463            _ => local_var_req_builder.query(&[(
13464                "primary_ip6_id__n",
13465                &local_var_str
13466                    .into_iter()
13467                    .map(|p| p.to_string())
13468                    .collect::<Vec<String>>()
13469                    .join(",")
13470                    .to_string(),
13471            )]),
13472        };
13473    }
13474    if let Some(ref local_var_str) = q {
13475        local_var_req_builder = local_var_req_builder.query(&[("q", &local_var_str.to_string())]);
13476    }
13477    if let Some(ref local_var_str) = region {
13478        local_var_req_builder = match "multi" {
13479            "multi" => local_var_req_builder.query(
13480                &local_var_str
13481                    .into_iter()
13482                    .map(|p| ("region".to_owned(), p.to_string()))
13483                    .collect::<Vec<(std::string::String, std::string::String)>>(),
13484            ),
13485            _ => local_var_req_builder.query(&[(
13486                "region",
13487                &local_var_str
13488                    .into_iter()
13489                    .map(|p| p.to_string())
13490                    .collect::<Vec<String>>()
13491                    .join(",")
13492                    .to_string(),
13493            )]),
13494        };
13495    }
13496    if let Some(ref local_var_str) = region__n {
13497        local_var_req_builder = match "multi" {
13498            "multi" => local_var_req_builder.query(
13499                &local_var_str
13500                    .into_iter()
13501                    .map(|p| ("region__n".to_owned(), p.to_string()))
13502                    .collect::<Vec<(std::string::String, std::string::String)>>(),
13503            ),
13504            _ => local_var_req_builder.query(&[(
13505                "region__n",
13506                &local_var_str
13507                    .into_iter()
13508                    .map(|p| p.to_string())
13509                    .collect::<Vec<String>>()
13510                    .join(",")
13511                    .to_string(),
13512            )]),
13513        };
13514    }
13515    if let Some(ref local_var_str) = region_id {
13516        local_var_req_builder = match "multi" {
13517            "multi" => local_var_req_builder.query(
13518                &local_var_str
13519                    .into_iter()
13520                    .map(|p| ("region_id".to_owned(), p.to_string()))
13521                    .collect::<Vec<(std::string::String, std::string::String)>>(),
13522            ),
13523            _ => local_var_req_builder.query(&[(
13524                "region_id",
13525                &local_var_str
13526                    .into_iter()
13527                    .map(|p| p.to_string())
13528                    .collect::<Vec<String>>()
13529                    .join(",")
13530                    .to_string(),
13531            )]),
13532        };
13533    }
13534    if let Some(ref local_var_str) = region_id__n {
13535        local_var_req_builder = match "multi" {
13536            "multi" => local_var_req_builder.query(
13537                &local_var_str
13538                    .into_iter()
13539                    .map(|p| ("region_id__n".to_owned(), p.to_string()))
13540                    .collect::<Vec<(std::string::String, std::string::String)>>(),
13541            ),
13542            _ => local_var_req_builder.query(&[(
13543                "region_id__n",
13544                &local_var_str
13545                    .into_iter()
13546                    .map(|p| p.to_string())
13547                    .collect::<Vec<String>>()
13548                    .join(",")
13549                    .to_string(),
13550            )]),
13551        };
13552    }
13553    if let Some(ref local_var_str) = role {
13554        local_var_req_builder = match "multi" {
13555            "multi" => local_var_req_builder.query(
13556                &local_var_str
13557                    .into_iter()
13558                    .map(|p| ("role".to_owned(), p.to_string()))
13559                    .collect::<Vec<(std::string::String, std::string::String)>>(),
13560            ),
13561            _ => local_var_req_builder.query(&[(
13562                "role",
13563                &local_var_str
13564                    .into_iter()
13565                    .map(|p| p.to_string())
13566                    .collect::<Vec<String>>()
13567                    .join(",")
13568                    .to_string(),
13569            )]),
13570        };
13571    }
13572    if let Some(ref local_var_str) = role__n {
13573        local_var_req_builder = match "multi" {
13574            "multi" => local_var_req_builder.query(
13575                &local_var_str
13576                    .into_iter()
13577                    .map(|p| ("role__n".to_owned(), p.to_string()))
13578                    .collect::<Vec<(std::string::String, std::string::String)>>(),
13579            ),
13580            _ => local_var_req_builder.query(&[(
13581                "role__n",
13582                &local_var_str
13583                    .into_iter()
13584                    .map(|p| p.to_string())
13585                    .collect::<Vec<String>>()
13586                    .join(",")
13587                    .to_string(),
13588            )]),
13589        };
13590    }
13591    if let Some(ref local_var_str) = role_id {
13592        local_var_req_builder = match "multi" {
13593            "multi" => local_var_req_builder.query(
13594                &local_var_str
13595                    .into_iter()
13596                    .map(|p| ("role_id".to_owned(), p.to_string()))
13597                    .collect::<Vec<(std::string::String, std::string::String)>>(),
13598            ),
13599            _ => local_var_req_builder.query(&[(
13600                "role_id",
13601                &local_var_str
13602                    .into_iter()
13603                    .map(|p| p.to_string())
13604                    .collect::<Vec<String>>()
13605                    .join(",")
13606                    .to_string(),
13607            )]),
13608        };
13609    }
13610    if let Some(ref local_var_str) = role_id__n {
13611        local_var_req_builder = match "multi" {
13612            "multi" => local_var_req_builder.query(
13613                &local_var_str
13614                    .into_iter()
13615                    .map(|p| ("role_id__n".to_owned(), p.to_string()))
13616                    .collect::<Vec<(std::string::String, std::string::String)>>(),
13617            ),
13618            _ => local_var_req_builder.query(&[(
13619                "role_id__n",
13620                &local_var_str
13621                    .into_iter()
13622                    .map(|p| p.to_string())
13623                    .collect::<Vec<String>>()
13624                    .join(",")
13625                    .to_string(),
13626            )]),
13627        };
13628    }
13629    if let Some(ref local_var_str) = serial {
13630        local_var_req_builder = match "multi" {
13631            "multi" => local_var_req_builder.query(
13632                &local_var_str
13633                    .into_iter()
13634                    .map(|p| ("serial".to_owned(), p.to_string()))
13635                    .collect::<Vec<(std::string::String, std::string::String)>>(),
13636            ),
13637            _ => local_var_req_builder.query(&[(
13638                "serial",
13639                &local_var_str
13640                    .into_iter()
13641                    .map(|p| p.to_string())
13642                    .collect::<Vec<String>>()
13643                    .join(",")
13644                    .to_string(),
13645            )]),
13646        };
13647    }
13648    if let Some(ref local_var_str) = serial__empty {
13649        local_var_req_builder =
13650            local_var_req_builder.query(&[("serial__empty", &local_var_str.to_string())]);
13651    }
13652    if let Some(ref local_var_str) = serial__ic {
13653        local_var_req_builder = match "multi" {
13654            "multi" => local_var_req_builder.query(
13655                &local_var_str
13656                    .into_iter()
13657                    .map(|p| ("serial__ic".to_owned(), p.to_string()))
13658                    .collect::<Vec<(std::string::String, std::string::String)>>(),
13659            ),
13660            _ => local_var_req_builder.query(&[(
13661                "serial__ic",
13662                &local_var_str
13663                    .into_iter()
13664                    .map(|p| p.to_string())
13665                    .collect::<Vec<String>>()
13666                    .join(",")
13667                    .to_string(),
13668            )]),
13669        };
13670    }
13671    if let Some(ref local_var_str) = serial__ie {
13672        local_var_req_builder = match "multi" {
13673            "multi" => local_var_req_builder.query(
13674                &local_var_str
13675                    .into_iter()
13676                    .map(|p| ("serial__ie".to_owned(), p.to_string()))
13677                    .collect::<Vec<(std::string::String, std::string::String)>>(),
13678            ),
13679            _ => local_var_req_builder.query(&[(
13680                "serial__ie",
13681                &local_var_str
13682                    .into_iter()
13683                    .map(|p| p.to_string())
13684                    .collect::<Vec<String>>()
13685                    .join(",")
13686                    .to_string(),
13687            )]),
13688        };
13689    }
13690    if let Some(ref local_var_str) = serial__iew {
13691        local_var_req_builder = match "multi" {
13692            "multi" => local_var_req_builder.query(
13693                &local_var_str
13694                    .into_iter()
13695                    .map(|p| ("serial__iew".to_owned(), p.to_string()))
13696                    .collect::<Vec<(std::string::String, std::string::String)>>(),
13697            ),
13698            _ => local_var_req_builder.query(&[(
13699                "serial__iew",
13700                &local_var_str
13701                    .into_iter()
13702                    .map(|p| p.to_string())
13703                    .collect::<Vec<String>>()
13704                    .join(",")
13705                    .to_string(),
13706            )]),
13707        };
13708    }
13709    if let Some(ref local_var_str) = serial__iregex {
13710        local_var_req_builder = match "multi" {
13711            "multi" => local_var_req_builder.query(
13712                &local_var_str
13713                    .into_iter()
13714                    .map(|p| ("serial__iregex".to_owned(), p.to_string()))
13715                    .collect::<Vec<(std::string::String, std::string::String)>>(),
13716            ),
13717            _ => local_var_req_builder.query(&[(
13718                "serial__iregex",
13719                &local_var_str
13720                    .into_iter()
13721                    .map(|p| p.to_string())
13722                    .collect::<Vec<String>>()
13723                    .join(",")
13724                    .to_string(),
13725            )]),
13726        };
13727    }
13728    if let Some(ref local_var_str) = serial__isw {
13729        local_var_req_builder = match "multi" {
13730            "multi" => local_var_req_builder.query(
13731                &local_var_str
13732                    .into_iter()
13733                    .map(|p| ("serial__isw".to_owned(), p.to_string()))
13734                    .collect::<Vec<(std::string::String, std::string::String)>>(),
13735            ),
13736            _ => local_var_req_builder.query(&[(
13737                "serial__isw",
13738                &local_var_str
13739                    .into_iter()
13740                    .map(|p| p.to_string())
13741                    .collect::<Vec<String>>()
13742                    .join(",")
13743                    .to_string(),
13744            )]),
13745        };
13746    }
13747    if let Some(ref local_var_str) = serial__n {
13748        local_var_req_builder = match "multi" {
13749            "multi" => local_var_req_builder.query(
13750                &local_var_str
13751                    .into_iter()
13752                    .map(|p| ("serial__n".to_owned(), p.to_string()))
13753                    .collect::<Vec<(std::string::String, std::string::String)>>(),
13754            ),
13755            _ => local_var_req_builder.query(&[(
13756                "serial__n",
13757                &local_var_str
13758                    .into_iter()
13759                    .map(|p| p.to_string())
13760                    .collect::<Vec<String>>()
13761                    .join(",")
13762                    .to_string(),
13763            )]),
13764        };
13765    }
13766    if let Some(ref local_var_str) = serial__nic {
13767        local_var_req_builder = match "multi" {
13768            "multi" => local_var_req_builder.query(
13769                &local_var_str
13770                    .into_iter()
13771                    .map(|p| ("serial__nic".to_owned(), p.to_string()))
13772                    .collect::<Vec<(std::string::String, std::string::String)>>(),
13773            ),
13774            _ => local_var_req_builder.query(&[(
13775                "serial__nic",
13776                &local_var_str
13777                    .into_iter()
13778                    .map(|p| p.to_string())
13779                    .collect::<Vec<String>>()
13780                    .join(",")
13781                    .to_string(),
13782            )]),
13783        };
13784    }
13785    if let Some(ref local_var_str) = serial__nie {
13786        local_var_req_builder = match "multi" {
13787            "multi" => local_var_req_builder.query(
13788                &local_var_str
13789                    .into_iter()
13790                    .map(|p| ("serial__nie".to_owned(), p.to_string()))
13791                    .collect::<Vec<(std::string::String, std::string::String)>>(),
13792            ),
13793            _ => local_var_req_builder.query(&[(
13794                "serial__nie",
13795                &local_var_str
13796                    .into_iter()
13797                    .map(|p| p.to_string())
13798                    .collect::<Vec<String>>()
13799                    .join(",")
13800                    .to_string(),
13801            )]),
13802        };
13803    }
13804    if let Some(ref local_var_str) = serial__niew {
13805        local_var_req_builder = match "multi" {
13806            "multi" => local_var_req_builder.query(
13807                &local_var_str
13808                    .into_iter()
13809                    .map(|p| ("serial__niew".to_owned(), p.to_string()))
13810                    .collect::<Vec<(std::string::String, std::string::String)>>(),
13811            ),
13812            _ => local_var_req_builder.query(&[(
13813                "serial__niew",
13814                &local_var_str
13815                    .into_iter()
13816                    .map(|p| p.to_string())
13817                    .collect::<Vec<String>>()
13818                    .join(",")
13819                    .to_string(),
13820            )]),
13821        };
13822    }
13823    if let Some(ref local_var_str) = serial__nisw {
13824        local_var_req_builder = match "multi" {
13825            "multi" => local_var_req_builder.query(
13826                &local_var_str
13827                    .into_iter()
13828                    .map(|p| ("serial__nisw".to_owned(), p.to_string()))
13829                    .collect::<Vec<(std::string::String, std::string::String)>>(),
13830            ),
13831            _ => local_var_req_builder.query(&[(
13832                "serial__nisw",
13833                &local_var_str
13834                    .into_iter()
13835                    .map(|p| p.to_string())
13836                    .collect::<Vec<String>>()
13837                    .join(",")
13838                    .to_string(),
13839            )]),
13840        };
13841    }
13842    if let Some(ref local_var_str) = serial__regex {
13843        local_var_req_builder = match "multi" {
13844            "multi" => local_var_req_builder.query(
13845                &local_var_str
13846                    .into_iter()
13847                    .map(|p| ("serial__regex".to_owned(), p.to_string()))
13848                    .collect::<Vec<(std::string::String, std::string::String)>>(),
13849            ),
13850            _ => local_var_req_builder.query(&[(
13851                "serial__regex",
13852                &local_var_str
13853                    .into_iter()
13854                    .map(|p| p.to_string())
13855                    .collect::<Vec<String>>()
13856                    .join(",")
13857                    .to_string(),
13858            )]),
13859        };
13860    }
13861    if let Some(ref local_var_str) = site {
13862        local_var_req_builder = match "multi" {
13863            "multi" => local_var_req_builder.query(
13864                &local_var_str
13865                    .into_iter()
13866                    .map(|p| ("site".to_owned(), p.to_string()))
13867                    .collect::<Vec<(std::string::String, std::string::String)>>(),
13868            ),
13869            _ => local_var_req_builder.query(&[(
13870                "site",
13871                &local_var_str
13872                    .into_iter()
13873                    .map(|p| p.to_string())
13874                    .collect::<Vec<String>>()
13875                    .join(",")
13876                    .to_string(),
13877            )]),
13878        };
13879    }
13880    if let Some(ref local_var_str) = site__n {
13881        local_var_req_builder = match "multi" {
13882            "multi" => local_var_req_builder.query(
13883                &local_var_str
13884                    .into_iter()
13885                    .map(|p| ("site__n".to_owned(), p.to_string()))
13886                    .collect::<Vec<(std::string::String, std::string::String)>>(),
13887            ),
13888            _ => local_var_req_builder.query(&[(
13889                "site__n",
13890                &local_var_str
13891                    .into_iter()
13892                    .map(|p| p.to_string())
13893                    .collect::<Vec<String>>()
13894                    .join(",")
13895                    .to_string(),
13896            )]),
13897        };
13898    }
13899    if let Some(ref local_var_str) = site_group {
13900        local_var_req_builder = match "multi" {
13901            "multi" => local_var_req_builder.query(
13902                &local_var_str
13903                    .into_iter()
13904                    .map(|p| ("site_group".to_owned(), p.to_string()))
13905                    .collect::<Vec<(std::string::String, std::string::String)>>(),
13906            ),
13907            _ => local_var_req_builder.query(&[(
13908                "site_group",
13909                &local_var_str
13910                    .into_iter()
13911                    .map(|p| p.to_string())
13912                    .collect::<Vec<String>>()
13913                    .join(",")
13914                    .to_string(),
13915            )]),
13916        };
13917    }
13918    if let Some(ref local_var_str) = site_group__n {
13919        local_var_req_builder = match "multi" {
13920            "multi" => local_var_req_builder.query(
13921                &local_var_str
13922                    .into_iter()
13923                    .map(|p| ("site_group__n".to_owned(), p.to_string()))
13924                    .collect::<Vec<(std::string::String, std::string::String)>>(),
13925            ),
13926            _ => local_var_req_builder.query(&[(
13927                "site_group__n",
13928                &local_var_str
13929                    .into_iter()
13930                    .map(|p| p.to_string())
13931                    .collect::<Vec<String>>()
13932                    .join(",")
13933                    .to_string(),
13934            )]),
13935        };
13936    }
13937    if let Some(ref local_var_str) = site_group_id {
13938        local_var_req_builder = match "multi" {
13939            "multi" => local_var_req_builder.query(
13940                &local_var_str
13941                    .into_iter()
13942                    .map(|p| ("site_group_id".to_owned(), p.to_string()))
13943                    .collect::<Vec<(std::string::String, std::string::String)>>(),
13944            ),
13945            _ => local_var_req_builder.query(&[(
13946                "site_group_id",
13947                &local_var_str
13948                    .into_iter()
13949                    .map(|p| p.to_string())
13950                    .collect::<Vec<String>>()
13951                    .join(",")
13952                    .to_string(),
13953            )]),
13954        };
13955    }
13956    if let Some(ref local_var_str) = site_group_id__n {
13957        local_var_req_builder = match "multi" {
13958            "multi" => local_var_req_builder.query(
13959                &local_var_str
13960                    .into_iter()
13961                    .map(|p| ("site_group_id__n".to_owned(), p.to_string()))
13962                    .collect::<Vec<(std::string::String, std::string::String)>>(),
13963            ),
13964            _ => local_var_req_builder.query(&[(
13965                "site_group_id__n",
13966                &local_var_str
13967                    .into_iter()
13968                    .map(|p| p.to_string())
13969                    .collect::<Vec<String>>()
13970                    .join(",")
13971                    .to_string(),
13972            )]),
13973        };
13974    }
13975    if let Some(ref local_var_str) = site_id {
13976        local_var_req_builder = match "multi" {
13977            "multi" => local_var_req_builder.query(
13978                &local_var_str
13979                    .into_iter()
13980                    .map(|p| ("site_id".to_owned(), p.to_string()))
13981                    .collect::<Vec<(std::string::String, std::string::String)>>(),
13982            ),
13983            _ => local_var_req_builder.query(&[(
13984                "site_id",
13985                &local_var_str
13986                    .into_iter()
13987                    .map(|p| p.to_string())
13988                    .collect::<Vec<String>>()
13989                    .join(",")
13990                    .to_string(),
13991            )]),
13992        };
13993    }
13994    if let Some(ref local_var_str) = site_id__n {
13995        local_var_req_builder = match "multi" {
13996            "multi" => local_var_req_builder.query(
13997                &local_var_str
13998                    .into_iter()
13999                    .map(|p| ("site_id__n".to_owned(), p.to_string()))
14000                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14001            ),
14002            _ => local_var_req_builder.query(&[(
14003                "site_id__n",
14004                &local_var_str
14005                    .into_iter()
14006                    .map(|p| p.to_string())
14007                    .collect::<Vec<String>>()
14008                    .join(",")
14009                    .to_string(),
14010            )]),
14011        };
14012    }
14013    if let Some(ref local_var_str) = status {
14014        local_var_req_builder = match "multi" {
14015            "multi" => local_var_req_builder.query(
14016                &local_var_str
14017                    .into_iter()
14018                    .map(|p| ("status".to_owned(), p.to_string()))
14019                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14020            ),
14021            _ => local_var_req_builder.query(&[(
14022                "status",
14023                &local_var_str
14024                    .into_iter()
14025                    .map(|p| p.to_string())
14026                    .collect::<Vec<String>>()
14027                    .join(",")
14028                    .to_string(),
14029            )]),
14030        };
14031    }
14032    if let Some(ref local_var_str) = status__empty {
14033        local_var_req_builder =
14034            local_var_req_builder.query(&[("status__empty", &local_var_str.to_string())]);
14035    }
14036    if let Some(ref local_var_str) = status__ic {
14037        local_var_req_builder = match "multi" {
14038            "multi" => local_var_req_builder.query(
14039                &local_var_str
14040                    .into_iter()
14041                    .map(|p| ("status__ic".to_owned(), p.to_string()))
14042                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14043            ),
14044            _ => local_var_req_builder.query(&[(
14045                "status__ic",
14046                &local_var_str
14047                    .into_iter()
14048                    .map(|p| p.to_string())
14049                    .collect::<Vec<String>>()
14050                    .join(",")
14051                    .to_string(),
14052            )]),
14053        };
14054    }
14055    if let Some(ref local_var_str) = status__ie {
14056        local_var_req_builder = match "multi" {
14057            "multi" => local_var_req_builder.query(
14058                &local_var_str
14059                    .into_iter()
14060                    .map(|p| ("status__ie".to_owned(), p.to_string()))
14061                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14062            ),
14063            _ => local_var_req_builder.query(&[(
14064                "status__ie",
14065                &local_var_str
14066                    .into_iter()
14067                    .map(|p| p.to_string())
14068                    .collect::<Vec<String>>()
14069                    .join(",")
14070                    .to_string(),
14071            )]),
14072        };
14073    }
14074    if let Some(ref local_var_str) = status__iew {
14075        local_var_req_builder = match "multi" {
14076            "multi" => local_var_req_builder.query(
14077                &local_var_str
14078                    .into_iter()
14079                    .map(|p| ("status__iew".to_owned(), p.to_string()))
14080                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14081            ),
14082            _ => local_var_req_builder.query(&[(
14083                "status__iew",
14084                &local_var_str
14085                    .into_iter()
14086                    .map(|p| p.to_string())
14087                    .collect::<Vec<String>>()
14088                    .join(",")
14089                    .to_string(),
14090            )]),
14091        };
14092    }
14093    if let Some(ref local_var_str) = status__iregex {
14094        local_var_req_builder = match "multi" {
14095            "multi" => local_var_req_builder.query(
14096                &local_var_str
14097                    .into_iter()
14098                    .map(|p| ("status__iregex".to_owned(), p.to_string()))
14099                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14100            ),
14101            _ => local_var_req_builder.query(&[(
14102                "status__iregex",
14103                &local_var_str
14104                    .into_iter()
14105                    .map(|p| p.to_string())
14106                    .collect::<Vec<String>>()
14107                    .join(",")
14108                    .to_string(),
14109            )]),
14110        };
14111    }
14112    if let Some(ref local_var_str) = status__isw {
14113        local_var_req_builder = match "multi" {
14114            "multi" => local_var_req_builder.query(
14115                &local_var_str
14116                    .into_iter()
14117                    .map(|p| ("status__isw".to_owned(), p.to_string()))
14118                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14119            ),
14120            _ => local_var_req_builder.query(&[(
14121                "status__isw",
14122                &local_var_str
14123                    .into_iter()
14124                    .map(|p| p.to_string())
14125                    .collect::<Vec<String>>()
14126                    .join(",")
14127                    .to_string(),
14128            )]),
14129        };
14130    }
14131    if let Some(ref local_var_str) = status__n {
14132        local_var_req_builder = match "multi" {
14133            "multi" => local_var_req_builder.query(
14134                &local_var_str
14135                    .into_iter()
14136                    .map(|p| ("status__n".to_owned(), p.to_string()))
14137                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14138            ),
14139            _ => local_var_req_builder.query(&[(
14140                "status__n",
14141                &local_var_str
14142                    .into_iter()
14143                    .map(|p| p.to_string())
14144                    .collect::<Vec<String>>()
14145                    .join(",")
14146                    .to_string(),
14147            )]),
14148        };
14149    }
14150    if let Some(ref local_var_str) = status__nic {
14151        local_var_req_builder = match "multi" {
14152            "multi" => local_var_req_builder.query(
14153                &local_var_str
14154                    .into_iter()
14155                    .map(|p| ("status__nic".to_owned(), p.to_string()))
14156                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14157            ),
14158            _ => local_var_req_builder.query(&[(
14159                "status__nic",
14160                &local_var_str
14161                    .into_iter()
14162                    .map(|p| p.to_string())
14163                    .collect::<Vec<String>>()
14164                    .join(",")
14165                    .to_string(),
14166            )]),
14167        };
14168    }
14169    if let Some(ref local_var_str) = status__nie {
14170        local_var_req_builder = match "multi" {
14171            "multi" => local_var_req_builder.query(
14172                &local_var_str
14173                    .into_iter()
14174                    .map(|p| ("status__nie".to_owned(), p.to_string()))
14175                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14176            ),
14177            _ => local_var_req_builder.query(&[(
14178                "status__nie",
14179                &local_var_str
14180                    .into_iter()
14181                    .map(|p| p.to_string())
14182                    .collect::<Vec<String>>()
14183                    .join(",")
14184                    .to_string(),
14185            )]),
14186        };
14187    }
14188    if let Some(ref local_var_str) = status__niew {
14189        local_var_req_builder = match "multi" {
14190            "multi" => local_var_req_builder.query(
14191                &local_var_str
14192                    .into_iter()
14193                    .map(|p| ("status__niew".to_owned(), p.to_string()))
14194                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14195            ),
14196            _ => local_var_req_builder.query(&[(
14197                "status__niew",
14198                &local_var_str
14199                    .into_iter()
14200                    .map(|p| p.to_string())
14201                    .collect::<Vec<String>>()
14202                    .join(",")
14203                    .to_string(),
14204            )]),
14205        };
14206    }
14207    if let Some(ref local_var_str) = status__nisw {
14208        local_var_req_builder = match "multi" {
14209            "multi" => local_var_req_builder.query(
14210                &local_var_str
14211                    .into_iter()
14212                    .map(|p| ("status__nisw".to_owned(), p.to_string()))
14213                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14214            ),
14215            _ => local_var_req_builder.query(&[(
14216                "status__nisw",
14217                &local_var_str
14218                    .into_iter()
14219                    .map(|p| p.to_string())
14220                    .collect::<Vec<String>>()
14221                    .join(",")
14222                    .to_string(),
14223            )]),
14224        };
14225    }
14226    if let Some(ref local_var_str) = status__regex {
14227        local_var_req_builder = match "multi" {
14228            "multi" => local_var_req_builder.query(
14229                &local_var_str
14230                    .into_iter()
14231                    .map(|p| ("status__regex".to_owned(), p.to_string()))
14232                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14233            ),
14234            _ => local_var_req_builder.query(&[(
14235                "status__regex",
14236                &local_var_str
14237                    .into_iter()
14238                    .map(|p| p.to_string())
14239                    .collect::<Vec<String>>()
14240                    .join(",")
14241                    .to_string(),
14242            )]),
14243        };
14244    }
14245    if let Some(ref local_var_str) = tag {
14246        local_var_req_builder = match "multi" {
14247            "multi" => local_var_req_builder.query(
14248                &local_var_str
14249                    .into_iter()
14250                    .map(|p| ("tag".to_owned(), p.to_string()))
14251                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14252            ),
14253            _ => local_var_req_builder.query(&[(
14254                "tag",
14255                &local_var_str
14256                    .into_iter()
14257                    .map(|p| p.to_string())
14258                    .collect::<Vec<String>>()
14259                    .join(",")
14260                    .to_string(),
14261            )]),
14262        };
14263    }
14264    if let Some(ref local_var_str) = tag__n {
14265        local_var_req_builder = match "multi" {
14266            "multi" => local_var_req_builder.query(
14267                &local_var_str
14268                    .into_iter()
14269                    .map(|p| ("tag__n".to_owned(), p.to_string()))
14270                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14271            ),
14272            _ => local_var_req_builder.query(&[(
14273                "tag__n",
14274                &local_var_str
14275                    .into_iter()
14276                    .map(|p| p.to_string())
14277                    .collect::<Vec<String>>()
14278                    .join(",")
14279                    .to_string(),
14280            )]),
14281        };
14282    }
14283    if let Some(ref local_var_str) = tag_id {
14284        local_var_req_builder = match "multi" {
14285            "multi" => local_var_req_builder.query(
14286                &local_var_str
14287                    .into_iter()
14288                    .map(|p| ("tag_id".to_owned(), p.to_string()))
14289                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14290            ),
14291            _ => local_var_req_builder.query(&[(
14292                "tag_id",
14293                &local_var_str
14294                    .into_iter()
14295                    .map(|p| p.to_string())
14296                    .collect::<Vec<String>>()
14297                    .join(",")
14298                    .to_string(),
14299            )]),
14300        };
14301    }
14302    if let Some(ref local_var_str) = tag_id__n {
14303        local_var_req_builder = match "multi" {
14304            "multi" => local_var_req_builder.query(
14305                &local_var_str
14306                    .into_iter()
14307                    .map(|p| ("tag_id__n".to_owned(), p.to_string()))
14308                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14309            ),
14310            _ => local_var_req_builder.query(&[(
14311                "tag_id__n",
14312                &local_var_str
14313                    .into_iter()
14314                    .map(|p| p.to_string())
14315                    .collect::<Vec<String>>()
14316                    .join(",")
14317                    .to_string(),
14318            )]),
14319        };
14320    }
14321    if let Some(ref local_var_str) = tenant {
14322        local_var_req_builder = match "multi" {
14323            "multi" => local_var_req_builder.query(
14324                &local_var_str
14325                    .into_iter()
14326                    .map(|p| ("tenant".to_owned(), p.to_string()))
14327                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14328            ),
14329            _ => local_var_req_builder.query(&[(
14330                "tenant",
14331                &local_var_str
14332                    .into_iter()
14333                    .map(|p| p.to_string())
14334                    .collect::<Vec<String>>()
14335                    .join(",")
14336                    .to_string(),
14337            )]),
14338        };
14339    }
14340    if let Some(ref local_var_str) = tenant__n {
14341        local_var_req_builder = match "multi" {
14342            "multi" => local_var_req_builder.query(
14343                &local_var_str
14344                    .into_iter()
14345                    .map(|p| ("tenant__n".to_owned(), p.to_string()))
14346                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14347            ),
14348            _ => local_var_req_builder.query(&[(
14349                "tenant__n",
14350                &local_var_str
14351                    .into_iter()
14352                    .map(|p| p.to_string())
14353                    .collect::<Vec<String>>()
14354                    .join(",")
14355                    .to_string(),
14356            )]),
14357        };
14358    }
14359    if let Some(ref local_var_str) = tenant_group {
14360        local_var_req_builder = match "multi" {
14361            "multi" => local_var_req_builder.query(
14362                &local_var_str
14363                    .into_iter()
14364                    .map(|p| ("tenant_group".to_owned(), p.to_string()))
14365                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14366            ),
14367            _ => local_var_req_builder.query(&[(
14368                "tenant_group",
14369                &local_var_str
14370                    .into_iter()
14371                    .map(|p| p.to_string())
14372                    .collect::<Vec<String>>()
14373                    .join(",")
14374                    .to_string(),
14375            )]),
14376        };
14377    }
14378    if let Some(ref local_var_str) = tenant_group__n {
14379        local_var_req_builder = match "multi" {
14380            "multi" => local_var_req_builder.query(
14381                &local_var_str
14382                    .into_iter()
14383                    .map(|p| ("tenant_group__n".to_owned(), p.to_string()))
14384                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14385            ),
14386            _ => local_var_req_builder.query(&[(
14387                "tenant_group__n",
14388                &local_var_str
14389                    .into_iter()
14390                    .map(|p| p.to_string())
14391                    .collect::<Vec<String>>()
14392                    .join(",")
14393                    .to_string(),
14394            )]),
14395        };
14396    }
14397    if let Some(ref local_var_str) = tenant_group_id {
14398        local_var_req_builder = match "multi" {
14399            "multi" => local_var_req_builder.query(
14400                &local_var_str
14401                    .into_iter()
14402                    .map(|p| ("tenant_group_id".to_owned(), p.to_string()))
14403                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14404            ),
14405            _ => local_var_req_builder.query(&[(
14406                "tenant_group_id",
14407                &local_var_str
14408                    .into_iter()
14409                    .map(|p| p.to_string())
14410                    .collect::<Vec<String>>()
14411                    .join(",")
14412                    .to_string(),
14413            )]),
14414        };
14415    }
14416    if let Some(ref local_var_str) = tenant_group_id__n {
14417        local_var_req_builder = match "multi" {
14418            "multi" => local_var_req_builder.query(
14419                &local_var_str
14420                    .into_iter()
14421                    .map(|p| ("tenant_group_id__n".to_owned(), p.to_string()))
14422                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14423            ),
14424            _ => local_var_req_builder.query(&[(
14425                "tenant_group_id__n",
14426                &local_var_str
14427                    .into_iter()
14428                    .map(|p| p.to_string())
14429                    .collect::<Vec<String>>()
14430                    .join(",")
14431                    .to_string(),
14432            )]),
14433        };
14434    }
14435    if let Some(ref local_var_str) = tenant_id {
14436        local_var_req_builder = match "multi" {
14437            "multi" => local_var_req_builder.query(
14438                &local_var_str
14439                    .into_iter()
14440                    .map(|p| ("tenant_id".to_owned(), p.to_string()))
14441                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14442            ),
14443            _ => local_var_req_builder.query(&[(
14444                "tenant_id",
14445                &local_var_str
14446                    .into_iter()
14447                    .map(|p| p.to_string())
14448                    .collect::<Vec<String>>()
14449                    .join(",")
14450                    .to_string(),
14451            )]),
14452        };
14453    }
14454    if let Some(ref local_var_str) = tenant_id__n {
14455        local_var_req_builder = match "multi" {
14456            "multi" => local_var_req_builder.query(
14457                &local_var_str
14458                    .into_iter()
14459                    .map(|p| ("tenant_id__n".to_owned(), p.to_string()))
14460                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14461            ),
14462            _ => local_var_req_builder.query(&[(
14463                "tenant_id__n",
14464                &local_var_str
14465                    .into_iter()
14466                    .map(|p| p.to_string())
14467                    .collect::<Vec<String>>()
14468                    .join(",")
14469                    .to_string(),
14470            )]),
14471        };
14472    }
14473    if let Some(ref local_var_str) = updated_by_request {
14474        local_var_req_builder =
14475            local_var_req_builder.query(&[("updated_by_request", &local_var_str.to_string())]);
14476    }
14477    if let Some(ref local_var_str) = vcpus {
14478        local_var_req_builder = match "multi" {
14479            "multi" => local_var_req_builder.query(
14480                &local_var_str
14481                    .into_iter()
14482                    .map(|p| ("vcpus".to_owned(), p.to_string()))
14483                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14484            ),
14485            _ => local_var_req_builder.query(&[(
14486                "vcpus",
14487                &local_var_str
14488                    .into_iter()
14489                    .map(|p| p.to_string())
14490                    .collect::<Vec<String>>()
14491                    .join(",")
14492                    .to_string(),
14493            )]),
14494        };
14495    }
14496    if let Some(ref local_var_str) = vcpus__empty {
14497        local_var_req_builder =
14498            local_var_req_builder.query(&[("vcpus__empty", &local_var_str.to_string())]);
14499    }
14500    if let Some(ref local_var_str) = vcpus__gt {
14501        local_var_req_builder = match "multi" {
14502            "multi" => local_var_req_builder.query(
14503                &local_var_str
14504                    .into_iter()
14505                    .map(|p| ("vcpus__gt".to_owned(), p.to_string()))
14506                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14507            ),
14508            _ => local_var_req_builder.query(&[(
14509                "vcpus__gt",
14510                &local_var_str
14511                    .into_iter()
14512                    .map(|p| p.to_string())
14513                    .collect::<Vec<String>>()
14514                    .join(",")
14515                    .to_string(),
14516            )]),
14517        };
14518    }
14519    if let Some(ref local_var_str) = vcpus__gte {
14520        local_var_req_builder = match "multi" {
14521            "multi" => local_var_req_builder.query(
14522                &local_var_str
14523                    .into_iter()
14524                    .map(|p| ("vcpus__gte".to_owned(), p.to_string()))
14525                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14526            ),
14527            _ => local_var_req_builder.query(&[(
14528                "vcpus__gte",
14529                &local_var_str
14530                    .into_iter()
14531                    .map(|p| p.to_string())
14532                    .collect::<Vec<String>>()
14533                    .join(",")
14534                    .to_string(),
14535            )]),
14536        };
14537    }
14538    if let Some(ref local_var_str) = vcpus__lt {
14539        local_var_req_builder = match "multi" {
14540            "multi" => local_var_req_builder.query(
14541                &local_var_str
14542                    .into_iter()
14543                    .map(|p| ("vcpus__lt".to_owned(), p.to_string()))
14544                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14545            ),
14546            _ => local_var_req_builder.query(&[(
14547                "vcpus__lt",
14548                &local_var_str
14549                    .into_iter()
14550                    .map(|p| p.to_string())
14551                    .collect::<Vec<String>>()
14552                    .join(",")
14553                    .to_string(),
14554            )]),
14555        };
14556    }
14557    if let Some(ref local_var_str) = vcpus__lte {
14558        local_var_req_builder = match "multi" {
14559            "multi" => local_var_req_builder.query(
14560                &local_var_str
14561                    .into_iter()
14562                    .map(|p| ("vcpus__lte".to_owned(), p.to_string()))
14563                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14564            ),
14565            _ => local_var_req_builder.query(&[(
14566                "vcpus__lte",
14567                &local_var_str
14568                    .into_iter()
14569                    .map(|p| p.to_string())
14570                    .collect::<Vec<String>>()
14571                    .join(",")
14572                    .to_string(),
14573            )]),
14574        };
14575    }
14576    if let Some(ref local_var_str) = vcpus__n {
14577        local_var_req_builder = match "multi" {
14578            "multi" => local_var_req_builder.query(
14579                &local_var_str
14580                    .into_iter()
14581                    .map(|p| ("vcpus__n".to_owned(), p.to_string()))
14582                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14583            ),
14584            _ => local_var_req_builder.query(&[(
14585                "vcpus__n",
14586                &local_var_str
14587                    .into_iter()
14588                    .map(|p| p.to_string())
14589                    .collect::<Vec<String>>()
14590                    .join(",")
14591                    .to_string(),
14592            )]),
14593        };
14594    }
14595    if let Some(ref local_var_str) = virtual_disk_count {
14596        local_var_req_builder = match "multi" {
14597            "multi" => local_var_req_builder.query(
14598                &local_var_str
14599                    .into_iter()
14600                    .map(|p| ("virtual_disk_count".to_owned(), p.to_string()))
14601                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14602            ),
14603            _ => local_var_req_builder.query(&[(
14604                "virtual_disk_count",
14605                &local_var_str
14606                    .into_iter()
14607                    .map(|p| p.to_string())
14608                    .collect::<Vec<String>>()
14609                    .join(",")
14610                    .to_string(),
14611            )]),
14612        };
14613    }
14614    if let Some(ref local_var_str) = virtual_disk_count__empty {
14615        local_var_req_builder = local_var_req_builder
14616            .query(&[("virtual_disk_count__empty", &local_var_str.to_string())]);
14617    }
14618    if let Some(ref local_var_str) = virtual_disk_count__gt {
14619        local_var_req_builder = match "multi" {
14620            "multi" => local_var_req_builder.query(
14621                &local_var_str
14622                    .into_iter()
14623                    .map(|p| ("virtual_disk_count__gt".to_owned(), p.to_string()))
14624                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14625            ),
14626            _ => local_var_req_builder.query(&[(
14627                "virtual_disk_count__gt",
14628                &local_var_str
14629                    .into_iter()
14630                    .map(|p| p.to_string())
14631                    .collect::<Vec<String>>()
14632                    .join(",")
14633                    .to_string(),
14634            )]),
14635        };
14636    }
14637    if let Some(ref local_var_str) = virtual_disk_count__gte {
14638        local_var_req_builder = match "multi" {
14639            "multi" => local_var_req_builder.query(
14640                &local_var_str
14641                    .into_iter()
14642                    .map(|p| ("virtual_disk_count__gte".to_owned(), p.to_string()))
14643                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14644            ),
14645            _ => local_var_req_builder.query(&[(
14646                "virtual_disk_count__gte",
14647                &local_var_str
14648                    .into_iter()
14649                    .map(|p| p.to_string())
14650                    .collect::<Vec<String>>()
14651                    .join(",")
14652                    .to_string(),
14653            )]),
14654        };
14655    }
14656    if let Some(ref local_var_str) = virtual_disk_count__lt {
14657        local_var_req_builder = match "multi" {
14658            "multi" => local_var_req_builder.query(
14659                &local_var_str
14660                    .into_iter()
14661                    .map(|p| ("virtual_disk_count__lt".to_owned(), p.to_string()))
14662                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14663            ),
14664            _ => local_var_req_builder.query(&[(
14665                "virtual_disk_count__lt",
14666                &local_var_str
14667                    .into_iter()
14668                    .map(|p| p.to_string())
14669                    .collect::<Vec<String>>()
14670                    .join(",")
14671                    .to_string(),
14672            )]),
14673        };
14674    }
14675    if let Some(ref local_var_str) = virtual_disk_count__lte {
14676        local_var_req_builder = match "multi" {
14677            "multi" => local_var_req_builder.query(
14678                &local_var_str
14679                    .into_iter()
14680                    .map(|p| ("virtual_disk_count__lte".to_owned(), p.to_string()))
14681                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14682            ),
14683            _ => local_var_req_builder.query(&[(
14684                "virtual_disk_count__lte",
14685                &local_var_str
14686                    .into_iter()
14687                    .map(|p| p.to_string())
14688                    .collect::<Vec<String>>()
14689                    .join(",")
14690                    .to_string(),
14691            )]),
14692        };
14693    }
14694    if let Some(ref local_var_str) = virtual_disk_count__n {
14695        local_var_req_builder = match "multi" {
14696            "multi" => local_var_req_builder.query(
14697                &local_var_str
14698                    .into_iter()
14699                    .map(|p| ("virtual_disk_count__n".to_owned(), p.to_string()))
14700                    .collect::<Vec<(std::string::String, std::string::String)>>(),
14701            ),
14702            _ => local_var_req_builder.query(&[(
14703                "virtual_disk_count__n",
14704                &local_var_str
14705                    .into_iter()
14706                    .map(|p| p.to_string())
14707                    .collect::<Vec<String>>()
14708                    .join(",")
14709                    .to_string(),
14710            )]),
14711        };
14712    }
14713    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
14714        local_var_req_builder =
14715            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
14716    }
14717    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
14718        let local_var_key = local_var_apikey.key.clone();
14719        let local_var_value = match local_var_apikey.prefix {
14720            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
14721            None => local_var_key,
14722        };
14723        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
14724    };
14725
14726    let local_var_req = local_var_req_builder.build()?;
14727    let local_var_resp = local_var_client.execute(local_var_req).await?;
14728
14729    let local_var_status = local_var_resp.status();
14730    let local_var_content = local_var_resp.text().await?;
14731
14732    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
14733        serde_json::from_str(&local_var_content).map_err(Error::from)
14734    } else {
14735        let local_var_entity: Option<VirtualizationVirtualMachinesListError> =
14736            serde_json::from_str(&local_var_content).ok();
14737        let local_var_error = ResponseContent {
14738            status: local_var_status,
14739            content: local_var_content,
14740            entity: local_var_entity,
14741        };
14742        Err(Error::ResponseError(local_var_error))
14743    }
14744}
14745
14746/// Patch a virtual machine object.
14747pub async fn virtualization_virtual_machines_partial_update(
14748    configuration: &configuration::Configuration,
14749    id: i32,
14750    patched_writable_virtual_machine_with_config_context_request: Option<
14751        crate::models::PatchedWritableVirtualMachineWithConfigContextRequest,
14752    >,
14753) -> Result<
14754    crate::models::VirtualMachineWithConfigContext,
14755    Error<VirtualizationVirtualMachinesPartialUpdateError>,
14756> {
14757    let local_var_configuration = configuration;
14758
14759    let local_var_client = &local_var_configuration.client;
14760
14761    let local_var_uri_str = format!(
14762        "{}/api/virtualization/virtual-machines/{id}/",
14763        local_var_configuration.base_path,
14764        id = id
14765    );
14766    let mut local_var_req_builder =
14767        local_var_client.request(reqwest::Method::PATCH, local_var_uri_str.as_str());
14768
14769    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
14770        local_var_req_builder =
14771            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
14772    }
14773    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
14774        let local_var_key = local_var_apikey.key.clone();
14775        let local_var_value = match local_var_apikey.prefix {
14776            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
14777            None => local_var_key,
14778        };
14779        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
14780    };
14781    local_var_req_builder =
14782        local_var_req_builder.json(&patched_writable_virtual_machine_with_config_context_request);
14783
14784    let local_var_req = local_var_req_builder.build()?;
14785    let local_var_resp = local_var_client.execute(local_var_req).await?;
14786
14787    let local_var_status = local_var_resp.status();
14788    let local_var_content = local_var_resp.text().await?;
14789
14790    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
14791        serde_json::from_str(&local_var_content).map_err(Error::from)
14792    } else {
14793        let local_var_entity: Option<VirtualizationVirtualMachinesPartialUpdateError> =
14794            serde_json::from_str(&local_var_content).ok();
14795        let local_var_error = ResponseContent {
14796            status: local_var_status,
14797            content: local_var_content,
14798            entity: local_var_entity,
14799        };
14800        Err(Error::ResponseError(local_var_error))
14801    }
14802}
14803
14804/// Resolve and render the preferred ConfigTemplate for this Device.
14805pub async fn virtualization_virtual_machines_render_config_create(
14806    configuration: &configuration::Configuration,
14807    id: i32,
14808    writable_virtual_machine_with_config_context_request: crate::models::WritableVirtualMachineWithConfigContextRequest,
14809    format: Option<&str>,
14810) -> Result<
14811    crate::models::VirtualMachineWithConfigContext,
14812    Error<VirtualizationVirtualMachinesRenderConfigCreateError>,
14813> {
14814    let local_var_configuration = configuration;
14815
14816    let local_var_client = &local_var_configuration.client;
14817
14818    let local_var_uri_str = format!(
14819        "{}/api/virtualization/virtual-machines/{id}/render-config/",
14820        local_var_configuration.base_path,
14821        id = id
14822    );
14823    let mut local_var_req_builder =
14824        local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
14825
14826    if let Some(ref local_var_str) = format {
14827        local_var_req_builder =
14828            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
14829    }
14830    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
14831        local_var_req_builder =
14832            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
14833    }
14834    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
14835        let local_var_key = local_var_apikey.key.clone();
14836        let local_var_value = match local_var_apikey.prefix {
14837            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
14838            None => local_var_key,
14839        };
14840        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
14841    };
14842    local_var_req_builder =
14843        local_var_req_builder.json(&writable_virtual_machine_with_config_context_request);
14844
14845    let local_var_req = local_var_req_builder.build()?;
14846    let local_var_resp = local_var_client.execute(local_var_req).await?;
14847
14848    let local_var_status = local_var_resp.status();
14849    let local_var_content = local_var_resp.text().await?;
14850
14851    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
14852        serde_json::from_str(&local_var_content).map_err(Error::from)
14853    } else {
14854        let local_var_entity: Option<VirtualizationVirtualMachinesRenderConfigCreateError> =
14855            serde_json::from_str(&local_var_content).ok();
14856        let local_var_error = ResponseContent {
14857            status: local_var_status,
14858            content: local_var_content,
14859            entity: local_var_entity,
14860        };
14861        Err(Error::ResponseError(local_var_error))
14862    }
14863}
14864
14865/// Get a virtual machine object.
14866pub async fn virtualization_virtual_machines_retrieve(
14867    configuration: &configuration::Configuration,
14868    id: i32,
14869) -> Result<
14870    crate::models::VirtualMachineWithConfigContext,
14871    Error<VirtualizationVirtualMachinesRetrieveError>,
14872> {
14873    let local_var_configuration = configuration;
14874
14875    let local_var_client = &local_var_configuration.client;
14876
14877    let local_var_uri_str = format!(
14878        "{}/api/virtualization/virtual-machines/{id}/",
14879        local_var_configuration.base_path,
14880        id = id
14881    );
14882    let mut local_var_req_builder =
14883        local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
14884
14885    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
14886        local_var_req_builder =
14887            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
14888    }
14889    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
14890        let local_var_key = local_var_apikey.key.clone();
14891        let local_var_value = match local_var_apikey.prefix {
14892            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
14893            None => local_var_key,
14894        };
14895        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
14896    };
14897
14898    let local_var_req = local_var_req_builder.build()?;
14899    let local_var_resp = local_var_client.execute(local_var_req).await?;
14900
14901    let local_var_status = local_var_resp.status();
14902    let local_var_content = local_var_resp.text().await?;
14903
14904    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
14905        serde_json::from_str(&local_var_content).map_err(Error::from)
14906    } else {
14907        let local_var_entity: Option<VirtualizationVirtualMachinesRetrieveError> =
14908            serde_json::from_str(&local_var_content).ok();
14909        let local_var_error = ResponseContent {
14910            status: local_var_status,
14911            content: local_var_content,
14912            entity: local_var_entity,
14913        };
14914        Err(Error::ResponseError(local_var_error))
14915    }
14916}
14917
14918/// Put a virtual machine object.
14919pub async fn virtualization_virtual_machines_update(
14920    configuration: &configuration::Configuration,
14921    id: i32,
14922    writable_virtual_machine_with_config_context_request: crate::models::WritableVirtualMachineWithConfigContextRequest,
14923) -> Result<
14924    crate::models::VirtualMachineWithConfigContext,
14925    Error<VirtualizationVirtualMachinesUpdateError>,
14926> {
14927    let local_var_configuration = configuration;
14928
14929    let local_var_client = &local_var_configuration.client;
14930
14931    let local_var_uri_str = format!(
14932        "{}/api/virtualization/virtual-machines/{id}/",
14933        local_var_configuration.base_path,
14934        id = id
14935    );
14936    let mut local_var_req_builder =
14937        local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());
14938
14939    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
14940        local_var_req_builder =
14941            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
14942    }
14943    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
14944        let local_var_key = local_var_apikey.key.clone();
14945        let local_var_value = match local_var_apikey.prefix {
14946            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
14947            None => local_var_key,
14948        };
14949        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
14950    };
14951    local_var_req_builder =
14952        local_var_req_builder.json(&writable_virtual_machine_with_config_context_request);
14953
14954    let local_var_req = local_var_req_builder.build()?;
14955    let local_var_resp = local_var_client.execute(local_var_req).await?;
14956
14957    let local_var_status = local_var_resp.status();
14958    let local_var_content = local_var_resp.text().await?;
14959
14960    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
14961        serde_json::from_str(&local_var_content).map_err(Error::from)
14962    } else {
14963        let local_var_entity: Option<VirtualizationVirtualMachinesUpdateError> =
14964            serde_json::from_str(&local_var_content).ok();
14965        let local_var_error = ResponseContent {
14966            status: local_var_status,
14967            content: local_var_content,
14968            entity: local_var_entity,
14969        };
14970        Err(Error::ResponseError(local_var_error))
14971    }
14972}
netbox_openapi/apis/virtualization_api.rs

netbox_openapi/apis/
virtualization_api.rs
