Skip to main content

nautobot_openapi/apis/
virtualization_api.rs

1/*
2 * API Documentation
3 *
4 * Source of truth and network automation platform
5 *
6 * The version of the OpenAPI document: 3.1.0 (3.1)
7 *
8 * Generated by: https://openapi-generator.tech
9 */
10
11use reqwest;
12
13use super::{Error, configuration};
14use crate::apis::ResponseContent;
15
16/// struct for typed errors of method [`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_notes_create`]
59#[derive(Debug, Clone, Serialize, Deserialize)]
60#[serde(untagged)]
61pub enum VirtualizationClusterGroupsNotesCreateError {
62    UnknownValue(serde_json::Value),
63}
64
65/// struct for typed errors of method [`virtualization_cluster_groups_notes_list`]
66#[derive(Debug, Clone, Serialize, Deserialize)]
67#[serde(untagged)]
68pub enum VirtualizationClusterGroupsNotesListError {
69    UnknownValue(serde_json::Value),
70}
71
72/// struct for typed errors of method [`virtualization_cluster_groups_partial_update`]
73#[derive(Debug, Clone, Serialize, Deserialize)]
74#[serde(untagged)]
75pub enum VirtualizationClusterGroupsPartialUpdateError {
76    UnknownValue(serde_json::Value),
77}
78
79/// struct for typed errors of method [`virtualization_cluster_groups_retrieve`]
80#[derive(Debug, Clone, Serialize, Deserialize)]
81#[serde(untagged)]
82pub enum VirtualizationClusterGroupsRetrieveError {
83    UnknownValue(serde_json::Value),
84}
85
86/// struct for typed errors of method [`virtualization_cluster_groups_update`]
87#[derive(Debug, Clone, Serialize, Deserialize)]
88#[serde(untagged)]
89pub enum VirtualizationClusterGroupsUpdateError {
90    UnknownValue(serde_json::Value),
91}
92
93/// struct for typed errors of method [`virtualization_cluster_types_bulk_destroy`]
94#[derive(Debug, Clone, Serialize, Deserialize)]
95#[serde(untagged)]
96pub enum VirtualizationClusterTypesBulkDestroyError {
97    UnknownValue(serde_json::Value),
98}
99
100/// struct for typed errors of method [`virtualization_cluster_types_bulk_partial_update`]
101#[derive(Debug, Clone, Serialize, Deserialize)]
102#[serde(untagged)]
103pub enum VirtualizationClusterTypesBulkPartialUpdateError {
104    UnknownValue(serde_json::Value),
105}
106
107/// struct for typed errors of method [`virtualization_cluster_types_bulk_update`]
108#[derive(Debug, Clone, Serialize, Deserialize)]
109#[serde(untagged)]
110pub enum VirtualizationClusterTypesBulkUpdateError {
111    UnknownValue(serde_json::Value),
112}
113
114/// struct for typed errors of method [`virtualization_cluster_types_create`]
115#[derive(Debug, Clone, Serialize, Deserialize)]
116#[serde(untagged)]
117pub enum VirtualizationClusterTypesCreateError {
118    UnknownValue(serde_json::Value),
119}
120
121/// struct for typed errors of method [`virtualization_cluster_types_destroy`]
122#[derive(Debug, Clone, Serialize, Deserialize)]
123#[serde(untagged)]
124pub enum VirtualizationClusterTypesDestroyError {
125    UnknownValue(serde_json::Value),
126}
127
128/// struct for typed errors of method [`virtualization_cluster_types_list`]
129#[derive(Debug, Clone, Serialize, Deserialize)]
130#[serde(untagged)]
131pub enum VirtualizationClusterTypesListError {
132    UnknownValue(serde_json::Value),
133}
134
135/// struct for typed errors of method [`virtualization_cluster_types_notes_create`]
136#[derive(Debug, Clone, Serialize, Deserialize)]
137#[serde(untagged)]
138pub enum VirtualizationClusterTypesNotesCreateError {
139    UnknownValue(serde_json::Value),
140}
141
142/// struct for typed errors of method [`virtualization_cluster_types_notes_list`]
143#[derive(Debug, Clone, Serialize, Deserialize)]
144#[serde(untagged)]
145pub enum VirtualizationClusterTypesNotesListError {
146    UnknownValue(serde_json::Value),
147}
148
149/// struct for typed errors of method [`virtualization_cluster_types_partial_update`]
150#[derive(Debug, Clone, Serialize, Deserialize)]
151#[serde(untagged)]
152pub enum VirtualizationClusterTypesPartialUpdateError {
153    UnknownValue(serde_json::Value),
154}
155
156/// struct for typed errors of method [`virtualization_cluster_types_retrieve`]
157#[derive(Debug, Clone, Serialize, Deserialize)]
158#[serde(untagged)]
159pub enum VirtualizationClusterTypesRetrieveError {
160    UnknownValue(serde_json::Value),
161}
162
163/// struct for typed errors of method [`virtualization_cluster_types_update`]
164#[derive(Debug, Clone, Serialize, Deserialize)]
165#[serde(untagged)]
166pub enum VirtualizationClusterTypesUpdateError {
167    UnknownValue(serde_json::Value),
168}
169
170/// struct for typed errors of method [`virtualization_clusters_bulk_destroy`]
171#[derive(Debug, Clone, Serialize, Deserialize)]
172#[serde(untagged)]
173pub enum VirtualizationClustersBulkDestroyError {
174    UnknownValue(serde_json::Value),
175}
176
177/// struct for typed errors of method [`virtualization_clusters_bulk_partial_update`]
178#[derive(Debug, Clone, Serialize, Deserialize)]
179#[serde(untagged)]
180pub enum VirtualizationClustersBulkPartialUpdateError {
181    UnknownValue(serde_json::Value),
182}
183
184/// struct for typed errors of method [`virtualization_clusters_bulk_update`]
185#[derive(Debug, Clone, Serialize, Deserialize)]
186#[serde(untagged)]
187pub enum VirtualizationClustersBulkUpdateError {
188    UnknownValue(serde_json::Value),
189}
190
191/// struct for typed errors of method [`virtualization_clusters_create`]
192#[derive(Debug, Clone, Serialize, Deserialize)]
193#[serde(untagged)]
194pub enum VirtualizationClustersCreateError {
195    UnknownValue(serde_json::Value),
196}
197
198/// struct for typed errors of method [`virtualization_clusters_destroy`]
199#[derive(Debug, Clone, Serialize, Deserialize)]
200#[serde(untagged)]
201pub enum VirtualizationClustersDestroyError {
202    UnknownValue(serde_json::Value),
203}
204
205/// struct for typed errors of method [`virtualization_clusters_list`]
206#[derive(Debug, Clone, Serialize, Deserialize)]
207#[serde(untagged)]
208pub enum VirtualizationClustersListError {
209    UnknownValue(serde_json::Value),
210}
211
212/// struct for typed errors of method [`virtualization_clusters_notes_create`]
213#[derive(Debug, Clone, Serialize, Deserialize)]
214#[serde(untagged)]
215pub enum VirtualizationClustersNotesCreateError {
216    UnknownValue(serde_json::Value),
217}
218
219/// struct for typed errors of method [`virtualization_clusters_notes_list`]
220#[derive(Debug, Clone, Serialize, Deserialize)]
221#[serde(untagged)]
222pub enum VirtualizationClustersNotesListError {
223    UnknownValue(serde_json::Value),
224}
225
226/// struct for typed errors of method [`virtualization_clusters_partial_update`]
227#[derive(Debug, Clone, Serialize, Deserialize)]
228#[serde(untagged)]
229pub enum VirtualizationClustersPartialUpdateError {
230    UnknownValue(serde_json::Value),
231}
232
233/// struct for typed errors of method [`virtualization_clusters_retrieve`]
234#[derive(Debug, Clone, Serialize, Deserialize)]
235#[serde(untagged)]
236pub enum VirtualizationClustersRetrieveError {
237    UnknownValue(serde_json::Value),
238}
239
240/// struct for typed errors of method [`virtualization_clusters_update`]
241#[derive(Debug, Clone, Serialize, Deserialize)]
242#[serde(untagged)]
243pub enum VirtualizationClustersUpdateError {
244    UnknownValue(serde_json::Value),
245}
246
247/// struct for typed errors of method [`virtualization_interfaces_bulk_destroy`]
248#[derive(Debug, Clone, Serialize, Deserialize)]
249#[serde(untagged)]
250pub enum VirtualizationInterfacesBulkDestroyError {
251    UnknownValue(serde_json::Value),
252}
253
254/// struct for typed errors of method [`virtualization_interfaces_bulk_partial_update`]
255#[derive(Debug, Clone, Serialize, Deserialize)]
256#[serde(untagged)]
257pub enum VirtualizationInterfacesBulkPartialUpdateError {
258    UnknownValue(serde_json::Value),
259}
260
261/// struct for typed errors of method [`virtualization_interfaces_bulk_update`]
262#[derive(Debug, Clone, Serialize, Deserialize)]
263#[serde(untagged)]
264pub enum VirtualizationInterfacesBulkUpdateError {
265    UnknownValue(serde_json::Value),
266}
267
268/// struct for typed errors of method [`virtualization_interfaces_create`]
269#[derive(Debug, Clone, Serialize, Deserialize)]
270#[serde(untagged)]
271pub enum VirtualizationInterfacesCreateError {
272    UnknownValue(serde_json::Value),
273}
274
275/// struct for typed errors of method [`virtualization_interfaces_destroy`]
276#[derive(Debug, Clone, Serialize, Deserialize)]
277#[serde(untagged)]
278pub enum VirtualizationInterfacesDestroyError {
279    UnknownValue(serde_json::Value),
280}
281
282/// struct for typed errors of method [`virtualization_interfaces_list`]
283#[derive(Debug, Clone, Serialize, Deserialize)]
284#[serde(untagged)]
285pub enum VirtualizationInterfacesListError {
286    UnknownValue(serde_json::Value),
287}
288
289/// struct for typed errors of method [`virtualization_interfaces_notes_create`]
290#[derive(Debug, Clone, Serialize, Deserialize)]
291#[serde(untagged)]
292pub enum VirtualizationInterfacesNotesCreateError {
293    UnknownValue(serde_json::Value),
294}
295
296/// struct for typed errors of method [`virtualization_interfaces_notes_list`]
297#[derive(Debug, Clone, Serialize, Deserialize)]
298#[serde(untagged)]
299pub enum VirtualizationInterfacesNotesListError {
300    UnknownValue(serde_json::Value),
301}
302
303/// struct for typed errors of method [`virtualization_interfaces_partial_update`]
304#[derive(Debug, Clone, Serialize, Deserialize)]
305#[serde(untagged)]
306pub enum VirtualizationInterfacesPartialUpdateError {
307    UnknownValue(serde_json::Value),
308}
309
310/// struct for typed errors of method [`virtualization_interfaces_retrieve`]
311#[derive(Debug, Clone, Serialize, Deserialize)]
312#[serde(untagged)]
313pub enum VirtualizationInterfacesRetrieveError {
314    UnknownValue(serde_json::Value),
315}
316
317/// struct for typed errors of method [`virtualization_interfaces_update`]
318#[derive(Debug, Clone, Serialize, Deserialize)]
319#[serde(untagged)]
320pub enum VirtualizationInterfacesUpdateError {
321    UnknownValue(serde_json::Value),
322}
323
324/// struct for typed errors of method [`virtualization_virtual_machines_bulk_destroy`]
325#[derive(Debug, Clone, Serialize, Deserialize)]
326#[serde(untagged)]
327pub enum VirtualizationVirtualMachinesBulkDestroyError {
328    UnknownValue(serde_json::Value),
329}
330
331/// struct for typed errors of method [`virtualization_virtual_machines_bulk_partial_update`]
332#[derive(Debug, Clone, Serialize, Deserialize)]
333#[serde(untagged)]
334pub enum VirtualizationVirtualMachinesBulkPartialUpdateError {
335    UnknownValue(serde_json::Value),
336}
337
338/// struct for typed errors of method [`virtualization_virtual_machines_bulk_update`]
339#[derive(Debug, Clone, Serialize, Deserialize)]
340#[serde(untagged)]
341pub enum VirtualizationVirtualMachinesBulkUpdateError {
342    UnknownValue(serde_json::Value),
343}
344
345/// struct for typed errors of method [`virtualization_virtual_machines_create`]
346#[derive(Debug, Clone, Serialize, Deserialize)]
347#[serde(untagged)]
348pub enum VirtualizationVirtualMachinesCreateError {
349    UnknownValue(serde_json::Value),
350}
351
352/// struct for typed errors of method [`virtualization_virtual_machines_destroy`]
353#[derive(Debug, Clone, Serialize, Deserialize)]
354#[serde(untagged)]
355pub enum VirtualizationVirtualMachinesDestroyError {
356    UnknownValue(serde_json::Value),
357}
358
359/// struct for typed errors of method [`virtualization_virtual_machines_list`]
360#[derive(Debug, Clone, Serialize, Deserialize)]
361#[serde(untagged)]
362pub enum VirtualizationVirtualMachinesListError {
363    UnknownValue(serde_json::Value),
364}
365
366/// struct for typed errors of method [`virtualization_virtual_machines_notes_create`]
367#[derive(Debug, Clone, Serialize, Deserialize)]
368#[serde(untagged)]
369pub enum VirtualizationVirtualMachinesNotesCreateError {
370    UnknownValue(serde_json::Value),
371}
372
373/// struct for typed errors of method [`virtualization_virtual_machines_notes_list`]
374#[derive(Debug, Clone, Serialize, Deserialize)]
375#[serde(untagged)]
376pub enum VirtualizationVirtualMachinesNotesListError {
377    UnknownValue(serde_json::Value),
378}
379
380/// struct for typed errors of method [`virtualization_virtual_machines_partial_update`]
381#[derive(Debug, Clone, Serialize, Deserialize)]
382#[serde(untagged)]
383pub enum VirtualizationVirtualMachinesPartialUpdateError {
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/// Destroy a list of cluster group objects.
402pub async fn virtualization_cluster_groups_bulk_destroy(
403    configuration: &configuration::Configuration,
404    bulk_operation_request: Vec<crate::models::BulkOperationRequest>,
405    format: Option<&str>,
406) -> Result<(), Error<VirtualizationClusterGroupsBulkDestroyError>> {
407    let local_var_configuration = configuration;
408
409    let local_var_client = &local_var_configuration.client;
410
411    let local_var_uri_str = format!(
412        "{}/virtualization/cluster-groups/",
413        local_var_configuration.base_path
414    );
415    let mut local_var_req_builder =
416        local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());
417
418    if let Some(ref local_var_str) = format {
419        local_var_req_builder =
420            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
421    }
422    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
423        local_var_req_builder =
424            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
425    }
426    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
427        let local_var_key = local_var_apikey.key.clone();
428        let local_var_value = match local_var_apikey.prefix {
429            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
430            None => local_var_key,
431        };
432        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
433    };
434    local_var_req_builder = local_var_req_builder.json(&bulk_operation_request);
435
436    let local_var_req = local_var_req_builder.build()?;
437    let local_var_resp = local_var_client.execute(local_var_req).await?;
438
439    let local_var_status = local_var_resp.status();
440    let local_var_content = local_var_resp.text().await?;
441
442    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
443        Ok(())
444    } else {
445        let local_var_entity: Option<VirtualizationClusterGroupsBulkDestroyError> =
446            serde_json::from_str(&local_var_content).ok();
447        let local_var_error = ResponseContent {
448            status: local_var_status,
449            content: local_var_content,
450            entity: local_var_entity,
451        };
452        Err(Error::ResponseError(local_var_error))
453    }
454}
455
456/// Partial update a list of cluster group objects.
457pub async fn virtualization_cluster_groups_bulk_partial_update(
458    configuration: &configuration::Configuration,
459    patched_bulk_writable_cluster_group_request: Vec<
460        crate::models::PatchedBulkWritableClusterGroupRequest,
461    >,
462    format: Option<&str>,
463) -> Result<
464    Vec<crate::models::ClusterGroup>,
465    Error<VirtualizationClusterGroupsBulkPartialUpdateError>,
466> {
467    let local_var_configuration = configuration;
468
469    let local_var_client = &local_var_configuration.client;
470
471    let local_var_uri_str = format!(
472        "{}/virtualization/cluster-groups/",
473        local_var_configuration.base_path
474    );
475    let mut local_var_req_builder =
476        local_var_client.request(reqwest::Method::PATCH, local_var_uri_str.as_str());
477
478    if let Some(ref local_var_str) = format {
479        local_var_req_builder =
480            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
481    }
482    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
483        local_var_req_builder =
484            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
485    }
486    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
487        let local_var_key = local_var_apikey.key.clone();
488        let local_var_value = match local_var_apikey.prefix {
489            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
490            None => local_var_key,
491        };
492        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
493    };
494    local_var_req_builder =
495        local_var_req_builder.json(&patched_bulk_writable_cluster_group_request);
496
497    let local_var_req = local_var_req_builder.build()?;
498    let local_var_resp = local_var_client.execute(local_var_req).await?;
499
500    let local_var_status = local_var_resp.status();
501    let local_var_content = local_var_resp.text().await?;
502
503    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
504        serde_json::from_str(&local_var_content).map_err(Error::from)
505    } else {
506        let local_var_entity: Option<VirtualizationClusterGroupsBulkPartialUpdateError> =
507            serde_json::from_str(&local_var_content).ok();
508        let local_var_error = ResponseContent {
509            status: local_var_status,
510            content: local_var_content,
511            entity: local_var_entity,
512        };
513        Err(Error::ResponseError(local_var_error))
514    }
515}
516
517/// Update a list of cluster group objects.
518pub async fn virtualization_cluster_groups_bulk_update(
519    configuration: &configuration::Configuration,
520    bulk_writable_cluster_group_request: Vec<crate::models::BulkWritableClusterGroupRequest>,
521    format: Option<&str>,
522) -> Result<Vec<crate::models::ClusterGroup>, Error<VirtualizationClusterGroupsBulkUpdateError>> {
523    let local_var_configuration = configuration;
524
525    let local_var_client = &local_var_configuration.client;
526
527    let local_var_uri_str = format!(
528        "{}/virtualization/cluster-groups/",
529        local_var_configuration.base_path
530    );
531    let mut local_var_req_builder =
532        local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());
533
534    if let Some(ref local_var_str) = format {
535        local_var_req_builder =
536            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
537    }
538    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
539        local_var_req_builder =
540            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
541    }
542    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
543        let local_var_key = local_var_apikey.key.clone();
544        let local_var_value = match local_var_apikey.prefix {
545            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
546            None => local_var_key,
547        };
548        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
549    };
550    local_var_req_builder = local_var_req_builder.json(&bulk_writable_cluster_group_request);
551
552    let local_var_req = local_var_req_builder.build()?;
553    let local_var_resp = local_var_client.execute(local_var_req).await?;
554
555    let local_var_status = local_var_resp.status();
556    let local_var_content = local_var_resp.text().await?;
557
558    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
559        serde_json::from_str(&local_var_content).map_err(Error::from)
560    } else {
561        let local_var_entity: Option<VirtualizationClusterGroupsBulkUpdateError> =
562            serde_json::from_str(&local_var_content).ok();
563        let local_var_error = ResponseContent {
564            status: local_var_status,
565            content: local_var_content,
566            entity: local_var_entity,
567        };
568        Err(Error::ResponseError(local_var_error))
569    }
570}
571
572/// Create one or more cluster group objects.
573pub async fn virtualization_cluster_groups_create(
574    configuration: &configuration::Configuration,
575    cluster_group_request: crate::models::ClusterGroupRequest,
576    format: Option<&str>,
577) -> Result<crate::models::ClusterGroup, Error<VirtualizationClusterGroupsCreateError>> {
578    let local_var_configuration = configuration;
579
580    let local_var_client = &local_var_configuration.client;
581
582    let local_var_uri_str = format!(
583        "{}/virtualization/cluster-groups/",
584        local_var_configuration.base_path
585    );
586    let mut local_var_req_builder =
587        local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
588
589    if let Some(ref local_var_str) = format {
590        local_var_req_builder =
591            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
592    }
593    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
594        local_var_req_builder =
595            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
596    }
597    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
598        let local_var_key = local_var_apikey.key.clone();
599        let local_var_value = match local_var_apikey.prefix {
600            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
601            None => local_var_key,
602        };
603        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
604    };
605    local_var_req_builder = local_var_req_builder.json(&cluster_group_request);
606
607    let local_var_req = local_var_req_builder.build()?;
608    let local_var_resp = local_var_client.execute(local_var_req).await?;
609
610    let local_var_status = local_var_resp.status();
611    let local_var_content = local_var_resp.text().await?;
612
613    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
614        serde_json::from_str(&local_var_content).map_err(Error::from)
615    } else {
616        let local_var_entity: Option<VirtualizationClusterGroupsCreateError> =
617            serde_json::from_str(&local_var_content).ok();
618        let local_var_error = ResponseContent {
619            status: local_var_status,
620            content: local_var_content,
621            entity: local_var_entity,
622        };
623        Err(Error::ResponseError(local_var_error))
624    }
625}
626
627/// Destroy a cluster group object.
628pub async fn virtualization_cluster_groups_destroy(
629    configuration: &configuration::Configuration,
630    id: &str,
631    format: Option<&str>,
632) -> Result<(), Error<VirtualizationClusterGroupsDestroyError>> {
633    let local_var_configuration = configuration;
634
635    let local_var_client = &local_var_configuration.client;
636
637    let local_var_uri_str = format!(
638        "{}/virtualization/cluster-groups/{id}/",
639        local_var_configuration.base_path,
640        id = crate::apis::urlencode(id)
641    );
642    let mut local_var_req_builder =
643        local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());
644
645    if let Some(ref local_var_str) = format {
646        local_var_req_builder =
647            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
648    }
649    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
650        local_var_req_builder =
651            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
652    }
653    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
654        let local_var_key = local_var_apikey.key.clone();
655        let local_var_value = match local_var_apikey.prefix {
656            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
657            None => local_var_key,
658        };
659        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
660    };
661
662    let local_var_req = local_var_req_builder.build()?;
663    let local_var_resp = local_var_client.execute(local_var_req).await?;
664
665    let local_var_status = local_var_resp.status();
666    let local_var_content = local_var_resp.text().await?;
667
668    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
669        Ok(())
670    } else {
671        let local_var_entity: Option<VirtualizationClusterGroupsDestroyError> =
672            serde_json::from_str(&local_var_content).ok();
673        let local_var_error = ResponseContent {
674            status: local_var_status,
675            content: local_var_content,
676            entity: local_var_entity,
677        };
678        Err(Error::ResponseError(local_var_error))
679    }
680}
681
682/// Retrieve a list of cluster group objects.
683pub async fn virtualization_cluster_groups_list(
684    configuration: &configuration::Configuration,
685    clusters: Option<Vec<String>>,
686    clusters__isnull: Option<bool>,
687    clusters__n: Option<Vec<String>>,
688    contacts: Option<Vec<String>>,
689    contacts__isnull: Option<bool>,
690    contacts__n: Option<Vec<String>>,
691    created: Option<Vec<String>>,
692    created__gt: Option<Vec<String>>,
693    created__gte: Option<Vec<String>>,
694    created__isnull: Option<bool>,
695    created__lt: Option<Vec<String>>,
696    created__lte: Option<Vec<String>>,
697    created__n: Option<Vec<String>>,
698    description: Option<Vec<String>>,
699    description__ic: Option<Vec<String>>,
700    description__ie: Option<Vec<String>>,
701    description__iew: Option<Vec<String>>,
702    description__ire: Option<Vec<String>>,
703    description__isw: Option<Vec<String>>,
704    description__n: Option<Vec<String>>,
705    description__nic: Option<Vec<String>>,
706    description__nie: Option<Vec<String>>,
707    description__niew: Option<Vec<String>>,
708    description__nire: Option<Vec<String>>,
709    description__nisw: Option<Vec<String>>,
710    description__nre: Option<Vec<String>>,
711    description__re: Option<Vec<String>>,
712    dynamic_groups: Option<Vec<String>>,
713    dynamic_groups__n: Option<Vec<String>>,
714    format: Option<&str>,
715    has_clusters: Option<bool>,
716    id: Option<Vec<uuid::Uuid>>,
717    id__n: Option<Vec<uuid::Uuid>>,
718    last_updated: Option<Vec<String>>,
719    last_updated__gt: Option<Vec<String>>,
720    last_updated__gte: Option<Vec<String>>,
721    last_updated__isnull: Option<bool>,
722    last_updated__lt: Option<Vec<String>>,
723    last_updated__lte: Option<Vec<String>>,
724    last_updated__n: Option<Vec<String>>,
725    limit: Option<i32>,
726    name: Option<Vec<String>>,
727    name__ic: Option<Vec<String>>,
728    name__ie: Option<Vec<String>>,
729    name__iew: Option<Vec<String>>,
730    name__ire: Option<Vec<String>>,
731    name__isw: Option<Vec<String>>,
732    name__n: Option<Vec<String>>,
733    name__nic: Option<Vec<String>>,
734    name__nie: Option<Vec<String>>,
735    name__niew: Option<Vec<String>>,
736    name__nire: Option<Vec<String>>,
737    name__nisw: Option<Vec<String>>,
738    name__nre: Option<Vec<String>>,
739    name__re: Option<Vec<String>>,
740    offset: Option<i32>,
741    q: Option<&str>,
742    sort: Option<&str>,
743    teams: Option<Vec<String>>,
744    teams__isnull: Option<bool>,
745    teams__n: Option<Vec<String>>,
746    depth: Option<i32>,
747    exclude_m2m: Option<bool>,
748) -> Result<crate::models::PaginatedClusterGroupList, Error<VirtualizationClusterGroupsListError>> {
749    let local_var_configuration = configuration;
750
751    let local_var_client = &local_var_configuration.client;
752
753    let local_var_uri_str = format!(
754        "{}/virtualization/cluster-groups/",
755        local_var_configuration.base_path
756    );
757    let mut local_var_req_builder =
758        local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
759
760    if let Some(ref local_var_str) = clusters {
761        local_var_req_builder = match "multi" {
762            "multi" => local_var_req_builder.query(
763                &local_var_str
764                    .into_iter()
765                    .map(|p| ("clusters".to_owned(), p.to_string()))
766                    .collect::<Vec<(std::string::String, std::string::String)>>(),
767            ),
768            _ => local_var_req_builder.query(&[(
769                "clusters",
770                &local_var_str
771                    .into_iter()
772                    .map(|p| p.to_string())
773                    .collect::<Vec<String>>()
774                    .join(",")
775                    .to_string(),
776            )]),
777        };
778    }
779    if let Some(ref local_var_str) = clusters__isnull {
780        local_var_req_builder =
781            local_var_req_builder.query(&[("clusters__isnull", &local_var_str.to_string())]);
782    }
783    if let Some(ref local_var_str) = clusters__n {
784        local_var_req_builder = match "multi" {
785            "multi" => local_var_req_builder.query(
786                &local_var_str
787                    .into_iter()
788                    .map(|p| ("clusters__n".to_owned(), p.to_string()))
789                    .collect::<Vec<(std::string::String, std::string::String)>>(),
790            ),
791            _ => local_var_req_builder.query(&[(
792                "clusters__n",
793                &local_var_str
794                    .into_iter()
795                    .map(|p| p.to_string())
796                    .collect::<Vec<String>>()
797                    .join(",")
798                    .to_string(),
799            )]),
800        };
801    }
802    if let Some(ref local_var_str) = contacts {
803        local_var_req_builder = match "multi" {
804            "multi" => local_var_req_builder.query(
805                &local_var_str
806                    .into_iter()
807                    .map(|p| ("contacts".to_owned(), p.to_string()))
808                    .collect::<Vec<(std::string::String, std::string::String)>>(),
809            ),
810            _ => local_var_req_builder.query(&[(
811                "contacts",
812                &local_var_str
813                    .into_iter()
814                    .map(|p| p.to_string())
815                    .collect::<Vec<String>>()
816                    .join(",")
817                    .to_string(),
818            )]),
819        };
820    }
821    if let Some(ref local_var_str) = contacts__isnull {
822        local_var_req_builder =
823            local_var_req_builder.query(&[("contacts__isnull", &local_var_str.to_string())]);
824    }
825    if let Some(ref local_var_str) = contacts__n {
826        local_var_req_builder = match "multi" {
827            "multi" => local_var_req_builder.query(
828                &local_var_str
829                    .into_iter()
830                    .map(|p| ("contacts__n".to_owned(), p.to_string()))
831                    .collect::<Vec<(std::string::String, std::string::String)>>(),
832            ),
833            _ => local_var_req_builder.query(&[(
834                "contacts__n",
835                &local_var_str
836                    .into_iter()
837                    .map(|p| p.to_string())
838                    .collect::<Vec<String>>()
839                    .join(",")
840                    .to_string(),
841            )]),
842        };
843    }
844    if let Some(ref local_var_str) = created {
845        local_var_req_builder = match "multi" {
846            "multi" => local_var_req_builder.query(
847                &local_var_str
848                    .into_iter()
849                    .map(|p| ("created".to_owned(), p.to_string()))
850                    .collect::<Vec<(std::string::String, std::string::String)>>(),
851            ),
852            _ => local_var_req_builder.query(&[(
853                "created",
854                &local_var_str
855                    .into_iter()
856                    .map(|p| p.to_string())
857                    .collect::<Vec<String>>()
858                    .join(",")
859                    .to_string(),
860            )]),
861        };
862    }
863    if let Some(ref local_var_str) = created__gt {
864        local_var_req_builder = match "multi" {
865            "multi" => local_var_req_builder.query(
866                &local_var_str
867                    .into_iter()
868                    .map(|p| ("created__gt".to_owned(), p.to_string()))
869                    .collect::<Vec<(std::string::String, std::string::String)>>(),
870            ),
871            _ => local_var_req_builder.query(&[(
872                "created__gt",
873                &local_var_str
874                    .into_iter()
875                    .map(|p| p.to_string())
876                    .collect::<Vec<String>>()
877                    .join(",")
878                    .to_string(),
879            )]),
880        };
881    }
882    if let Some(ref local_var_str) = created__gte {
883        local_var_req_builder = match "multi" {
884            "multi" => local_var_req_builder.query(
885                &local_var_str
886                    .into_iter()
887                    .map(|p| ("created__gte".to_owned(), p.to_string()))
888                    .collect::<Vec<(std::string::String, std::string::String)>>(),
889            ),
890            _ => local_var_req_builder.query(&[(
891                "created__gte",
892                &local_var_str
893                    .into_iter()
894                    .map(|p| p.to_string())
895                    .collect::<Vec<String>>()
896                    .join(",")
897                    .to_string(),
898            )]),
899        };
900    }
901    if let Some(ref local_var_str) = created__isnull {
902        local_var_req_builder =
903            local_var_req_builder.query(&[("created__isnull", &local_var_str.to_string())]);
904    }
905    if let Some(ref local_var_str) = created__lt {
906        local_var_req_builder = match "multi" {
907            "multi" => local_var_req_builder.query(
908                &local_var_str
909                    .into_iter()
910                    .map(|p| ("created__lt".to_owned(), p.to_string()))
911                    .collect::<Vec<(std::string::String, std::string::String)>>(),
912            ),
913            _ => local_var_req_builder.query(&[(
914                "created__lt",
915                &local_var_str
916                    .into_iter()
917                    .map(|p| p.to_string())
918                    .collect::<Vec<String>>()
919                    .join(",")
920                    .to_string(),
921            )]),
922        };
923    }
924    if let Some(ref local_var_str) = created__lte {
925        local_var_req_builder = match "multi" {
926            "multi" => local_var_req_builder.query(
927                &local_var_str
928                    .into_iter()
929                    .map(|p| ("created__lte".to_owned(), p.to_string()))
930                    .collect::<Vec<(std::string::String, std::string::String)>>(),
931            ),
932            _ => local_var_req_builder.query(&[(
933                "created__lte",
934                &local_var_str
935                    .into_iter()
936                    .map(|p| p.to_string())
937                    .collect::<Vec<String>>()
938                    .join(",")
939                    .to_string(),
940            )]),
941        };
942    }
943    if let Some(ref local_var_str) = created__n {
944        local_var_req_builder = match "multi" {
945            "multi" => local_var_req_builder.query(
946                &local_var_str
947                    .into_iter()
948                    .map(|p| ("created__n".to_owned(), p.to_string()))
949                    .collect::<Vec<(std::string::String, std::string::String)>>(),
950            ),
951            _ => local_var_req_builder.query(&[(
952                "created__n",
953                &local_var_str
954                    .into_iter()
955                    .map(|p| p.to_string())
956                    .collect::<Vec<String>>()
957                    .join(",")
958                    .to_string(),
959            )]),
960        };
961    }
962    if let Some(ref local_var_str) = description {
963        local_var_req_builder = match "multi" {
964            "multi" => local_var_req_builder.query(
965                &local_var_str
966                    .into_iter()
967                    .map(|p| ("description".to_owned(), p.to_string()))
968                    .collect::<Vec<(std::string::String, std::string::String)>>(),
969            ),
970            _ => local_var_req_builder.query(&[(
971                "description",
972                &local_var_str
973                    .into_iter()
974                    .map(|p| p.to_string())
975                    .collect::<Vec<String>>()
976                    .join(",")
977                    .to_string(),
978            )]),
979        };
980    }
981    if let Some(ref local_var_str) = description__ic {
982        local_var_req_builder = match "multi" {
983            "multi" => local_var_req_builder.query(
984                &local_var_str
985                    .into_iter()
986                    .map(|p| ("description__ic".to_owned(), p.to_string()))
987                    .collect::<Vec<(std::string::String, std::string::String)>>(),
988            ),
989            _ => local_var_req_builder.query(&[(
990                "description__ic",
991                &local_var_str
992                    .into_iter()
993                    .map(|p| p.to_string())
994                    .collect::<Vec<String>>()
995                    .join(",")
996                    .to_string(),
997            )]),
998        };
999    }
1000    if let Some(ref local_var_str) = description__ie {
1001        local_var_req_builder = match "multi" {
1002            "multi" => local_var_req_builder.query(
1003                &local_var_str
1004                    .into_iter()
1005                    .map(|p| ("description__ie".to_owned(), p.to_string()))
1006                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1007            ),
1008            _ => local_var_req_builder.query(&[(
1009                "description__ie",
1010                &local_var_str
1011                    .into_iter()
1012                    .map(|p| p.to_string())
1013                    .collect::<Vec<String>>()
1014                    .join(",")
1015                    .to_string(),
1016            )]),
1017        };
1018    }
1019    if let Some(ref local_var_str) = description__iew {
1020        local_var_req_builder = match "multi" {
1021            "multi" => local_var_req_builder.query(
1022                &local_var_str
1023                    .into_iter()
1024                    .map(|p| ("description__iew".to_owned(), p.to_string()))
1025                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1026            ),
1027            _ => local_var_req_builder.query(&[(
1028                "description__iew",
1029                &local_var_str
1030                    .into_iter()
1031                    .map(|p| p.to_string())
1032                    .collect::<Vec<String>>()
1033                    .join(",")
1034                    .to_string(),
1035            )]),
1036        };
1037    }
1038    if let Some(ref local_var_str) = description__ire {
1039        local_var_req_builder = match "multi" {
1040            "multi" => local_var_req_builder.query(
1041                &local_var_str
1042                    .into_iter()
1043                    .map(|p| ("description__ire".to_owned(), p.to_string()))
1044                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1045            ),
1046            _ => local_var_req_builder.query(&[(
1047                "description__ire",
1048                &local_var_str
1049                    .into_iter()
1050                    .map(|p| p.to_string())
1051                    .collect::<Vec<String>>()
1052                    .join(",")
1053                    .to_string(),
1054            )]),
1055        };
1056    }
1057    if let Some(ref local_var_str) = description__isw {
1058        local_var_req_builder = match "multi" {
1059            "multi" => local_var_req_builder.query(
1060                &local_var_str
1061                    .into_iter()
1062                    .map(|p| ("description__isw".to_owned(), p.to_string()))
1063                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1064            ),
1065            _ => local_var_req_builder.query(&[(
1066                "description__isw",
1067                &local_var_str
1068                    .into_iter()
1069                    .map(|p| p.to_string())
1070                    .collect::<Vec<String>>()
1071                    .join(",")
1072                    .to_string(),
1073            )]),
1074        };
1075    }
1076    if let Some(ref local_var_str) = description__n {
1077        local_var_req_builder = match "multi" {
1078            "multi" => local_var_req_builder.query(
1079                &local_var_str
1080                    .into_iter()
1081                    .map(|p| ("description__n".to_owned(), p.to_string()))
1082                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1083            ),
1084            _ => local_var_req_builder.query(&[(
1085                "description__n",
1086                &local_var_str
1087                    .into_iter()
1088                    .map(|p| p.to_string())
1089                    .collect::<Vec<String>>()
1090                    .join(",")
1091                    .to_string(),
1092            )]),
1093        };
1094    }
1095    if let Some(ref local_var_str) = description__nic {
1096        local_var_req_builder = match "multi" {
1097            "multi" => local_var_req_builder.query(
1098                &local_var_str
1099                    .into_iter()
1100                    .map(|p| ("description__nic".to_owned(), p.to_string()))
1101                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1102            ),
1103            _ => local_var_req_builder.query(&[(
1104                "description__nic",
1105                &local_var_str
1106                    .into_iter()
1107                    .map(|p| p.to_string())
1108                    .collect::<Vec<String>>()
1109                    .join(",")
1110                    .to_string(),
1111            )]),
1112        };
1113    }
1114    if let Some(ref local_var_str) = description__nie {
1115        local_var_req_builder = match "multi" {
1116            "multi" => local_var_req_builder.query(
1117                &local_var_str
1118                    .into_iter()
1119                    .map(|p| ("description__nie".to_owned(), p.to_string()))
1120                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1121            ),
1122            _ => local_var_req_builder.query(&[(
1123                "description__nie",
1124                &local_var_str
1125                    .into_iter()
1126                    .map(|p| p.to_string())
1127                    .collect::<Vec<String>>()
1128                    .join(",")
1129                    .to_string(),
1130            )]),
1131        };
1132    }
1133    if let Some(ref local_var_str) = description__niew {
1134        local_var_req_builder = match "multi" {
1135            "multi" => local_var_req_builder.query(
1136                &local_var_str
1137                    .into_iter()
1138                    .map(|p| ("description__niew".to_owned(), p.to_string()))
1139                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1140            ),
1141            _ => local_var_req_builder.query(&[(
1142                "description__niew",
1143                &local_var_str
1144                    .into_iter()
1145                    .map(|p| p.to_string())
1146                    .collect::<Vec<String>>()
1147                    .join(",")
1148                    .to_string(),
1149            )]),
1150        };
1151    }
1152    if let Some(ref local_var_str) = description__nire {
1153        local_var_req_builder = match "multi" {
1154            "multi" => local_var_req_builder.query(
1155                &local_var_str
1156                    .into_iter()
1157                    .map(|p| ("description__nire".to_owned(), p.to_string()))
1158                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1159            ),
1160            _ => local_var_req_builder.query(&[(
1161                "description__nire",
1162                &local_var_str
1163                    .into_iter()
1164                    .map(|p| p.to_string())
1165                    .collect::<Vec<String>>()
1166                    .join(",")
1167                    .to_string(),
1168            )]),
1169        };
1170    }
1171    if let Some(ref local_var_str) = description__nisw {
1172        local_var_req_builder = match "multi" {
1173            "multi" => local_var_req_builder.query(
1174                &local_var_str
1175                    .into_iter()
1176                    .map(|p| ("description__nisw".to_owned(), p.to_string()))
1177                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1178            ),
1179            _ => local_var_req_builder.query(&[(
1180                "description__nisw",
1181                &local_var_str
1182                    .into_iter()
1183                    .map(|p| p.to_string())
1184                    .collect::<Vec<String>>()
1185                    .join(",")
1186                    .to_string(),
1187            )]),
1188        };
1189    }
1190    if let Some(ref local_var_str) = description__nre {
1191        local_var_req_builder = match "multi" {
1192            "multi" => local_var_req_builder.query(
1193                &local_var_str
1194                    .into_iter()
1195                    .map(|p| ("description__nre".to_owned(), p.to_string()))
1196                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1197            ),
1198            _ => local_var_req_builder.query(&[(
1199                "description__nre",
1200                &local_var_str
1201                    .into_iter()
1202                    .map(|p| p.to_string())
1203                    .collect::<Vec<String>>()
1204                    .join(",")
1205                    .to_string(),
1206            )]),
1207        };
1208    }
1209    if let Some(ref local_var_str) = description__re {
1210        local_var_req_builder = match "multi" {
1211            "multi" => local_var_req_builder.query(
1212                &local_var_str
1213                    .into_iter()
1214                    .map(|p| ("description__re".to_owned(), p.to_string()))
1215                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1216            ),
1217            _ => local_var_req_builder.query(&[(
1218                "description__re",
1219                &local_var_str
1220                    .into_iter()
1221                    .map(|p| p.to_string())
1222                    .collect::<Vec<String>>()
1223                    .join(",")
1224                    .to_string(),
1225            )]),
1226        };
1227    }
1228    if let Some(ref local_var_str) = dynamic_groups {
1229        local_var_req_builder = match "multi" {
1230            "multi" => local_var_req_builder.query(
1231                &local_var_str
1232                    .into_iter()
1233                    .map(|p| ("dynamic_groups".to_owned(), p.to_string()))
1234                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1235            ),
1236            _ => local_var_req_builder.query(&[(
1237                "dynamic_groups",
1238                &local_var_str
1239                    .into_iter()
1240                    .map(|p| p.to_string())
1241                    .collect::<Vec<String>>()
1242                    .join(",")
1243                    .to_string(),
1244            )]),
1245        };
1246    }
1247    if let Some(ref local_var_str) = dynamic_groups__n {
1248        local_var_req_builder = match "multi" {
1249            "multi" => local_var_req_builder.query(
1250                &local_var_str
1251                    .into_iter()
1252                    .map(|p| ("dynamic_groups__n".to_owned(), p.to_string()))
1253                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1254            ),
1255            _ => local_var_req_builder.query(&[(
1256                "dynamic_groups__n",
1257                &local_var_str
1258                    .into_iter()
1259                    .map(|p| p.to_string())
1260                    .collect::<Vec<String>>()
1261                    .join(",")
1262                    .to_string(),
1263            )]),
1264        };
1265    }
1266    if let Some(ref local_var_str) = format {
1267        local_var_req_builder =
1268            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
1269    }
1270    if let Some(ref local_var_str) = has_clusters {
1271        local_var_req_builder =
1272            local_var_req_builder.query(&[("has_clusters", &local_var_str.to_string())]);
1273    }
1274    if let Some(ref local_var_str) = id {
1275        local_var_req_builder = match "multi" {
1276            "multi" => local_var_req_builder.query(
1277                &local_var_str
1278                    .into_iter()
1279                    .map(|p| ("id".to_owned(), p.to_string()))
1280                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1281            ),
1282            _ => local_var_req_builder.query(&[(
1283                "id",
1284                &local_var_str
1285                    .into_iter()
1286                    .map(|p| p.to_string())
1287                    .collect::<Vec<String>>()
1288                    .join(",")
1289                    .to_string(),
1290            )]),
1291        };
1292    }
1293    if let Some(ref local_var_str) = id__n {
1294        local_var_req_builder = match "multi" {
1295            "multi" => local_var_req_builder.query(
1296                &local_var_str
1297                    .into_iter()
1298                    .map(|p| ("id__n".to_owned(), p.to_string()))
1299                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1300            ),
1301            _ => local_var_req_builder.query(&[(
1302                "id__n",
1303                &local_var_str
1304                    .into_iter()
1305                    .map(|p| p.to_string())
1306                    .collect::<Vec<String>>()
1307                    .join(",")
1308                    .to_string(),
1309            )]),
1310        };
1311    }
1312    if let Some(ref local_var_str) = last_updated {
1313        local_var_req_builder = match "multi" {
1314            "multi" => local_var_req_builder.query(
1315                &local_var_str
1316                    .into_iter()
1317                    .map(|p| ("last_updated".to_owned(), p.to_string()))
1318                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1319            ),
1320            _ => local_var_req_builder.query(&[(
1321                "last_updated",
1322                &local_var_str
1323                    .into_iter()
1324                    .map(|p| p.to_string())
1325                    .collect::<Vec<String>>()
1326                    .join(",")
1327                    .to_string(),
1328            )]),
1329        };
1330    }
1331    if let Some(ref local_var_str) = last_updated__gt {
1332        local_var_req_builder = match "multi" {
1333            "multi" => local_var_req_builder.query(
1334                &local_var_str
1335                    .into_iter()
1336                    .map(|p| ("last_updated__gt".to_owned(), p.to_string()))
1337                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1338            ),
1339            _ => local_var_req_builder.query(&[(
1340                "last_updated__gt",
1341                &local_var_str
1342                    .into_iter()
1343                    .map(|p| p.to_string())
1344                    .collect::<Vec<String>>()
1345                    .join(",")
1346                    .to_string(),
1347            )]),
1348        };
1349    }
1350    if let Some(ref local_var_str) = last_updated__gte {
1351        local_var_req_builder = match "multi" {
1352            "multi" => local_var_req_builder.query(
1353                &local_var_str
1354                    .into_iter()
1355                    .map(|p| ("last_updated__gte".to_owned(), p.to_string()))
1356                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1357            ),
1358            _ => local_var_req_builder.query(&[(
1359                "last_updated__gte",
1360                &local_var_str
1361                    .into_iter()
1362                    .map(|p| p.to_string())
1363                    .collect::<Vec<String>>()
1364                    .join(",")
1365                    .to_string(),
1366            )]),
1367        };
1368    }
1369    if let Some(ref local_var_str) = last_updated__isnull {
1370        local_var_req_builder =
1371            local_var_req_builder.query(&[("last_updated__isnull", &local_var_str.to_string())]);
1372    }
1373    if let Some(ref local_var_str) = last_updated__lt {
1374        local_var_req_builder = match "multi" {
1375            "multi" => local_var_req_builder.query(
1376                &local_var_str
1377                    .into_iter()
1378                    .map(|p| ("last_updated__lt".to_owned(), p.to_string()))
1379                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1380            ),
1381            _ => local_var_req_builder.query(&[(
1382                "last_updated__lt",
1383                &local_var_str
1384                    .into_iter()
1385                    .map(|p| p.to_string())
1386                    .collect::<Vec<String>>()
1387                    .join(",")
1388                    .to_string(),
1389            )]),
1390        };
1391    }
1392    if let Some(ref local_var_str) = last_updated__lte {
1393        local_var_req_builder = match "multi" {
1394            "multi" => local_var_req_builder.query(
1395                &local_var_str
1396                    .into_iter()
1397                    .map(|p| ("last_updated__lte".to_owned(), p.to_string()))
1398                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1399            ),
1400            _ => local_var_req_builder.query(&[(
1401                "last_updated__lte",
1402                &local_var_str
1403                    .into_iter()
1404                    .map(|p| p.to_string())
1405                    .collect::<Vec<String>>()
1406                    .join(",")
1407                    .to_string(),
1408            )]),
1409        };
1410    }
1411    if let Some(ref local_var_str) = last_updated__n {
1412        local_var_req_builder = match "multi" {
1413            "multi" => local_var_req_builder.query(
1414                &local_var_str
1415                    .into_iter()
1416                    .map(|p| ("last_updated__n".to_owned(), p.to_string()))
1417                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1418            ),
1419            _ => local_var_req_builder.query(&[(
1420                "last_updated__n",
1421                &local_var_str
1422                    .into_iter()
1423                    .map(|p| p.to_string())
1424                    .collect::<Vec<String>>()
1425                    .join(",")
1426                    .to_string(),
1427            )]),
1428        };
1429    }
1430    if let Some(ref local_var_str) = limit {
1431        local_var_req_builder =
1432            local_var_req_builder.query(&[("limit", &local_var_str.to_string())]);
1433    }
1434    if let Some(ref local_var_str) = name {
1435        local_var_req_builder = match "multi" {
1436            "multi" => local_var_req_builder.query(
1437                &local_var_str
1438                    .into_iter()
1439                    .map(|p| ("name".to_owned(), p.to_string()))
1440                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1441            ),
1442            _ => local_var_req_builder.query(&[(
1443                "name",
1444                &local_var_str
1445                    .into_iter()
1446                    .map(|p| p.to_string())
1447                    .collect::<Vec<String>>()
1448                    .join(",")
1449                    .to_string(),
1450            )]),
1451        };
1452    }
1453    if let Some(ref local_var_str) = name__ic {
1454        local_var_req_builder = match "multi" {
1455            "multi" => local_var_req_builder.query(
1456                &local_var_str
1457                    .into_iter()
1458                    .map(|p| ("name__ic".to_owned(), p.to_string()))
1459                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1460            ),
1461            _ => local_var_req_builder.query(&[(
1462                "name__ic",
1463                &local_var_str
1464                    .into_iter()
1465                    .map(|p| p.to_string())
1466                    .collect::<Vec<String>>()
1467                    .join(",")
1468                    .to_string(),
1469            )]),
1470        };
1471    }
1472    if let Some(ref local_var_str) = name__ie {
1473        local_var_req_builder = match "multi" {
1474            "multi" => local_var_req_builder.query(
1475                &local_var_str
1476                    .into_iter()
1477                    .map(|p| ("name__ie".to_owned(), p.to_string()))
1478                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1479            ),
1480            _ => local_var_req_builder.query(&[(
1481                "name__ie",
1482                &local_var_str
1483                    .into_iter()
1484                    .map(|p| p.to_string())
1485                    .collect::<Vec<String>>()
1486                    .join(",")
1487                    .to_string(),
1488            )]),
1489        };
1490    }
1491    if let Some(ref local_var_str) = name__iew {
1492        local_var_req_builder = match "multi" {
1493            "multi" => local_var_req_builder.query(
1494                &local_var_str
1495                    .into_iter()
1496                    .map(|p| ("name__iew".to_owned(), p.to_string()))
1497                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1498            ),
1499            _ => local_var_req_builder.query(&[(
1500                "name__iew",
1501                &local_var_str
1502                    .into_iter()
1503                    .map(|p| p.to_string())
1504                    .collect::<Vec<String>>()
1505                    .join(",")
1506                    .to_string(),
1507            )]),
1508        };
1509    }
1510    if let Some(ref local_var_str) = name__ire {
1511        local_var_req_builder = match "multi" {
1512            "multi" => local_var_req_builder.query(
1513                &local_var_str
1514                    .into_iter()
1515                    .map(|p| ("name__ire".to_owned(), p.to_string()))
1516                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1517            ),
1518            _ => local_var_req_builder.query(&[(
1519                "name__ire",
1520                &local_var_str
1521                    .into_iter()
1522                    .map(|p| p.to_string())
1523                    .collect::<Vec<String>>()
1524                    .join(",")
1525                    .to_string(),
1526            )]),
1527        };
1528    }
1529    if let Some(ref local_var_str) = name__isw {
1530        local_var_req_builder = match "multi" {
1531            "multi" => local_var_req_builder.query(
1532                &local_var_str
1533                    .into_iter()
1534                    .map(|p| ("name__isw".to_owned(), p.to_string()))
1535                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1536            ),
1537            _ => local_var_req_builder.query(&[(
1538                "name__isw",
1539                &local_var_str
1540                    .into_iter()
1541                    .map(|p| p.to_string())
1542                    .collect::<Vec<String>>()
1543                    .join(",")
1544                    .to_string(),
1545            )]),
1546        };
1547    }
1548    if let Some(ref local_var_str) = name__n {
1549        local_var_req_builder = match "multi" {
1550            "multi" => local_var_req_builder.query(
1551                &local_var_str
1552                    .into_iter()
1553                    .map(|p| ("name__n".to_owned(), p.to_string()))
1554                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1555            ),
1556            _ => local_var_req_builder.query(&[(
1557                "name__n",
1558                &local_var_str
1559                    .into_iter()
1560                    .map(|p| p.to_string())
1561                    .collect::<Vec<String>>()
1562                    .join(",")
1563                    .to_string(),
1564            )]),
1565        };
1566    }
1567    if let Some(ref local_var_str) = name__nic {
1568        local_var_req_builder = match "multi" {
1569            "multi" => local_var_req_builder.query(
1570                &local_var_str
1571                    .into_iter()
1572                    .map(|p| ("name__nic".to_owned(), p.to_string()))
1573                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1574            ),
1575            _ => local_var_req_builder.query(&[(
1576                "name__nic",
1577                &local_var_str
1578                    .into_iter()
1579                    .map(|p| p.to_string())
1580                    .collect::<Vec<String>>()
1581                    .join(",")
1582                    .to_string(),
1583            )]),
1584        };
1585    }
1586    if let Some(ref local_var_str) = name__nie {
1587        local_var_req_builder = match "multi" {
1588            "multi" => local_var_req_builder.query(
1589                &local_var_str
1590                    .into_iter()
1591                    .map(|p| ("name__nie".to_owned(), p.to_string()))
1592                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1593            ),
1594            _ => local_var_req_builder.query(&[(
1595                "name__nie",
1596                &local_var_str
1597                    .into_iter()
1598                    .map(|p| p.to_string())
1599                    .collect::<Vec<String>>()
1600                    .join(",")
1601                    .to_string(),
1602            )]),
1603        };
1604    }
1605    if let Some(ref local_var_str) = name__niew {
1606        local_var_req_builder = match "multi" {
1607            "multi" => local_var_req_builder.query(
1608                &local_var_str
1609                    .into_iter()
1610                    .map(|p| ("name__niew".to_owned(), p.to_string()))
1611                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1612            ),
1613            _ => local_var_req_builder.query(&[(
1614                "name__niew",
1615                &local_var_str
1616                    .into_iter()
1617                    .map(|p| p.to_string())
1618                    .collect::<Vec<String>>()
1619                    .join(",")
1620                    .to_string(),
1621            )]),
1622        };
1623    }
1624    if let Some(ref local_var_str) = name__nire {
1625        local_var_req_builder = match "multi" {
1626            "multi" => local_var_req_builder.query(
1627                &local_var_str
1628                    .into_iter()
1629                    .map(|p| ("name__nire".to_owned(), p.to_string()))
1630                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1631            ),
1632            _ => local_var_req_builder.query(&[(
1633                "name__nire",
1634                &local_var_str
1635                    .into_iter()
1636                    .map(|p| p.to_string())
1637                    .collect::<Vec<String>>()
1638                    .join(",")
1639                    .to_string(),
1640            )]),
1641        };
1642    }
1643    if let Some(ref local_var_str) = name__nisw {
1644        local_var_req_builder = match "multi" {
1645            "multi" => local_var_req_builder.query(
1646                &local_var_str
1647                    .into_iter()
1648                    .map(|p| ("name__nisw".to_owned(), p.to_string()))
1649                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1650            ),
1651            _ => local_var_req_builder.query(&[(
1652                "name__nisw",
1653                &local_var_str
1654                    .into_iter()
1655                    .map(|p| p.to_string())
1656                    .collect::<Vec<String>>()
1657                    .join(",")
1658                    .to_string(),
1659            )]),
1660        };
1661    }
1662    if let Some(ref local_var_str) = name__nre {
1663        local_var_req_builder = match "multi" {
1664            "multi" => local_var_req_builder.query(
1665                &local_var_str
1666                    .into_iter()
1667                    .map(|p| ("name__nre".to_owned(), p.to_string()))
1668                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1669            ),
1670            _ => local_var_req_builder.query(&[(
1671                "name__nre",
1672                &local_var_str
1673                    .into_iter()
1674                    .map(|p| p.to_string())
1675                    .collect::<Vec<String>>()
1676                    .join(",")
1677                    .to_string(),
1678            )]),
1679        };
1680    }
1681    if let Some(ref local_var_str) = name__re {
1682        local_var_req_builder = match "multi" {
1683            "multi" => local_var_req_builder.query(
1684                &local_var_str
1685                    .into_iter()
1686                    .map(|p| ("name__re".to_owned(), p.to_string()))
1687                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1688            ),
1689            _ => local_var_req_builder.query(&[(
1690                "name__re",
1691                &local_var_str
1692                    .into_iter()
1693                    .map(|p| p.to_string())
1694                    .collect::<Vec<String>>()
1695                    .join(",")
1696                    .to_string(),
1697            )]),
1698        };
1699    }
1700    if let Some(ref local_var_str) = offset {
1701        local_var_req_builder =
1702            local_var_req_builder.query(&[("offset", &local_var_str.to_string())]);
1703    }
1704    if let Some(ref local_var_str) = q {
1705        local_var_req_builder = local_var_req_builder.query(&[("q", &local_var_str.to_string())]);
1706    }
1707    if let Some(ref local_var_str) = sort {
1708        local_var_req_builder =
1709            local_var_req_builder.query(&[("sort", &local_var_str.to_string())]);
1710    }
1711    if let Some(ref local_var_str) = teams {
1712        local_var_req_builder = match "multi" {
1713            "multi" => local_var_req_builder.query(
1714                &local_var_str
1715                    .into_iter()
1716                    .map(|p| ("teams".to_owned(), p.to_string()))
1717                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1718            ),
1719            _ => local_var_req_builder.query(&[(
1720                "teams",
1721                &local_var_str
1722                    .into_iter()
1723                    .map(|p| p.to_string())
1724                    .collect::<Vec<String>>()
1725                    .join(",")
1726                    .to_string(),
1727            )]),
1728        };
1729    }
1730    if let Some(ref local_var_str) = teams__isnull {
1731        local_var_req_builder =
1732            local_var_req_builder.query(&[("teams__isnull", &local_var_str.to_string())]);
1733    }
1734    if let Some(ref local_var_str) = teams__n {
1735        local_var_req_builder = match "multi" {
1736            "multi" => local_var_req_builder.query(
1737                &local_var_str
1738                    .into_iter()
1739                    .map(|p| ("teams__n".to_owned(), p.to_string()))
1740                    .collect::<Vec<(std::string::String, std::string::String)>>(),
1741            ),
1742            _ => local_var_req_builder.query(&[(
1743                "teams__n",
1744                &local_var_str
1745                    .into_iter()
1746                    .map(|p| p.to_string())
1747                    .collect::<Vec<String>>()
1748                    .join(",")
1749                    .to_string(),
1750            )]),
1751        };
1752    }
1753    if let Some(ref local_var_str) = depth {
1754        local_var_req_builder =
1755            local_var_req_builder.query(&[("depth", &local_var_str.to_string())]);
1756    }
1757    if let Some(ref local_var_str) = exclude_m2m {
1758        local_var_req_builder =
1759            local_var_req_builder.query(&[("exclude_m2m", &local_var_str.to_string())]);
1760    }
1761    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
1762        local_var_req_builder =
1763            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
1764    }
1765    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
1766        let local_var_key = local_var_apikey.key.clone();
1767        let local_var_value = match local_var_apikey.prefix {
1768            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
1769            None => local_var_key,
1770        };
1771        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
1772    };
1773
1774    let local_var_req = local_var_req_builder.build()?;
1775    let local_var_resp = local_var_client.execute(local_var_req).await?;
1776
1777    let local_var_status = local_var_resp.status();
1778    let local_var_content = local_var_resp.text().await?;
1779
1780    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
1781        serde_json::from_str(&local_var_content).map_err(Error::from)
1782    } else {
1783        let local_var_entity: Option<VirtualizationClusterGroupsListError> =
1784            serde_json::from_str(&local_var_content).ok();
1785        let local_var_error = ResponseContent {
1786            status: local_var_status,
1787            content: local_var_content,
1788            entity: local_var_entity,
1789        };
1790        Err(Error::ResponseError(local_var_error))
1791    }
1792}
1793
1794/// API methods for returning or creating notes on an object.
1795pub async fn virtualization_cluster_groups_notes_create(
1796    configuration: &configuration::Configuration,
1797    id: &str,
1798    note_input_request: crate::models::NoteInputRequest,
1799    format: Option<&str>,
1800) -> Result<crate::models::Note, Error<VirtualizationClusterGroupsNotesCreateError>> {
1801    let local_var_configuration = configuration;
1802
1803    let local_var_client = &local_var_configuration.client;
1804
1805    let local_var_uri_str = format!(
1806        "{}/virtualization/cluster-groups/{id}/notes/",
1807        local_var_configuration.base_path,
1808        id = crate::apis::urlencode(id)
1809    );
1810    let mut local_var_req_builder =
1811        local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
1812
1813    if let Some(ref local_var_str) = format {
1814        local_var_req_builder =
1815            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
1816    }
1817    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
1818        local_var_req_builder =
1819            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
1820    }
1821    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
1822        let local_var_key = local_var_apikey.key.clone();
1823        let local_var_value = match local_var_apikey.prefix {
1824            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
1825            None => local_var_key,
1826        };
1827        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
1828    };
1829    local_var_req_builder = local_var_req_builder.json(&note_input_request);
1830
1831    let local_var_req = local_var_req_builder.build()?;
1832    let local_var_resp = local_var_client.execute(local_var_req).await?;
1833
1834    let local_var_status = local_var_resp.status();
1835    let local_var_content = local_var_resp.text().await?;
1836
1837    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
1838        serde_json::from_str(&local_var_content).map_err(Error::from)
1839    } else {
1840        let local_var_entity: Option<VirtualizationClusterGroupsNotesCreateError> =
1841            serde_json::from_str(&local_var_content).ok();
1842        let local_var_error = ResponseContent {
1843            status: local_var_status,
1844            content: local_var_content,
1845            entity: local_var_entity,
1846        };
1847        Err(Error::ResponseError(local_var_error))
1848    }
1849}
1850
1851/// API methods for returning or creating notes on an object.
1852pub async fn virtualization_cluster_groups_notes_list(
1853    configuration: &configuration::Configuration,
1854    id: &str,
1855    format: Option<&str>,
1856    limit: Option<i32>,
1857    offset: Option<i32>,
1858    depth: Option<i32>,
1859    exclude_m2m: Option<bool>,
1860) -> Result<crate::models::PaginatedNoteList, Error<VirtualizationClusterGroupsNotesListError>> {
1861    let local_var_configuration = configuration;
1862
1863    let local_var_client = &local_var_configuration.client;
1864
1865    let local_var_uri_str = format!(
1866        "{}/virtualization/cluster-groups/{id}/notes/",
1867        local_var_configuration.base_path,
1868        id = crate::apis::urlencode(id)
1869    );
1870    let mut local_var_req_builder =
1871        local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
1872
1873    if let Some(ref local_var_str) = format {
1874        local_var_req_builder =
1875            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
1876    }
1877    if let Some(ref local_var_str) = limit {
1878        local_var_req_builder =
1879            local_var_req_builder.query(&[("limit", &local_var_str.to_string())]);
1880    }
1881    if let Some(ref local_var_str) = offset {
1882        local_var_req_builder =
1883            local_var_req_builder.query(&[("offset", &local_var_str.to_string())]);
1884    }
1885    if let Some(ref local_var_str) = depth {
1886        local_var_req_builder =
1887            local_var_req_builder.query(&[("depth", &local_var_str.to_string())]);
1888    }
1889    if let Some(ref local_var_str) = exclude_m2m {
1890        local_var_req_builder =
1891            local_var_req_builder.query(&[("exclude_m2m", &local_var_str.to_string())]);
1892    }
1893    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
1894        local_var_req_builder =
1895            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
1896    }
1897    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
1898        let local_var_key = local_var_apikey.key.clone();
1899        let local_var_value = match local_var_apikey.prefix {
1900            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
1901            None => local_var_key,
1902        };
1903        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
1904    };
1905
1906    let local_var_req = local_var_req_builder.build()?;
1907    let local_var_resp = local_var_client.execute(local_var_req).await?;
1908
1909    let local_var_status = local_var_resp.status();
1910    let local_var_content = local_var_resp.text().await?;
1911
1912    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
1913        serde_json::from_str(&local_var_content).map_err(Error::from)
1914    } else {
1915        let local_var_entity: Option<VirtualizationClusterGroupsNotesListError> =
1916            serde_json::from_str(&local_var_content).ok();
1917        let local_var_error = ResponseContent {
1918            status: local_var_status,
1919            content: local_var_content,
1920            entity: local_var_entity,
1921        };
1922        Err(Error::ResponseError(local_var_error))
1923    }
1924}
1925
1926/// Partial update a cluster group object.
1927pub async fn virtualization_cluster_groups_partial_update(
1928    configuration: &configuration::Configuration,
1929    id: &str,
1930    format: Option<&str>,
1931    patched_cluster_group_request: Option<crate::models::PatchedClusterGroupRequest>,
1932) -> Result<crate::models::ClusterGroup, Error<VirtualizationClusterGroupsPartialUpdateError>> {
1933    let local_var_configuration = configuration;
1934
1935    let local_var_client = &local_var_configuration.client;
1936
1937    let local_var_uri_str = format!(
1938        "{}/virtualization/cluster-groups/{id}/",
1939        local_var_configuration.base_path,
1940        id = crate::apis::urlencode(id)
1941    );
1942    let mut local_var_req_builder =
1943        local_var_client.request(reqwest::Method::PATCH, local_var_uri_str.as_str());
1944
1945    if let Some(ref local_var_str) = format {
1946        local_var_req_builder =
1947            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
1948    }
1949    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
1950        local_var_req_builder =
1951            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
1952    }
1953    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
1954        let local_var_key = local_var_apikey.key.clone();
1955        let local_var_value = match local_var_apikey.prefix {
1956            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
1957            None => local_var_key,
1958        };
1959        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
1960    };
1961    local_var_req_builder = local_var_req_builder.json(&patched_cluster_group_request);
1962
1963    let local_var_req = local_var_req_builder.build()?;
1964    let local_var_resp = local_var_client.execute(local_var_req).await?;
1965
1966    let local_var_status = local_var_resp.status();
1967    let local_var_content = local_var_resp.text().await?;
1968
1969    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
1970        serde_json::from_str(&local_var_content).map_err(Error::from)
1971    } else {
1972        let local_var_entity: Option<VirtualizationClusterGroupsPartialUpdateError> =
1973            serde_json::from_str(&local_var_content).ok();
1974        let local_var_error = ResponseContent {
1975            status: local_var_status,
1976            content: local_var_content,
1977            entity: local_var_entity,
1978        };
1979        Err(Error::ResponseError(local_var_error))
1980    }
1981}
1982
1983/// Retrieve a cluster group object.
1984pub async fn virtualization_cluster_groups_retrieve(
1985    configuration: &configuration::Configuration,
1986    id: &str,
1987    format: Option<&str>,
1988    depth: Option<i32>,
1989    exclude_m2m: Option<bool>,
1990) -> Result<crate::models::ClusterGroup, Error<VirtualizationClusterGroupsRetrieveError>> {
1991    let local_var_configuration = configuration;
1992
1993    let local_var_client = &local_var_configuration.client;
1994
1995    let local_var_uri_str = format!(
1996        "{}/virtualization/cluster-groups/{id}/",
1997        local_var_configuration.base_path,
1998        id = crate::apis::urlencode(id)
1999    );
2000    let mut local_var_req_builder =
2001        local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
2002
2003    if let Some(ref local_var_str) = format {
2004        local_var_req_builder =
2005            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
2006    }
2007    if let Some(ref local_var_str) = depth {
2008        local_var_req_builder =
2009            local_var_req_builder.query(&[("depth", &local_var_str.to_string())]);
2010    }
2011    if let Some(ref local_var_str) = exclude_m2m {
2012        local_var_req_builder =
2013            local_var_req_builder.query(&[("exclude_m2m", &local_var_str.to_string())]);
2014    }
2015    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
2016        local_var_req_builder =
2017            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
2018    }
2019    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
2020        let local_var_key = local_var_apikey.key.clone();
2021        let local_var_value = match local_var_apikey.prefix {
2022            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
2023            None => local_var_key,
2024        };
2025        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
2026    };
2027
2028    let local_var_req = local_var_req_builder.build()?;
2029    let local_var_resp = local_var_client.execute(local_var_req).await?;
2030
2031    let local_var_status = local_var_resp.status();
2032    let local_var_content = local_var_resp.text().await?;
2033
2034    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
2035        serde_json::from_str(&local_var_content).map_err(Error::from)
2036    } else {
2037        let local_var_entity: Option<VirtualizationClusterGroupsRetrieveError> =
2038            serde_json::from_str(&local_var_content).ok();
2039        let local_var_error = ResponseContent {
2040            status: local_var_status,
2041            content: local_var_content,
2042            entity: local_var_entity,
2043        };
2044        Err(Error::ResponseError(local_var_error))
2045    }
2046}
2047
2048/// Update a cluster group object.
2049pub async fn virtualization_cluster_groups_update(
2050    configuration: &configuration::Configuration,
2051    id: &str,
2052    cluster_group_request: crate::models::ClusterGroupRequest,
2053    format: Option<&str>,
2054) -> Result<crate::models::ClusterGroup, Error<VirtualizationClusterGroupsUpdateError>> {
2055    let local_var_configuration = configuration;
2056
2057    let local_var_client = &local_var_configuration.client;
2058
2059    let local_var_uri_str = format!(
2060        "{}/virtualization/cluster-groups/{id}/",
2061        local_var_configuration.base_path,
2062        id = crate::apis::urlencode(id)
2063    );
2064    let mut local_var_req_builder =
2065        local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());
2066
2067    if let Some(ref local_var_str) = format {
2068        local_var_req_builder =
2069            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
2070    }
2071    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
2072        local_var_req_builder =
2073            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
2074    }
2075    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
2076        let local_var_key = local_var_apikey.key.clone();
2077        let local_var_value = match local_var_apikey.prefix {
2078            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
2079            None => local_var_key,
2080        };
2081        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
2082    };
2083    local_var_req_builder = local_var_req_builder.json(&cluster_group_request);
2084
2085    let local_var_req = local_var_req_builder.build()?;
2086    let local_var_resp = local_var_client.execute(local_var_req).await?;
2087
2088    let local_var_status = local_var_resp.status();
2089    let local_var_content = local_var_resp.text().await?;
2090
2091    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
2092        serde_json::from_str(&local_var_content).map_err(Error::from)
2093    } else {
2094        let local_var_entity: Option<VirtualizationClusterGroupsUpdateError> =
2095            serde_json::from_str(&local_var_content).ok();
2096        let local_var_error = ResponseContent {
2097            status: local_var_status,
2098            content: local_var_content,
2099            entity: local_var_entity,
2100        };
2101        Err(Error::ResponseError(local_var_error))
2102    }
2103}
2104
2105/// Destroy a list of cluster type objects.
2106pub async fn virtualization_cluster_types_bulk_destroy(
2107    configuration: &configuration::Configuration,
2108    bulk_operation_request: Vec<crate::models::BulkOperationRequest>,
2109    format: Option<&str>,
2110) -> Result<(), Error<VirtualizationClusterTypesBulkDestroyError>> {
2111    let local_var_configuration = configuration;
2112
2113    let local_var_client = &local_var_configuration.client;
2114
2115    let local_var_uri_str = format!(
2116        "{}/virtualization/cluster-types/",
2117        local_var_configuration.base_path
2118    );
2119    let mut local_var_req_builder =
2120        local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());
2121
2122    if let Some(ref local_var_str) = format {
2123        local_var_req_builder =
2124            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
2125    }
2126    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
2127        local_var_req_builder =
2128            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
2129    }
2130    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
2131        let local_var_key = local_var_apikey.key.clone();
2132        let local_var_value = match local_var_apikey.prefix {
2133            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
2134            None => local_var_key,
2135        };
2136        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
2137    };
2138    local_var_req_builder = local_var_req_builder.json(&bulk_operation_request);
2139
2140    let local_var_req = local_var_req_builder.build()?;
2141    let local_var_resp = local_var_client.execute(local_var_req).await?;
2142
2143    let local_var_status = local_var_resp.status();
2144    let local_var_content = local_var_resp.text().await?;
2145
2146    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
2147        Ok(())
2148    } else {
2149        let local_var_entity: Option<VirtualizationClusterTypesBulkDestroyError> =
2150            serde_json::from_str(&local_var_content).ok();
2151        let local_var_error = ResponseContent {
2152            status: local_var_status,
2153            content: local_var_content,
2154            entity: local_var_entity,
2155        };
2156        Err(Error::ResponseError(local_var_error))
2157    }
2158}
2159
2160/// Partial update a list of cluster type objects.
2161pub async fn virtualization_cluster_types_bulk_partial_update(
2162    configuration: &configuration::Configuration,
2163    patched_bulk_writable_cluster_type_request: Vec<
2164        crate::models::PatchedBulkWritableClusterTypeRequest,
2165    >,
2166    format: Option<&str>,
2167) -> Result<Vec<crate::models::ClusterType>, Error<VirtualizationClusterTypesBulkPartialUpdateError>>
2168{
2169    let local_var_configuration = configuration;
2170
2171    let local_var_client = &local_var_configuration.client;
2172
2173    let local_var_uri_str = format!(
2174        "{}/virtualization/cluster-types/",
2175        local_var_configuration.base_path
2176    );
2177    let mut local_var_req_builder =
2178        local_var_client.request(reqwest::Method::PATCH, local_var_uri_str.as_str());
2179
2180    if let Some(ref local_var_str) = format {
2181        local_var_req_builder =
2182            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
2183    }
2184    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
2185        local_var_req_builder =
2186            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
2187    }
2188    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
2189        let local_var_key = local_var_apikey.key.clone();
2190        let local_var_value = match local_var_apikey.prefix {
2191            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
2192            None => local_var_key,
2193        };
2194        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
2195    };
2196    local_var_req_builder = local_var_req_builder.json(&patched_bulk_writable_cluster_type_request);
2197
2198    let local_var_req = local_var_req_builder.build()?;
2199    let local_var_resp = local_var_client.execute(local_var_req).await?;
2200
2201    let local_var_status = local_var_resp.status();
2202    let local_var_content = local_var_resp.text().await?;
2203
2204    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
2205        serde_json::from_str(&local_var_content).map_err(Error::from)
2206    } else {
2207        let local_var_entity: Option<VirtualizationClusterTypesBulkPartialUpdateError> =
2208            serde_json::from_str(&local_var_content).ok();
2209        let local_var_error = ResponseContent {
2210            status: local_var_status,
2211            content: local_var_content,
2212            entity: local_var_entity,
2213        };
2214        Err(Error::ResponseError(local_var_error))
2215    }
2216}
2217
2218/// Update a list of cluster type objects.
2219pub async fn virtualization_cluster_types_bulk_update(
2220    configuration: &configuration::Configuration,
2221    bulk_writable_cluster_type_request: Vec<crate::models::BulkWritableClusterTypeRequest>,
2222    format: Option<&str>,
2223) -> Result<Vec<crate::models::ClusterType>, Error<VirtualizationClusterTypesBulkUpdateError>> {
2224    let local_var_configuration = configuration;
2225
2226    let local_var_client = &local_var_configuration.client;
2227
2228    let local_var_uri_str = format!(
2229        "{}/virtualization/cluster-types/",
2230        local_var_configuration.base_path
2231    );
2232    let mut local_var_req_builder =
2233        local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());
2234
2235    if let Some(ref local_var_str) = format {
2236        local_var_req_builder =
2237            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
2238    }
2239    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
2240        local_var_req_builder =
2241            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
2242    }
2243    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
2244        let local_var_key = local_var_apikey.key.clone();
2245        let local_var_value = match local_var_apikey.prefix {
2246            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
2247            None => local_var_key,
2248        };
2249        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
2250    };
2251    local_var_req_builder = local_var_req_builder.json(&bulk_writable_cluster_type_request);
2252
2253    let local_var_req = local_var_req_builder.build()?;
2254    let local_var_resp = local_var_client.execute(local_var_req).await?;
2255
2256    let local_var_status = local_var_resp.status();
2257    let local_var_content = local_var_resp.text().await?;
2258
2259    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
2260        serde_json::from_str(&local_var_content).map_err(Error::from)
2261    } else {
2262        let local_var_entity: Option<VirtualizationClusterTypesBulkUpdateError> =
2263            serde_json::from_str(&local_var_content).ok();
2264        let local_var_error = ResponseContent {
2265            status: local_var_status,
2266            content: local_var_content,
2267            entity: local_var_entity,
2268        };
2269        Err(Error::ResponseError(local_var_error))
2270    }
2271}
2272
2273/// Create one or more cluster type objects.
2274pub async fn virtualization_cluster_types_create(
2275    configuration: &configuration::Configuration,
2276    cluster_type_request: crate::models::ClusterTypeRequest,
2277    format: Option<&str>,
2278) -> Result<crate::models::ClusterType, Error<VirtualizationClusterTypesCreateError>> {
2279    let local_var_configuration = configuration;
2280
2281    let local_var_client = &local_var_configuration.client;
2282
2283    let local_var_uri_str = format!(
2284        "{}/virtualization/cluster-types/",
2285        local_var_configuration.base_path
2286    );
2287    let mut local_var_req_builder =
2288        local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
2289
2290    if let Some(ref local_var_str) = format {
2291        local_var_req_builder =
2292            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
2293    }
2294    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
2295        local_var_req_builder =
2296            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
2297    }
2298    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
2299        let local_var_key = local_var_apikey.key.clone();
2300        let local_var_value = match local_var_apikey.prefix {
2301            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
2302            None => local_var_key,
2303        };
2304        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
2305    };
2306    local_var_req_builder = local_var_req_builder.json(&cluster_type_request);
2307
2308    let local_var_req = local_var_req_builder.build()?;
2309    let local_var_resp = local_var_client.execute(local_var_req).await?;
2310
2311    let local_var_status = local_var_resp.status();
2312    let local_var_content = local_var_resp.text().await?;
2313
2314    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
2315        serde_json::from_str(&local_var_content).map_err(Error::from)
2316    } else {
2317        let local_var_entity: Option<VirtualizationClusterTypesCreateError> =
2318            serde_json::from_str(&local_var_content).ok();
2319        let local_var_error = ResponseContent {
2320            status: local_var_status,
2321            content: local_var_content,
2322            entity: local_var_entity,
2323        };
2324        Err(Error::ResponseError(local_var_error))
2325    }
2326}
2327
2328/// Destroy a cluster type object.
2329pub async fn virtualization_cluster_types_destroy(
2330    configuration: &configuration::Configuration,
2331    id: &str,
2332    format: Option<&str>,
2333) -> Result<(), Error<VirtualizationClusterTypesDestroyError>> {
2334    let local_var_configuration = configuration;
2335
2336    let local_var_client = &local_var_configuration.client;
2337
2338    let local_var_uri_str = format!(
2339        "{}/virtualization/cluster-types/{id}/",
2340        local_var_configuration.base_path,
2341        id = crate::apis::urlencode(id)
2342    );
2343    let mut local_var_req_builder =
2344        local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());
2345
2346    if let Some(ref local_var_str) = format {
2347        local_var_req_builder =
2348            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
2349    }
2350    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
2351        local_var_req_builder =
2352            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
2353    }
2354    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
2355        let local_var_key = local_var_apikey.key.clone();
2356        let local_var_value = match local_var_apikey.prefix {
2357            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
2358            None => local_var_key,
2359        };
2360        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
2361    };
2362
2363    let local_var_req = local_var_req_builder.build()?;
2364    let local_var_resp = local_var_client.execute(local_var_req).await?;
2365
2366    let local_var_status = local_var_resp.status();
2367    let local_var_content = local_var_resp.text().await?;
2368
2369    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
2370        Ok(())
2371    } else {
2372        let local_var_entity: Option<VirtualizationClusterTypesDestroyError> =
2373            serde_json::from_str(&local_var_content).ok();
2374        let local_var_error = ResponseContent {
2375            status: local_var_status,
2376            content: local_var_content,
2377            entity: local_var_entity,
2378        };
2379        Err(Error::ResponseError(local_var_error))
2380    }
2381}
2382
2383/// Retrieve a list of cluster type objects.
2384pub async fn virtualization_cluster_types_list(
2385    configuration: &configuration::Configuration,
2386    clusters: Option<Vec<String>>,
2387    clusters__isnull: Option<bool>,
2388    clusters__n: Option<Vec<String>>,
2389    contacts: Option<Vec<String>>,
2390    contacts__isnull: Option<bool>,
2391    contacts__n: Option<Vec<String>>,
2392    created: Option<Vec<String>>,
2393    created__gt: Option<Vec<String>>,
2394    created__gte: Option<Vec<String>>,
2395    created__isnull: Option<bool>,
2396    created__lt: Option<Vec<String>>,
2397    created__lte: Option<Vec<String>>,
2398    created__n: Option<Vec<String>>,
2399    description: Option<Vec<String>>,
2400    description__ic: Option<Vec<String>>,
2401    description__ie: Option<Vec<String>>,
2402    description__iew: Option<Vec<String>>,
2403    description__ire: Option<Vec<String>>,
2404    description__isw: Option<Vec<String>>,
2405    description__n: Option<Vec<String>>,
2406    description__nic: Option<Vec<String>>,
2407    description__nie: Option<Vec<String>>,
2408    description__niew: Option<Vec<String>>,
2409    description__nire: Option<Vec<String>>,
2410    description__nisw: Option<Vec<String>>,
2411    description__nre: Option<Vec<String>>,
2412    description__re: Option<Vec<String>>,
2413    dynamic_groups: Option<Vec<String>>,
2414    dynamic_groups__n: Option<Vec<String>>,
2415    format: Option<&str>,
2416    has_clusters: Option<bool>,
2417    id: Option<Vec<uuid::Uuid>>,
2418    id__n: Option<Vec<uuid::Uuid>>,
2419    last_updated: Option<Vec<String>>,
2420    last_updated__gt: Option<Vec<String>>,
2421    last_updated__gte: Option<Vec<String>>,
2422    last_updated__isnull: Option<bool>,
2423    last_updated__lt: Option<Vec<String>>,
2424    last_updated__lte: Option<Vec<String>>,
2425    last_updated__n: Option<Vec<String>>,
2426    limit: Option<i32>,
2427    name: Option<Vec<String>>,
2428    name__ic: Option<Vec<String>>,
2429    name__ie: Option<Vec<String>>,
2430    name__iew: Option<Vec<String>>,
2431    name__ire: Option<Vec<String>>,
2432    name__isw: Option<Vec<String>>,
2433    name__n: Option<Vec<String>>,
2434    name__nic: Option<Vec<String>>,
2435    name__nie: Option<Vec<String>>,
2436    name__niew: Option<Vec<String>>,
2437    name__nire: Option<Vec<String>>,
2438    name__nisw: Option<Vec<String>>,
2439    name__nre: Option<Vec<String>>,
2440    name__re: Option<Vec<String>>,
2441    offset: Option<i32>,
2442    q: Option<&str>,
2443    sort: Option<&str>,
2444    teams: Option<Vec<String>>,
2445    teams__isnull: Option<bool>,
2446    teams__n: Option<Vec<String>>,
2447    depth: Option<i32>,
2448    exclude_m2m: Option<bool>,
2449) -> Result<crate::models::PaginatedClusterTypeList, Error<VirtualizationClusterTypesListError>> {
2450    let local_var_configuration = configuration;
2451
2452    let local_var_client = &local_var_configuration.client;
2453
2454    let local_var_uri_str = format!(
2455        "{}/virtualization/cluster-types/",
2456        local_var_configuration.base_path
2457    );
2458    let mut local_var_req_builder =
2459        local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
2460
2461    if let Some(ref local_var_str) = clusters {
2462        local_var_req_builder = match "multi" {
2463            "multi" => local_var_req_builder.query(
2464                &local_var_str
2465                    .into_iter()
2466                    .map(|p| ("clusters".to_owned(), p.to_string()))
2467                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2468            ),
2469            _ => local_var_req_builder.query(&[(
2470                "clusters",
2471                &local_var_str
2472                    .into_iter()
2473                    .map(|p| p.to_string())
2474                    .collect::<Vec<String>>()
2475                    .join(",")
2476                    .to_string(),
2477            )]),
2478        };
2479    }
2480    if let Some(ref local_var_str) = clusters__isnull {
2481        local_var_req_builder =
2482            local_var_req_builder.query(&[("clusters__isnull", &local_var_str.to_string())]);
2483    }
2484    if let Some(ref local_var_str) = clusters__n {
2485        local_var_req_builder = match "multi" {
2486            "multi" => local_var_req_builder.query(
2487                &local_var_str
2488                    .into_iter()
2489                    .map(|p| ("clusters__n".to_owned(), p.to_string()))
2490                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2491            ),
2492            _ => local_var_req_builder.query(&[(
2493                "clusters__n",
2494                &local_var_str
2495                    .into_iter()
2496                    .map(|p| p.to_string())
2497                    .collect::<Vec<String>>()
2498                    .join(",")
2499                    .to_string(),
2500            )]),
2501        };
2502    }
2503    if let Some(ref local_var_str) = contacts {
2504        local_var_req_builder = match "multi" {
2505            "multi" => local_var_req_builder.query(
2506                &local_var_str
2507                    .into_iter()
2508                    .map(|p| ("contacts".to_owned(), p.to_string()))
2509                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2510            ),
2511            _ => local_var_req_builder.query(&[(
2512                "contacts",
2513                &local_var_str
2514                    .into_iter()
2515                    .map(|p| p.to_string())
2516                    .collect::<Vec<String>>()
2517                    .join(",")
2518                    .to_string(),
2519            )]),
2520        };
2521    }
2522    if let Some(ref local_var_str) = contacts__isnull {
2523        local_var_req_builder =
2524            local_var_req_builder.query(&[("contacts__isnull", &local_var_str.to_string())]);
2525    }
2526    if let Some(ref local_var_str) = contacts__n {
2527        local_var_req_builder = match "multi" {
2528            "multi" => local_var_req_builder.query(
2529                &local_var_str
2530                    .into_iter()
2531                    .map(|p| ("contacts__n".to_owned(), p.to_string()))
2532                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2533            ),
2534            _ => local_var_req_builder.query(&[(
2535                "contacts__n",
2536                &local_var_str
2537                    .into_iter()
2538                    .map(|p| p.to_string())
2539                    .collect::<Vec<String>>()
2540                    .join(",")
2541                    .to_string(),
2542            )]),
2543        };
2544    }
2545    if let Some(ref local_var_str) = created {
2546        local_var_req_builder = match "multi" {
2547            "multi" => local_var_req_builder.query(
2548                &local_var_str
2549                    .into_iter()
2550                    .map(|p| ("created".to_owned(), p.to_string()))
2551                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2552            ),
2553            _ => local_var_req_builder.query(&[(
2554                "created",
2555                &local_var_str
2556                    .into_iter()
2557                    .map(|p| p.to_string())
2558                    .collect::<Vec<String>>()
2559                    .join(",")
2560                    .to_string(),
2561            )]),
2562        };
2563    }
2564    if let Some(ref local_var_str) = created__gt {
2565        local_var_req_builder = match "multi" {
2566            "multi" => local_var_req_builder.query(
2567                &local_var_str
2568                    .into_iter()
2569                    .map(|p| ("created__gt".to_owned(), p.to_string()))
2570                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2571            ),
2572            _ => local_var_req_builder.query(&[(
2573                "created__gt",
2574                &local_var_str
2575                    .into_iter()
2576                    .map(|p| p.to_string())
2577                    .collect::<Vec<String>>()
2578                    .join(",")
2579                    .to_string(),
2580            )]),
2581        };
2582    }
2583    if let Some(ref local_var_str) = created__gte {
2584        local_var_req_builder = match "multi" {
2585            "multi" => local_var_req_builder.query(
2586                &local_var_str
2587                    .into_iter()
2588                    .map(|p| ("created__gte".to_owned(), p.to_string()))
2589                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2590            ),
2591            _ => local_var_req_builder.query(&[(
2592                "created__gte",
2593                &local_var_str
2594                    .into_iter()
2595                    .map(|p| p.to_string())
2596                    .collect::<Vec<String>>()
2597                    .join(",")
2598                    .to_string(),
2599            )]),
2600        };
2601    }
2602    if let Some(ref local_var_str) = created__isnull {
2603        local_var_req_builder =
2604            local_var_req_builder.query(&[("created__isnull", &local_var_str.to_string())]);
2605    }
2606    if let Some(ref local_var_str) = created__lt {
2607        local_var_req_builder = match "multi" {
2608            "multi" => local_var_req_builder.query(
2609                &local_var_str
2610                    .into_iter()
2611                    .map(|p| ("created__lt".to_owned(), p.to_string()))
2612                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2613            ),
2614            _ => local_var_req_builder.query(&[(
2615                "created__lt",
2616                &local_var_str
2617                    .into_iter()
2618                    .map(|p| p.to_string())
2619                    .collect::<Vec<String>>()
2620                    .join(",")
2621                    .to_string(),
2622            )]),
2623        };
2624    }
2625    if let Some(ref local_var_str) = created__lte {
2626        local_var_req_builder = match "multi" {
2627            "multi" => local_var_req_builder.query(
2628                &local_var_str
2629                    .into_iter()
2630                    .map(|p| ("created__lte".to_owned(), p.to_string()))
2631                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2632            ),
2633            _ => local_var_req_builder.query(&[(
2634                "created__lte",
2635                &local_var_str
2636                    .into_iter()
2637                    .map(|p| p.to_string())
2638                    .collect::<Vec<String>>()
2639                    .join(",")
2640                    .to_string(),
2641            )]),
2642        };
2643    }
2644    if let Some(ref local_var_str) = created__n {
2645        local_var_req_builder = match "multi" {
2646            "multi" => local_var_req_builder.query(
2647                &local_var_str
2648                    .into_iter()
2649                    .map(|p| ("created__n".to_owned(), p.to_string()))
2650                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2651            ),
2652            _ => local_var_req_builder.query(&[(
2653                "created__n",
2654                &local_var_str
2655                    .into_iter()
2656                    .map(|p| p.to_string())
2657                    .collect::<Vec<String>>()
2658                    .join(",")
2659                    .to_string(),
2660            )]),
2661        };
2662    }
2663    if let Some(ref local_var_str) = description {
2664        local_var_req_builder = match "multi" {
2665            "multi" => local_var_req_builder.query(
2666                &local_var_str
2667                    .into_iter()
2668                    .map(|p| ("description".to_owned(), p.to_string()))
2669                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2670            ),
2671            _ => local_var_req_builder.query(&[(
2672                "description",
2673                &local_var_str
2674                    .into_iter()
2675                    .map(|p| p.to_string())
2676                    .collect::<Vec<String>>()
2677                    .join(",")
2678                    .to_string(),
2679            )]),
2680        };
2681    }
2682    if let Some(ref local_var_str) = description__ic {
2683        local_var_req_builder = match "multi" {
2684            "multi" => local_var_req_builder.query(
2685                &local_var_str
2686                    .into_iter()
2687                    .map(|p| ("description__ic".to_owned(), p.to_string()))
2688                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2689            ),
2690            _ => local_var_req_builder.query(&[(
2691                "description__ic",
2692                &local_var_str
2693                    .into_iter()
2694                    .map(|p| p.to_string())
2695                    .collect::<Vec<String>>()
2696                    .join(",")
2697                    .to_string(),
2698            )]),
2699        };
2700    }
2701    if let Some(ref local_var_str) = description__ie {
2702        local_var_req_builder = match "multi" {
2703            "multi" => local_var_req_builder.query(
2704                &local_var_str
2705                    .into_iter()
2706                    .map(|p| ("description__ie".to_owned(), p.to_string()))
2707                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2708            ),
2709            _ => local_var_req_builder.query(&[(
2710                "description__ie",
2711                &local_var_str
2712                    .into_iter()
2713                    .map(|p| p.to_string())
2714                    .collect::<Vec<String>>()
2715                    .join(",")
2716                    .to_string(),
2717            )]),
2718        };
2719    }
2720    if let Some(ref local_var_str) = description__iew {
2721        local_var_req_builder = match "multi" {
2722            "multi" => local_var_req_builder.query(
2723                &local_var_str
2724                    .into_iter()
2725                    .map(|p| ("description__iew".to_owned(), p.to_string()))
2726                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2727            ),
2728            _ => local_var_req_builder.query(&[(
2729                "description__iew",
2730                &local_var_str
2731                    .into_iter()
2732                    .map(|p| p.to_string())
2733                    .collect::<Vec<String>>()
2734                    .join(",")
2735                    .to_string(),
2736            )]),
2737        };
2738    }
2739    if let Some(ref local_var_str) = description__ire {
2740        local_var_req_builder = match "multi" {
2741            "multi" => local_var_req_builder.query(
2742                &local_var_str
2743                    .into_iter()
2744                    .map(|p| ("description__ire".to_owned(), p.to_string()))
2745                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2746            ),
2747            _ => local_var_req_builder.query(&[(
2748                "description__ire",
2749                &local_var_str
2750                    .into_iter()
2751                    .map(|p| p.to_string())
2752                    .collect::<Vec<String>>()
2753                    .join(",")
2754                    .to_string(),
2755            )]),
2756        };
2757    }
2758    if let Some(ref local_var_str) = description__isw {
2759        local_var_req_builder = match "multi" {
2760            "multi" => local_var_req_builder.query(
2761                &local_var_str
2762                    .into_iter()
2763                    .map(|p| ("description__isw".to_owned(), p.to_string()))
2764                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2765            ),
2766            _ => local_var_req_builder.query(&[(
2767                "description__isw",
2768                &local_var_str
2769                    .into_iter()
2770                    .map(|p| p.to_string())
2771                    .collect::<Vec<String>>()
2772                    .join(",")
2773                    .to_string(),
2774            )]),
2775        };
2776    }
2777    if let Some(ref local_var_str) = description__n {
2778        local_var_req_builder = match "multi" {
2779            "multi" => local_var_req_builder.query(
2780                &local_var_str
2781                    .into_iter()
2782                    .map(|p| ("description__n".to_owned(), p.to_string()))
2783                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2784            ),
2785            _ => local_var_req_builder.query(&[(
2786                "description__n",
2787                &local_var_str
2788                    .into_iter()
2789                    .map(|p| p.to_string())
2790                    .collect::<Vec<String>>()
2791                    .join(",")
2792                    .to_string(),
2793            )]),
2794        };
2795    }
2796    if let Some(ref local_var_str) = description__nic {
2797        local_var_req_builder = match "multi" {
2798            "multi" => local_var_req_builder.query(
2799                &local_var_str
2800                    .into_iter()
2801                    .map(|p| ("description__nic".to_owned(), p.to_string()))
2802                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2803            ),
2804            _ => local_var_req_builder.query(&[(
2805                "description__nic",
2806                &local_var_str
2807                    .into_iter()
2808                    .map(|p| p.to_string())
2809                    .collect::<Vec<String>>()
2810                    .join(",")
2811                    .to_string(),
2812            )]),
2813        };
2814    }
2815    if let Some(ref local_var_str) = description__nie {
2816        local_var_req_builder = match "multi" {
2817            "multi" => local_var_req_builder.query(
2818                &local_var_str
2819                    .into_iter()
2820                    .map(|p| ("description__nie".to_owned(), p.to_string()))
2821                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2822            ),
2823            _ => local_var_req_builder.query(&[(
2824                "description__nie",
2825                &local_var_str
2826                    .into_iter()
2827                    .map(|p| p.to_string())
2828                    .collect::<Vec<String>>()
2829                    .join(",")
2830                    .to_string(),
2831            )]),
2832        };
2833    }
2834    if let Some(ref local_var_str) = description__niew {
2835        local_var_req_builder = match "multi" {
2836            "multi" => local_var_req_builder.query(
2837                &local_var_str
2838                    .into_iter()
2839                    .map(|p| ("description__niew".to_owned(), p.to_string()))
2840                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2841            ),
2842            _ => local_var_req_builder.query(&[(
2843                "description__niew",
2844                &local_var_str
2845                    .into_iter()
2846                    .map(|p| p.to_string())
2847                    .collect::<Vec<String>>()
2848                    .join(",")
2849                    .to_string(),
2850            )]),
2851        };
2852    }
2853    if let Some(ref local_var_str) = description__nire {
2854        local_var_req_builder = match "multi" {
2855            "multi" => local_var_req_builder.query(
2856                &local_var_str
2857                    .into_iter()
2858                    .map(|p| ("description__nire".to_owned(), p.to_string()))
2859                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2860            ),
2861            _ => local_var_req_builder.query(&[(
2862                "description__nire",
2863                &local_var_str
2864                    .into_iter()
2865                    .map(|p| p.to_string())
2866                    .collect::<Vec<String>>()
2867                    .join(",")
2868                    .to_string(),
2869            )]),
2870        };
2871    }
2872    if let Some(ref local_var_str) = description__nisw {
2873        local_var_req_builder = match "multi" {
2874            "multi" => local_var_req_builder.query(
2875                &local_var_str
2876                    .into_iter()
2877                    .map(|p| ("description__nisw".to_owned(), p.to_string()))
2878                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2879            ),
2880            _ => local_var_req_builder.query(&[(
2881                "description__nisw",
2882                &local_var_str
2883                    .into_iter()
2884                    .map(|p| p.to_string())
2885                    .collect::<Vec<String>>()
2886                    .join(",")
2887                    .to_string(),
2888            )]),
2889        };
2890    }
2891    if let Some(ref local_var_str) = description__nre {
2892        local_var_req_builder = match "multi" {
2893            "multi" => local_var_req_builder.query(
2894                &local_var_str
2895                    .into_iter()
2896                    .map(|p| ("description__nre".to_owned(), p.to_string()))
2897                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2898            ),
2899            _ => local_var_req_builder.query(&[(
2900                "description__nre",
2901                &local_var_str
2902                    .into_iter()
2903                    .map(|p| p.to_string())
2904                    .collect::<Vec<String>>()
2905                    .join(",")
2906                    .to_string(),
2907            )]),
2908        };
2909    }
2910    if let Some(ref local_var_str) = description__re {
2911        local_var_req_builder = match "multi" {
2912            "multi" => local_var_req_builder.query(
2913                &local_var_str
2914                    .into_iter()
2915                    .map(|p| ("description__re".to_owned(), p.to_string()))
2916                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2917            ),
2918            _ => local_var_req_builder.query(&[(
2919                "description__re",
2920                &local_var_str
2921                    .into_iter()
2922                    .map(|p| p.to_string())
2923                    .collect::<Vec<String>>()
2924                    .join(",")
2925                    .to_string(),
2926            )]),
2927        };
2928    }
2929    if let Some(ref local_var_str) = dynamic_groups {
2930        local_var_req_builder = match "multi" {
2931            "multi" => local_var_req_builder.query(
2932                &local_var_str
2933                    .into_iter()
2934                    .map(|p| ("dynamic_groups".to_owned(), p.to_string()))
2935                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2936            ),
2937            _ => local_var_req_builder.query(&[(
2938                "dynamic_groups",
2939                &local_var_str
2940                    .into_iter()
2941                    .map(|p| p.to_string())
2942                    .collect::<Vec<String>>()
2943                    .join(",")
2944                    .to_string(),
2945            )]),
2946        };
2947    }
2948    if let Some(ref local_var_str) = dynamic_groups__n {
2949        local_var_req_builder = match "multi" {
2950            "multi" => local_var_req_builder.query(
2951                &local_var_str
2952                    .into_iter()
2953                    .map(|p| ("dynamic_groups__n".to_owned(), p.to_string()))
2954                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2955            ),
2956            _ => local_var_req_builder.query(&[(
2957                "dynamic_groups__n",
2958                &local_var_str
2959                    .into_iter()
2960                    .map(|p| p.to_string())
2961                    .collect::<Vec<String>>()
2962                    .join(",")
2963                    .to_string(),
2964            )]),
2965        };
2966    }
2967    if let Some(ref local_var_str) = format {
2968        local_var_req_builder =
2969            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
2970    }
2971    if let Some(ref local_var_str) = has_clusters {
2972        local_var_req_builder =
2973            local_var_req_builder.query(&[("has_clusters", &local_var_str.to_string())]);
2974    }
2975    if let Some(ref local_var_str) = id {
2976        local_var_req_builder = match "multi" {
2977            "multi" => local_var_req_builder.query(
2978                &local_var_str
2979                    .into_iter()
2980                    .map(|p| ("id".to_owned(), p.to_string()))
2981                    .collect::<Vec<(std::string::String, std::string::String)>>(),
2982            ),
2983            _ => local_var_req_builder.query(&[(
2984                "id",
2985                &local_var_str
2986                    .into_iter()
2987                    .map(|p| p.to_string())
2988                    .collect::<Vec<String>>()
2989                    .join(",")
2990                    .to_string(),
2991            )]),
2992        };
2993    }
2994    if let Some(ref local_var_str) = id__n {
2995        local_var_req_builder = match "multi" {
2996            "multi" => local_var_req_builder.query(
2997                &local_var_str
2998                    .into_iter()
2999                    .map(|p| ("id__n".to_owned(), p.to_string()))
3000                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3001            ),
3002            _ => local_var_req_builder.query(&[(
3003                "id__n",
3004                &local_var_str
3005                    .into_iter()
3006                    .map(|p| p.to_string())
3007                    .collect::<Vec<String>>()
3008                    .join(",")
3009                    .to_string(),
3010            )]),
3011        };
3012    }
3013    if let Some(ref local_var_str) = last_updated {
3014        local_var_req_builder = match "multi" {
3015            "multi" => local_var_req_builder.query(
3016                &local_var_str
3017                    .into_iter()
3018                    .map(|p| ("last_updated".to_owned(), p.to_string()))
3019                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3020            ),
3021            _ => local_var_req_builder.query(&[(
3022                "last_updated",
3023                &local_var_str
3024                    .into_iter()
3025                    .map(|p| p.to_string())
3026                    .collect::<Vec<String>>()
3027                    .join(",")
3028                    .to_string(),
3029            )]),
3030        };
3031    }
3032    if let Some(ref local_var_str) = last_updated__gt {
3033        local_var_req_builder = match "multi" {
3034            "multi" => local_var_req_builder.query(
3035                &local_var_str
3036                    .into_iter()
3037                    .map(|p| ("last_updated__gt".to_owned(), p.to_string()))
3038                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3039            ),
3040            _ => local_var_req_builder.query(&[(
3041                "last_updated__gt",
3042                &local_var_str
3043                    .into_iter()
3044                    .map(|p| p.to_string())
3045                    .collect::<Vec<String>>()
3046                    .join(",")
3047                    .to_string(),
3048            )]),
3049        };
3050    }
3051    if let Some(ref local_var_str) = last_updated__gte {
3052        local_var_req_builder = match "multi" {
3053            "multi" => local_var_req_builder.query(
3054                &local_var_str
3055                    .into_iter()
3056                    .map(|p| ("last_updated__gte".to_owned(), p.to_string()))
3057                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3058            ),
3059            _ => local_var_req_builder.query(&[(
3060                "last_updated__gte",
3061                &local_var_str
3062                    .into_iter()
3063                    .map(|p| p.to_string())
3064                    .collect::<Vec<String>>()
3065                    .join(",")
3066                    .to_string(),
3067            )]),
3068        };
3069    }
3070    if let Some(ref local_var_str) = last_updated__isnull {
3071        local_var_req_builder =
3072            local_var_req_builder.query(&[("last_updated__isnull", &local_var_str.to_string())]);
3073    }
3074    if let Some(ref local_var_str) = last_updated__lt {
3075        local_var_req_builder = match "multi" {
3076            "multi" => local_var_req_builder.query(
3077                &local_var_str
3078                    .into_iter()
3079                    .map(|p| ("last_updated__lt".to_owned(), p.to_string()))
3080                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3081            ),
3082            _ => local_var_req_builder.query(&[(
3083                "last_updated__lt",
3084                &local_var_str
3085                    .into_iter()
3086                    .map(|p| p.to_string())
3087                    .collect::<Vec<String>>()
3088                    .join(",")
3089                    .to_string(),
3090            )]),
3091        };
3092    }
3093    if let Some(ref local_var_str) = last_updated__lte {
3094        local_var_req_builder = match "multi" {
3095            "multi" => local_var_req_builder.query(
3096                &local_var_str
3097                    .into_iter()
3098                    .map(|p| ("last_updated__lte".to_owned(), p.to_string()))
3099                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3100            ),
3101            _ => local_var_req_builder.query(&[(
3102                "last_updated__lte",
3103                &local_var_str
3104                    .into_iter()
3105                    .map(|p| p.to_string())
3106                    .collect::<Vec<String>>()
3107                    .join(",")
3108                    .to_string(),
3109            )]),
3110        };
3111    }
3112    if let Some(ref local_var_str) = last_updated__n {
3113        local_var_req_builder = match "multi" {
3114            "multi" => local_var_req_builder.query(
3115                &local_var_str
3116                    .into_iter()
3117                    .map(|p| ("last_updated__n".to_owned(), p.to_string()))
3118                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3119            ),
3120            _ => local_var_req_builder.query(&[(
3121                "last_updated__n",
3122                &local_var_str
3123                    .into_iter()
3124                    .map(|p| p.to_string())
3125                    .collect::<Vec<String>>()
3126                    .join(",")
3127                    .to_string(),
3128            )]),
3129        };
3130    }
3131    if let Some(ref local_var_str) = limit {
3132        local_var_req_builder =
3133            local_var_req_builder.query(&[("limit", &local_var_str.to_string())]);
3134    }
3135    if let Some(ref local_var_str) = name {
3136        local_var_req_builder = match "multi" {
3137            "multi" => local_var_req_builder.query(
3138                &local_var_str
3139                    .into_iter()
3140                    .map(|p| ("name".to_owned(), p.to_string()))
3141                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3142            ),
3143            _ => local_var_req_builder.query(&[(
3144                "name",
3145                &local_var_str
3146                    .into_iter()
3147                    .map(|p| p.to_string())
3148                    .collect::<Vec<String>>()
3149                    .join(",")
3150                    .to_string(),
3151            )]),
3152        };
3153    }
3154    if let Some(ref local_var_str) = name__ic {
3155        local_var_req_builder = match "multi" {
3156            "multi" => local_var_req_builder.query(
3157                &local_var_str
3158                    .into_iter()
3159                    .map(|p| ("name__ic".to_owned(), p.to_string()))
3160                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3161            ),
3162            _ => local_var_req_builder.query(&[(
3163                "name__ic",
3164                &local_var_str
3165                    .into_iter()
3166                    .map(|p| p.to_string())
3167                    .collect::<Vec<String>>()
3168                    .join(",")
3169                    .to_string(),
3170            )]),
3171        };
3172    }
3173    if let Some(ref local_var_str) = name__ie {
3174        local_var_req_builder = match "multi" {
3175            "multi" => local_var_req_builder.query(
3176                &local_var_str
3177                    .into_iter()
3178                    .map(|p| ("name__ie".to_owned(), p.to_string()))
3179                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3180            ),
3181            _ => local_var_req_builder.query(&[(
3182                "name__ie",
3183                &local_var_str
3184                    .into_iter()
3185                    .map(|p| p.to_string())
3186                    .collect::<Vec<String>>()
3187                    .join(",")
3188                    .to_string(),
3189            )]),
3190        };
3191    }
3192    if let Some(ref local_var_str) = name__iew {
3193        local_var_req_builder = match "multi" {
3194            "multi" => local_var_req_builder.query(
3195                &local_var_str
3196                    .into_iter()
3197                    .map(|p| ("name__iew".to_owned(), p.to_string()))
3198                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3199            ),
3200            _ => local_var_req_builder.query(&[(
3201                "name__iew",
3202                &local_var_str
3203                    .into_iter()
3204                    .map(|p| p.to_string())
3205                    .collect::<Vec<String>>()
3206                    .join(",")
3207                    .to_string(),
3208            )]),
3209        };
3210    }
3211    if let Some(ref local_var_str) = name__ire {
3212        local_var_req_builder = match "multi" {
3213            "multi" => local_var_req_builder.query(
3214                &local_var_str
3215                    .into_iter()
3216                    .map(|p| ("name__ire".to_owned(), p.to_string()))
3217                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3218            ),
3219            _ => local_var_req_builder.query(&[(
3220                "name__ire",
3221                &local_var_str
3222                    .into_iter()
3223                    .map(|p| p.to_string())
3224                    .collect::<Vec<String>>()
3225                    .join(",")
3226                    .to_string(),
3227            )]),
3228        };
3229    }
3230    if let Some(ref local_var_str) = name__isw {
3231        local_var_req_builder = match "multi" {
3232            "multi" => local_var_req_builder.query(
3233                &local_var_str
3234                    .into_iter()
3235                    .map(|p| ("name__isw".to_owned(), p.to_string()))
3236                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3237            ),
3238            _ => local_var_req_builder.query(&[(
3239                "name__isw",
3240                &local_var_str
3241                    .into_iter()
3242                    .map(|p| p.to_string())
3243                    .collect::<Vec<String>>()
3244                    .join(",")
3245                    .to_string(),
3246            )]),
3247        };
3248    }
3249    if let Some(ref local_var_str) = name__n {
3250        local_var_req_builder = match "multi" {
3251            "multi" => local_var_req_builder.query(
3252                &local_var_str
3253                    .into_iter()
3254                    .map(|p| ("name__n".to_owned(), p.to_string()))
3255                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3256            ),
3257            _ => local_var_req_builder.query(&[(
3258                "name__n",
3259                &local_var_str
3260                    .into_iter()
3261                    .map(|p| p.to_string())
3262                    .collect::<Vec<String>>()
3263                    .join(",")
3264                    .to_string(),
3265            )]),
3266        };
3267    }
3268    if let Some(ref local_var_str) = name__nic {
3269        local_var_req_builder = match "multi" {
3270            "multi" => local_var_req_builder.query(
3271                &local_var_str
3272                    .into_iter()
3273                    .map(|p| ("name__nic".to_owned(), p.to_string()))
3274                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3275            ),
3276            _ => local_var_req_builder.query(&[(
3277                "name__nic",
3278                &local_var_str
3279                    .into_iter()
3280                    .map(|p| p.to_string())
3281                    .collect::<Vec<String>>()
3282                    .join(",")
3283                    .to_string(),
3284            )]),
3285        };
3286    }
3287    if let Some(ref local_var_str) = name__nie {
3288        local_var_req_builder = match "multi" {
3289            "multi" => local_var_req_builder.query(
3290                &local_var_str
3291                    .into_iter()
3292                    .map(|p| ("name__nie".to_owned(), p.to_string()))
3293                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3294            ),
3295            _ => local_var_req_builder.query(&[(
3296                "name__nie",
3297                &local_var_str
3298                    .into_iter()
3299                    .map(|p| p.to_string())
3300                    .collect::<Vec<String>>()
3301                    .join(",")
3302                    .to_string(),
3303            )]),
3304        };
3305    }
3306    if let Some(ref local_var_str) = name__niew {
3307        local_var_req_builder = match "multi" {
3308            "multi" => local_var_req_builder.query(
3309                &local_var_str
3310                    .into_iter()
3311                    .map(|p| ("name__niew".to_owned(), p.to_string()))
3312                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3313            ),
3314            _ => local_var_req_builder.query(&[(
3315                "name__niew",
3316                &local_var_str
3317                    .into_iter()
3318                    .map(|p| p.to_string())
3319                    .collect::<Vec<String>>()
3320                    .join(",")
3321                    .to_string(),
3322            )]),
3323        };
3324    }
3325    if let Some(ref local_var_str) = name__nire {
3326        local_var_req_builder = match "multi" {
3327            "multi" => local_var_req_builder.query(
3328                &local_var_str
3329                    .into_iter()
3330                    .map(|p| ("name__nire".to_owned(), p.to_string()))
3331                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3332            ),
3333            _ => local_var_req_builder.query(&[(
3334                "name__nire",
3335                &local_var_str
3336                    .into_iter()
3337                    .map(|p| p.to_string())
3338                    .collect::<Vec<String>>()
3339                    .join(",")
3340                    .to_string(),
3341            )]),
3342        };
3343    }
3344    if let Some(ref local_var_str) = name__nisw {
3345        local_var_req_builder = match "multi" {
3346            "multi" => local_var_req_builder.query(
3347                &local_var_str
3348                    .into_iter()
3349                    .map(|p| ("name__nisw".to_owned(), p.to_string()))
3350                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3351            ),
3352            _ => local_var_req_builder.query(&[(
3353                "name__nisw",
3354                &local_var_str
3355                    .into_iter()
3356                    .map(|p| p.to_string())
3357                    .collect::<Vec<String>>()
3358                    .join(",")
3359                    .to_string(),
3360            )]),
3361        };
3362    }
3363    if let Some(ref local_var_str) = name__nre {
3364        local_var_req_builder = match "multi" {
3365            "multi" => local_var_req_builder.query(
3366                &local_var_str
3367                    .into_iter()
3368                    .map(|p| ("name__nre".to_owned(), p.to_string()))
3369                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3370            ),
3371            _ => local_var_req_builder.query(&[(
3372                "name__nre",
3373                &local_var_str
3374                    .into_iter()
3375                    .map(|p| p.to_string())
3376                    .collect::<Vec<String>>()
3377                    .join(",")
3378                    .to_string(),
3379            )]),
3380        };
3381    }
3382    if let Some(ref local_var_str) = name__re {
3383        local_var_req_builder = match "multi" {
3384            "multi" => local_var_req_builder.query(
3385                &local_var_str
3386                    .into_iter()
3387                    .map(|p| ("name__re".to_owned(), p.to_string()))
3388                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3389            ),
3390            _ => local_var_req_builder.query(&[(
3391                "name__re",
3392                &local_var_str
3393                    .into_iter()
3394                    .map(|p| p.to_string())
3395                    .collect::<Vec<String>>()
3396                    .join(",")
3397                    .to_string(),
3398            )]),
3399        };
3400    }
3401    if let Some(ref local_var_str) = offset {
3402        local_var_req_builder =
3403            local_var_req_builder.query(&[("offset", &local_var_str.to_string())]);
3404    }
3405    if let Some(ref local_var_str) = q {
3406        local_var_req_builder = local_var_req_builder.query(&[("q", &local_var_str.to_string())]);
3407    }
3408    if let Some(ref local_var_str) = sort {
3409        local_var_req_builder =
3410            local_var_req_builder.query(&[("sort", &local_var_str.to_string())]);
3411    }
3412    if let Some(ref local_var_str) = teams {
3413        local_var_req_builder = match "multi" {
3414            "multi" => local_var_req_builder.query(
3415                &local_var_str
3416                    .into_iter()
3417                    .map(|p| ("teams".to_owned(), p.to_string()))
3418                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3419            ),
3420            _ => local_var_req_builder.query(&[(
3421                "teams",
3422                &local_var_str
3423                    .into_iter()
3424                    .map(|p| p.to_string())
3425                    .collect::<Vec<String>>()
3426                    .join(",")
3427                    .to_string(),
3428            )]),
3429        };
3430    }
3431    if let Some(ref local_var_str) = teams__isnull {
3432        local_var_req_builder =
3433            local_var_req_builder.query(&[("teams__isnull", &local_var_str.to_string())]);
3434    }
3435    if let Some(ref local_var_str) = teams__n {
3436        local_var_req_builder = match "multi" {
3437            "multi" => local_var_req_builder.query(
3438                &local_var_str
3439                    .into_iter()
3440                    .map(|p| ("teams__n".to_owned(), p.to_string()))
3441                    .collect::<Vec<(std::string::String, std::string::String)>>(),
3442            ),
3443            _ => local_var_req_builder.query(&[(
3444                "teams__n",
3445                &local_var_str
3446                    .into_iter()
3447                    .map(|p| p.to_string())
3448                    .collect::<Vec<String>>()
3449                    .join(",")
3450                    .to_string(),
3451            )]),
3452        };
3453    }
3454    if let Some(ref local_var_str) = depth {
3455        local_var_req_builder =
3456            local_var_req_builder.query(&[("depth", &local_var_str.to_string())]);
3457    }
3458    if let Some(ref local_var_str) = exclude_m2m {
3459        local_var_req_builder =
3460            local_var_req_builder.query(&[("exclude_m2m", &local_var_str.to_string())]);
3461    }
3462    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
3463        local_var_req_builder =
3464            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
3465    }
3466    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
3467        let local_var_key = local_var_apikey.key.clone();
3468        let local_var_value = match local_var_apikey.prefix {
3469            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
3470            None => local_var_key,
3471        };
3472        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
3473    };
3474
3475    let local_var_req = local_var_req_builder.build()?;
3476    let local_var_resp = local_var_client.execute(local_var_req).await?;
3477
3478    let local_var_status = local_var_resp.status();
3479    let local_var_content = local_var_resp.text().await?;
3480
3481    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
3482        serde_json::from_str(&local_var_content).map_err(Error::from)
3483    } else {
3484        let local_var_entity: Option<VirtualizationClusterTypesListError> =
3485            serde_json::from_str(&local_var_content).ok();
3486        let local_var_error = ResponseContent {
3487            status: local_var_status,
3488            content: local_var_content,
3489            entity: local_var_entity,
3490        };
3491        Err(Error::ResponseError(local_var_error))
3492    }
3493}
3494
3495/// API methods for returning or creating notes on an object.
3496pub async fn virtualization_cluster_types_notes_create(
3497    configuration: &configuration::Configuration,
3498    id: &str,
3499    note_input_request: crate::models::NoteInputRequest,
3500    format: Option<&str>,
3501) -> Result<crate::models::Note, Error<VirtualizationClusterTypesNotesCreateError>> {
3502    let local_var_configuration = configuration;
3503
3504    let local_var_client = &local_var_configuration.client;
3505
3506    let local_var_uri_str = format!(
3507        "{}/virtualization/cluster-types/{id}/notes/",
3508        local_var_configuration.base_path,
3509        id = crate::apis::urlencode(id)
3510    );
3511    let mut local_var_req_builder =
3512        local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
3513
3514    if let Some(ref local_var_str) = format {
3515        local_var_req_builder =
3516            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
3517    }
3518    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
3519        local_var_req_builder =
3520            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
3521    }
3522    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
3523        let local_var_key = local_var_apikey.key.clone();
3524        let local_var_value = match local_var_apikey.prefix {
3525            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
3526            None => local_var_key,
3527        };
3528        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
3529    };
3530    local_var_req_builder = local_var_req_builder.json(&note_input_request);
3531
3532    let local_var_req = local_var_req_builder.build()?;
3533    let local_var_resp = local_var_client.execute(local_var_req).await?;
3534
3535    let local_var_status = local_var_resp.status();
3536    let local_var_content = local_var_resp.text().await?;
3537
3538    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
3539        serde_json::from_str(&local_var_content).map_err(Error::from)
3540    } else {
3541        let local_var_entity: Option<VirtualizationClusterTypesNotesCreateError> =
3542            serde_json::from_str(&local_var_content).ok();
3543        let local_var_error = ResponseContent {
3544            status: local_var_status,
3545            content: local_var_content,
3546            entity: local_var_entity,
3547        };
3548        Err(Error::ResponseError(local_var_error))
3549    }
3550}
3551
3552/// API methods for returning or creating notes on an object.
3553pub async fn virtualization_cluster_types_notes_list(
3554    configuration: &configuration::Configuration,
3555    id: &str,
3556    format: Option<&str>,
3557    limit: Option<i32>,
3558    offset: Option<i32>,
3559    depth: Option<i32>,
3560    exclude_m2m: Option<bool>,
3561) -> Result<crate::models::PaginatedNoteList, Error<VirtualizationClusterTypesNotesListError>> {
3562    let local_var_configuration = configuration;
3563
3564    let local_var_client = &local_var_configuration.client;
3565
3566    let local_var_uri_str = format!(
3567        "{}/virtualization/cluster-types/{id}/notes/",
3568        local_var_configuration.base_path,
3569        id = crate::apis::urlencode(id)
3570    );
3571    let mut local_var_req_builder =
3572        local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
3573
3574    if let Some(ref local_var_str) = format {
3575        local_var_req_builder =
3576            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
3577    }
3578    if let Some(ref local_var_str) = limit {
3579        local_var_req_builder =
3580            local_var_req_builder.query(&[("limit", &local_var_str.to_string())]);
3581    }
3582    if let Some(ref local_var_str) = offset {
3583        local_var_req_builder =
3584            local_var_req_builder.query(&[("offset", &local_var_str.to_string())]);
3585    }
3586    if let Some(ref local_var_str) = depth {
3587        local_var_req_builder =
3588            local_var_req_builder.query(&[("depth", &local_var_str.to_string())]);
3589    }
3590    if let Some(ref local_var_str) = exclude_m2m {
3591        local_var_req_builder =
3592            local_var_req_builder.query(&[("exclude_m2m", &local_var_str.to_string())]);
3593    }
3594    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
3595        local_var_req_builder =
3596            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
3597    }
3598    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
3599        let local_var_key = local_var_apikey.key.clone();
3600        let local_var_value = match local_var_apikey.prefix {
3601            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
3602            None => local_var_key,
3603        };
3604        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
3605    };
3606
3607    let local_var_req = local_var_req_builder.build()?;
3608    let local_var_resp = local_var_client.execute(local_var_req).await?;
3609
3610    let local_var_status = local_var_resp.status();
3611    let local_var_content = local_var_resp.text().await?;
3612
3613    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
3614        serde_json::from_str(&local_var_content).map_err(Error::from)
3615    } else {
3616        let local_var_entity: Option<VirtualizationClusterTypesNotesListError> =
3617            serde_json::from_str(&local_var_content).ok();
3618        let local_var_error = ResponseContent {
3619            status: local_var_status,
3620            content: local_var_content,
3621            entity: local_var_entity,
3622        };
3623        Err(Error::ResponseError(local_var_error))
3624    }
3625}
3626
3627/// Partial update a cluster type object.
3628pub async fn virtualization_cluster_types_partial_update(
3629    configuration: &configuration::Configuration,
3630    id: &str,
3631    format: Option<&str>,
3632    patched_cluster_type_request: Option<crate::models::PatchedClusterTypeRequest>,
3633) -> Result<crate::models::ClusterType, Error<VirtualizationClusterTypesPartialUpdateError>> {
3634    let local_var_configuration = configuration;
3635
3636    let local_var_client = &local_var_configuration.client;
3637
3638    let local_var_uri_str = format!(
3639        "{}/virtualization/cluster-types/{id}/",
3640        local_var_configuration.base_path,
3641        id = crate::apis::urlencode(id)
3642    );
3643    let mut local_var_req_builder =
3644        local_var_client.request(reqwest::Method::PATCH, local_var_uri_str.as_str());
3645
3646    if let Some(ref local_var_str) = format {
3647        local_var_req_builder =
3648            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
3649    }
3650    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
3651        local_var_req_builder =
3652            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
3653    }
3654    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
3655        let local_var_key = local_var_apikey.key.clone();
3656        let local_var_value = match local_var_apikey.prefix {
3657            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
3658            None => local_var_key,
3659        };
3660        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
3661    };
3662    local_var_req_builder = local_var_req_builder.json(&patched_cluster_type_request);
3663
3664    let local_var_req = local_var_req_builder.build()?;
3665    let local_var_resp = local_var_client.execute(local_var_req).await?;
3666
3667    let local_var_status = local_var_resp.status();
3668    let local_var_content = local_var_resp.text().await?;
3669
3670    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
3671        serde_json::from_str(&local_var_content).map_err(Error::from)
3672    } else {
3673        let local_var_entity: Option<VirtualizationClusterTypesPartialUpdateError> =
3674            serde_json::from_str(&local_var_content).ok();
3675        let local_var_error = ResponseContent {
3676            status: local_var_status,
3677            content: local_var_content,
3678            entity: local_var_entity,
3679        };
3680        Err(Error::ResponseError(local_var_error))
3681    }
3682}
3683
3684/// Retrieve a cluster type object.
3685pub async fn virtualization_cluster_types_retrieve(
3686    configuration: &configuration::Configuration,
3687    id: &str,
3688    format: Option<&str>,
3689    depth: Option<i32>,
3690    exclude_m2m: Option<bool>,
3691) -> Result<crate::models::ClusterType, Error<VirtualizationClusterTypesRetrieveError>> {
3692    let local_var_configuration = configuration;
3693
3694    let local_var_client = &local_var_configuration.client;
3695
3696    let local_var_uri_str = format!(
3697        "{}/virtualization/cluster-types/{id}/",
3698        local_var_configuration.base_path,
3699        id = crate::apis::urlencode(id)
3700    );
3701    let mut local_var_req_builder =
3702        local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
3703
3704    if let Some(ref local_var_str) = format {
3705        local_var_req_builder =
3706            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
3707    }
3708    if let Some(ref local_var_str) = depth {
3709        local_var_req_builder =
3710            local_var_req_builder.query(&[("depth", &local_var_str.to_string())]);
3711    }
3712    if let Some(ref local_var_str) = exclude_m2m {
3713        local_var_req_builder =
3714            local_var_req_builder.query(&[("exclude_m2m", &local_var_str.to_string())]);
3715    }
3716    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
3717        local_var_req_builder =
3718            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
3719    }
3720    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
3721        let local_var_key = local_var_apikey.key.clone();
3722        let local_var_value = match local_var_apikey.prefix {
3723            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
3724            None => local_var_key,
3725        };
3726        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
3727    };
3728
3729    let local_var_req = local_var_req_builder.build()?;
3730    let local_var_resp = local_var_client.execute(local_var_req).await?;
3731
3732    let local_var_status = local_var_resp.status();
3733    let local_var_content = local_var_resp.text().await?;
3734
3735    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
3736        serde_json::from_str(&local_var_content).map_err(Error::from)
3737    } else {
3738        let local_var_entity: Option<VirtualizationClusterTypesRetrieveError> =
3739            serde_json::from_str(&local_var_content).ok();
3740        let local_var_error = ResponseContent {
3741            status: local_var_status,
3742            content: local_var_content,
3743            entity: local_var_entity,
3744        };
3745        Err(Error::ResponseError(local_var_error))
3746    }
3747}
3748
3749/// Update a cluster type object.
3750pub async fn virtualization_cluster_types_update(
3751    configuration: &configuration::Configuration,
3752    id: &str,
3753    cluster_type_request: crate::models::ClusterTypeRequest,
3754    format: Option<&str>,
3755) -> Result<crate::models::ClusterType, Error<VirtualizationClusterTypesUpdateError>> {
3756    let local_var_configuration = configuration;
3757
3758    let local_var_client = &local_var_configuration.client;
3759
3760    let local_var_uri_str = format!(
3761        "{}/virtualization/cluster-types/{id}/",
3762        local_var_configuration.base_path,
3763        id = crate::apis::urlencode(id)
3764    );
3765    let mut local_var_req_builder =
3766        local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());
3767
3768    if let Some(ref local_var_str) = format {
3769        local_var_req_builder =
3770            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
3771    }
3772    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
3773        local_var_req_builder =
3774            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
3775    }
3776    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
3777        let local_var_key = local_var_apikey.key.clone();
3778        let local_var_value = match local_var_apikey.prefix {
3779            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
3780            None => local_var_key,
3781        };
3782        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
3783    };
3784    local_var_req_builder = local_var_req_builder.json(&cluster_type_request);
3785
3786    let local_var_req = local_var_req_builder.build()?;
3787    let local_var_resp = local_var_client.execute(local_var_req).await?;
3788
3789    let local_var_status = local_var_resp.status();
3790    let local_var_content = local_var_resp.text().await?;
3791
3792    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
3793        serde_json::from_str(&local_var_content).map_err(Error::from)
3794    } else {
3795        let local_var_entity: Option<VirtualizationClusterTypesUpdateError> =
3796            serde_json::from_str(&local_var_content).ok();
3797        let local_var_error = ResponseContent {
3798            status: local_var_status,
3799            content: local_var_content,
3800            entity: local_var_entity,
3801        };
3802        Err(Error::ResponseError(local_var_error))
3803    }
3804}
3805
3806/// Destroy a list of cluster objects.
3807pub async fn virtualization_clusters_bulk_destroy(
3808    configuration: &configuration::Configuration,
3809    bulk_operation_request: Vec<crate::models::BulkOperationRequest>,
3810    format: Option<&str>,
3811) -> Result<(), Error<VirtualizationClustersBulkDestroyError>> {
3812    let local_var_configuration = configuration;
3813
3814    let local_var_client = &local_var_configuration.client;
3815
3816    let local_var_uri_str = format!(
3817        "{}/virtualization/clusters/",
3818        local_var_configuration.base_path
3819    );
3820    let mut local_var_req_builder =
3821        local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());
3822
3823    if let Some(ref local_var_str) = format {
3824        local_var_req_builder =
3825            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
3826    }
3827    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
3828        local_var_req_builder =
3829            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
3830    }
3831    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
3832        let local_var_key = local_var_apikey.key.clone();
3833        let local_var_value = match local_var_apikey.prefix {
3834            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
3835            None => local_var_key,
3836        };
3837        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
3838    };
3839    local_var_req_builder = local_var_req_builder.json(&bulk_operation_request);
3840
3841    let local_var_req = local_var_req_builder.build()?;
3842    let local_var_resp = local_var_client.execute(local_var_req).await?;
3843
3844    let local_var_status = local_var_resp.status();
3845    let local_var_content = local_var_resp.text().await?;
3846
3847    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
3848        Ok(())
3849    } else {
3850        let local_var_entity: Option<VirtualizationClustersBulkDestroyError> =
3851            serde_json::from_str(&local_var_content).ok();
3852        let local_var_error = ResponseContent {
3853            status: local_var_status,
3854            content: local_var_content,
3855            entity: local_var_entity,
3856        };
3857        Err(Error::ResponseError(local_var_error))
3858    }
3859}
3860
3861/// Partial update a list of cluster objects.
3862pub async fn virtualization_clusters_bulk_partial_update(
3863    configuration: &configuration::Configuration,
3864    patched_bulk_writable_cluster_request: Vec<crate::models::PatchedBulkWritableClusterRequest>,
3865    format: Option<&str>,
3866) -> Result<Vec<crate::models::Cluster>, Error<VirtualizationClustersBulkPartialUpdateError>> {
3867    let local_var_configuration = configuration;
3868
3869    let local_var_client = &local_var_configuration.client;
3870
3871    let local_var_uri_str = format!(
3872        "{}/virtualization/clusters/",
3873        local_var_configuration.base_path
3874    );
3875    let mut local_var_req_builder =
3876        local_var_client.request(reqwest::Method::PATCH, local_var_uri_str.as_str());
3877
3878    if let Some(ref local_var_str) = format {
3879        local_var_req_builder =
3880            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
3881    }
3882    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
3883        local_var_req_builder =
3884            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
3885    }
3886    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
3887        let local_var_key = local_var_apikey.key.clone();
3888        let local_var_value = match local_var_apikey.prefix {
3889            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
3890            None => local_var_key,
3891        };
3892        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
3893    };
3894    local_var_req_builder = local_var_req_builder.json(&patched_bulk_writable_cluster_request);
3895
3896    let local_var_req = local_var_req_builder.build()?;
3897    let local_var_resp = local_var_client.execute(local_var_req).await?;
3898
3899    let local_var_status = local_var_resp.status();
3900    let local_var_content = local_var_resp.text().await?;
3901
3902    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
3903        serde_json::from_str(&local_var_content).map_err(Error::from)
3904    } else {
3905        let local_var_entity: Option<VirtualizationClustersBulkPartialUpdateError> =
3906            serde_json::from_str(&local_var_content).ok();
3907        let local_var_error = ResponseContent {
3908            status: local_var_status,
3909            content: local_var_content,
3910            entity: local_var_entity,
3911        };
3912        Err(Error::ResponseError(local_var_error))
3913    }
3914}
3915
3916/// Update a list of cluster objects.
3917pub async fn virtualization_clusters_bulk_update(
3918    configuration: &configuration::Configuration,
3919    bulk_writable_cluster_request: Vec<crate::models::BulkWritableClusterRequest>,
3920    format: Option<&str>,
3921) -> Result<Vec<crate::models::Cluster>, Error<VirtualizationClustersBulkUpdateError>> {
3922    let local_var_configuration = configuration;
3923
3924    let local_var_client = &local_var_configuration.client;
3925
3926    let local_var_uri_str = format!(
3927        "{}/virtualization/clusters/",
3928        local_var_configuration.base_path
3929    );
3930    let mut local_var_req_builder =
3931        local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());
3932
3933    if let Some(ref local_var_str) = format {
3934        local_var_req_builder =
3935            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
3936    }
3937    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
3938        local_var_req_builder =
3939            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
3940    }
3941    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
3942        let local_var_key = local_var_apikey.key.clone();
3943        let local_var_value = match local_var_apikey.prefix {
3944            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
3945            None => local_var_key,
3946        };
3947        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
3948    };
3949    local_var_req_builder = local_var_req_builder.json(&bulk_writable_cluster_request);
3950
3951    let local_var_req = local_var_req_builder.build()?;
3952    let local_var_resp = local_var_client.execute(local_var_req).await?;
3953
3954    let local_var_status = local_var_resp.status();
3955    let local_var_content = local_var_resp.text().await?;
3956
3957    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
3958        serde_json::from_str(&local_var_content).map_err(Error::from)
3959    } else {
3960        let local_var_entity: Option<VirtualizationClustersBulkUpdateError> =
3961            serde_json::from_str(&local_var_content).ok();
3962        let local_var_error = ResponseContent {
3963            status: local_var_status,
3964            content: local_var_content,
3965            entity: local_var_entity,
3966        };
3967        Err(Error::ResponseError(local_var_error))
3968    }
3969}
3970
3971/// Create one or more cluster objects.
3972pub async fn virtualization_clusters_create(
3973    configuration: &configuration::Configuration,
3974    cluster_request: crate::models::ClusterRequest,
3975    format: Option<&str>,
3976) -> Result<crate::models::Cluster, Error<VirtualizationClustersCreateError>> {
3977    let local_var_configuration = configuration;
3978
3979    let local_var_client = &local_var_configuration.client;
3980
3981    let local_var_uri_str = format!(
3982        "{}/virtualization/clusters/",
3983        local_var_configuration.base_path
3984    );
3985    let mut local_var_req_builder =
3986        local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
3987
3988    if let Some(ref local_var_str) = format {
3989        local_var_req_builder =
3990            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
3991    }
3992    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
3993        local_var_req_builder =
3994            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
3995    }
3996    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
3997        let local_var_key = local_var_apikey.key.clone();
3998        let local_var_value = match local_var_apikey.prefix {
3999            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
4000            None => local_var_key,
4001        };
4002        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
4003    };
4004    local_var_req_builder = local_var_req_builder.json(&cluster_request);
4005
4006    let local_var_req = local_var_req_builder.build()?;
4007    let local_var_resp = local_var_client.execute(local_var_req).await?;
4008
4009    let local_var_status = local_var_resp.status();
4010    let local_var_content = local_var_resp.text().await?;
4011
4012    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
4013        serde_json::from_str(&local_var_content).map_err(Error::from)
4014    } else {
4015        let local_var_entity: Option<VirtualizationClustersCreateError> =
4016            serde_json::from_str(&local_var_content).ok();
4017        let local_var_error = ResponseContent {
4018            status: local_var_status,
4019            content: local_var_content,
4020            entity: local_var_entity,
4021        };
4022        Err(Error::ResponseError(local_var_error))
4023    }
4024}
4025
4026/// Destroy a cluster object.
4027pub async fn virtualization_clusters_destroy(
4028    configuration: &configuration::Configuration,
4029    id: &str,
4030    format: Option<&str>,
4031) -> Result<(), Error<VirtualizationClustersDestroyError>> {
4032    let local_var_configuration = configuration;
4033
4034    let local_var_client = &local_var_configuration.client;
4035
4036    let local_var_uri_str = format!(
4037        "{}/virtualization/clusters/{id}/",
4038        local_var_configuration.base_path,
4039        id = crate::apis::urlencode(id)
4040    );
4041    let mut local_var_req_builder =
4042        local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());
4043
4044    if let Some(ref local_var_str) = format {
4045        local_var_req_builder =
4046            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
4047    }
4048    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
4049        local_var_req_builder =
4050            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
4051    }
4052    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
4053        let local_var_key = local_var_apikey.key.clone();
4054        let local_var_value = match local_var_apikey.prefix {
4055            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
4056            None => local_var_key,
4057        };
4058        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
4059    };
4060
4061    let local_var_req = local_var_req_builder.build()?;
4062    let local_var_resp = local_var_client.execute(local_var_req).await?;
4063
4064    let local_var_status = local_var_resp.status();
4065    let local_var_content = local_var_resp.text().await?;
4066
4067    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
4068        Ok(())
4069    } else {
4070        let local_var_entity: Option<VirtualizationClustersDestroyError> =
4071            serde_json::from_str(&local_var_content).ok();
4072        let local_var_error = ResponseContent {
4073            status: local_var_status,
4074            content: local_var_content,
4075            entity: local_var_entity,
4076        };
4077        Err(Error::ResponseError(local_var_error))
4078    }
4079}
4080
4081/// Retrieve a list of cluster objects.
4082pub async fn virtualization_clusters_list(
4083    configuration: &configuration::Configuration,
4084    cluster_group: Option<Vec<String>>,
4085    cluster_group__isnull: Option<bool>,
4086    cluster_group__n: Option<Vec<String>>,
4087    cluster_group_id: Option<Vec<uuid::Uuid>>,
4088    cluster_group_id__isnull: Option<bool>,
4089    cluster_group_id__n: Option<Vec<uuid::Uuid>>,
4090    cluster_type: Option<Vec<String>>,
4091    cluster_type__n: Option<Vec<String>>,
4092    cluster_type_id: Option<Vec<uuid::Uuid>>,
4093    cluster_type_id__n: Option<Vec<uuid::Uuid>>,
4094    comments: Option<Vec<String>>,
4095    comments__ic: Option<Vec<String>>,
4096    comments__ie: Option<Vec<String>>,
4097    comments__iew: Option<Vec<String>>,
4098    comments__ire: Option<Vec<String>>,
4099    comments__isw: Option<Vec<String>>,
4100    comments__n: Option<Vec<String>>,
4101    comments__nic: Option<Vec<String>>,
4102    comments__nie: Option<Vec<String>>,
4103    comments__niew: Option<Vec<String>>,
4104    comments__nire: Option<Vec<String>>,
4105    comments__nisw: Option<Vec<String>>,
4106    comments__nre: Option<Vec<String>>,
4107    comments__re: Option<Vec<String>>,
4108    contacts: Option<Vec<String>>,
4109    contacts__isnull: Option<bool>,
4110    contacts__n: Option<Vec<String>>,
4111    created: Option<Vec<String>>,
4112    created__gt: Option<Vec<String>>,
4113    created__gte: Option<Vec<String>>,
4114    created__isnull: Option<bool>,
4115    created__lt: Option<Vec<String>>,
4116    created__lte: Option<Vec<String>>,
4117    created__n: Option<Vec<String>>,
4118    devices: Option<Vec<String>>,
4119    devices__isnull: Option<bool>,
4120    devices__n: Option<Vec<String>>,
4121    dynamic_groups: Option<Vec<String>>,
4122    dynamic_groups__n: Option<Vec<String>>,
4123    format: Option<&str>,
4124    has_devices: Option<bool>,
4125    has_virtual_machines: Option<bool>,
4126    id: Option<Vec<uuid::Uuid>>,
4127    id__n: Option<Vec<uuid::Uuid>>,
4128    last_updated: Option<Vec<String>>,
4129    last_updated__gt: Option<Vec<String>>,
4130    last_updated__gte: Option<Vec<String>>,
4131    last_updated__isnull: Option<bool>,
4132    last_updated__lt: Option<Vec<String>>,
4133    last_updated__lte: Option<Vec<String>>,
4134    last_updated__n: Option<Vec<String>>,
4135    limit: Option<i32>,
4136    location: Option<Vec<String>>,
4137    location__isnull: Option<bool>,
4138    location__n: Option<Vec<String>>,
4139    name: Option<Vec<String>>,
4140    name__ic: Option<Vec<String>>,
4141    name__ie: Option<Vec<String>>,
4142    name__iew: Option<Vec<String>>,
4143    name__ire: Option<Vec<String>>,
4144    name__isw: Option<Vec<String>>,
4145    name__n: Option<Vec<String>>,
4146    name__nic: Option<Vec<String>>,
4147    name__nie: Option<Vec<String>>,
4148    name__niew: Option<Vec<String>>,
4149    name__nire: Option<Vec<String>>,
4150    name__nisw: Option<Vec<String>>,
4151    name__nre: Option<Vec<String>>,
4152    name__re: Option<Vec<String>>,
4153    offset: Option<i32>,
4154    q: Option<&str>,
4155    sort: Option<&str>,
4156    tags: Option<Vec<String>>,
4157    tags__isnull: Option<bool>,
4158    tags__n: Option<Vec<String>>,
4159    teams: Option<Vec<String>>,
4160    teams__isnull: Option<bool>,
4161    teams__n: Option<Vec<String>>,
4162    tenant: Option<Vec<String>>,
4163    tenant__isnull: Option<bool>,
4164    tenant__n: Option<Vec<String>>,
4165    tenant_group: Option<Vec<String>>,
4166    tenant_group__isnull: Option<bool>,
4167    tenant_group__n: Option<Vec<String>>,
4168    tenant_id: Option<Vec<uuid::Uuid>>,
4169    tenant_id__isnull: Option<bool>,
4170    tenant_id__n: Option<Vec<uuid::Uuid>>,
4171    virtual_machines: Option<Vec<String>>,
4172    virtual_machines__isnull: Option<bool>,
4173    virtual_machines__n: Option<Vec<String>>,
4174    depth: Option<i32>,
4175    exclude_m2m: Option<bool>,
4176) -> Result<crate::models::PaginatedClusterList, Error<VirtualizationClustersListError>> {
4177    let local_var_configuration = configuration;
4178
4179    let local_var_client = &local_var_configuration.client;
4180
4181    let local_var_uri_str = format!(
4182        "{}/virtualization/clusters/",
4183        local_var_configuration.base_path
4184    );
4185    let mut local_var_req_builder =
4186        local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
4187
4188    if let Some(ref local_var_str) = cluster_group {
4189        local_var_req_builder = match "multi" {
4190            "multi" => local_var_req_builder.query(
4191                &local_var_str
4192                    .into_iter()
4193                    .map(|p| ("cluster_group".to_owned(), p.to_string()))
4194                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4195            ),
4196            _ => local_var_req_builder.query(&[(
4197                "cluster_group",
4198                &local_var_str
4199                    .into_iter()
4200                    .map(|p| p.to_string())
4201                    .collect::<Vec<String>>()
4202                    .join(",")
4203                    .to_string(),
4204            )]),
4205        };
4206    }
4207    if let Some(ref local_var_str) = cluster_group__isnull {
4208        local_var_req_builder =
4209            local_var_req_builder.query(&[("cluster_group__isnull", &local_var_str.to_string())]);
4210    }
4211    if let Some(ref local_var_str) = cluster_group__n {
4212        local_var_req_builder = match "multi" {
4213            "multi" => local_var_req_builder.query(
4214                &local_var_str
4215                    .into_iter()
4216                    .map(|p| ("cluster_group__n".to_owned(), p.to_string()))
4217                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4218            ),
4219            _ => local_var_req_builder.query(&[(
4220                "cluster_group__n",
4221                &local_var_str
4222                    .into_iter()
4223                    .map(|p| p.to_string())
4224                    .collect::<Vec<String>>()
4225                    .join(",")
4226                    .to_string(),
4227            )]),
4228        };
4229    }
4230    if let Some(ref local_var_str) = cluster_group_id {
4231        local_var_req_builder = match "multi" {
4232            "multi" => local_var_req_builder.query(
4233                &local_var_str
4234                    .into_iter()
4235                    .map(|p| ("cluster_group_id".to_owned(), p.to_string()))
4236                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4237            ),
4238            _ => local_var_req_builder.query(&[(
4239                "cluster_group_id",
4240                &local_var_str
4241                    .into_iter()
4242                    .map(|p| p.to_string())
4243                    .collect::<Vec<String>>()
4244                    .join(",")
4245                    .to_string(),
4246            )]),
4247        };
4248    }
4249    if let Some(ref local_var_str) = cluster_group_id__isnull {
4250        local_var_req_builder = local_var_req_builder
4251            .query(&[("cluster_group_id__isnull", &local_var_str.to_string())]);
4252    }
4253    if let Some(ref local_var_str) = cluster_group_id__n {
4254        local_var_req_builder = match "multi" {
4255            "multi" => local_var_req_builder.query(
4256                &local_var_str
4257                    .into_iter()
4258                    .map(|p| ("cluster_group_id__n".to_owned(), p.to_string()))
4259                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4260            ),
4261            _ => local_var_req_builder.query(&[(
4262                "cluster_group_id__n",
4263                &local_var_str
4264                    .into_iter()
4265                    .map(|p| p.to_string())
4266                    .collect::<Vec<String>>()
4267                    .join(",")
4268                    .to_string(),
4269            )]),
4270        };
4271    }
4272    if let Some(ref local_var_str) = cluster_type {
4273        local_var_req_builder = match "multi" {
4274            "multi" => local_var_req_builder.query(
4275                &local_var_str
4276                    .into_iter()
4277                    .map(|p| ("cluster_type".to_owned(), p.to_string()))
4278                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4279            ),
4280            _ => local_var_req_builder.query(&[(
4281                "cluster_type",
4282                &local_var_str
4283                    .into_iter()
4284                    .map(|p| p.to_string())
4285                    .collect::<Vec<String>>()
4286                    .join(",")
4287                    .to_string(),
4288            )]),
4289        };
4290    }
4291    if let Some(ref local_var_str) = cluster_type__n {
4292        local_var_req_builder = match "multi" {
4293            "multi" => local_var_req_builder.query(
4294                &local_var_str
4295                    .into_iter()
4296                    .map(|p| ("cluster_type__n".to_owned(), p.to_string()))
4297                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4298            ),
4299            _ => local_var_req_builder.query(&[(
4300                "cluster_type__n",
4301                &local_var_str
4302                    .into_iter()
4303                    .map(|p| p.to_string())
4304                    .collect::<Vec<String>>()
4305                    .join(",")
4306                    .to_string(),
4307            )]),
4308        };
4309    }
4310    if let Some(ref local_var_str) = cluster_type_id {
4311        local_var_req_builder = match "multi" {
4312            "multi" => local_var_req_builder.query(
4313                &local_var_str
4314                    .into_iter()
4315                    .map(|p| ("cluster_type_id".to_owned(), p.to_string()))
4316                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4317            ),
4318            _ => local_var_req_builder.query(&[(
4319                "cluster_type_id",
4320                &local_var_str
4321                    .into_iter()
4322                    .map(|p| p.to_string())
4323                    .collect::<Vec<String>>()
4324                    .join(",")
4325                    .to_string(),
4326            )]),
4327        };
4328    }
4329    if let Some(ref local_var_str) = cluster_type_id__n {
4330        local_var_req_builder = match "multi" {
4331            "multi" => local_var_req_builder.query(
4332                &local_var_str
4333                    .into_iter()
4334                    .map(|p| ("cluster_type_id__n".to_owned(), p.to_string()))
4335                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4336            ),
4337            _ => local_var_req_builder.query(&[(
4338                "cluster_type_id__n",
4339                &local_var_str
4340                    .into_iter()
4341                    .map(|p| p.to_string())
4342                    .collect::<Vec<String>>()
4343                    .join(",")
4344                    .to_string(),
4345            )]),
4346        };
4347    }
4348    if let Some(ref local_var_str) = comments {
4349        local_var_req_builder = match "multi" {
4350            "multi" => local_var_req_builder.query(
4351                &local_var_str
4352                    .into_iter()
4353                    .map(|p| ("comments".to_owned(), p.to_string()))
4354                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4355            ),
4356            _ => local_var_req_builder.query(&[(
4357                "comments",
4358                &local_var_str
4359                    .into_iter()
4360                    .map(|p| p.to_string())
4361                    .collect::<Vec<String>>()
4362                    .join(",")
4363                    .to_string(),
4364            )]),
4365        };
4366    }
4367    if let Some(ref local_var_str) = comments__ic {
4368        local_var_req_builder = match "multi" {
4369            "multi" => local_var_req_builder.query(
4370                &local_var_str
4371                    .into_iter()
4372                    .map(|p| ("comments__ic".to_owned(), p.to_string()))
4373                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4374            ),
4375            _ => local_var_req_builder.query(&[(
4376                "comments__ic",
4377                &local_var_str
4378                    .into_iter()
4379                    .map(|p| p.to_string())
4380                    .collect::<Vec<String>>()
4381                    .join(",")
4382                    .to_string(),
4383            )]),
4384        };
4385    }
4386    if let Some(ref local_var_str) = comments__ie {
4387        local_var_req_builder = match "multi" {
4388            "multi" => local_var_req_builder.query(
4389                &local_var_str
4390                    .into_iter()
4391                    .map(|p| ("comments__ie".to_owned(), p.to_string()))
4392                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4393            ),
4394            _ => local_var_req_builder.query(&[(
4395                "comments__ie",
4396                &local_var_str
4397                    .into_iter()
4398                    .map(|p| p.to_string())
4399                    .collect::<Vec<String>>()
4400                    .join(",")
4401                    .to_string(),
4402            )]),
4403        };
4404    }
4405    if let Some(ref local_var_str) = comments__iew {
4406        local_var_req_builder = match "multi" {
4407            "multi" => local_var_req_builder.query(
4408                &local_var_str
4409                    .into_iter()
4410                    .map(|p| ("comments__iew".to_owned(), p.to_string()))
4411                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4412            ),
4413            _ => local_var_req_builder.query(&[(
4414                "comments__iew",
4415                &local_var_str
4416                    .into_iter()
4417                    .map(|p| p.to_string())
4418                    .collect::<Vec<String>>()
4419                    .join(",")
4420                    .to_string(),
4421            )]),
4422        };
4423    }
4424    if let Some(ref local_var_str) = comments__ire {
4425        local_var_req_builder = match "multi" {
4426            "multi" => local_var_req_builder.query(
4427                &local_var_str
4428                    .into_iter()
4429                    .map(|p| ("comments__ire".to_owned(), p.to_string()))
4430                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4431            ),
4432            _ => local_var_req_builder.query(&[(
4433                "comments__ire",
4434                &local_var_str
4435                    .into_iter()
4436                    .map(|p| p.to_string())
4437                    .collect::<Vec<String>>()
4438                    .join(",")
4439                    .to_string(),
4440            )]),
4441        };
4442    }
4443    if let Some(ref local_var_str) = comments__isw {
4444        local_var_req_builder = match "multi" {
4445            "multi" => local_var_req_builder.query(
4446                &local_var_str
4447                    .into_iter()
4448                    .map(|p| ("comments__isw".to_owned(), p.to_string()))
4449                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4450            ),
4451            _ => local_var_req_builder.query(&[(
4452                "comments__isw",
4453                &local_var_str
4454                    .into_iter()
4455                    .map(|p| p.to_string())
4456                    .collect::<Vec<String>>()
4457                    .join(",")
4458                    .to_string(),
4459            )]),
4460        };
4461    }
4462    if let Some(ref local_var_str) = comments__n {
4463        local_var_req_builder = match "multi" {
4464            "multi" => local_var_req_builder.query(
4465                &local_var_str
4466                    .into_iter()
4467                    .map(|p| ("comments__n".to_owned(), p.to_string()))
4468                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4469            ),
4470            _ => local_var_req_builder.query(&[(
4471                "comments__n",
4472                &local_var_str
4473                    .into_iter()
4474                    .map(|p| p.to_string())
4475                    .collect::<Vec<String>>()
4476                    .join(",")
4477                    .to_string(),
4478            )]),
4479        };
4480    }
4481    if let Some(ref local_var_str) = comments__nic {
4482        local_var_req_builder = match "multi" {
4483            "multi" => local_var_req_builder.query(
4484                &local_var_str
4485                    .into_iter()
4486                    .map(|p| ("comments__nic".to_owned(), p.to_string()))
4487                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4488            ),
4489            _ => local_var_req_builder.query(&[(
4490                "comments__nic",
4491                &local_var_str
4492                    .into_iter()
4493                    .map(|p| p.to_string())
4494                    .collect::<Vec<String>>()
4495                    .join(",")
4496                    .to_string(),
4497            )]),
4498        };
4499    }
4500    if let Some(ref local_var_str) = comments__nie {
4501        local_var_req_builder = match "multi" {
4502            "multi" => local_var_req_builder.query(
4503                &local_var_str
4504                    .into_iter()
4505                    .map(|p| ("comments__nie".to_owned(), p.to_string()))
4506                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4507            ),
4508            _ => local_var_req_builder.query(&[(
4509                "comments__nie",
4510                &local_var_str
4511                    .into_iter()
4512                    .map(|p| p.to_string())
4513                    .collect::<Vec<String>>()
4514                    .join(",")
4515                    .to_string(),
4516            )]),
4517        };
4518    }
4519    if let Some(ref local_var_str) = comments__niew {
4520        local_var_req_builder = match "multi" {
4521            "multi" => local_var_req_builder.query(
4522                &local_var_str
4523                    .into_iter()
4524                    .map(|p| ("comments__niew".to_owned(), p.to_string()))
4525                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4526            ),
4527            _ => local_var_req_builder.query(&[(
4528                "comments__niew",
4529                &local_var_str
4530                    .into_iter()
4531                    .map(|p| p.to_string())
4532                    .collect::<Vec<String>>()
4533                    .join(",")
4534                    .to_string(),
4535            )]),
4536        };
4537    }
4538    if let Some(ref local_var_str) = comments__nire {
4539        local_var_req_builder = match "multi" {
4540            "multi" => local_var_req_builder.query(
4541                &local_var_str
4542                    .into_iter()
4543                    .map(|p| ("comments__nire".to_owned(), p.to_string()))
4544                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4545            ),
4546            _ => local_var_req_builder.query(&[(
4547                "comments__nire",
4548                &local_var_str
4549                    .into_iter()
4550                    .map(|p| p.to_string())
4551                    .collect::<Vec<String>>()
4552                    .join(",")
4553                    .to_string(),
4554            )]),
4555        };
4556    }
4557    if let Some(ref local_var_str) = comments__nisw {
4558        local_var_req_builder = match "multi" {
4559            "multi" => local_var_req_builder.query(
4560                &local_var_str
4561                    .into_iter()
4562                    .map(|p| ("comments__nisw".to_owned(), p.to_string()))
4563                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4564            ),
4565            _ => local_var_req_builder.query(&[(
4566                "comments__nisw",
4567                &local_var_str
4568                    .into_iter()
4569                    .map(|p| p.to_string())
4570                    .collect::<Vec<String>>()
4571                    .join(",")
4572                    .to_string(),
4573            )]),
4574        };
4575    }
4576    if let Some(ref local_var_str) = comments__nre {
4577        local_var_req_builder = match "multi" {
4578            "multi" => local_var_req_builder.query(
4579                &local_var_str
4580                    .into_iter()
4581                    .map(|p| ("comments__nre".to_owned(), p.to_string()))
4582                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4583            ),
4584            _ => local_var_req_builder.query(&[(
4585                "comments__nre",
4586                &local_var_str
4587                    .into_iter()
4588                    .map(|p| p.to_string())
4589                    .collect::<Vec<String>>()
4590                    .join(",")
4591                    .to_string(),
4592            )]),
4593        };
4594    }
4595    if let Some(ref local_var_str) = comments__re {
4596        local_var_req_builder = match "multi" {
4597            "multi" => local_var_req_builder.query(
4598                &local_var_str
4599                    .into_iter()
4600                    .map(|p| ("comments__re".to_owned(), p.to_string()))
4601                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4602            ),
4603            _ => local_var_req_builder.query(&[(
4604                "comments__re",
4605                &local_var_str
4606                    .into_iter()
4607                    .map(|p| p.to_string())
4608                    .collect::<Vec<String>>()
4609                    .join(",")
4610                    .to_string(),
4611            )]),
4612        };
4613    }
4614    if let Some(ref local_var_str) = contacts {
4615        local_var_req_builder = match "multi" {
4616            "multi" => local_var_req_builder.query(
4617                &local_var_str
4618                    .into_iter()
4619                    .map(|p| ("contacts".to_owned(), p.to_string()))
4620                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4621            ),
4622            _ => local_var_req_builder.query(&[(
4623                "contacts",
4624                &local_var_str
4625                    .into_iter()
4626                    .map(|p| p.to_string())
4627                    .collect::<Vec<String>>()
4628                    .join(",")
4629                    .to_string(),
4630            )]),
4631        };
4632    }
4633    if let Some(ref local_var_str) = contacts__isnull {
4634        local_var_req_builder =
4635            local_var_req_builder.query(&[("contacts__isnull", &local_var_str.to_string())]);
4636    }
4637    if let Some(ref local_var_str) = contacts__n {
4638        local_var_req_builder = match "multi" {
4639            "multi" => local_var_req_builder.query(
4640                &local_var_str
4641                    .into_iter()
4642                    .map(|p| ("contacts__n".to_owned(), p.to_string()))
4643                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4644            ),
4645            _ => local_var_req_builder.query(&[(
4646                "contacts__n",
4647                &local_var_str
4648                    .into_iter()
4649                    .map(|p| p.to_string())
4650                    .collect::<Vec<String>>()
4651                    .join(",")
4652                    .to_string(),
4653            )]),
4654        };
4655    }
4656    if let Some(ref local_var_str) = created {
4657        local_var_req_builder = match "multi" {
4658            "multi" => local_var_req_builder.query(
4659                &local_var_str
4660                    .into_iter()
4661                    .map(|p| ("created".to_owned(), p.to_string()))
4662                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4663            ),
4664            _ => local_var_req_builder.query(&[(
4665                "created",
4666                &local_var_str
4667                    .into_iter()
4668                    .map(|p| p.to_string())
4669                    .collect::<Vec<String>>()
4670                    .join(",")
4671                    .to_string(),
4672            )]),
4673        };
4674    }
4675    if let Some(ref local_var_str) = created__gt {
4676        local_var_req_builder = match "multi" {
4677            "multi" => local_var_req_builder.query(
4678                &local_var_str
4679                    .into_iter()
4680                    .map(|p| ("created__gt".to_owned(), p.to_string()))
4681                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4682            ),
4683            _ => local_var_req_builder.query(&[(
4684                "created__gt",
4685                &local_var_str
4686                    .into_iter()
4687                    .map(|p| p.to_string())
4688                    .collect::<Vec<String>>()
4689                    .join(",")
4690                    .to_string(),
4691            )]),
4692        };
4693    }
4694    if let Some(ref local_var_str) = created__gte {
4695        local_var_req_builder = match "multi" {
4696            "multi" => local_var_req_builder.query(
4697                &local_var_str
4698                    .into_iter()
4699                    .map(|p| ("created__gte".to_owned(), p.to_string()))
4700                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4701            ),
4702            _ => local_var_req_builder.query(&[(
4703                "created__gte",
4704                &local_var_str
4705                    .into_iter()
4706                    .map(|p| p.to_string())
4707                    .collect::<Vec<String>>()
4708                    .join(",")
4709                    .to_string(),
4710            )]),
4711        };
4712    }
4713    if let Some(ref local_var_str) = created__isnull {
4714        local_var_req_builder =
4715            local_var_req_builder.query(&[("created__isnull", &local_var_str.to_string())]);
4716    }
4717    if let Some(ref local_var_str) = created__lt {
4718        local_var_req_builder = match "multi" {
4719            "multi" => local_var_req_builder.query(
4720                &local_var_str
4721                    .into_iter()
4722                    .map(|p| ("created__lt".to_owned(), p.to_string()))
4723                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4724            ),
4725            _ => local_var_req_builder.query(&[(
4726                "created__lt",
4727                &local_var_str
4728                    .into_iter()
4729                    .map(|p| p.to_string())
4730                    .collect::<Vec<String>>()
4731                    .join(",")
4732                    .to_string(),
4733            )]),
4734        };
4735    }
4736    if let Some(ref local_var_str) = created__lte {
4737        local_var_req_builder = match "multi" {
4738            "multi" => local_var_req_builder.query(
4739                &local_var_str
4740                    .into_iter()
4741                    .map(|p| ("created__lte".to_owned(), p.to_string()))
4742                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4743            ),
4744            _ => local_var_req_builder.query(&[(
4745                "created__lte",
4746                &local_var_str
4747                    .into_iter()
4748                    .map(|p| p.to_string())
4749                    .collect::<Vec<String>>()
4750                    .join(",")
4751                    .to_string(),
4752            )]),
4753        };
4754    }
4755    if let Some(ref local_var_str) = created__n {
4756        local_var_req_builder = match "multi" {
4757            "multi" => local_var_req_builder.query(
4758                &local_var_str
4759                    .into_iter()
4760                    .map(|p| ("created__n".to_owned(), p.to_string()))
4761                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4762            ),
4763            _ => local_var_req_builder.query(&[(
4764                "created__n",
4765                &local_var_str
4766                    .into_iter()
4767                    .map(|p| p.to_string())
4768                    .collect::<Vec<String>>()
4769                    .join(",")
4770                    .to_string(),
4771            )]),
4772        };
4773    }
4774    if let Some(ref local_var_str) = devices {
4775        local_var_req_builder = match "multi" {
4776            "multi" => local_var_req_builder.query(
4777                &local_var_str
4778                    .into_iter()
4779                    .map(|p| ("devices".to_owned(), p.to_string()))
4780                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4781            ),
4782            _ => local_var_req_builder.query(&[(
4783                "devices",
4784                &local_var_str
4785                    .into_iter()
4786                    .map(|p| p.to_string())
4787                    .collect::<Vec<String>>()
4788                    .join(",")
4789                    .to_string(),
4790            )]),
4791        };
4792    }
4793    if let Some(ref local_var_str) = devices__isnull {
4794        local_var_req_builder =
4795            local_var_req_builder.query(&[("devices__isnull", &local_var_str.to_string())]);
4796    }
4797    if let Some(ref local_var_str) = devices__n {
4798        local_var_req_builder = match "multi" {
4799            "multi" => local_var_req_builder.query(
4800                &local_var_str
4801                    .into_iter()
4802                    .map(|p| ("devices__n".to_owned(), p.to_string()))
4803                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4804            ),
4805            _ => local_var_req_builder.query(&[(
4806                "devices__n",
4807                &local_var_str
4808                    .into_iter()
4809                    .map(|p| p.to_string())
4810                    .collect::<Vec<String>>()
4811                    .join(",")
4812                    .to_string(),
4813            )]),
4814        };
4815    }
4816    if let Some(ref local_var_str) = dynamic_groups {
4817        local_var_req_builder = match "multi" {
4818            "multi" => local_var_req_builder.query(
4819                &local_var_str
4820                    .into_iter()
4821                    .map(|p| ("dynamic_groups".to_owned(), p.to_string()))
4822                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4823            ),
4824            _ => local_var_req_builder.query(&[(
4825                "dynamic_groups",
4826                &local_var_str
4827                    .into_iter()
4828                    .map(|p| p.to_string())
4829                    .collect::<Vec<String>>()
4830                    .join(",")
4831                    .to_string(),
4832            )]),
4833        };
4834    }
4835    if let Some(ref local_var_str) = dynamic_groups__n {
4836        local_var_req_builder = match "multi" {
4837            "multi" => local_var_req_builder.query(
4838                &local_var_str
4839                    .into_iter()
4840                    .map(|p| ("dynamic_groups__n".to_owned(), p.to_string()))
4841                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4842            ),
4843            _ => local_var_req_builder.query(&[(
4844                "dynamic_groups__n",
4845                &local_var_str
4846                    .into_iter()
4847                    .map(|p| p.to_string())
4848                    .collect::<Vec<String>>()
4849                    .join(",")
4850                    .to_string(),
4851            )]),
4852        };
4853    }
4854    if let Some(ref local_var_str) = format {
4855        local_var_req_builder =
4856            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
4857    }
4858    if let Some(ref local_var_str) = has_devices {
4859        local_var_req_builder =
4860            local_var_req_builder.query(&[("has_devices", &local_var_str.to_string())]);
4861    }
4862    if let Some(ref local_var_str) = has_virtual_machines {
4863        local_var_req_builder =
4864            local_var_req_builder.query(&[("has_virtual_machines", &local_var_str.to_string())]);
4865    }
4866    if let Some(ref local_var_str) = id {
4867        local_var_req_builder = match "multi" {
4868            "multi" => local_var_req_builder.query(
4869                &local_var_str
4870                    .into_iter()
4871                    .map(|p| ("id".to_owned(), p.to_string()))
4872                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4873            ),
4874            _ => local_var_req_builder.query(&[(
4875                "id",
4876                &local_var_str
4877                    .into_iter()
4878                    .map(|p| p.to_string())
4879                    .collect::<Vec<String>>()
4880                    .join(",")
4881                    .to_string(),
4882            )]),
4883        };
4884    }
4885    if let Some(ref local_var_str) = id__n {
4886        local_var_req_builder = match "multi" {
4887            "multi" => local_var_req_builder.query(
4888                &local_var_str
4889                    .into_iter()
4890                    .map(|p| ("id__n".to_owned(), p.to_string()))
4891                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4892            ),
4893            _ => local_var_req_builder.query(&[(
4894                "id__n",
4895                &local_var_str
4896                    .into_iter()
4897                    .map(|p| p.to_string())
4898                    .collect::<Vec<String>>()
4899                    .join(",")
4900                    .to_string(),
4901            )]),
4902        };
4903    }
4904    if let Some(ref local_var_str) = last_updated {
4905        local_var_req_builder = match "multi" {
4906            "multi" => local_var_req_builder.query(
4907                &local_var_str
4908                    .into_iter()
4909                    .map(|p| ("last_updated".to_owned(), p.to_string()))
4910                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4911            ),
4912            _ => local_var_req_builder.query(&[(
4913                "last_updated",
4914                &local_var_str
4915                    .into_iter()
4916                    .map(|p| p.to_string())
4917                    .collect::<Vec<String>>()
4918                    .join(",")
4919                    .to_string(),
4920            )]),
4921        };
4922    }
4923    if let Some(ref local_var_str) = last_updated__gt {
4924        local_var_req_builder = match "multi" {
4925            "multi" => local_var_req_builder.query(
4926                &local_var_str
4927                    .into_iter()
4928                    .map(|p| ("last_updated__gt".to_owned(), p.to_string()))
4929                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4930            ),
4931            _ => local_var_req_builder.query(&[(
4932                "last_updated__gt",
4933                &local_var_str
4934                    .into_iter()
4935                    .map(|p| p.to_string())
4936                    .collect::<Vec<String>>()
4937                    .join(",")
4938                    .to_string(),
4939            )]),
4940        };
4941    }
4942    if let Some(ref local_var_str) = last_updated__gte {
4943        local_var_req_builder = match "multi" {
4944            "multi" => local_var_req_builder.query(
4945                &local_var_str
4946                    .into_iter()
4947                    .map(|p| ("last_updated__gte".to_owned(), p.to_string()))
4948                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4949            ),
4950            _ => local_var_req_builder.query(&[(
4951                "last_updated__gte",
4952                &local_var_str
4953                    .into_iter()
4954                    .map(|p| p.to_string())
4955                    .collect::<Vec<String>>()
4956                    .join(",")
4957                    .to_string(),
4958            )]),
4959        };
4960    }
4961    if let Some(ref local_var_str) = last_updated__isnull {
4962        local_var_req_builder =
4963            local_var_req_builder.query(&[("last_updated__isnull", &local_var_str.to_string())]);
4964    }
4965    if let Some(ref local_var_str) = last_updated__lt {
4966        local_var_req_builder = match "multi" {
4967            "multi" => local_var_req_builder.query(
4968                &local_var_str
4969                    .into_iter()
4970                    .map(|p| ("last_updated__lt".to_owned(), p.to_string()))
4971                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4972            ),
4973            _ => local_var_req_builder.query(&[(
4974                "last_updated__lt",
4975                &local_var_str
4976                    .into_iter()
4977                    .map(|p| p.to_string())
4978                    .collect::<Vec<String>>()
4979                    .join(",")
4980                    .to_string(),
4981            )]),
4982        };
4983    }
4984    if let Some(ref local_var_str) = last_updated__lte {
4985        local_var_req_builder = match "multi" {
4986            "multi" => local_var_req_builder.query(
4987                &local_var_str
4988                    .into_iter()
4989                    .map(|p| ("last_updated__lte".to_owned(), p.to_string()))
4990                    .collect::<Vec<(std::string::String, std::string::String)>>(),
4991            ),
4992            _ => local_var_req_builder.query(&[(
4993                "last_updated__lte",
4994                &local_var_str
4995                    .into_iter()
4996                    .map(|p| p.to_string())
4997                    .collect::<Vec<String>>()
4998                    .join(",")
4999                    .to_string(),
5000            )]),
5001        };
5002    }
5003    if let Some(ref local_var_str) = last_updated__n {
5004        local_var_req_builder = match "multi" {
5005            "multi" => local_var_req_builder.query(
5006                &local_var_str
5007                    .into_iter()
5008                    .map(|p| ("last_updated__n".to_owned(), p.to_string()))
5009                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5010            ),
5011            _ => local_var_req_builder.query(&[(
5012                "last_updated__n",
5013                &local_var_str
5014                    .into_iter()
5015                    .map(|p| p.to_string())
5016                    .collect::<Vec<String>>()
5017                    .join(",")
5018                    .to_string(),
5019            )]),
5020        };
5021    }
5022    if let Some(ref local_var_str) = limit {
5023        local_var_req_builder =
5024            local_var_req_builder.query(&[("limit", &local_var_str.to_string())]);
5025    }
5026    if let Some(ref local_var_str) = location {
5027        local_var_req_builder = match "multi" {
5028            "multi" => local_var_req_builder.query(
5029                &local_var_str
5030                    .into_iter()
5031                    .map(|p| ("location".to_owned(), p.to_string()))
5032                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5033            ),
5034            _ => local_var_req_builder.query(&[(
5035                "location",
5036                &local_var_str
5037                    .into_iter()
5038                    .map(|p| p.to_string())
5039                    .collect::<Vec<String>>()
5040                    .join(",")
5041                    .to_string(),
5042            )]),
5043        };
5044    }
5045    if let Some(ref local_var_str) = location__isnull {
5046        local_var_req_builder =
5047            local_var_req_builder.query(&[("location__isnull", &local_var_str.to_string())]);
5048    }
5049    if let Some(ref local_var_str) = location__n {
5050        local_var_req_builder = match "multi" {
5051            "multi" => local_var_req_builder.query(
5052                &local_var_str
5053                    .into_iter()
5054                    .map(|p| ("location__n".to_owned(), p.to_string()))
5055                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5056            ),
5057            _ => local_var_req_builder.query(&[(
5058                "location__n",
5059                &local_var_str
5060                    .into_iter()
5061                    .map(|p| p.to_string())
5062                    .collect::<Vec<String>>()
5063                    .join(",")
5064                    .to_string(),
5065            )]),
5066        };
5067    }
5068    if let Some(ref local_var_str) = name {
5069        local_var_req_builder = match "multi" {
5070            "multi" => local_var_req_builder.query(
5071                &local_var_str
5072                    .into_iter()
5073                    .map(|p| ("name".to_owned(), p.to_string()))
5074                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5075            ),
5076            _ => local_var_req_builder.query(&[(
5077                "name",
5078                &local_var_str
5079                    .into_iter()
5080                    .map(|p| p.to_string())
5081                    .collect::<Vec<String>>()
5082                    .join(",")
5083                    .to_string(),
5084            )]),
5085        };
5086    }
5087    if let Some(ref local_var_str) = name__ic {
5088        local_var_req_builder = match "multi" {
5089            "multi" => local_var_req_builder.query(
5090                &local_var_str
5091                    .into_iter()
5092                    .map(|p| ("name__ic".to_owned(), p.to_string()))
5093                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5094            ),
5095            _ => local_var_req_builder.query(&[(
5096                "name__ic",
5097                &local_var_str
5098                    .into_iter()
5099                    .map(|p| p.to_string())
5100                    .collect::<Vec<String>>()
5101                    .join(",")
5102                    .to_string(),
5103            )]),
5104        };
5105    }
5106    if let Some(ref local_var_str) = name__ie {
5107        local_var_req_builder = match "multi" {
5108            "multi" => local_var_req_builder.query(
5109                &local_var_str
5110                    .into_iter()
5111                    .map(|p| ("name__ie".to_owned(), p.to_string()))
5112                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5113            ),
5114            _ => local_var_req_builder.query(&[(
5115                "name__ie",
5116                &local_var_str
5117                    .into_iter()
5118                    .map(|p| p.to_string())
5119                    .collect::<Vec<String>>()
5120                    .join(",")
5121                    .to_string(),
5122            )]),
5123        };
5124    }
5125    if let Some(ref local_var_str) = name__iew {
5126        local_var_req_builder = match "multi" {
5127            "multi" => local_var_req_builder.query(
5128                &local_var_str
5129                    .into_iter()
5130                    .map(|p| ("name__iew".to_owned(), p.to_string()))
5131                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5132            ),
5133            _ => local_var_req_builder.query(&[(
5134                "name__iew",
5135                &local_var_str
5136                    .into_iter()
5137                    .map(|p| p.to_string())
5138                    .collect::<Vec<String>>()
5139                    .join(",")
5140                    .to_string(),
5141            )]),
5142        };
5143    }
5144    if let Some(ref local_var_str) = name__ire {
5145        local_var_req_builder = match "multi" {
5146            "multi" => local_var_req_builder.query(
5147                &local_var_str
5148                    .into_iter()
5149                    .map(|p| ("name__ire".to_owned(), p.to_string()))
5150                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5151            ),
5152            _ => local_var_req_builder.query(&[(
5153                "name__ire",
5154                &local_var_str
5155                    .into_iter()
5156                    .map(|p| p.to_string())
5157                    .collect::<Vec<String>>()
5158                    .join(",")
5159                    .to_string(),
5160            )]),
5161        };
5162    }
5163    if let Some(ref local_var_str) = name__isw {
5164        local_var_req_builder = match "multi" {
5165            "multi" => local_var_req_builder.query(
5166                &local_var_str
5167                    .into_iter()
5168                    .map(|p| ("name__isw".to_owned(), p.to_string()))
5169                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5170            ),
5171            _ => local_var_req_builder.query(&[(
5172                "name__isw",
5173                &local_var_str
5174                    .into_iter()
5175                    .map(|p| p.to_string())
5176                    .collect::<Vec<String>>()
5177                    .join(",")
5178                    .to_string(),
5179            )]),
5180        };
5181    }
5182    if let Some(ref local_var_str) = name__n {
5183        local_var_req_builder = match "multi" {
5184            "multi" => local_var_req_builder.query(
5185                &local_var_str
5186                    .into_iter()
5187                    .map(|p| ("name__n".to_owned(), p.to_string()))
5188                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5189            ),
5190            _ => local_var_req_builder.query(&[(
5191                "name__n",
5192                &local_var_str
5193                    .into_iter()
5194                    .map(|p| p.to_string())
5195                    .collect::<Vec<String>>()
5196                    .join(",")
5197                    .to_string(),
5198            )]),
5199        };
5200    }
5201    if let Some(ref local_var_str) = name__nic {
5202        local_var_req_builder = match "multi" {
5203            "multi" => local_var_req_builder.query(
5204                &local_var_str
5205                    .into_iter()
5206                    .map(|p| ("name__nic".to_owned(), p.to_string()))
5207                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5208            ),
5209            _ => local_var_req_builder.query(&[(
5210                "name__nic",
5211                &local_var_str
5212                    .into_iter()
5213                    .map(|p| p.to_string())
5214                    .collect::<Vec<String>>()
5215                    .join(",")
5216                    .to_string(),
5217            )]),
5218        };
5219    }
5220    if let Some(ref local_var_str) = name__nie {
5221        local_var_req_builder = match "multi" {
5222            "multi" => local_var_req_builder.query(
5223                &local_var_str
5224                    .into_iter()
5225                    .map(|p| ("name__nie".to_owned(), p.to_string()))
5226                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5227            ),
5228            _ => local_var_req_builder.query(&[(
5229                "name__nie",
5230                &local_var_str
5231                    .into_iter()
5232                    .map(|p| p.to_string())
5233                    .collect::<Vec<String>>()
5234                    .join(",")
5235                    .to_string(),
5236            )]),
5237        };
5238    }
5239    if let Some(ref local_var_str) = name__niew {
5240        local_var_req_builder = match "multi" {
5241            "multi" => local_var_req_builder.query(
5242                &local_var_str
5243                    .into_iter()
5244                    .map(|p| ("name__niew".to_owned(), p.to_string()))
5245                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5246            ),
5247            _ => local_var_req_builder.query(&[(
5248                "name__niew",
5249                &local_var_str
5250                    .into_iter()
5251                    .map(|p| p.to_string())
5252                    .collect::<Vec<String>>()
5253                    .join(",")
5254                    .to_string(),
5255            )]),
5256        };
5257    }
5258    if let Some(ref local_var_str) = name__nire {
5259        local_var_req_builder = match "multi" {
5260            "multi" => local_var_req_builder.query(
5261                &local_var_str
5262                    .into_iter()
5263                    .map(|p| ("name__nire".to_owned(), p.to_string()))
5264                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5265            ),
5266            _ => local_var_req_builder.query(&[(
5267                "name__nire",
5268                &local_var_str
5269                    .into_iter()
5270                    .map(|p| p.to_string())
5271                    .collect::<Vec<String>>()
5272                    .join(",")
5273                    .to_string(),
5274            )]),
5275        };
5276    }
5277    if let Some(ref local_var_str) = name__nisw {
5278        local_var_req_builder = match "multi" {
5279            "multi" => local_var_req_builder.query(
5280                &local_var_str
5281                    .into_iter()
5282                    .map(|p| ("name__nisw".to_owned(), p.to_string()))
5283                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5284            ),
5285            _ => local_var_req_builder.query(&[(
5286                "name__nisw",
5287                &local_var_str
5288                    .into_iter()
5289                    .map(|p| p.to_string())
5290                    .collect::<Vec<String>>()
5291                    .join(",")
5292                    .to_string(),
5293            )]),
5294        };
5295    }
5296    if let Some(ref local_var_str) = name__nre {
5297        local_var_req_builder = match "multi" {
5298            "multi" => local_var_req_builder.query(
5299                &local_var_str
5300                    .into_iter()
5301                    .map(|p| ("name__nre".to_owned(), p.to_string()))
5302                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5303            ),
5304            _ => local_var_req_builder.query(&[(
5305                "name__nre",
5306                &local_var_str
5307                    .into_iter()
5308                    .map(|p| p.to_string())
5309                    .collect::<Vec<String>>()
5310                    .join(",")
5311                    .to_string(),
5312            )]),
5313        };
5314    }
5315    if let Some(ref local_var_str) = name__re {
5316        local_var_req_builder = match "multi" {
5317            "multi" => local_var_req_builder.query(
5318                &local_var_str
5319                    .into_iter()
5320                    .map(|p| ("name__re".to_owned(), p.to_string()))
5321                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5322            ),
5323            _ => local_var_req_builder.query(&[(
5324                "name__re",
5325                &local_var_str
5326                    .into_iter()
5327                    .map(|p| p.to_string())
5328                    .collect::<Vec<String>>()
5329                    .join(",")
5330                    .to_string(),
5331            )]),
5332        };
5333    }
5334    if let Some(ref local_var_str) = offset {
5335        local_var_req_builder =
5336            local_var_req_builder.query(&[("offset", &local_var_str.to_string())]);
5337    }
5338    if let Some(ref local_var_str) = q {
5339        local_var_req_builder = local_var_req_builder.query(&[("q", &local_var_str.to_string())]);
5340    }
5341    if let Some(ref local_var_str) = sort {
5342        local_var_req_builder =
5343            local_var_req_builder.query(&[("sort", &local_var_str.to_string())]);
5344    }
5345    if let Some(ref local_var_str) = tags {
5346        local_var_req_builder = match "multi" {
5347            "multi" => local_var_req_builder.query(
5348                &local_var_str
5349                    .into_iter()
5350                    .map(|p| ("tags".to_owned(), p.to_string()))
5351                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5352            ),
5353            _ => local_var_req_builder.query(&[(
5354                "tags",
5355                &local_var_str
5356                    .into_iter()
5357                    .map(|p| p.to_string())
5358                    .collect::<Vec<String>>()
5359                    .join(",")
5360                    .to_string(),
5361            )]),
5362        };
5363    }
5364    if let Some(ref local_var_str) = tags__isnull {
5365        local_var_req_builder =
5366            local_var_req_builder.query(&[("tags__isnull", &local_var_str.to_string())]);
5367    }
5368    if let Some(ref local_var_str) = tags__n {
5369        local_var_req_builder = match "multi" {
5370            "multi" => local_var_req_builder.query(
5371                &local_var_str
5372                    .into_iter()
5373                    .map(|p| ("tags__n".to_owned(), p.to_string()))
5374                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5375            ),
5376            _ => local_var_req_builder.query(&[(
5377                "tags__n",
5378                &local_var_str
5379                    .into_iter()
5380                    .map(|p| p.to_string())
5381                    .collect::<Vec<String>>()
5382                    .join(",")
5383                    .to_string(),
5384            )]),
5385        };
5386    }
5387    if let Some(ref local_var_str) = teams {
5388        local_var_req_builder = match "multi" {
5389            "multi" => local_var_req_builder.query(
5390                &local_var_str
5391                    .into_iter()
5392                    .map(|p| ("teams".to_owned(), p.to_string()))
5393                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5394            ),
5395            _ => local_var_req_builder.query(&[(
5396                "teams",
5397                &local_var_str
5398                    .into_iter()
5399                    .map(|p| p.to_string())
5400                    .collect::<Vec<String>>()
5401                    .join(",")
5402                    .to_string(),
5403            )]),
5404        };
5405    }
5406    if let Some(ref local_var_str) = teams__isnull {
5407        local_var_req_builder =
5408            local_var_req_builder.query(&[("teams__isnull", &local_var_str.to_string())]);
5409    }
5410    if let Some(ref local_var_str) = teams__n {
5411        local_var_req_builder = match "multi" {
5412            "multi" => local_var_req_builder.query(
5413                &local_var_str
5414                    .into_iter()
5415                    .map(|p| ("teams__n".to_owned(), p.to_string()))
5416                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5417            ),
5418            _ => local_var_req_builder.query(&[(
5419                "teams__n",
5420                &local_var_str
5421                    .into_iter()
5422                    .map(|p| p.to_string())
5423                    .collect::<Vec<String>>()
5424                    .join(",")
5425                    .to_string(),
5426            )]),
5427        };
5428    }
5429    if let Some(ref local_var_str) = tenant {
5430        local_var_req_builder = match "multi" {
5431            "multi" => local_var_req_builder.query(
5432                &local_var_str
5433                    .into_iter()
5434                    .map(|p| ("tenant".to_owned(), p.to_string()))
5435                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5436            ),
5437            _ => local_var_req_builder.query(&[(
5438                "tenant",
5439                &local_var_str
5440                    .into_iter()
5441                    .map(|p| p.to_string())
5442                    .collect::<Vec<String>>()
5443                    .join(",")
5444                    .to_string(),
5445            )]),
5446        };
5447    }
5448    if let Some(ref local_var_str) = tenant__isnull {
5449        local_var_req_builder =
5450            local_var_req_builder.query(&[("tenant__isnull", &local_var_str.to_string())]);
5451    }
5452    if let Some(ref local_var_str) = tenant__n {
5453        local_var_req_builder = match "multi" {
5454            "multi" => local_var_req_builder.query(
5455                &local_var_str
5456                    .into_iter()
5457                    .map(|p| ("tenant__n".to_owned(), p.to_string()))
5458                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5459            ),
5460            _ => local_var_req_builder.query(&[(
5461                "tenant__n",
5462                &local_var_str
5463                    .into_iter()
5464                    .map(|p| p.to_string())
5465                    .collect::<Vec<String>>()
5466                    .join(",")
5467                    .to_string(),
5468            )]),
5469        };
5470    }
5471    if let Some(ref local_var_str) = tenant_group {
5472        local_var_req_builder = match "multi" {
5473            "multi" => local_var_req_builder.query(
5474                &local_var_str
5475                    .into_iter()
5476                    .map(|p| ("tenant_group".to_owned(), p.to_string()))
5477                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5478            ),
5479            _ => local_var_req_builder.query(&[(
5480                "tenant_group",
5481                &local_var_str
5482                    .into_iter()
5483                    .map(|p| p.to_string())
5484                    .collect::<Vec<String>>()
5485                    .join(",")
5486                    .to_string(),
5487            )]),
5488        };
5489    }
5490    if let Some(ref local_var_str) = tenant_group__isnull {
5491        local_var_req_builder =
5492            local_var_req_builder.query(&[("tenant_group__isnull", &local_var_str.to_string())]);
5493    }
5494    if let Some(ref local_var_str) = tenant_group__n {
5495        local_var_req_builder = match "multi" {
5496            "multi" => local_var_req_builder.query(
5497                &local_var_str
5498                    .into_iter()
5499                    .map(|p| ("tenant_group__n".to_owned(), p.to_string()))
5500                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5501            ),
5502            _ => local_var_req_builder.query(&[(
5503                "tenant_group__n",
5504                &local_var_str
5505                    .into_iter()
5506                    .map(|p| p.to_string())
5507                    .collect::<Vec<String>>()
5508                    .join(",")
5509                    .to_string(),
5510            )]),
5511        };
5512    }
5513    if let Some(ref local_var_str) = tenant_id {
5514        local_var_req_builder = match "multi" {
5515            "multi" => local_var_req_builder.query(
5516                &local_var_str
5517                    .into_iter()
5518                    .map(|p| ("tenant_id".to_owned(), p.to_string()))
5519                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5520            ),
5521            _ => local_var_req_builder.query(&[(
5522                "tenant_id",
5523                &local_var_str
5524                    .into_iter()
5525                    .map(|p| p.to_string())
5526                    .collect::<Vec<String>>()
5527                    .join(",")
5528                    .to_string(),
5529            )]),
5530        };
5531    }
5532    if let Some(ref local_var_str) = tenant_id__isnull {
5533        local_var_req_builder =
5534            local_var_req_builder.query(&[("tenant_id__isnull", &local_var_str.to_string())]);
5535    }
5536    if let Some(ref local_var_str) = tenant_id__n {
5537        local_var_req_builder = match "multi" {
5538            "multi" => local_var_req_builder.query(
5539                &local_var_str
5540                    .into_iter()
5541                    .map(|p| ("tenant_id__n".to_owned(), p.to_string()))
5542                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5543            ),
5544            _ => local_var_req_builder.query(&[(
5545                "tenant_id__n",
5546                &local_var_str
5547                    .into_iter()
5548                    .map(|p| p.to_string())
5549                    .collect::<Vec<String>>()
5550                    .join(",")
5551                    .to_string(),
5552            )]),
5553        };
5554    }
5555    if let Some(ref local_var_str) = virtual_machines {
5556        local_var_req_builder = match "multi" {
5557            "multi" => local_var_req_builder.query(
5558                &local_var_str
5559                    .into_iter()
5560                    .map(|p| ("virtual_machines".to_owned(), p.to_string()))
5561                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5562            ),
5563            _ => local_var_req_builder.query(&[(
5564                "virtual_machines",
5565                &local_var_str
5566                    .into_iter()
5567                    .map(|p| p.to_string())
5568                    .collect::<Vec<String>>()
5569                    .join(",")
5570                    .to_string(),
5571            )]),
5572        };
5573    }
5574    if let Some(ref local_var_str) = virtual_machines__isnull {
5575        local_var_req_builder = local_var_req_builder
5576            .query(&[("virtual_machines__isnull", &local_var_str.to_string())]);
5577    }
5578    if let Some(ref local_var_str) = virtual_machines__n {
5579        local_var_req_builder = match "multi" {
5580            "multi" => local_var_req_builder.query(
5581                &local_var_str
5582                    .into_iter()
5583                    .map(|p| ("virtual_machines__n".to_owned(), p.to_string()))
5584                    .collect::<Vec<(std::string::String, std::string::String)>>(),
5585            ),
5586            _ => local_var_req_builder.query(&[(
5587                "virtual_machines__n",
5588                &local_var_str
5589                    .into_iter()
5590                    .map(|p| p.to_string())
5591                    .collect::<Vec<String>>()
5592                    .join(",")
5593                    .to_string(),
5594            )]),
5595        };
5596    }
5597    if let Some(ref local_var_str) = depth {
5598        local_var_req_builder =
5599            local_var_req_builder.query(&[("depth", &local_var_str.to_string())]);
5600    }
5601    if let Some(ref local_var_str) = exclude_m2m {
5602        local_var_req_builder =
5603            local_var_req_builder.query(&[("exclude_m2m", &local_var_str.to_string())]);
5604    }
5605    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
5606        local_var_req_builder =
5607            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
5608    }
5609    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
5610        let local_var_key = local_var_apikey.key.clone();
5611        let local_var_value = match local_var_apikey.prefix {
5612            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
5613            None => local_var_key,
5614        };
5615        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
5616    };
5617
5618    let local_var_req = local_var_req_builder.build()?;
5619    let local_var_resp = local_var_client.execute(local_var_req).await?;
5620
5621    let local_var_status = local_var_resp.status();
5622    let local_var_content = local_var_resp.text().await?;
5623
5624    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
5625        serde_json::from_str(&local_var_content).map_err(Error::from)
5626    } else {
5627        let local_var_entity: Option<VirtualizationClustersListError> =
5628            serde_json::from_str(&local_var_content).ok();
5629        let local_var_error = ResponseContent {
5630            status: local_var_status,
5631            content: local_var_content,
5632            entity: local_var_entity,
5633        };
5634        Err(Error::ResponseError(local_var_error))
5635    }
5636}
5637
5638/// API methods for returning or creating notes on an object.
5639pub async fn virtualization_clusters_notes_create(
5640    configuration: &configuration::Configuration,
5641    id: &str,
5642    note_input_request: crate::models::NoteInputRequest,
5643    format: Option<&str>,
5644) -> Result<crate::models::Note, Error<VirtualizationClustersNotesCreateError>> {
5645    let local_var_configuration = configuration;
5646
5647    let local_var_client = &local_var_configuration.client;
5648
5649    let local_var_uri_str = format!(
5650        "{}/virtualization/clusters/{id}/notes/",
5651        local_var_configuration.base_path,
5652        id = crate::apis::urlencode(id)
5653    );
5654    let mut local_var_req_builder =
5655        local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
5656
5657    if let Some(ref local_var_str) = format {
5658        local_var_req_builder =
5659            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
5660    }
5661    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
5662        local_var_req_builder =
5663            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
5664    }
5665    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
5666        let local_var_key = local_var_apikey.key.clone();
5667        let local_var_value = match local_var_apikey.prefix {
5668            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
5669            None => local_var_key,
5670        };
5671        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
5672    };
5673    local_var_req_builder = local_var_req_builder.json(&note_input_request);
5674
5675    let local_var_req = local_var_req_builder.build()?;
5676    let local_var_resp = local_var_client.execute(local_var_req).await?;
5677
5678    let local_var_status = local_var_resp.status();
5679    let local_var_content = local_var_resp.text().await?;
5680
5681    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
5682        serde_json::from_str(&local_var_content).map_err(Error::from)
5683    } else {
5684        let local_var_entity: Option<VirtualizationClustersNotesCreateError> =
5685            serde_json::from_str(&local_var_content).ok();
5686        let local_var_error = ResponseContent {
5687            status: local_var_status,
5688            content: local_var_content,
5689            entity: local_var_entity,
5690        };
5691        Err(Error::ResponseError(local_var_error))
5692    }
5693}
5694
5695/// API methods for returning or creating notes on an object.
5696pub async fn virtualization_clusters_notes_list(
5697    configuration: &configuration::Configuration,
5698    id: &str,
5699    format: Option<&str>,
5700    limit: Option<i32>,
5701    offset: Option<i32>,
5702    depth: Option<i32>,
5703    exclude_m2m: Option<bool>,
5704) -> Result<crate::models::PaginatedNoteList, Error<VirtualizationClustersNotesListError>> {
5705    let local_var_configuration = configuration;
5706
5707    let local_var_client = &local_var_configuration.client;
5708
5709    let local_var_uri_str = format!(
5710        "{}/virtualization/clusters/{id}/notes/",
5711        local_var_configuration.base_path,
5712        id = crate::apis::urlencode(id)
5713    );
5714    let mut local_var_req_builder =
5715        local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
5716
5717    if let Some(ref local_var_str) = format {
5718        local_var_req_builder =
5719            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
5720    }
5721    if let Some(ref local_var_str) = limit {
5722        local_var_req_builder =
5723            local_var_req_builder.query(&[("limit", &local_var_str.to_string())]);
5724    }
5725    if let Some(ref local_var_str) = offset {
5726        local_var_req_builder =
5727            local_var_req_builder.query(&[("offset", &local_var_str.to_string())]);
5728    }
5729    if let Some(ref local_var_str) = depth {
5730        local_var_req_builder =
5731            local_var_req_builder.query(&[("depth", &local_var_str.to_string())]);
5732    }
5733    if let Some(ref local_var_str) = exclude_m2m {
5734        local_var_req_builder =
5735            local_var_req_builder.query(&[("exclude_m2m", &local_var_str.to_string())]);
5736    }
5737    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
5738        local_var_req_builder =
5739            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
5740    }
5741    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
5742        let local_var_key = local_var_apikey.key.clone();
5743        let local_var_value = match local_var_apikey.prefix {
5744            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
5745            None => local_var_key,
5746        };
5747        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
5748    };
5749
5750    let local_var_req = local_var_req_builder.build()?;
5751    let local_var_resp = local_var_client.execute(local_var_req).await?;
5752
5753    let local_var_status = local_var_resp.status();
5754    let local_var_content = local_var_resp.text().await?;
5755
5756    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
5757        serde_json::from_str(&local_var_content).map_err(Error::from)
5758    } else {
5759        let local_var_entity: Option<VirtualizationClustersNotesListError> =
5760            serde_json::from_str(&local_var_content).ok();
5761        let local_var_error = ResponseContent {
5762            status: local_var_status,
5763            content: local_var_content,
5764            entity: local_var_entity,
5765        };
5766        Err(Error::ResponseError(local_var_error))
5767    }
5768}
5769
5770/// Partial update a cluster object.
5771pub async fn virtualization_clusters_partial_update(
5772    configuration: &configuration::Configuration,
5773    id: &str,
5774    format: Option<&str>,
5775    patched_cluster_request: Option<crate::models::PatchedClusterRequest>,
5776) -> Result<crate::models::Cluster, Error<VirtualizationClustersPartialUpdateError>> {
5777    let local_var_configuration = configuration;
5778
5779    let local_var_client = &local_var_configuration.client;
5780
5781    let local_var_uri_str = format!(
5782        "{}/virtualization/clusters/{id}/",
5783        local_var_configuration.base_path,
5784        id = crate::apis::urlencode(id)
5785    );
5786    let mut local_var_req_builder =
5787        local_var_client.request(reqwest::Method::PATCH, local_var_uri_str.as_str());
5788
5789    if let Some(ref local_var_str) = format {
5790        local_var_req_builder =
5791            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
5792    }
5793    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
5794        local_var_req_builder =
5795            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
5796    }
5797    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
5798        let local_var_key = local_var_apikey.key.clone();
5799        let local_var_value = match local_var_apikey.prefix {
5800            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
5801            None => local_var_key,
5802        };
5803        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
5804    };
5805    local_var_req_builder = local_var_req_builder.json(&patched_cluster_request);
5806
5807    let local_var_req = local_var_req_builder.build()?;
5808    let local_var_resp = local_var_client.execute(local_var_req).await?;
5809
5810    let local_var_status = local_var_resp.status();
5811    let local_var_content = local_var_resp.text().await?;
5812
5813    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
5814        serde_json::from_str(&local_var_content).map_err(Error::from)
5815    } else {
5816        let local_var_entity: Option<VirtualizationClustersPartialUpdateError> =
5817            serde_json::from_str(&local_var_content).ok();
5818        let local_var_error = ResponseContent {
5819            status: local_var_status,
5820            content: local_var_content,
5821            entity: local_var_entity,
5822        };
5823        Err(Error::ResponseError(local_var_error))
5824    }
5825}
5826
5827/// Retrieve a cluster object.
5828pub async fn virtualization_clusters_retrieve(
5829    configuration: &configuration::Configuration,
5830    id: &str,
5831    format: Option<&str>,
5832    depth: Option<i32>,
5833    exclude_m2m: Option<bool>,
5834) -> Result<crate::models::Cluster, Error<VirtualizationClustersRetrieveError>> {
5835    let local_var_configuration = configuration;
5836
5837    let local_var_client = &local_var_configuration.client;
5838
5839    let local_var_uri_str = format!(
5840        "{}/virtualization/clusters/{id}/",
5841        local_var_configuration.base_path,
5842        id = crate::apis::urlencode(id)
5843    );
5844    let mut local_var_req_builder =
5845        local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
5846
5847    if let Some(ref local_var_str) = format {
5848        local_var_req_builder =
5849            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
5850    }
5851    if let Some(ref local_var_str) = depth {
5852        local_var_req_builder =
5853            local_var_req_builder.query(&[("depth", &local_var_str.to_string())]);
5854    }
5855    if let Some(ref local_var_str) = exclude_m2m {
5856        local_var_req_builder =
5857            local_var_req_builder.query(&[("exclude_m2m", &local_var_str.to_string())]);
5858    }
5859    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
5860        local_var_req_builder =
5861            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
5862    }
5863    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
5864        let local_var_key = local_var_apikey.key.clone();
5865        let local_var_value = match local_var_apikey.prefix {
5866            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
5867            None => local_var_key,
5868        };
5869        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
5870    };
5871
5872    let local_var_req = local_var_req_builder.build()?;
5873    let local_var_resp = local_var_client.execute(local_var_req).await?;
5874
5875    let local_var_status = local_var_resp.status();
5876    let local_var_content = local_var_resp.text().await?;
5877
5878    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
5879        serde_json::from_str(&local_var_content).map_err(Error::from)
5880    } else {
5881        let local_var_entity: Option<VirtualizationClustersRetrieveError> =
5882            serde_json::from_str(&local_var_content).ok();
5883        let local_var_error = ResponseContent {
5884            status: local_var_status,
5885            content: local_var_content,
5886            entity: local_var_entity,
5887        };
5888        Err(Error::ResponseError(local_var_error))
5889    }
5890}
5891
5892/// Update a cluster object.
5893pub async fn virtualization_clusters_update(
5894    configuration: &configuration::Configuration,
5895    id: &str,
5896    cluster_request: crate::models::ClusterRequest,
5897    format: Option<&str>,
5898) -> Result<crate::models::Cluster, Error<VirtualizationClustersUpdateError>> {
5899    let local_var_configuration = configuration;
5900
5901    let local_var_client = &local_var_configuration.client;
5902
5903    let local_var_uri_str = format!(
5904        "{}/virtualization/clusters/{id}/",
5905        local_var_configuration.base_path,
5906        id = crate::apis::urlencode(id)
5907    );
5908    let mut local_var_req_builder =
5909        local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());
5910
5911    if let Some(ref local_var_str) = format {
5912        local_var_req_builder =
5913            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
5914    }
5915    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
5916        local_var_req_builder =
5917            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
5918    }
5919    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
5920        let local_var_key = local_var_apikey.key.clone();
5921        let local_var_value = match local_var_apikey.prefix {
5922            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
5923            None => local_var_key,
5924        };
5925        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
5926    };
5927    local_var_req_builder = local_var_req_builder.json(&cluster_request);
5928
5929    let local_var_req = local_var_req_builder.build()?;
5930    let local_var_resp = local_var_client.execute(local_var_req).await?;
5931
5932    let local_var_status = local_var_resp.status();
5933    let local_var_content = local_var_resp.text().await?;
5934
5935    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
5936        serde_json::from_str(&local_var_content).map_err(Error::from)
5937    } else {
5938        let local_var_entity: Option<VirtualizationClustersUpdateError> =
5939            serde_json::from_str(&local_var_content).ok();
5940        let local_var_error = ResponseContent {
5941            status: local_var_status,
5942            content: local_var_content,
5943            entity: local_var_entity,
5944        };
5945        Err(Error::ResponseError(local_var_error))
5946    }
5947}
5948
5949/// Destroy a list of VM interface objects.
5950pub async fn virtualization_interfaces_bulk_destroy(
5951    configuration: &configuration::Configuration,
5952    bulk_operation_request: Vec<crate::models::BulkOperationRequest>,
5953    format: Option<&str>,
5954) -> Result<(), Error<VirtualizationInterfacesBulkDestroyError>> {
5955    let local_var_configuration = configuration;
5956
5957    let local_var_client = &local_var_configuration.client;
5958
5959    let local_var_uri_str = format!(
5960        "{}/virtualization/interfaces/",
5961        local_var_configuration.base_path
5962    );
5963    let mut local_var_req_builder =
5964        local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());
5965
5966    if let Some(ref local_var_str) = format {
5967        local_var_req_builder =
5968            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
5969    }
5970    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
5971        local_var_req_builder =
5972            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
5973    }
5974    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
5975        let local_var_key = local_var_apikey.key.clone();
5976        let local_var_value = match local_var_apikey.prefix {
5977            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
5978            None => local_var_key,
5979        };
5980        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
5981    };
5982    local_var_req_builder = local_var_req_builder.json(&bulk_operation_request);
5983
5984    let local_var_req = local_var_req_builder.build()?;
5985    let local_var_resp = local_var_client.execute(local_var_req).await?;
5986
5987    let local_var_status = local_var_resp.status();
5988    let local_var_content = local_var_resp.text().await?;
5989
5990    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
5991        Ok(())
5992    } else {
5993        let local_var_entity: Option<VirtualizationInterfacesBulkDestroyError> =
5994            serde_json::from_str(&local_var_content).ok();
5995        let local_var_error = ResponseContent {
5996            status: local_var_status,
5997            content: local_var_content,
5998            entity: local_var_entity,
5999        };
6000        Err(Error::ResponseError(local_var_error))
6001    }
6002}
6003
6004/// Partial update a list of VM interface objects.
6005pub async fn virtualization_interfaces_bulk_partial_update(
6006    configuration: &configuration::Configuration,
6007    patched_bulk_writable_vm_interface_request: Vec<
6008        crate::models::PatchedBulkWritableVmInterfaceRequest,
6009    >,
6010    format: Option<&str>,
6011) -> Result<Vec<crate::models::VmInterface>, Error<VirtualizationInterfacesBulkPartialUpdateError>>
6012{
6013    let local_var_configuration = configuration;
6014
6015    let local_var_client = &local_var_configuration.client;
6016
6017    let local_var_uri_str = format!(
6018        "{}/virtualization/interfaces/",
6019        local_var_configuration.base_path
6020    );
6021    let mut local_var_req_builder =
6022        local_var_client.request(reqwest::Method::PATCH, local_var_uri_str.as_str());
6023
6024    if let Some(ref local_var_str) = format {
6025        local_var_req_builder =
6026            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
6027    }
6028    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
6029        local_var_req_builder =
6030            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
6031    }
6032    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
6033        let local_var_key = local_var_apikey.key.clone();
6034        let local_var_value = match local_var_apikey.prefix {
6035            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
6036            None => local_var_key,
6037        };
6038        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
6039    };
6040    local_var_req_builder = local_var_req_builder.json(&patched_bulk_writable_vm_interface_request);
6041
6042    let local_var_req = local_var_req_builder.build()?;
6043    let local_var_resp = local_var_client.execute(local_var_req).await?;
6044
6045    let local_var_status = local_var_resp.status();
6046    let local_var_content = local_var_resp.text().await?;
6047
6048    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
6049        serde_json::from_str(&local_var_content).map_err(Error::from)
6050    } else {
6051        let local_var_entity: Option<VirtualizationInterfacesBulkPartialUpdateError> =
6052            serde_json::from_str(&local_var_content).ok();
6053        let local_var_error = ResponseContent {
6054            status: local_var_status,
6055            content: local_var_content,
6056            entity: local_var_entity,
6057        };
6058        Err(Error::ResponseError(local_var_error))
6059    }
6060}
6061
6062/// Update a list of VM interface objects.
6063pub async fn virtualization_interfaces_bulk_update(
6064    configuration: &configuration::Configuration,
6065    bulk_writable_vm_interface_request: Vec<crate::models::BulkWritableVmInterfaceRequest>,
6066    format: Option<&str>,
6067) -> Result<Vec<crate::models::VmInterface>, Error<VirtualizationInterfacesBulkUpdateError>> {
6068    let local_var_configuration = configuration;
6069
6070    let local_var_client = &local_var_configuration.client;
6071
6072    let local_var_uri_str = format!(
6073        "{}/virtualization/interfaces/",
6074        local_var_configuration.base_path
6075    );
6076    let mut local_var_req_builder =
6077        local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());
6078
6079    if let Some(ref local_var_str) = format {
6080        local_var_req_builder =
6081            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
6082    }
6083    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
6084        local_var_req_builder =
6085            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
6086    }
6087    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
6088        let local_var_key = local_var_apikey.key.clone();
6089        let local_var_value = match local_var_apikey.prefix {
6090            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
6091            None => local_var_key,
6092        };
6093        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
6094    };
6095    local_var_req_builder = local_var_req_builder.json(&bulk_writable_vm_interface_request);
6096
6097    let local_var_req = local_var_req_builder.build()?;
6098    let local_var_resp = local_var_client.execute(local_var_req).await?;
6099
6100    let local_var_status = local_var_resp.status();
6101    let local_var_content = local_var_resp.text().await?;
6102
6103    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
6104        serde_json::from_str(&local_var_content).map_err(Error::from)
6105    } else {
6106        let local_var_entity: Option<VirtualizationInterfacesBulkUpdateError> =
6107            serde_json::from_str(&local_var_content).ok();
6108        let local_var_error = ResponseContent {
6109            status: local_var_status,
6110            content: local_var_content,
6111            entity: local_var_entity,
6112        };
6113        Err(Error::ResponseError(local_var_error))
6114    }
6115}
6116
6117/// Create one or more VM interface objects.
6118pub async fn virtualization_interfaces_create(
6119    configuration: &configuration::Configuration,
6120    writable_vm_interface_request: crate::models::WritableVmInterfaceRequest,
6121    format: Option<&str>,
6122) -> Result<crate::models::VmInterface, Error<VirtualizationInterfacesCreateError>> {
6123    let local_var_configuration = configuration;
6124
6125    let local_var_client = &local_var_configuration.client;
6126
6127    let local_var_uri_str = format!(
6128        "{}/virtualization/interfaces/",
6129        local_var_configuration.base_path
6130    );
6131    let mut local_var_req_builder =
6132        local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
6133
6134    if let Some(ref local_var_str) = format {
6135        local_var_req_builder =
6136            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
6137    }
6138    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
6139        local_var_req_builder =
6140            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
6141    }
6142    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
6143        let local_var_key = local_var_apikey.key.clone();
6144        let local_var_value = match local_var_apikey.prefix {
6145            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
6146            None => local_var_key,
6147        };
6148        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
6149    };
6150    local_var_req_builder = local_var_req_builder.json(&writable_vm_interface_request);
6151
6152    let local_var_req = local_var_req_builder.build()?;
6153    let local_var_resp = local_var_client.execute(local_var_req).await?;
6154
6155    let local_var_status = local_var_resp.status();
6156    let local_var_content = local_var_resp.text().await?;
6157
6158    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
6159        serde_json::from_str(&local_var_content).map_err(Error::from)
6160    } else {
6161        let local_var_entity: Option<VirtualizationInterfacesCreateError> =
6162            serde_json::from_str(&local_var_content).ok();
6163        let local_var_error = ResponseContent {
6164            status: local_var_status,
6165            content: local_var_content,
6166            entity: local_var_entity,
6167        };
6168        Err(Error::ResponseError(local_var_error))
6169    }
6170}
6171
6172/// Destroy a VM interface object.
6173pub async fn virtualization_interfaces_destroy(
6174    configuration: &configuration::Configuration,
6175    id: &str,
6176    format: Option<&str>,
6177) -> Result<(), Error<VirtualizationInterfacesDestroyError>> {
6178    let local_var_configuration = configuration;
6179
6180    let local_var_client = &local_var_configuration.client;
6181
6182    let local_var_uri_str = format!(
6183        "{}/virtualization/interfaces/{id}/",
6184        local_var_configuration.base_path,
6185        id = crate::apis::urlencode(id)
6186    );
6187    let mut local_var_req_builder =
6188        local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());
6189
6190    if let Some(ref local_var_str) = format {
6191        local_var_req_builder =
6192            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
6193    }
6194    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
6195        local_var_req_builder =
6196            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
6197    }
6198    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
6199        let local_var_key = local_var_apikey.key.clone();
6200        let local_var_value = match local_var_apikey.prefix {
6201            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
6202            None => local_var_key,
6203        };
6204        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
6205    };
6206
6207    let local_var_req = local_var_req_builder.build()?;
6208    let local_var_resp = local_var_client.execute(local_var_req).await?;
6209
6210    let local_var_status = local_var_resp.status();
6211    let local_var_content = local_var_resp.text().await?;
6212
6213    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
6214        Ok(())
6215    } else {
6216        let local_var_entity: Option<VirtualizationInterfacesDestroyError> =
6217            serde_json::from_str(&local_var_content).ok();
6218        let local_var_error = ResponseContent {
6219            status: local_var_status,
6220            content: local_var_content,
6221            entity: local_var_entity,
6222        };
6223        Err(Error::ResponseError(local_var_error))
6224    }
6225}
6226
6227/// Retrieve a list of VM interface objects.
6228pub async fn virtualization_interfaces_list(
6229    configuration: &configuration::Configuration,
6230    bridge: Option<Vec<String>>,
6231    bridge__isnull: Option<bool>,
6232    bridge__n: Option<Vec<String>>,
6233    bridged_interfaces: Option<Vec<String>>,
6234    bridged_interfaces__isnull: Option<bool>,
6235    bridged_interfaces__n: Option<Vec<String>>,
6236    child_interfaces: Option<Vec<String>>,
6237    child_interfaces__isnull: Option<bool>,
6238    child_interfaces__n: Option<Vec<String>>,
6239    cluster: Option<Vec<String>>,
6240    cluster__n: Option<Vec<String>>,
6241    cluster_id: Option<Vec<uuid::Uuid>>,
6242    cluster_id__n: Option<Vec<uuid::Uuid>>,
6243    contacts: Option<Vec<String>>,
6244    contacts__isnull: Option<bool>,
6245    contacts__n: Option<Vec<String>>,
6246    description: Option<Vec<String>>,
6247    description__ic: Option<Vec<String>>,
6248    description__ie: Option<Vec<String>>,
6249    description__iew: Option<Vec<String>>,
6250    description__ire: Option<Vec<String>>,
6251    description__isw: Option<Vec<String>>,
6252    description__n: Option<Vec<String>>,
6253    description__nic: Option<Vec<String>>,
6254    description__nie: Option<Vec<String>>,
6255    description__niew: Option<Vec<String>>,
6256    description__nire: Option<Vec<String>>,
6257    description__nisw: Option<Vec<String>>,
6258    description__nre: Option<Vec<String>>,
6259    description__re: Option<Vec<String>>,
6260    dynamic_groups: Option<Vec<String>>,
6261    dynamic_groups__n: Option<Vec<String>>,
6262    enabled: Option<bool>,
6263    format: Option<&str>,
6264    has_bridged_interfaces: Option<bool>,
6265    has_child_interfaces: Option<bool>,
6266    has_ip_addresses: Option<bool>,
6267    has_tagged_vlans: Option<bool>,
6268    id: Option<Vec<uuid::Uuid>>,
6269    id__n: Option<Vec<uuid::Uuid>>,
6270    ip_addresses: Option<Vec<String>>,
6271    limit: Option<i32>,
6272    mac_address: Option<Vec<String>>,
6273    mac_address__ic: Option<Vec<String>>,
6274    mac_address__ie: Option<Vec<String>>,
6275    mac_address__iew: Option<Vec<String>>,
6276    mac_address__ire: Option<Vec<String>>,
6277    mac_address__isw: Option<Vec<String>>,
6278    mac_address__n: Option<Vec<String>>,
6279    mac_address__nic: Option<Vec<String>>,
6280    mac_address__nie: Option<Vec<String>>,
6281    mac_address__niew: Option<Vec<String>>,
6282    mac_address__nire: Option<Vec<String>>,
6283    mac_address__nisw: Option<Vec<String>>,
6284    mac_address__nre: Option<Vec<String>>,
6285    mac_address__re: Option<Vec<String>>,
6286    mode: Option<Vec<String>>,
6287    mode__ic: Option<Vec<String>>,
6288    mode__ie: Option<Vec<String>>,
6289    mode__iew: Option<Vec<String>>,
6290    mode__ire: Option<Vec<String>>,
6291    mode__isw: Option<Vec<String>>,
6292    mode__n: Option<Vec<String>>,
6293    mode__nic: Option<Vec<String>>,
6294    mode__nie: Option<Vec<String>>,
6295    mode__niew: Option<Vec<String>>,
6296    mode__nire: Option<Vec<String>>,
6297    mode__nisw: Option<Vec<String>>,
6298    mode__nre: Option<Vec<String>>,
6299    mode__re: Option<Vec<String>>,
6300    mtu: Option<Vec<i32>>,
6301    mtu__gt: Option<Vec<i32>>,
6302    mtu__gte: Option<Vec<i32>>,
6303    mtu__isnull: Option<bool>,
6304    mtu__lt: Option<Vec<i32>>,
6305    mtu__lte: Option<Vec<i32>>,
6306    mtu__n: Option<Vec<i32>>,
6307    name: Option<Vec<String>>,
6308    name__ic: Option<Vec<String>>,
6309    name__ie: Option<Vec<String>>,
6310    name__iew: Option<Vec<String>>,
6311    name__ire: Option<Vec<String>>,
6312    name__isw: Option<Vec<String>>,
6313    name__n: Option<Vec<String>>,
6314    name__nic: Option<Vec<String>>,
6315    name__nie: Option<Vec<String>>,
6316    name__niew: Option<Vec<String>>,
6317    name__nire: Option<Vec<String>>,
6318    name__nisw: Option<Vec<String>>,
6319    name__nre: Option<Vec<String>>,
6320    name__re: Option<Vec<String>>,
6321    offset: Option<i32>,
6322    parent_interface: Option<Vec<String>>,
6323    parent_interface__isnull: Option<bool>,
6324    parent_interface__n: Option<Vec<String>>,
6325    q: Option<&str>,
6326    role: Option<Vec<String>>,
6327    role__isnull: Option<bool>,
6328    role__n: Option<Vec<String>>,
6329    sort: Option<&str>,
6330    status: Option<Vec<String>>,
6331    status__n: Option<Vec<String>>,
6332    tagged_vlans: Option<Vec<String>>,
6333    tagged_vlans__n: Option<Vec<String>>,
6334    tags: Option<Vec<String>>,
6335    tags__isnull: Option<bool>,
6336    tags__n: Option<Vec<String>>,
6337    teams: Option<Vec<String>>,
6338    teams__isnull: Option<bool>,
6339    teams__n: Option<Vec<String>>,
6340    untagged_vlan: Option<Vec<String>>,
6341    untagged_vlan__isnull: Option<bool>,
6342    untagged_vlan__n: Option<Vec<String>>,
6343    virtual_machine: Option<Vec<String>>,
6344    virtual_machine__n: Option<Vec<String>>,
6345    virtual_machine_id: Option<Vec<uuid::Uuid>>,
6346    virtual_machine_id__n: Option<Vec<uuid::Uuid>>,
6347    vlan_id: Option<&str>,
6348    depth: Option<i32>,
6349    exclude_m2m: Option<bool>,
6350) -> Result<crate::models::PaginatedVmInterfaceList, Error<VirtualizationInterfacesListError>> {
6351    let local_var_configuration = configuration;
6352
6353    let local_var_client = &local_var_configuration.client;
6354
6355    let local_var_uri_str = format!(
6356        "{}/virtualization/interfaces/",
6357        local_var_configuration.base_path
6358    );
6359    let mut local_var_req_builder =
6360        local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
6361
6362    if let Some(ref local_var_str) = bridge {
6363        local_var_req_builder = match "multi" {
6364            "multi" => local_var_req_builder.query(
6365                &local_var_str
6366                    .into_iter()
6367                    .map(|p| ("bridge".to_owned(), p.to_string()))
6368                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6369            ),
6370            _ => local_var_req_builder.query(&[(
6371                "bridge",
6372                &local_var_str
6373                    .into_iter()
6374                    .map(|p| p.to_string())
6375                    .collect::<Vec<String>>()
6376                    .join(",")
6377                    .to_string(),
6378            )]),
6379        };
6380    }
6381    if let Some(ref local_var_str) = bridge__isnull {
6382        local_var_req_builder =
6383            local_var_req_builder.query(&[("bridge__isnull", &local_var_str.to_string())]);
6384    }
6385    if let Some(ref local_var_str) = bridge__n {
6386        local_var_req_builder = match "multi" {
6387            "multi" => local_var_req_builder.query(
6388                &local_var_str
6389                    .into_iter()
6390                    .map(|p| ("bridge__n".to_owned(), p.to_string()))
6391                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6392            ),
6393            _ => local_var_req_builder.query(&[(
6394                "bridge__n",
6395                &local_var_str
6396                    .into_iter()
6397                    .map(|p| p.to_string())
6398                    .collect::<Vec<String>>()
6399                    .join(",")
6400                    .to_string(),
6401            )]),
6402        };
6403    }
6404    if let Some(ref local_var_str) = bridged_interfaces {
6405        local_var_req_builder = match "multi" {
6406            "multi" => local_var_req_builder.query(
6407                &local_var_str
6408                    .into_iter()
6409                    .map(|p| ("bridged_interfaces".to_owned(), p.to_string()))
6410                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6411            ),
6412            _ => local_var_req_builder.query(&[(
6413                "bridged_interfaces",
6414                &local_var_str
6415                    .into_iter()
6416                    .map(|p| p.to_string())
6417                    .collect::<Vec<String>>()
6418                    .join(",")
6419                    .to_string(),
6420            )]),
6421        };
6422    }
6423    if let Some(ref local_var_str) = bridged_interfaces__isnull {
6424        local_var_req_builder = local_var_req_builder
6425            .query(&[("bridged_interfaces__isnull", &local_var_str.to_string())]);
6426    }
6427    if let Some(ref local_var_str) = bridged_interfaces__n {
6428        local_var_req_builder = match "multi" {
6429            "multi" => local_var_req_builder.query(
6430                &local_var_str
6431                    .into_iter()
6432                    .map(|p| ("bridged_interfaces__n".to_owned(), p.to_string()))
6433                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6434            ),
6435            _ => local_var_req_builder.query(&[(
6436                "bridged_interfaces__n",
6437                &local_var_str
6438                    .into_iter()
6439                    .map(|p| p.to_string())
6440                    .collect::<Vec<String>>()
6441                    .join(",")
6442                    .to_string(),
6443            )]),
6444        };
6445    }
6446    if let Some(ref local_var_str) = child_interfaces {
6447        local_var_req_builder = match "multi" {
6448            "multi" => local_var_req_builder.query(
6449                &local_var_str
6450                    .into_iter()
6451                    .map(|p| ("child_interfaces".to_owned(), p.to_string()))
6452                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6453            ),
6454            _ => local_var_req_builder.query(&[(
6455                "child_interfaces",
6456                &local_var_str
6457                    .into_iter()
6458                    .map(|p| p.to_string())
6459                    .collect::<Vec<String>>()
6460                    .join(",")
6461                    .to_string(),
6462            )]),
6463        };
6464    }
6465    if let Some(ref local_var_str) = child_interfaces__isnull {
6466        local_var_req_builder = local_var_req_builder
6467            .query(&[("child_interfaces__isnull", &local_var_str.to_string())]);
6468    }
6469    if let Some(ref local_var_str) = child_interfaces__n {
6470        local_var_req_builder = match "multi" {
6471            "multi" => local_var_req_builder.query(
6472                &local_var_str
6473                    .into_iter()
6474                    .map(|p| ("child_interfaces__n".to_owned(), p.to_string()))
6475                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6476            ),
6477            _ => local_var_req_builder.query(&[(
6478                "child_interfaces__n",
6479                &local_var_str
6480                    .into_iter()
6481                    .map(|p| p.to_string())
6482                    .collect::<Vec<String>>()
6483                    .join(",")
6484                    .to_string(),
6485            )]),
6486        };
6487    }
6488    if let Some(ref local_var_str) = cluster {
6489        local_var_req_builder = match "multi" {
6490            "multi" => local_var_req_builder.query(
6491                &local_var_str
6492                    .into_iter()
6493                    .map(|p| ("cluster".to_owned(), p.to_string()))
6494                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6495            ),
6496            _ => local_var_req_builder.query(&[(
6497                "cluster",
6498                &local_var_str
6499                    .into_iter()
6500                    .map(|p| p.to_string())
6501                    .collect::<Vec<String>>()
6502                    .join(",")
6503                    .to_string(),
6504            )]),
6505        };
6506    }
6507    if let Some(ref local_var_str) = cluster__n {
6508        local_var_req_builder = match "multi" {
6509            "multi" => local_var_req_builder.query(
6510                &local_var_str
6511                    .into_iter()
6512                    .map(|p| ("cluster__n".to_owned(), p.to_string()))
6513                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6514            ),
6515            _ => local_var_req_builder.query(&[(
6516                "cluster__n",
6517                &local_var_str
6518                    .into_iter()
6519                    .map(|p| p.to_string())
6520                    .collect::<Vec<String>>()
6521                    .join(",")
6522                    .to_string(),
6523            )]),
6524        };
6525    }
6526    if let Some(ref local_var_str) = cluster_id {
6527        local_var_req_builder = match "multi" {
6528            "multi" => local_var_req_builder.query(
6529                &local_var_str
6530                    .into_iter()
6531                    .map(|p| ("cluster_id".to_owned(), p.to_string()))
6532                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6533            ),
6534            _ => local_var_req_builder.query(&[(
6535                "cluster_id",
6536                &local_var_str
6537                    .into_iter()
6538                    .map(|p| p.to_string())
6539                    .collect::<Vec<String>>()
6540                    .join(",")
6541                    .to_string(),
6542            )]),
6543        };
6544    }
6545    if let Some(ref local_var_str) = cluster_id__n {
6546        local_var_req_builder = match "multi" {
6547            "multi" => local_var_req_builder.query(
6548                &local_var_str
6549                    .into_iter()
6550                    .map(|p| ("cluster_id__n".to_owned(), p.to_string()))
6551                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6552            ),
6553            _ => local_var_req_builder.query(&[(
6554                "cluster_id__n",
6555                &local_var_str
6556                    .into_iter()
6557                    .map(|p| p.to_string())
6558                    .collect::<Vec<String>>()
6559                    .join(",")
6560                    .to_string(),
6561            )]),
6562        };
6563    }
6564    if let Some(ref local_var_str) = contacts {
6565        local_var_req_builder = match "multi" {
6566            "multi" => local_var_req_builder.query(
6567                &local_var_str
6568                    .into_iter()
6569                    .map(|p| ("contacts".to_owned(), p.to_string()))
6570                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6571            ),
6572            _ => local_var_req_builder.query(&[(
6573                "contacts",
6574                &local_var_str
6575                    .into_iter()
6576                    .map(|p| p.to_string())
6577                    .collect::<Vec<String>>()
6578                    .join(",")
6579                    .to_string(),
6580            )]),
6581        };
6582    }
6583    if let Some(ref local_var_str) = contacts__isnull {
6584        local_var_req_builder =
6585            local_var_req_builder.query(&[("contacts__isnull", &local_var_str.to_string())]);
6586    }
6587    if let Some(ref local_var_str) = contacts__n {
6588        local_var_req_builder = match "multi" {
6589            "multi" => local_var_req_builder.query(
6590                &local_var_str
6591                    .into_iter()
6592                    .map(|p| ("contacts__n".to_owned(), p.to_string()))
6593                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6594            ),
6595            _ => local_var_req_builder.query(&[(
6596                "contacts__n",
6597                &local_var_str
6598                    .into_iter()
6599                    .map(|p| p.to_string())
6600                    .collect::<Vec<String>>()
6601                    .join(",")
6602                    .to_string(),
6603            )]),
6604        };
6605    }
6606    if let Some(ref local_var_str) = description {
6607        local_var_req_builder = match "multi" {
6608            "multi" => local_var_req_builder.query(
6609                &local_var_str
6610                    .into_iter()
6611                    .map(|p| ("description".to_owned(), p.to_string()))
6612                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6613            ),
6614            _ => local_var_req_builder.query(&[(
6615                "description",
6616                &local_var_str
6617                    .into_iter()
6618                    .map(|p| p.to_string())
6619                    .collect::<Vec<String>>()
6620                    .join(",")
6621                    .to_string(),
6622            )]),
6623        };
6624    }
6625    if let Some(ref local_var_str) = description__ic {
6626        local_var_req_builder = match "multi" {
6627            "multi" => local_var_req_builder.query(
6628                &local_var_str
6629                    .into_iter()
6630                    .map(|p| ("description__ic".to_owned(), p.to_string()))
6631                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6632            ),
6633            _ => local_var_req_builder.query(&[(
6634                "description__ic",
6635                &local_var_str
6636                    .into_iter()
6637                    .map(|p| p.to_string())
6638                    .collect::<Vec<String>>()
6639                    .join(",")
6640                    .to_string(),
6641            )]),
6642        };
6643    }
6644    if let Some(ref local_var_str) = description__ie {
6645        local_var_req_builder = match "multi" {
6646            "multi" => local_var_req_builder.query(
6647                &local_var_str
6648                    .into_iter()
6649                    .map(|p| ("description__ie".to_owned(), p.to_string()))
6650                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6651            ),
6652            _ => local_var_req_builder.query(&[(
6653                "description__ie",
6654                &local_var_str
6655                    .into_iter()
6656                    .map(|p| p.to_string())
6657                    .collect::<Vec<String>>()
6658                    .join(",")
6659                    .to_string(),
6660            )]),
6661        };
6662    }
6663    if let Some(ref local_var_str) = description__iew {
6664        local_var_req_builder = match "multi" {
6665            "multi" => local_var_req_builder.query(
6666                &local_var_str
6667                    .into_iter()
6668                    .map(|p| ("description__iew".to_owned(), p.to_string()))
6669                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6670            ),
6671            _ => local_var_req_builder.query(&[(
6672                "description__iew",
6673                &local_var_str
6674                    .into_iter()
6675                    .map(|p| p.to_string())
6676                    .collect::<Vec<String>>()
6677                    .join(",")
6678                    .to_string(),
6679            )]),
6680        };
6681    }
6682    if let Some(ref local_var_str) = description__ire {
6683        local_var_req_builder = match "multi" {
6684            "multi" => local_var_req_builder.query(
6685                &local_var_str
6686                    .into_iter()
6687                    .map(|p| ("description__ire".to_owned(), p.to_string()))
6688                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6689            ),
6690            _ => local_var_req_builder.query(&[(
6691                "description__ire",
6692                &local_var_str
6693                    .into_iter()
6694                    .map(|p| p.to_string())
6695                    .collect::<Vec<String>>()
6696                    .join(",")
6697                    .to_string(),
6698            )]),
6699        };
6700    }
6701    if let Some(ref local_var_str) = description__isw {
6702        local_var_req_builder = match "multi" {
6703            "multi" => local_var_req_builder.query(
6704                &local_var_str
6705                    .into_iter()
6706                    .map(|p| ("description__isw".to_owned(), p.to_string()))
6707                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6708            ),
6709            _ => local_var_req_builder.query(&[(
6710                "description__isw",
6711                &local_var_str
6712                    .into_iter()
6713                    .map(|p| p.to_string())
6714                    .collect::<Vec<String>>()
6715                    .join(",")
6716                    .to_string(),
6717            )]),
6718        };
6719    }
6720    if let Some(ref local_var_str) = description__n {
6721        local_var_req_builder = match "multi" {
6722            "multi" => local_var_req_builder.query(
6723                &local_var_str
6724                    .into_iter()
6725                    .map(|p| ("description__n".to_owned(), p.to_string()))
6726                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6727            ),
6728            _ => local_var_req_builder.query(&[(
6729                "description__n",
6730                &local_var_str
6731                    .into_iter()
6732                    .map(|p| p.to_string())
6733                    .collect::<Vec<String>>()
6734                    .join(",")
6735                    .to_string(),
6736            )]),
6737        };
6738    }
6739    if let Some(ref local_var_str) = description__nic {
6740        local_var_req_builder = match "multi" {
6741            "multi" => local_var_req_builder.query(
6742                &local_var_str
6743                    .into_iter()
6744                    .map(|p| ("description__nic".to_owned(), p.to_string()))
6745                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6746            ),
6747            _ => local_var_req_builder.query(&[(
6748                "description__nic",
6749                &local_var_str
6750                    .into_iter()
6751                    .map(|p| p.to_string())
6752                    .collect::<Vec<String>>()
6753                    .join(",")
6754                    .to_string(),
6755            )]),
6756        };
6757    }
6758    if let Some(ref local_var_str) = description__nie {
6759        local_var_req_builder = match "multi" {
6760            "multi" => local_var_req_builder.query(
6761                &local_var_str
6762                    .into_iter()
6763                    .map(|p| ("description__nie".to_owned(), p.to_string()))
6764                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6765            ),
6766            _ => local_var_req_builder.query(&[(
6767                "description__nie",
6768                &local_var_str
6769                    .into_iter()
6770                    .map(|p| p.to_string())
6771                    .collect::<Vec<String>>()
6772                    .join(",")
6773                    .to_string(),
6774            )]),
6775        };
6776    }
6777    if let Some(ref local_var_str) = description__niew {
6778        local_var_req_builder = match "multi" {
6779            "multi" => local_var_req_builder.query(
6780                &local_var_str
6781                    .into_iter()
6782                    .map(|p| ("description__niew".to_owned(), p.to_string()))
6783                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6784            ),
6785            _ => local_var_req_builder.query(&[(
6786                "description__niew",
6787                &local_var_str
6788                    .into_iter()
6789                    .map(|p| p.to_string())
6790                    .collect::<Vec<String>>()
6791                    .join(",")
6792                    .to_string(),
6793            )]),
6794        };
6795    }
6796    if let Some(ref local_var_str) = description__nire {
6797        local_var_req_builder = match "multi" {
6798            "multi" => local_var_req_builder.query(
6799                &local_var_str
6800                    .into_iter()
6801                    .map(|p| ("description__nire".to_owned(), p.to_string()))
6802                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6803            ),
6804            _ => local_var_req_builder.query(&[(
6805                "description__nire",
6806                &local_var_str
6807                    .into_iter()
6808                    .map(|p| p.to_string())
6809                    .collect::<Vec<String>>()
6810                    .join(",")
6811                    .to_string(),
6812            )]),
6813        };
6814    }
6815    if let Some(ref local_var_str) = description__nisw {
6816        local_var_req_builder = match "multi" {
6817            "multi" => local_var_req_builder.query(
6818                &local_var_str
6819                    .into_iter()
6820                    .map(|p| ("description__nisw".to_owned(), p.to_string()))
6821                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6822            ),
6823            _ => local_var_req_builder.query(&[(
6824                "description__nisw",
6825                &local_var_str
6826                    .into_iter()
6827                    .map(|p| p.to_string())
6828                    .collect::<Vec<String>>()
6829                    .join(",")
6830                    .to_string(),
6831            )]),
6832        };
6833    }
6834    if let Some(ref local_var_str) = description__nre {
6835        local_var_req_builder = match "multi" {
6836            "multi" => local_var_req_builder.query(
6837                &local_var_str
6838                    .into_iter()
6839                    .map(|p| ("description__nre".to_owned(), p.to_string()))
6840                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6841            ),
6842            _ => local_var_req_builder.query(&[(
6843                "description__nre",
6844                &local_var_str
6845                    .into_iter()
6846                    .map(|p| p.to_string())
6847                    .collect::<Vec<String>>()
6848                    .join(",")
6849                    .to_string(),
6850            )]),
6851        };
6852    }
6853    if let Some(ref local_var_str) = description__re {
6854        local_var_req_builder = match "multi" {
6855            "multi" => local_var_req_builder.query(
6856                &local_var_str
6857                    .into_iter()
6858                    .map(|p| ("description__re".to_owned(), p.to_string()))
6859                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6860            ),
6861            _ => local_var_req_builder.query(&[(
6862                "description__re",
6863                &local_var_str
6864                    .into_iter()
6865                    .map(|p| p.to_string())
6866                    .collect::<Vec<String>>()
6867                    .join(",")
6868                    .to_string(),
6869            )]),
6870        };
6871    }
6872    if let Some(ref local_var_str) = dynamic_groups {
6873        local_var_req_builder = match "multi" {
6874            "multi" => local_var_req_builder.query(
6875                &local_var_str
6876                    .into_iter()
6877                    .map(|p| ("dynamic_groups".to_owned(), p.to_string()))
6878                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6879            ),
6880            _ => local_var_req_builder.query(&[(
6881                "dynamic_groups",
6882                &local_var_str
6883                    .into_iter()
6884                    .map(|p| p.to_string())
6885                    .collect::<Vec<String>>()
6886                    .join(",")
6887                    .to_string(),
6888            )]),
6889        };
6890    }
6891    if let Some(ref local_var_str) = dynamic_groups__n {
6892        local_var_req_builder = match "multi" {
6893            "multi" => local_var_req_builder.query(
6894                &local_var_str
6895                    .into_iter()
6896                    .map(|p| ("dynamic_groups__n".to_owned(), p.to_string()))
6897                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6898            ),
6899            _ => local_var_req_builder.query(&[(
6900                "dynamic_groups__n",
6901                &local_var_str
6902                    .into_iter()
6903                    .map(|p| p.to_string())
6904                    .collect::<Vec<String>>()
6905                    .join(",")
6906                    .to_string(),
6907            )]),
6908        };
6909    }
6910    if let Some(ref local_var_str) = enabled {
6911        local_var_req_builder =
6912            local_var_req_builder.query(&[("enabled", &local_var_str.to_string())]);
6913    }
6914    if let Some(ref local_var_str) = format {
6915        local_var_req_builder =
6916            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
6917    }
6918    if let Some(ref local_var_str) = has_bridged_interfaces {
6919        local_var_req_builder =
6920            local_var_req_builder.query(&[("has_bridged_interfaces", &local_var_str.to_string())]);
6921    }
6922    if let Some(ref local_var_str) = has_child_interfaces {
6923        local_var_req_builder =
6924            local_var_req_builder.query(&[("has_child_interfaces", &local_var_str.to_string())]);
6925    }
6926    if let Some(ref local_var_str) = has_ip_addresses {
6927        local_var_req_builder =
6928            local_var_req_builder.query(&[("has_ip_addresses", &local_var_str.to_string())]);
6929    }
6930    if let Some(ref local_var_str) = has_tagged_vlans {
6931        local_var_req_builder =
6932            local_var_req_builder.query(&[("has_tagged_vlans", &local_var_str.to_string())]);
6933    }
6934    if let Some(ref local_var_str) = id {
6935        local_var_req_builder = match "multi" {
6936            "multi" => local_var_req_builder.query(
6937                &local_var_str
6938                    .into_iter()
6939                    .map(|p| ("id".to_owned(), p.to_string()))
6940                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6941            ),
6942            _ => local_var_req_builder.query(&[(
6943                "id",
6944                &local_var_str
6945                    .into_iter()
6946                    .map(|p| p.to_string())
6947                    .collect::<Vec<String>>()
6948                    .join(",")
6949                    .to_string(),
6950            )]),
6951        };
6952    }
6953    if let Some(ref local_var_str) = id__n {
6954        local_var_req_builder = match "multi" {
6955            "multi" => local_var_req_builder.query(
6956                &local_var_str
6957                    .into_iter()
6958                    .map(|p| ("id__n".to_owned(), p.to_string()))
6959                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6960            ),
6961            _ => local_var_req_builder.query(&[(
6962                "id__n",
6963                &local_var_str
6964                    .into_iter()
6965                    .map(|p| p.to_string())
6966                    .collect::<Vec<String>>()
6967                    .join(",")
6968                    .to_string(),
6969            )]),
6970        };
6971    }
6972    if let Some(ref local_var_str) = ip_addresses {
6973        local_var_req_builder = match "multi" {
6974            "multi" => local_var_req_builder.query(
6975                &local_var_str
6976                    .into_iter()
6977                    .map(|p| ("ip_addresses".to_owned(), p.to_string()))
6978                    .collect::<Vec<(std::string::String, std::string::String)>>(),
6979            ),
6980            _ => local_var_req_builder.query(&[(
6981                "ip_addresses",
6982                &local_var_str
6983                    .into_iter()
6984                    .map(|p| p.to_string())
6985                    .collect::<Vec<String>>()
6986                    .join(",")
6987                    .to_string(),
6988            )]),
6989        };
6990    }
6991    if let Some(ref local_var_str) = limit {
6992        local_var_req_builder =
6993            local_var_req_builder.query(&[("limit", &local_var_str.to_string())]);
6994    }
6995    if let Some(ref local_var_str) = mac_address {
6996        local_var_req_builder = match "multi" {
6997            "multi" => local_var_req_builder.query(
6998                &local_var_str
6999                    .into_iter()
7000                    .map(|p| ("mac_address".to_owned(), p.to_string()))
7001                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7002            ),
7003            _ => local_var_req_builder.query(&[(
7004                "mac_address",
7005                &local_var_str
7006                    .into_iter()
7007                    .map(|p| p.to_string())
7008                    .collect::<Vec<String>>()
7009                    .join(",")
7010                    .to_string(),
7011            )]),
7012        };
7013    }
7014    if let Some(ref local_var_str) = mac_address__ic {
7015        local_var_req_builder = match "multi" {
7016            "multi" => local_var_req_builder.query(
7017                &local_var_str
7018                    .into_iter()
7019                    .map(|p| ("mac_address__ic".to_owned(), p.to_string()))
7020                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7021            ),
7022            _ => local_var_req_builder.query(&[(
7023                "mac_address__ic",
7024                &local_var_str
7025                    .into_iter()
7026                    .map(|p| p.to_string())
7027                    .collect::<Vec<String>>()
7028                    .join(",")
7029                    .to_string(),
7030            )]),
7031        };
7032    }
7033    if let Some(ref local_var_str) = mac_address__ie {
7034        local_var_req_builder = match "multi" {
7035            "multi" => local_var_req_builder.query(
7036                &local_var_str
7037                    .into_iter()
7038                    .map(|p| ("mac_address__ie".to_owned(), p.to_string()))
7039                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7040            ),
7041            _ => local_var_req_builder.query(&[(
7042                "mac_address__ie",
7043                &local_var_str
7044                    .into_iter()
7045                    .map(|p| p.to_string())
7046                    .collect::<Vec<String>>()
7047                    .join(",")
7048                    .to_string(),
7049            )]),
7050        };
7051    }
7052    if let Some(ref local_var_str) = mac_address__iew {
7053        local_var_req_builder = match "multi" {
7054            "multi" => local_var_req_builder.query(
7055                &local_var_str
7056                    .into_iter()
7057                    .map(|p| ("mac_address__iew".to_owned(), p.to_string()))
7058                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7059            ),
7060            _ => local_var_req_builder.query(&[(
7061                "mac_address__iew",
7062                &local_var_str
7063                    .into_iter()
7064                    .map(|p| p.to_string())
7065                    .collect::<Vec<String>>()
7066                    .join(",")
7067                    .to_string(),
7068            )]),
7069        };
7070    }
7071    if let Some(ref local_var_str) = mac_address__ire {
7072        local_var_req_builder = match "multi" {
7073            "multi" => local_var_req_builder.query(
7074                &local_var_str
7075                    .into_iter()
7076                    .map(|p| ("mac_address__ire".to_owned(), p.to_string()))
7077                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7078            ),
7079            _ => local_var_req_builder.query(&[(
7080                "mac_address__ire",
7081                &local_var_str
7082                    .into_iter()
7083                    .map(|p| p.to_string())
7084                    .collect::<Vec<String>>()
7085                    .join(",")
7086                    .to_string(),
7087            )]),
7088        };
7089    }
7090    if let Some(ref local_var_str) = mac_address__isw {
7091        local_var_req_builder = match "multi" {
7092            "multi" => local_var_req_builder.query(
7093                &local_var_str
7094                    .into_iter()
7095                    .map(|p| ("mac_address__isw".to_owned(), p.to_string()))
7096                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7097            ),
7098            _ => local_var_req_builder.query(&[(
7099                "mac_address__isw",
7100                &local_var_str
7101                    .into_iter()
7102                    .map(|p| p.to_string())
7103                    .collect::<Vec<String>>()
7104                    .join(",")
7105                    .to_string(),
7106            )]),
7107        };
7108    }
7109    if let Some(ref local_var_str) = mac_address__n {
7110        local_var_req_builder = match "multi" {
7111            "multi" => local_var_req_builder.query(
7112                &local_var_str
7113                    .into_iter()
7114                    .map(|p| ("mac_address__n".to_owned(), p.to_string()))
7115                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7116            ),
7117            _ => local_var_req_builder.query(&[(
7118                "mac_address__n",
7119                &local_var_str
7120                    .into_iter()
7121                    .map(|p| p.to_string())
7122                    .collect::<Vec<String>>()
7123                    .join(",")
7124                    .to_string(),
7125            )]),
7126        };
7127    }
7128    if let Some(ref local_var_str) = mac_address__nic {
7129        local_var_req_builder = match "multi" {
7130            "multi" => local_var_req_builder.query(
7131                &local_var_str
7132                    .into_iter()
7133                    .map(|p| ("mac_address__nic".to_owned(), p.to_string()))
7134                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7135            ),
7136            _ => local_var_req_builder.query(&[(
7137                "mac_address__nic",
7138                &local_var_str
7139                    .into_iter()
7140                    .map(|p| p.to_string())
7141                    .collect::<Vec<String>>()
7142                    .join(",")
7143                    .to_string(),
7144            )]),
7145        };
7146    }
7147    if let Some(ref local_var_str) = mac_address__nie {
7148        local_var_req_builder = match "multi" {
7149            "multi" => local_var_req_builder.query(
7150                &local_var_str
7151                    .into_iter()
7152                    .map(|p| ("mac_address__nie".to_owned(), p.to_string()))
7153                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7154            ),
7155            _ => local_var_req_builder.query(&[(
7156                "mac_address__nie",
7157                &local_var_str
7158                    .into_iter()
7159                    .map(|p| p.to_string())
7160                    .collect::<Vec<String>>()
7161                    .join(",")
7162                    .to_string(),
7163            )]),
7164        };
7165    }
7166    if let Some(ref local_var_str) = mac_address__niew {
7167        local_var_req_builder = match "multi" {
7168            "multi" => local_var_req_builder.query(
7169                &local_var_str
7170                    .into_iter()
7171                    .map(|p| ("mac_address__niew".to_owned(), p.to_string()))
7172                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7173            ),
7174            _ => local_var_req_builder.query(&[(
7175                "mac_address__niew",
7176                &local_var_str
7177                    .into_iter()
7178                    .map(|p| p.to_string())
7179                    .collect::<Vec<String>>()
7180                    .join(",")
7181                    .to_string(),
7182            )]),
7183        };
7184    }
7185    if let Some(ref local_var_str) = mac_address__nire {
7186        local_var_req_builder = match "multi" {
7187            "multi" => local_var_req_builder.query(
7188                &local_var_str
7189                    .into_iter()
7190                    .map(|p| ("mac_address__nire".to_owned(), p.to_string()))
7191                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7192            ),
7193            _ => local_var_req_builder.query(&[(
7194                "mac_address__nire",
7195                &local_var_str
7196                    .into_iter()
7197                    .map(|p| p.to_string())
7198                    .collect::<Vec<String>>()
7199                    .join(",")
7200                    .to_string(),
7201            )]),
7202        };
7203    }
7204    if let Some(ref local_var_str) = mac_address__nisw {
7205        local_var_req_builder = match "multi" {
7206            "multi" => local_var_req_builder.query(
7207                &local_var_str
7208                    .into_iter()
7209                    .map(|p| ("mac_address__nisw".to_owned(), p.to_string()))
7210                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7211            ),
7212            _ => local_var_req_builder.query(&[(
7213                "mac_address__nisw",
7214                &local_var_str
7215                    .into_iter()
7216                    .map(|p| p.to_string())
7217                    .collect::<Vec<String>>()
7218                    .join(",")
7219                    .to_string(),
7220            )]),
7221        };
7222    }
7223    if let Some(ref local_var_str) = mac_address__nre {
7224        local_var_req_builder = match "multi" {
7225            "multi" => local_var_req_builder.query(
7226                &local_var_str
7227                    .into_iter()
7228                    .map(|p| ("mac_address__nre".to_owned(), p.to_string()))
7229                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7230            ),
7231            _ => local_var_req_builder.query(&[(
7232                "mac_address__nre",
7233                &local_var_str
7234                    .into_iter()
7235                    .map(|p| p.to_string())
7236                    .collect::<Vec<String>>()
7237                    .join(",")
7238                    .to_string(),
7239            )]),
7240        };
7241    }
7242    if let Some(ref local_var_str) = mac_address__re {
7243        local_var_req_builder = match "multi" {
7244            "multi" => local_var_req_builder.query(
7245                &local_var_str
7246                    .into_iter()
7247                    .map(|p| ("mac_address__re".to_owned(), p.to_string()))
7248                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7249            ),
7250            _ => local_var_req_builder.query(&[(
7251                "mac_address__re",
7252                &local_var_str
7253                    .into_iter()
7254                    .map(|p| p.to_string())
7255                    .collect::<Vec<String>>()
7256                    .join(",")
7257                    .to_string(),
7258            )]),
7259        };
7260    }
7261    if let Some(ref local_var_str) = mode {
7262        local_var_req_builder = match "multi" {
7263            "multi" => local_var_req_builder.query(
7264                &local_var_str
7265                    .into_iter()
7266                    .map(|p| ("mode".to_owned(), p.to_string()))
7267                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7268            ),
7269            _ => local_var_req_builder.query(&[(
7270                "mode",
7271                &local_var_str
7272                    .into_iter()
7273                    .map(|p| p.to_string())
7274                    .collect::<Vec<String>>()
7275                    .join(",")
7276                    .to_string(),
7277            )]),
7278        };
7279    }
7280    if let Some(ref local_var_str) = mode__ic {
7281        local_var_req_builder = match "multi" {
7282            "multi" => local_var_req_builder.query(
7283                &local_var_str
7284                    .into_iter()
7285                    .map(|p| ("mode__ic".to_owned(), p.to_string()))
7286                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7287            ),
7288            _ => local_var_req_builder.query(&[(
7289                "mode__ic",
7290                &local_var_str
7291                    .into_iter()
7292                    .map(|p| p.to_string())
7293                    .collect::<Vec<String>>()
7294                    .join(",")
7295                    .to_string(),
7296            )]),
7297        };
7298    }
7299    if let Some(ref local_var_str) = mode__ie {
7300        local_var_req_builder = match "multi" {
7301            "multi" => local_var_req_builder.query(
7302                &local_var_str
7303                    .into_iter()
7304                    .map(|p| ("mode__ie".to_owned(), p.to_string()))
7305                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7306            ),
7307            _ => local_var_req_builder.query(&[(
7308                "mode__ie",
7309                &local_var_str
7310                    .into_iter()
7311                    .map(|p| p.to_string())
7312                    .collect::<Vec<String>>()
7313                    .join(",")
7314                    .to_string(),
7315            )]),
7316        };
7317    }
7318    if let Some(ref local_var_str) = mode__iew {
7319        local_var_req_builder = match "multi" {
7320            "multi" => local_var_req_builder.query(
7321                &local_var_str
7322                    .into_iter()
7323                    .map(|p| ("mode__iew".to_owned(), p.to_string()))
7324                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7325            ),
7326            _ => local_var_req_builder.query(&[(
7327                "mode__iew",
7328                &local_var_str
7329                    .into_iter()
7330                    .map(|p| p.to_string())
7331                    .collect::<Vec<String>>()
7332                    .join(",")
7333                    .to_string(),
7334            )]),
7335        };
7336    }
7337    if let Some(ref local_var_str) = mode__ire {
7338        local_var_req_builder = match "multi" {
7339            "multi" => local_var_req_builder.query(
7340                &local_var_str
7341                    .into_iter()
7342                    .map(|p| ("mode__ire".to_owned(), p.to_string()))
7343                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7344            ),
7345            _ => local_var_req_builder.query(&[(
7346                "mode__ire",
7347                &local_var_str
7348                    .into_iter()
7349                    .map(|p| p.to_string())
7350                    .collect::<Vec<String>>()
7351                    .join(",")
7352                    .to_string(),
7353            )]),
7354        };
7355    }
7356    if let Some(ref local_var_str) = mode__isw {
7357        local_var_req_builder = match "multi" {
7358            "multi" => local_var_req_builder.query(
7359                &local_var_str
7360                    .into_iter()
7361                    .map(|p| ("mode__isw".to_owned(), p.to_string()))
7362                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7363            ),
7364            _ => local_var_req_builder.query(&[(
7365                "mode__isw",
7366                &local_var_str
7367                    .into_iter()
7368                    .map(|p| p.to_string())
7369                    .collect::<Vec<String>>()
7370                    .join(",")
7371                    .to_string(),
7372            )]),
7373        };
7374    }
7375    if let Some(ref local_var_str) = mode__n {
7376        local_var_req_builder = match "multi" {
7377            "multi" => local_var_req_builder.query(
7378                &local_var_str
7379                    .into_iter()
7380                    .map(|p| ("mode__n".to_owned(), p.to_string()))
7381                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7382            ),
7383            _ => local_var_req_builder.query(&[(
7384                "mode__n",
7385                &local_var_str
7386                    .into_iter()
7387                    .map(|p| p.to_string())
7388                    .collect::<Vec<String>>()
7389                    .join(",")
7390                    .to_string(),
7391            )]),
7392        };
7393    }
7394    if let Some(ref local_var_str) = mode__nic {
7395        local_var_req_builder = match "multi" {
7396            "multi" => local_var_req_builder.query(
7397                &local_var_str
7398                    .into_iter()
7399                    .map(|p| ("mode__nic".to_owned(), p.to_string()))
7400                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7401            ),
7402            _ => local_var_req_builder.query(&[(
7403                "mode__nic",
7404                &local_var_str
7405                    .into_iter()
7406                    .map(|p| p.to_string())
7407                    .collect::<Vec<String>>()
7408                    .join(",")
7409                    .to_string(),
7410            )]),
7411        };
7412    }
7413    if let Some(ref local_var_str) = mode__nie {
7414        local_var_req_builder = match "multi" {
7415            "multi" => local_var_req_builder.query(
7416                &local_var_str
7417                    .into_iter()
7418                    .map(|p| ("mode__nie".to_owned(), p.to_string()))
7419                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7420            ),
7421            _ => local_var_req_builder.query(&[(
7422                "mode__nie",
7423                &local_var_str
7424                    .into_iter()
7425                    .map(|p| p.to_string())
7426                    .collect::<Vec<String>>()
7427                    .join(",")
7428                    .to_string(),
7429            )]),
7430        };
7431    }
7432    if let Some(ref local_var_str) = mode__niew {
7433        local_var_req_builder = match "multi" {
7434            "multi" => local_var_req_builder.query(
7435                &local_var_str
7436                    .into_iter()
7437                    .map(|p| ("mode__niew".to_owned(), p.to_string()))
7438                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7439            ),
7440            _ => local_var_req_builder.query(&[(
7441                "mode__niew",
7442                &local_var_str
7443                    .into_iter()
7444                    .map(|p| p.to_string())
7445                    .collect::<Vec<String>>()
7446                    .join(",")
7447                    .to_string(),
7448            )]),
7449        };
7450    }
7451    if let Some(ref local_var_str) = mode__nire {
7452        local_var_req_builder = match "multi" {
7453            "multi" => local_var_req_builder.query(
7454                &local_var_str
7455                    .into_iter()
7456                    .map(|p| ("mode__nire".to_owned(), p.to_string()))
7457                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7458            ),
7459            _ => local_var_req_builder.query(&[(
7460                "mode__nire",
7461                &local_var_str
7462                    .into_iter()
7463                    .map(|p| p.to_string())
7464                    .collect::<Vec<String>>()
7465                    .join(",")
7466                    .to_string(),
7467            )]),
7468        };
7469    }
7470    if let Some(ref local_var_str) = mode__nisw {
7471        local_var_req_builder = match "multi" {
7472            "multi" => local_var_req_builder.query(
7473                &local_var_str
7474                    .into_iter()
7475                    .map(|p| ("mode__nisw".to_owned(), p.to_string()))
7476                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7477            ),
7478            _ => local_var_req_builder.query(&[(
7479                "mode__nisw",
7480                &local_var_str
7481                    .into_iter()
7482                    .map(|p| p.to_string())
7483                    .collect::<Vec<String>>()
7484                    .join(",")
7485                    .to_string(),
7486            )]),
7487        };
7488    }
7489    if let Some(ref local_var_str) = mode__nre {
7490        local_var_req_builder = match "multi" {
7491            "multi" => local_var_req_builder.query(
7492                &local_var_str
7493                    .into_iter()
7494                    .map(|p| ("mode__nre".to_owned(), p.to_string()))
7495                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7496            ),
7497            _ => local_var_req_builder.query(&[(
7498                "mode__nre",
7499                &local_var_str
7500                    .into_iter()
7501                    .map(|p| p.to_string())
7502                    .collect::<Vec<String>>()
7503                    .join(",")
7504                    .to_string(),
7505            )]),
7506        };
7507    }
7508    if let Some(ref local_var_str) = mode__re {
7509        local_var_req_builder = match "multi" {
7510            "multi" => local_var_req_builder.query(
7511                &local_var_str
7512                    .into_iter()
7513                    .map(|p| ("mode__re".to_owned(), p.to_string()))
7514                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7515            ),
7516            _ => local_var_req_builder.query(&[(
7517                "mode__re",
7518                &local_var_str
7519                    .into_iter()
7520                    .map(|p| p.to_string())
7521                    .collect::<Vec<String>>()
7522                    .join(",")
7523                    .to_string(),
7524            )]),
7525        };
7526    }
7527    if let Some(ref local_var_str) = mtu {
7528        local_var_req_builder = match "multi" {
7529            "multi" => local_var_req_builder.query(
7530                &local_var_str
7531                    .into_iter()
7532                    .map(|p| ("mtu".to_owned(), p.to_string()))
7533                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7534            ),
7535            _ => local_var_req_builder.query(&[(
7536                "mtu",
7537                &local_var_str
7538                    .into_iter()
7539                    .map(|p| p.to_string())
7540                    .collect::<Vec<String>>()
7541                    .join(",")
7542                    .to_string(),
7543            )]),
7544        };
7545    }
7546    if let Some(ref local_var_str) = mtu__gt {
7547        local_var_req_builder = match "multi" {
7548            "multi" => local_var_req_builder.query(
7549                &local_var_str
7550                    .into_iter()
7551                    .map(|p| ("mtu__gt".to_owned(), p.to_string()))
7552                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7553            ),
7554            _ => local_var_req_builder.query(&[(
7555                "mtu__gt",
7556                &local_var_str
7557                    .into_iter()
7558                    .map(|p| p.to_string())
7559                    .collect::<Vec<String>>()
7560                    .join(",")
7561                    .to_string(),
7562            )]),
7563        };
7564    }
7565    if let Some(ref local_var_str) = mtu__gte {
7566        local_var_req_builder = match "multi" {
7567            "multi" => local_var_req_builder.query(
7568                &local_var_str
7569                    .into_iter()
7570                    .map(|p| ("mtu__gte".to_owned(), p.to_string()))
7571                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7572            ),
7573            _ => local_var_req_builder.query(&[(
7574                "mtu__gte",
7575                &local_var_str
7576                    .into_iter()
7577                    .map(|p| p.to_string())
7578                    .collect::<Vec<String>>()
7579                    .join(",")
7580                    .to_string(),
7581            )]),
7582        };
7583    }
7584    if let Some(ref local_var_str) = mtu__isnull {
7585        local_var_req_builder =
7586            local_var_req_builder.query(&[("mtu__isnull", &local_var_str.to_string())]);
7587    }
7588    if let Some(ref local_var_str) = mtu__lt {
7589        local_var_req_builder = match "multi" {
7590            "multi" => local_var_req_builder.query(
7591                &local_var_str
7592                    .into_iter()
7593                    .map(|p| ("mtu__lt".to_owned(), p.to_string()))
7594                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7595            ),
7596            _ => local_var_req_builder.query(&[(
7597                "mtu__lt",
7598                &local_var_str
7599                    .into_iter()
7600                    .map(|p| p.to_string())
7601                    .collect::<Vec<String>>()
7602                    .join(",")
7603                    .to_string(),
7604            )]),
7605        };
7606    }
7607    if let Some(ref local_var_str) = mtu__lte {
7608        local_var_req_builder = match "multi" {
7609            "multi" => local_var_req_builder.query(
7610                &local_var_str
7611                    .into_iter()
7612                    .map(|p| ("mtu__lte".to_owned(), p.to_string()))
7613                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7614            ),
7615            _ => local_var_req_builder.query(&[(
7616                "mtu__lte",
7617                &local_var_str
7618                    .into_iter()
7619                    .map(|p| p.to_string())
7620                    .collect::<Vec<String>>()
7621                    .join(",")
7622                    .to_string(),
7623            )]),
7624        };
7625    }
7626    if let Some(ref local_var_str) = mtu__n {
7627        local_var_req_builder = match "multi" {
7628            "multi" => local_var_req_builder.query(
7629                &local_var_str
7630                    .into_iter()
7631                    .map(|p| ("mtu__n".to_owned(), p.to_string()))
7632                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7633            ),
7634            _ => local_var_req_builder.query(&[(
7635                "mtu__n",
7636                &local_var_str
7637                    .into_iter()
7638                    .map(|p| p.to_string())
7639                    .collect::<Vec<String>>()
7640                    .join(",")
7641                    .to_string(),
7642            )]),
7643        };
7644    }
7645    if let Some(ref local_var_str) = name {
7646        local_var_req_builder = match "multi" {
7647            "multi" => local_var_req_builder.query(
7648                &local_var_str
7649                    .into_iter()
7650                    .map(|p| ("name".to_owned(), p.to_string()))
7651                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7652            ),
7653            _ => local_var_req_builder.query(&[(
7654                "name",
7655                &local_var_str
7656                    .into_iter()
7657                    .map(|p| p.to_string())
7658                    .collect::<Vec<String>>()
7659                    .join(",")
7660                    .to_string(),
7661            )]),
7662        };
7663    }
7664    if let Some(ref local_var_str) = name__ic {
7665        local_var_req_builder = match "multi" {
7666            "multi" => local_var_req_builder.query(
7667                &local_var_str
7668                    .into_iter()
7669                    .map(|p| ("name__ic".to_owned(), p.to_string()))
7670                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7671            ),
7672            _ => local_var_req_builder.query(&[(
7673                "name__ic",
7674                &local_var_str
7675                    .into_iter()
7676                    .map(|p| p.to_string())
7677                    .collect::<Vec<String>>()
7678                    .join(",")
7679                    .to_string(),
7680            )]),
7681        };
7682    }
7683    if let Some(ref local_var_str) = name__ie {
7684        local_var_req_builder = match "multi" {
7685            "multi" => local_var_req_builder.query(
7686                &local_var_str
7687                    .into_iter()
7688                    .map(|p| ("name__ie".to_owned(), p.to_string()))
7689                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7690            ),
7691            _ => local_var_req_builder.query(&[(
7692                "name__ie",
7693                &local_var_str
7694                    .into_iter()
7695                    .map(|p| p.to_string())
7696                    .collect::<Vec<String>>()
7697                    .join(",")
7698                    .to_string(),
7699            )]),
7700        };
7701    }
7702    if let Some(ref local_var_str) = name__iew {
7703        local_var_req_builder = match "multi" {
7704            "multi" => local_var_req_builder.query(
7705                &local_var_str
7706                    .into_iter()
7707                    .map(|p| ("name__iew".to_owned(), p.to_string()))
7708                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7709            ),
7710            _ => local_var_req_builder.query(&[(
7711                "name__iew",
7712                &local_var_str
7713                    .into_iter()
7714                    .map(|p| p.to_string())
7715                    .collect::<Vec<String>>()
7716                    .join(",")
7717                    .to_string(),
7718            )]),
7719        };
7720    }
7721    if let Some(ref local_var_str) = name__ire {
7722        local_var_req_builder = match "multi" {
7723            "multi" => local_var_req_builder.query(
7724                &local_var_str
7725                    .into_iter()
7726                    .map(|p| ("name__ire".to_owned(), p.to_string()))
7727                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7728            ),
7729            _ => local_var_req_builder.query(&[(
7730                "name__ire",
7731                &local_var_str
7732                    .into_iter()
7733                    .map(|p| p.to_string())
7734                    .collect::<Vec<String>>()
7735                    .join(",")
7736                    .to_string(),
7737            )]),
7738        };
7739    }
7740    if let Some(ref local_var_str) = name__isw {
7741        local_var_req_builder = match "multi" {
7742            "multi" => local_var_req_builder.query(
7743                &local_var_str
7744                    .into_iter()
7745                    .map(|p| ("name__isw".to_owned(), p.to_string()))
7746                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7747            ),
7748            _ => local_var_req_builder.query(&[(
7749                "name__isw",
7750                &local_var_str
7751                    .into_iter()
7752                    .map(|p| p.to_string())
7753                    .collect::<Vec<String>>()
7754                    .join(",")
7755                    .to_string(),
7756            )]),
7757        };
7758    }
7759    if let Some(ref local_var_str) = name__n {
7760        local_var_req_builder = match "multi" {
7761            "multi" => local_var_req_builder.query(
7762                &local_var_str
7763                    .into_iter()
7764                    .map(|p| ("name__n".to_owned(), p.to_string()))
7765                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7766            ),
7767            _ => local_var_req_builder.query(&[(
7768                "name__n",
7769                &local_var_str
7770                    .into_iter()
7771                    .map(|p| p.to_string())
7772                    .collect::<Vec<String>>()
7773                    .join(",")
7774                    .to_string(),
7775            )]),
7776        };
7777    }
7778    if let Some(ref local_var_str) = name__nic {
7779        local_var_req_builder = match "multi" {
7780            "multi" => local_var_req_builder.query(
7781                &local_var_str
7782                    .into_iter()
7783                    .map(|p| ("name__nic".to_owned(), p.to_string()))
7784                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7785            ),
7786            _ => local_var_req_builder.query(&[(
7787                "name__nic",
7788                &local_var_str
7789                    .into_iter()
7790                    .map(|p| p.to_string())
7791                    .collect::<Vec<String>>()
7792                    .join(",")
7793                    .to_string(),
7794            )]),
7795        };
7796    }
7797    if let Some(ref local_var_str) = name__nie {
7798        local_var_req_builder = match "multi" {
7799            "multi" => local_var_req_builder.query(
7800                &local_var_str
7801                    .into_iter()
7802                    .map(|p| ("name__nie".to_owned(), p.to_string()))
7803                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7804            ),
7805            _ => local_var_req_builder.query(&[(
7806                "name__nie",
7807                &local_var_str
7808                    .into_iter()
7809                    .map(|p| p.to_string())
7810                    .collect::<Vec<String>>()
7811                    .join(",")
7812                    .to_string(),
7813            )]),
7814        };
7815    }
7816    if let Some(ref local_var_str) = name__niew {
7817        local_var_req_builder = match "multi" {
7818            "multi" => local_var_req_builder.query(
7819                &local_var_str
7820                    .into_iter()
7821                    .map(|p| ("name__niew".to_owned(), p.to_string()))
7822                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7823            ),
7824            _ => local_var_req_builder.query(&[(
7825                "name__niew",
7826                &local_var_str
7827                    .into_iter()
7828                    .map(|p| p.to_string())
7829                    .collect::<Vec<String>>()
7830                    .join(",")
7831                    .to_string(),
7832            )]),
7833        };
7834    }
7835    if let Some(ref local_var_str) = name__nire {
7836        local_var_req_builder = match "multi" {
7837            "multi" => local_var_req_builder.query(
7838                &local_var_str
7839                    .into_iter()
7840                    .map(|p| ("name__nire".to_owned(), p.to_string()))
7841                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7842            ),
7843            _ => local_var_req_builder.query(&[(
7844                "name__nire",
7845                &local_var_str
7846                    .into_iter()
7847                    .map(|p| p.to_string())
7848                    .collect::<Vec<String>>()
7849                    .join(",")
7850                    .to_string(),
7851            )]),
7852        };
7853    }
7854    if let Some(ref local_var_str) = name__nisw {
7855        local_var_req_builder = match "multi" {
7856            "multi" => local_var_req_builder.query(
7857                &local_var_str
7858                    .into_iter()
7859                    .map(|p| ("name__nisw".to_owned(), p.to_string()))
7860                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7861            ),
7862            _ => local_var_req_builder.query(&[(
7863                "name__nisw",
7864                &local_var_str
7865                    .into_iter()
7866                    .map(|p| p.to_string())
7867                    .collect::<Vec<String>>()
7868                    .join(",")
7869                    .to_string(),
7870            )]),
7871        };
7872    }
7873    if let Some(ref local_var_str) = name__nre {
7874        local_var_req_builder = match "multi" {
7875            "multi" => local_var_req_builder.query(
7876                &local_var_str
7877                    .into_iter()
7878                    .map(|p| ("name__nre".to_owned(), p.to_string()))
7879                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7880            ),
7881            _ => local_var_req_builder.query(&[(
7882                "name__nre",
7883                &local_var_str
7884                    .into_iter()
7885                    .map(|p| p.to_string())
7886                    .collect::<Vec<String>>()
7887                    .join(",")
7888                    .to_string(),
7889            )]),
7890        };
7891    }
7892    if let Some(ref local_var_str) = name__re {
7893        local_var_req_builder = match "multi" {
7894            "multi" => local_var_req_builder.query(
7895                &local_var_str
7896                    .into_iter()
7897                    .map(|p| ("name__re".to_owned(), p.to_string()))
7898                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7899            ),
7900            _ => local_var_req_builder.query(&[(
7901                "name__re",
7902                &local_var_str
7903                    .into_iter()
7904                    .map(|p| p.to_string())
7905                    .collect::<Vec<String>>()
7906                    .join(",")
7907                    .to_string(),
7908            )]),
7909        };
7910    }
7911    if let Some(ref local_var_str) = offset {
7912        local_var_req_builder =
7913            local_var_req_builder.query(&[("offset", &local_var_str.to_string())]);
7914    }
7915    if let Some(ref local_var_str) = parent_interface {
7916        local_var_req_builder = match "multi" {
7917            "multi" => local_var_req_builder.query(
7918                &local_var_str
7919                    .into_iter()
7920                    .map(|p| ("parent_interface".to_owned(), p.to_string()))
7921                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7922            ),
7923            _ => local_var_req_builder.query(&[(
7924                "parent_interface",
7925                &local_var_str
7926                    .into_iter()
7927                    .map(|p| p.to_string())
7928                    .collect::<Vec<String>>()
7929                    .join(",")
7930                    .to_string(),
7931            )]),
7932        };
7933    }
7934    if let Some(ref local_var_str) = parent_interface__isnull {
7935        local_var_req_builder = local_var_req_builder
7936            .query(&[("parent_interface__isnull", &local_var_str.to_string())]);
7937    }
7938    if let Some(ref local_var_str) = parent_interface__n {
7939        local_var_req_builder = match "multi" {
7940            "multi" => local_var_req_builder.query(
7941                &local_var_str
7942                    .into_iter()
7943                    .map(|p| ("parent_interface__n".to_owned(), p.to_string()))
7944                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7945            ),
7946            _ => local_var_req_builder.query(&[(
7947                "parent_interface__n",
7948                &local_var_str
7949                    .into_iter()
7950                    .map(|p| p.to_string())
7951                    .collect::<Vec<String>>()
7952                    .join(",")
7953                    .to_string(),
7954            )]),
7955        };
7956    }
7957    if let Some(ref local_var_str) = q {
7958        local_var_req_builder = local_var_req_builder.query(&[("q", &local_var_str.to_string())]);
7959    }
7960    if let Some(ref local_var_str) = role {
7961        local_var_req_builder = match "multi" {
7962            "multi" => local_var_req_builder.query(
7963                &local_var_str
7964                    .into_iter()
7965                    .map(|p| ("role".to_owned(), p.to_string()))
7966                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7967            ),
7968            _ => local_var_req_builder.query(&[(
7969                "role",
7970                &local_var_str
7971                    .into_iter()
7972                    .map(|p| p.to_string())
7973                    .collect::<Vec<String>>()
7974                    .join(",")
7975                    .to_string(),
7976            )]),
7977        };
7978    }
7979    if let Some(ref local_var_str) = role__isnull {
7980        local_var_req_builder =
7981            local_var_req_builder.query(&[("role__isnull", &local_var_str.to_string())]);
7982    }
7983    if let Some(ref local_var_str) = role__n {
7984        local_var_req_builder = match "multi" {
7985            "multi" => local_var_req_builder.query(
7986                &local_var_str
7987                    .into_iter()
7988                    .map(|p| ("role__n".to_owned(), p.to_string()))
7989                    .collect::<Vec<(std::string::String, std::string::String)>>(),
7990            ),
7991            _ => local_var_req_builder.query(&[(
7992                "role__n",
7993                &local_var_str
7994                    .into_iter()
7995                    .map(|p| p.to_string())
7996                    .collect::<Vec<String>>()
7997                    .join(",")
7998                    .to_string(),
7999            )]),
8000        };
8001    }
8002    if let Some(ref local_var_str) = sort {
8003        local_var_req_builder =
8004            local_var_req_builder.query(&[("sort", &local_var_str.to_string())]);
8005    }
8006    if let Some(ref local_var_str) = status {
8007        local_var_req_builder = match "multi" {
8008            "multi" => local_var_req_builder.query(
8009                &local_var_str
8010                    .into_iter()
8011                    .map(|p| ("status".to_owned(), p.to_string()))
8012                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8013            ),
8014            _ => local_var_req_builder.query(&[(
8015                "status",
8016                &local_var_str
8017                    .into_iter()
8018                    .map(|p| p.to_string())
8019                    .collect::<Vec<String>>()
8020                    .join(",")
8021                    .to_string(),
8022            )]),
8023        };
8024    }
8025    if let Some(ref local_var_str) = status__n {
8026        local_var_req_builder = match "multi" {
8027            "multi" => local_var_req_builder.query(
8028                &local_var_str
8029                    .into_iter()
8030                    .map(|p| ("status__n".to_owned(), p.to_string()))
8031                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8032            ),
8033            _ => local_var_req_builder.query(&[(
8034                "status__n",
8035                &local_var_str
8036                    .into_iter()
8037                    .map(|p| p.to_string())
8038                    .collect::<Vec<String>>()
8039                    .join(",")
8040                    .to_string(),
8041            )]),
8042        };
8043    }
8044    if let Some(ref local_var_str) = tagged_vlans {
8045        local_var_req_builder = match "multi" {
8046            "multi" => local_var_req_builder.query(
8047                &local_var_str
8048                    .into_iter()
8049                    .map(|p| ("tagged_vlans".to_owned(), p.to_string()))
8050                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8051            ),
8052            _ => local_var_req_builder.query(&[(
8053                "tagged_vlans",
8054                &local_var_str
8055                    .into_iter()
8056                    .map(|p| p.to_string())
8057                    .collect::<Vec<String>>()
8058                    .join(",")
8059                    .to_string(),
8060            )]),
8061        };
8062    }
8063    if let Some(ref local_var_str) = tagged_vlans__n {
8064        local_var_req_builder = match "multi" {
8065            "multi" => local_var_req_builder.query(
8066                &local_var_str
8067                    .into_iter()
8068                    .map(|p| ("tagged_vlans__n".to_owned(), p.to_string()))
8069                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8070            ),
8071            _ => local_var_req_builder.query(&[(
8072                "tagged_vlans__n",
8073                &local_var_str
8074                    .into_iter()
8075                    .map(|p| p.to_string())
8076                    .collect::<Vec<String>>()
8077                    .join(",")
8078                    .to_string(),
8079            )]),
8080        };
8081    }
8082    if let Some(ref local_var_str) = tags {
8083        local_var_req_builder = match "multi" {
8084            "multi" => local_var_req_builder.query(
8085                &local_var_str
8086                    .into_iter()
8087                    .map(|p| ("tags".to_owned(), p.to_string()))
8088                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8089            ),
8090            _ => local_var_req_builder.query(&[(
8091                "tags",
8092                &local_var_str
8093                    .into_iter()
8094                    .map(|p| p.to_string())
8095                    .collect::<Vec<String>>()
8096                    .join(",")
8097                    .to_string(),
8098            )]),
8099        };
8100    }
8101    if let Some(ref local_var_str) = tags__isnull {
8102        local_var_req_builder =
8103            local_var_req_builder.query(&[("tags__isnull", &local_var_str.to_string())]);
8104    }
8105    if let Some(ref local_var_str) = tags__n {
8106        local_var_req_builder = match "multi" {
8107            "multi" => local_var_req_builder.query(
8108                &local_var_str
8109                    .into_iter()
8110                    .map(|p| ("tags__n".to_owned(), p.to_string()))
8111                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8112            ),
8113            _ => local_var_req_builder.query(&[(
8114                "tags__n",
8115                &local_var_str
8116                    .into_iter()
8117                    .map(|p| p.to_string())
8118                    .collect::<Vec<String>>()
8119                    .join(",")
8120                    .to_string(),
8121            )]),
8122        };
8123    }
8124    if let Some(ref local_var_str) = teams {
8125        local_var_req_builder = match "multi" {
8126            "multi" => local_var_req_builder.query(
8127                &local_var_str
8128                    .into_iter()
8129                    .map(|p| ("teams".to_owned(), p.to_string()))
8130                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8131            ),
8132            _ => local_var_req_builder.query(&[(
8133                "teams",
8134                &local_var_str
8135                    .into_iter()
8136                    .map(|p| p.to_string())
8137                    .collect::<Vec<String>>()
8138                    .join(",")
8139                    .to_string(),
8140            )]),
8141        };
8142    }
8143    if let Some(ref local_var_str) = teams__isnull {
8144        local_var_req_builder =
8145            local_var_req_builder.query(&[("teams__isnull", &local_var_str.to_string())]);
8146    }
8147    if let Some(ref local_var_str) = teams__n {
8148        local_var_req_builder = match "multi" {
8149            "multi" => local_var_req_builder.query(
8150                &local_var_str
8151                    .into_iter()
8152                    .map(|p| ("teams__n".to_owned(), p.to_string()))
8153                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8154            ),
8155            _ => local_var_req_builder.query(&[(
8156                "teams__n",
8157                &local_var_str
8158                    .into_iter()
8159                    .map(|p| p.to_string())
8160                    .collect::<Vec<String>>()
8161                    .join(",")
8162                    .to_string(),
8163            )]),
8164        };
8165    }
8166    if let Some(ref local_var_str) = untagged_vlan {
8167        local_var_req_builder = match "multi" {
8168            "multi" => local_var_req_builder.query(
8169                &local_var_str
8170                    .into_iter()
8171                    .map(|p| ("untagged_vlan".to_owned(), p.to_string()))
8172                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8173            ),
8174            _ => local_var_req_builder.query(&[(
8175                "untagged_vlan",
8176                &local_var_str
8177                    .into_iter()
8178                    .map(|p| p.to_string())
8179                    .collect::<Vec<String>>()
8180                    .join(",")
8181                    .to_string(),
8182            )]),
8183        };
8184    }
8185    if let Some(ref local_var_str) = untagged_vlan__isnull {
8186        local_var_req_builder =
8187            local_var_req_builder.query(&[("untagged_vlan__isnull", &local_var_str.to_string())]);
8188    }
8189    if let Some(ref local_var_str) = untagged_vlan__n {
8190        local_var_req_builder = match "multi" {
8191            "multi" => local_var_req_builder.query(
8192                &local_var_str
8193                    .into_iter()
8194                    .map(|p| ("untagged_vlan__n".to_owned(), p.to_string()))
8195                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8196            ),
8197            _ => local_var_req_builder.query(&[(
8198                "untagged_vlan__n",
8199                &local_var_str
8200                    .into_iter()
8201                    .map(|p| p.to_string())
8202                    .collect::<Vec<String>>()
8203                    .join(",")
8204                    .to_string(),
8205            )]),
8206        };
8207    }
8208    if let Some(ref local_var_str) = virtual_machine {
8209        local_var_req_builder = match "multi" {
8210            "multi" => local_var_req_builder.query(
8211                &local_var_str
8212                    .into_iter()
8213                    .map(|p| ("virtual_machine".to_owned(), p.to_string()))
8214                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8215            ),
8216            _ => local_var_req_builder.query(&[(
8217                "virtual_machine",
8218                &local_var_str
8219                    .into_iter()
8220                    .map(|p| p.to_string())
8221                    .collect::<Vec<String>>()
8222                    .join(",")
8223                    .to_string(),
8224            )]),
8225        };
8226    }
8227    if let Some(ref local_var_str) = virtual_machine__n {
8228        local_var_req_builder = match "multi" {
8229            "multi" => local_var_req_builder.query(
8230                &local_var_str
8231                    .into_iter()
8232                    .map(|p| ("virtual_machine__n".to_owned(), p.to_string()))
8233                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8234            ),
8235            _ => local_var_req_builder.query(&[(
8236                "virtual_machine__n",
8237                &local_var_str
8238                    .into_iter()
8239                    .map(|p| p.to_string())
8240                    .collect::<Vec<String>>()
8241                    .join(",")
8242                    .to_string(),
8243            )]),
8244        };
8245    }
8246    if let Some(ref local_var_str) = virtual_machine_id {
8247        local_var_req_builder = match "multi" {
8248            "multi" => local_var_req_builder.query(
8249                &local_var_str
8250                    .into_iter()
8251                    .map(|p| ("virtual_machine_id".to_owned(), p.to_string()))
8252                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8253            ),
8254            _ => local_var_req_builder.query(&[(
8255                "virtual_machine_id",
8256                &local_var_str
8257                    .into_iter()
8258                    .map(|p| p.to_string())
8259                    .collect::<Vec<String>>()
8260                    .join(",")
8261                    .to_string(),
8262            )]),
8263        };
8264    }
8265    if let Some(ref local_var_str) = virtual_machine_id__n {
8266        local_var_req_builder = match "multi" {
8267            "multi" => local_var_req_builder.query(
8268                &local_var_str
8269                    .into_iter()
8270                    .map(|p| ("virtual_machine_id__n".to_owned(), p.to_string()))
8271                    .collect::<Vec<(std::string::String, std::string::String)>>(),
8272            ),
8273            _ => local_var_req_builder.query(&[(
8274                "virtual_machine_id__n",
8275                &local_var_str
8276                    .into_iter()
8277                    .map(|p| p.to_string())
8278                    .collect::<Vec<String>>()
8279                    .join(",")
8280                    .to_string(),
8281            )]),
8282        };
8283    }
8284    if let Some(ref local_var_str) = vlan_id {
8285        local_var_req_builder =
8286            local_var_req_builder.query(&[("vlan_id", &local_var_str.to_string())]);
8287    }
8288    if let Some(ref local_var_str) = depth {
8289        local_var_req_builder =
8290            local_var_req_builder.query(&[("depth", &local_var_str.to_string())]);
8291    }
8292    if let Some(ref local_var_str) = exclude_m2m {
8293        local_var_req_builder =
8294            local_var_req_builder.query(&[("exclude_m2m", &local_var_str.to_string())]);
8295    }
8296    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
8297        local_var_req_builder =
8298            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
8299    }
8300    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
8301        let local_var_key = local_var_apikey.key.clone();
8302        let local_var_value = match local_var_apikey.prefix {
8303            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
8304            None => local_var_key,
8305        };
8306        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
8307    };
8308
8309    let local_var_req = local_var_req_builder.build()?;
8310    let local_var_resp = local_var_client.execute(local_var_req).await?;
8311
8312    let local_var_status = local_var_resp.status();
8313    let local_var_content = local_var_resp.text().await?;
8314
8315    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
8316        serde_json::from_str(&local_var_content).map_err(Error::from)
8317    } else {
8318        let local_var_entity: Option<VirtualizationInterfacesListError> =
8319            serde_json::from_str(&local_var_content).ok();
8320        let local_var_error = ResponseContent {
8321            status: local_var_status,
8322            content: local_var_content,
8323            entity: local_var_entity,
8324        };
8325        Err(Error::ResponseError(local_var_error))
8326    }
8327}
8328
8329/// API methods for returning or creating notes on an object.
8330pub async fn virtualization_interfaces_notes_create(
8331    configuration: &configuration::Configuration,
8332    id: &str,
8333    note_input_request: crate::models::NoteInputRequest,
8334    format: Option<&str>,
8335) -> Result<crate::models::Note, Error<VirtualizationInterfacesNotesCreateError>> {
8336    let local_var_configuration = configuration;
8337
8338    let local_var_client = &local_var_configuration.client;
8339
8340    let local_var_uri_str = format!(
8341        "{}/virtualization/interfaces/{id}/notes/",
8342        local_var_configuration.base_path,
8343        id = crate::apis::urlencode(id)
8344    );
8345    let mut local_var_req_builder =
8346        local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
8347
8348    if let Some(ref local_var_str) = format {
8349        local_var_req_builder =
8350            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
8351    }
8352    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
8353        local_var_req_builder =
8354            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
8355    }
8356    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
8357        let local_var_key = local_var_apikey.key.clone();
8358        let local_var_value = match local_var_apikey.prefix {
8359            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
8360            None => local_var_key,
8361        };
8362        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
8363    };
8364    local_var_req_builder = local_var_req_builder.json(&note_input_request);
8365
8366    let local_var_req = local_var_req_builder.build()?;
8367    let local_var_resp = local_var_client.execute(local_var_req).await?;
8368
8369    let local_var_status = local_var_resp.status();
8370    let local_var_content = local_var_resp.text().await?;
8371
8372    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
8373        serde_json::from_str(&local_var_content).map_err(Error::from)
8374    } else {
8375        let local_var_entity: Option<VirtualizationInterfacesNotesCreateError> =
8376            serde_json::from_str(&local_var_content).ok();
8377        let local_var_error = ResponseContent {
8378            status: local_var_status,
8379            content: local_var_content,
8380            entity: local_var_entity,
8381        };
8382        Err(Error::ResponseError(local_var_error))
8383    }
8384}
8385
8386/// API methods for returning or creating notes on an object.
8387pub async fn virtualization_interfaces_notes_list(
8388    configuration: &configuration::Configuration,
8389    id: &str,
8390    format: Option<&str>,
8391    limit: Option<i32>,
8392    offset: Option<i32>,
8393    depth: Option<i32>,
8394    exclude_m2m: Option<bool>,
8395) -> Result<crate::models::PaginatedNoteList, Error<VirtualizationInterfacesNotesListError>> {
8396    let local_var_configuration = configuration;
8397
8398    let local_var_client = &local_var_configuration.client;
8399
8400    let local_var_uri_str = format!(
8401        "{}/virtualization/interfaces/{id}/notes/",
8402        local_var_configuration.base_path,
8403        id = crate::apis::urlencode(id)
8404    );
8405    let mut local_var_req_builder =
8406        local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
8407
8408    if let Some(ref local_var_str) = format {
8409        local_var_req_builder =
8410            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
8411    }
8412    if let Some(ref local_var_str) = limit {
8413        local_var_req_builder =
8414            local_var_req_builder.query(&[("limit", &local_var_str.to_string())]);
8415    }
8416    if let Some(ref local_var_str) = offset {
8417        local_var_req_builder =
8418            local_var_req_builder.query(&[("offset", &local_var_str.to_string())]);
8419    }
8420    if let Some(ref local_var_str) = depth {
8421        local_var_req_builder =
8422            local_var_req_builder.query(&[("depth", &local_var_str.to_string())]);
8423    }
8424    if let Some(ref local_var_str) = exclude_m2m {
8425        local_var_req_builder =
8426            local_var_req_builder.query(&[("exclude_m2m", &local_var_str.to_string())]);
8427    }
8428    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
8429        local_var_req_builder =
8430            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
8431    }
8432    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
8433        let local_var_key = local_var_apikey.key.clone();
8434        let local_var_value = match local_var_apikey.prefix {
8435            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
8436            None => local_var_key,
8437        };
8438        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
8439    };
8440
8441    let local_var_req = local_var_req_builder.build()?;
8442    let local_var_resp = local_var_client.execute(local_var_req).await?;
8443
8444    let local_var_status = local_var_resp.status();
8445    let local_var_content = local_var_resp.text().await?;
8446
8447    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
8448        serde_json::from_str(&local_var_content).map_err(Error::from)
8449    } else {
8450        let local_var_entity: Option<VirtualizationInterfacesNotesListError> =
8451            serde_json::from_str(&local_var_content).ok();
8452        let local_var_error = ResponseContent {
8453            status: local_var_status,
8454            content: local_var_content,
8455            entity: local_var_entity,
8456        };
8457        Err(Error::ResponseError(local_var_error))
8458    }
8459}
8460
8461/// Partial update a VM interface object.
8462pub async fn virtualization_interfaces_partial_update(
8463    configuration: &configuration::Configuration,
8464    id: &str,
8465    format: Option<&str>,
8466    patched_writable_vm_interface_request: Option<crate::models::PatchedWritableVmInterfaceRequest>,
8467) -> Result<crate::models::VmInterface, Error<VirtualizationInterfacesPartialUpdateError>> {
8468    let local_var_configuration = configuration;
8469
8470    let local_var_client = &local_var_configuration.client;
8471
8472    let local_var_uri_str = format!(
8473        "{}/virtualization/interfaces/{id}/",
8474        local_var_configuration.base_path,
8475        id = crate::apis::urlencode(id)
8476    );
8477    let mut local_var_req_builder =
8478        local_var_client.request(reqwest::Method::PATCH, local_var_uri_str.as_str());
8479
8480    if let Some(ref local_var_str) = format {
8481        local_var_req_builder =
8482            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
8483    }
8484    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
8485        local_var_req_builder =
8486            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
8487    }
8488    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
8489        let local_var_key = local_var_apikey.key.clone();
8490        let local_var_value = match local_var_apikey.prefix {
8491            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
8492            None => local_var_key,
8493        };
8494        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
8495    };
8496    local_var_req_builder = local_var_req_builder.json(&patched_writable_vm_interface_request);
8497
8498    let local_var_req = local_var_req_builder.build()?;
8499    let local_var_resp = local_var_client.execute(local_var_req).await?;
8500
8501    let local_var_status = local_var_resp.status();
8502    let local_var_content = local_var_resp.text().await?;
8503
8504    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
8505        serde_json::from_str(&local_var_content).map_err(Error::from)
8506    } else {
8507        let local_var_entity: Option<VirtualizationInterfacesPartialUpdateError> =
8508            serde_json::from_str(&local_var_content).ok();
8509        let local_var_error = ResponseContent {
8510            status: local_var_status,
8511            content: local_var_content,
8512            entity: local_var_entity,
8513        };
8514        Err(Error::ResponseError(local_var_error))
8515    }
8516}
8517
8518/// Retrieve a VM interface object.
8519pub async fn virtualization_interfaces_retrieve(
8520    configuration: &configuration::Configuration,
8521    id: &str,
8522    format: Option<&str>,
8523    depth: Option<i32>,
8524    exclude_m2m: Option<bool>,
8525) -> Result<crate::models::VmInterface, Error<VirtualizationInterfacesRetrieveError>> {
8526    let local_var_configuration = configuration;
8527
8528    let local_var_client = &local_var_configuration.client;
8529
8530    let local_var_uri_str = format!(
8531        "{}/virtualization/interfaces/{id}/",
8532        local_var_configuration.base_path,
8533        id = crate::apis::urlencode(id)
8534    );
8535    let mut local_var_req_builder =
8536        local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
8537
8538    if let Some(ref local_var_str) = format {
8539        local_var_req_builder =
8540            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
8541    }
8542    if let Some(ref local_var_str) = depth {
8543        local_var_req_builder =
8544            local_var_req_builder.query(&[("depth", &local_var_str.to_string())]);
8545    }
8546    if let Some(ref local_var_str) = exclude_m2m {
8547        local_var_req_builder =
8548            local_var_req_builder.query(&[("exclude_m2m", &local_var_str.to_string())]);
8549    }
8550    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
8551        local_var_req_builder =
8552            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
8553    }
8554    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
8555        let local_var_key = local_var_apikey.key.clone();
8556        let local_var_value = match local_var_apikey.prefix {
8557            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
8558            None => local_var_key,
8559        };
8560        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
8561    };
8562
8563    let local_var_req = local_var_req_builder.build()?;
8564    let local_var_resp = local_var_client.execute(local_var_req).await?;
8565
8566    let local_var_status = local_var_resp.status();
8567    let local_var_content = local_var_resp.text().await?;
8568
8569    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
8570        serde_json::from_str(&local_var_content).map_err(Error::from)
8571    } else {
8572        let local_var_entity: Option<VirtualizationInterfacesRetrieveError> =
8573            serde_json::from_str(&local_var_content).ok();
8574        let local_var_error = ResponseContent {
8575            status: local_var_status,
8576            content: local_var_content,
8577            entity: local_var_entity,
8578        };
8579        Err(Error::ResponseError(local_var_error))
8580    }
8581}
8582
8583/// Update a VM interface object.
8584pub async fn virtualization_interfaces_update(
8585    configuration: &configuration::Configuration,
8586    id: &str,
8587    writable_vm_interface_request: crate::models::WritableVmInterfaceRequest,
8588    format: Option<&str>,
8589) -> Result<crate::models::VmInterface, Error<VirtualizationInterfacesUpdateError>> {
8590    let local_var_configuration = configuration;
8591
8592    let local_var_client = &local_var_configuration.client;
8593
8594    let local_var_uri_str = format!(
8595        "{}/virtualization/interfaces/{id}/",
8596        local_var_configuration.base_path,
8597        id = crate::apis::urlencode(id)
8598    );
8599    let mut local_var_req_builder =
8600        local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());
8601
8602    if let Some(ref local_var_str) = format {
8603        local_var_req_builder =
8604            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
8605    }
8606    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
8607        local_var_req_builder =
8608            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
8609    }
8610    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
8611        let local_var_key = local_var_apikey.key.clone();
8612        let local_var_value = match local_var_apikey.prefix {
8613            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
8614            None => local_var_key,
8615        };
8616        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
8617    };
8618    local_var_req_builder = local_var_req_builder.json(&writable_vm_interface_request);
8619
8620    let local_var_req = local_var_req_builder.build()?;
8621    let local_var_resp = local_var_client.execute(local_var_req).await?;
8622
8623    let local_var_status = local_var_resp.status();
8624    let local_var_content = local_var_resp.text().await?;
8625
8626    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
8627        serde_json::from_str(&local_var_content).map_err(Error::from)
8628    } else {
8629        let local_var_entity: Option<VirtualizationInterfacesUpdateError> =
8630            serde_json::from_str(&local_var_content).ok();
8631        let local_var_error = ResponseContent {
8632            status: local_var_status,
8633            content: local_var_content,
8634            entity: local_var_entity,
8635        };
8636        Err(Error::ResponseError(local_var_error))
8637    }
8638}
8639
8640/// Destroy a list of virtual machine objects.
8641pub async fn virtualization_virtual_machines_bulk_destroy(
8642    configuration: &configuration::Configuration,
8643    bulk_operation_request: Vec<crate::models::BulkOperationRequest>,
8644    format: Option<&str>,
8645) -> Result<(), Error<VirtualizationVirtualMachinesBulkDestroyError>> {
8646    let local_var_configuration = configuration;
8647
8648    let local_var_client = &local_var_configuration.client;
8649
8650    let local_var_uri_str = format!(
8651        "{}/virtualization/virtual-machines/",
8652        local_var_configuration.base_path
8653    );
8654    let mut local_var_req_builder =
8655        local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());
8656
8657    if let Some(ref local_var_str) = format {
8658        local_var_req_builder =
8659            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
8660    }
8661    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
8662        local_var_req_builder =
8663            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
8664    }
8665    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
8666        let local_var_key = local_var_apikey.key.clone();
8667        let local_var_value = match local_var_apikey.prefix {
8668            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
8669            None => local_var_key,
8670        };
8671        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
8672    };
8673    local_var_req_builder = local_var_req_builder.json(&bulk_operation_request);
8674
8675    let local_var_req = local_var_req_builder.build()?;
8676    let local_var_resp = local_var_client.execute(local_var_req).await?;
8677
8678    let local_var_status = local_var_resp.status();
8679    let local_var_content = local_var_resp.text().await?;
8680
8681    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
8682        Ok(())
8683    } else {
8684        let local_var_entity: Option<VirtualizationVirtualMachinesBulkDestroyError> =
8685            serde_json::from_str(&local_var_content).ok();
8686        let local_var_error = ResponseContent {
8687            status: local_var_status,
8688            content: local_var_content,
8689            entity: local_var_entity,
8690        };
8691        Err(Error::ResponseError(local_var_error))
8692    }
8693}
8694
8695/// Partial update a list of virtual machine objects.
8696pub async fn virtualization_virtual_machines_bulk_partial_update(
8697    configuration: &configuration::Configuration,
8698    patched_bulk_writable_virtual_machine_request: Vec<
8699        crate::models::PatchedBulkWritableVirtualMachineRequest,
8700    >,
8701    format: Option<&str>,
8702) -> Result<
8703    Vec<crate::models::VirtualMachine>,
8704    Error<VirtualizationVirtualMachinesBulkPartialUpdateError>,
8705> {
8706    let local_var_configuration = configuration;
8707
8708    let local_var_client = &local_var_configuration.client;
8709
8710    let local_var_uri_str = format!(
8711        "{}/virtualization/virtual-machines/",
8712        local_var_configuration.base_path
8713    );
8714    let mut local_var_req_builder =
8715        local_var_client.request(reqwest::Method::PATCH, local_var_uri_str.as_str());
8716
8717    if let Some(ref local_var_str) = format {
8718        local_var_req_builder =
8719            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
8720    }
8721    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
8722        local_var_req_builder =
8723            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
8724    }
8725    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
8726        let local_var_key = local_var_apikey.key.clone();
8727        let local_var_value = match local_var_apikey.prefix {
8728            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
8729            None => local_var_key,
8730        };
8731        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
8732    };
8733    local_var_req_builder =
8734        local_var_req_builder.json(&patched_bulk_writable_virtual_machine_request);
8735
8736    let local_var_req = local_var_req_builder.build()?;
8737    let local_var_resp = local_var_client.execute(local_var_req).await?;
8738
8739    let local_var_status = local_var_resp.status();
8740    let local_var_content = local_var_resp.text().await?;
8741
8742    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
8743        serde_json::from_str(&local_var_content).map_err(Error::from)
8744    } else {
8745        let local_var_entity: Option<VirtualizationVirtualMachinesBulkPartialUpdateError> =
8746            serde_json::from_str(&local_var_content).ok();
8747        let local_var_error = ResponseContent {
8748            status: local_var_status,
8749            content: local_var_content,
8750            entity: local_var_entity,
8751        };
8752        Err(Error::ResponseError(local_var_error))
8753    }
8754}
8755
8756/// Update a list of virtual machine objects.
8757pub async fn virtualization_virtual_machines_bulk_update(
8758    configuration: &configuration::Configuration,
8759    bulk_writable_virtual_machine_request: Vec<crate::models::BulkWritableVirtualMachineRequest>,
8760    format: Option<&str>,
8761) -> Result<Vec<crate::models::VirtualMachine>, Error<VirtualizationVirtualMachinesBulkUpdateError>>
8762{
8763    let local_var_configuration = configuration;
8764
8765    let local_var_client = &local_var_configuration.client;
8766
8767    let local_var_uri_str = format!(
8768        "{}/virtualization/virtual-machines/",
8769        local_var_configuration.base_path
8770    );
8771    let mut local_var_req_builder =
8772        local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());
8773
8774    if let Some(ref local_var_str) = format {
8775        local_var_req_builder =
8776            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
8777    }
8778    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
8779        local_var_req_builder =
8780            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
8781    }
8782    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
8783        let local_var_key = local_var_apikey.key.clone();
8784        let local_var_value = match local_var_apikey.prefix {
8785            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
8786            None => local_var_key,
8787        };
8788        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
8789    };
8790    local_var_req_builder = local_var_req_builder.json(&bulk_writable_virtual_machine_request);
8791
8792    let local_var_req = local_var_req_builder.build()?;
8793    let local_var_resp = local_var_client.execute(local_var_req).await?;
8794
8795    let local_var_status = local_var_resp.status();
8796    let local_var_content = local_var_resp.text().await?;
8797
8798    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
8799        serde_json::from_str(&local_var_content).map_err(Error::from)
8800    } else {
8801        let local_var_entity: Option<VirtualizationVirtualMachinesBulkUpdateError> =
8802            serde_json::from_str(&local_var_content).ok();
8803        let local_var_error = ResponseContent {
8804            status: local_var_status,
8805            content: local_var_content,
8806            entity: local_var_entity,
8807        };
8808        Err(Error::ResponseError(local_var_error))
8809    }
8810}
8811
8812/// Create one or more virtual machine objects.
8813pub async fn virtualization_virtual_machines_create(
8814    configuration: &configuration::Configuration,
8815    virtual_machine_request: crate::models::VirtualMachineRequest,
8816    format: Option<&str>,
8817) -> Result<crate::models::VirtualMachine, Error<VirtualizationVirtualMachinesCreateError>> {
8818    let local_var_configuration = configuration;
8819
8820    let local_var_client = &local_var_configuration.client;
8821
8822    let local_var_uri_str = format!(
8823        "{}/virtualization/virtual-machines/",
8824        local_var_configuration.base_path
8825    );
8826    let mut local_var_req_builder =
8827        local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
8828
8829    if let Some(ref local_var_str) = format {
8830        local_var_req_builder =
8831            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
8832    }
8833    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
8834        local_var_req_builder =
8835            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
8836    }
8837    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
8838        let local_var_key = local_var_apikey.key.clone();
8839        let local_var_value = match local_var_apikey.prefix {
8840            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
8841            None => local_var_key,
8842        };
8843        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
8844    };
8845    local_var_req_builder = local_var_req_builder.json(&virtual_machine_request);
8846
8847    let local_var_req = local_var_req_builder.build()?;
8848    let local_var_resp = local_var_client.execute(local_var_req).await?;
8849
8850    let local_var_status = local_var_resp.status();
8851    let local_var_content = local_var_resp.text().await?;
8852
8853    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
8854        serde_json::from_str(&local_var_content).map_err(Error::from)
8855    } else {
8856        let local_var_entity: Option<VirtualizationVirtualMachinesCreateError> =
8857            serde_json::from_str(&local_var_content).ok();
8858        let local_var_error = ResponseContent {
8859            status: local_var_status,
8860            content: local_var_content,
8861            entity: local_var_entity,
8862        };
8863        Err(Error::ResponseError(local_var_error))
8864    }
8865}
8866
8867/// Destroy a virtual machine object.
8868pub async fn virtualization_virtual_machines_destroy(
8869    configuration: &configuration::Configuration,
8870    id: &str,
8871    format: Option<&str>,
8872) -> Result<(), Error<VirtualizationVirtualMachinesDestroyError>> {
8873    let local_var_configuration = configuration;
8874
8875    let local_var_client = &local_var_configuration.client;
8876
8877    let local_var_uri_str = format!(
8878        "{}/virtualization/virtual-machines/{id}/",
8879        local_var_configuration.base_path,
8880        id = crate::apis::urlencode(id)
8881    );
8882    let mut local_var_req_builder =
8883        local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());
8884
8885    if let Some(ref local_var_str) = format {
8886        local_var_req_builder =
8887            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
8888    }
8889    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
8890        local_var_req_builder =
8891            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
8892    }
8893    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
8894        let local_var_key = local_var_apikey.key.clone();
8895        let local_var_value = match local_var_apikey.prefix {
8896            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
8897            None => local_var_key,
8898        };
8899        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
8900    };
8901
8902    let local_var_req = local_var_req_builder.build()?;
8903    let local_var_resp = local_var_client.execute(local_var_req).await?;
8904
8905    let local_var_status = local_var_resp.status();
8906    let local_var_content = local_var_resp.text().await?;
8907
8908    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
8909        Ok(())
8910    } else {
8911        let local_var_entity: Option<VirtualizationVirtualMachinesDestroyError> =
8912            serde_json::from_str(&local_var_content).ok();
8913        let local_var_error = ResponseContent {
8914            status: local_var_status,
8915            content: local_var_content,
8916            entity: local_var_entity,
8917        };
8918        Err(Error::ResponseError(local_var_error))
8919    }
8920}
8921
8922/// Retrieve a list of virtual machine objects.
8923pub async fn virtualization_virtual_machines_list(
8924    configuration: &configuration::Configuration,
8925    cluster: Option<Vec<String>>,
8926    cluster__n: Option<Vec<String>>,
8927    cluster_group: Option<Vec<String>>,
8928    cluster_group__isnull: Option<bool>,
8929    cluster_group__n: Option<Vec<String>>,
8930    cluster_group_id: Option<Vec<uuid::Uuid>>,
8931    cluster_group_id__isnull: Option<bool>,
8932    cluster_group_id__n: Option<Vec<uuid::Uuid>>,
8933    cluster_id: Option<Vec<uuid::Uuid>>,
8934    cluster_id__n: Option<Vec<uuid::Uuid>>,
8935    cluster_type: Option<Vec<String>>,
8936    cluster_type__n: Option<Vec<String>>,
8937    cluster_type_id: Option<Vec<uuid::Uuid>>,
8938    cluster_type_id__n: Option<Vec<uuid::Uuid>>,
8939    comments: Option<Vec<String>>,
8940    comments__ic: Option<Vec<String>>,
8941    comments__ie: Option<Vec<String>>,
8942    comments__iew: Option<Vec<String>>,
8943    comments__ire: Option<Vec<String>>,
8944    comments__isw: Option<Vec<String>>,
8945    comments__n: Option<Vec<String>>,
8946    comments__nic: Option<Vec<String>>,
8947    comments__nie: Option<Vec<String>>,
8948    comments__niew: Option<Vec<String>>,
8949    comments__nire: Option<Vec<String>>,
8950    comments__nisw: Option<Vec<String>>,
8951    comments__nre: Option<Vec<String>>,
8952    comments__re: Option<Vec<String>>,
8953    contacts: Option<Vec<String>>,
8954    contacts__isnull: Option<bool>,
8955    contacts__n: Option<Vec<String>>,
8956    created: Option<Vec<String>>,
8957    created__gt: Option<Vec<String>>,
8958    created__gte: Option<Vec<String>>,
8959    created__isnull: Option<bool>,
8960    created__lt: Option<Vec<String>>,
8961    created__lte: Option<Vec<String>>,
8962    created__n: Option<Vec<String>>,
8963    disk: Option<Vec<i32>>,
8964    disk__gt: Option<Vec<i32>>,
8965    disk__gte: Option<Vec<i32>>,
8966    disk__isnull: Option<bool>,
8967    disk__lt: Option<Vec<i32>>,
8968    disk__lte: Option<Vec<i32>>,
8969    disk__n: Option<Vec<i32>>,
8970    dynamic_groups: Option<Vec<String>>,
8971    dynamic_groups__n: Option<Vec<String>>,
8972    format: Option<&str>,
8973    has_interfaces: Option<bool>,
8974    has_ip_addresses: Option<bool>,
8975    has_primary_ip: Option<bool>,
8976    has_services: Option<bool>,
8977    has_software_image_files: Option<bool>,
8978    has_software_version: Option<bool>,
8979    id: Option<Vec<uuid::Uuid>>,
8980    id__n: Option<Vec<uuid::Uuid>>,
8981    interfaces: Option<Vec<String>>,
8982    interfaces__isnull: Option<bool>,
8983    interfaces__n: Option<Vec<String>>,
8984    ip_addresses: Option<Vec<String>>,
8985    last_updated: Option<Vec<String>>,
8986    last_updated__gt: Option<Vec<String>>,
8987    last_updated__gte: Option<Vec<String>>,
8988    last_updated__isnull: Option<bool>,
8989    last_updated__lt: Option<Vec<String>>,
8990    last_updated__lte: Option<Vec<String>>,
8991    last_updated__n: Option<Vec<String>>,
8992    limit: Option<i32>,
8993    local_config_context_data: Option<bool>,
8994    local_config_context_schema: Option<Vec<String>>,
8995    local_config_context_schema__isnull: Option<bool>,
8996    local_config_context_schema__n: Option<Vec<String>>,
8997    local_config_context_schema_id: Option<Vec<uuid::Uuid>>,
8998    local_config_context_schema_id__isnull: Option<bool>,
8999    local_config_context_schema_id__n: Option<Vec<uuid::Uuid>>,
9000    location: Option<Vec<String>>,
9001    location__isnull: Option<bool>,
9002    location__n: Option<Vec<String>>,
9003    mac_address: Option<Vec<String>>,
9004    mac_address__ic: Option<Vec<String>>,
9005    mac_address__ie: Option<Vec<String>>,
9006    mac_address__iew: Option<Vec<String>>,
9007    mac_address__ire: Option<Vec<String>>,
9008    mac_address__isw: Option<Vec<String>>,
9009    mac_address__n: Option<Vec<String>>,
9010    mac_address__nic: Option<Vec<String>>,
9011    mac_address__nie: Option<Vec<String>>,
9012    mac_address__niew: Option<Vec<String>>,
9013    mac_address__nire: Option<Vec<String>>,
9014    mac_address__nisw: Option<Vec<String>>,
9015    mac_address__nre: Option<Vec<String>>,
9016    mac_address__re: Option<Vec<String>>,
9017    memory: Option<Vec<i32>>,
9018    memory__gt: Option<Vec<i32>>,
9019    memory__gte: Option<Vec<i32>>,
9020    memory__isnull: Option<bool>,
9021    memory__lt: Option<Vec<i32>>,
9022    memory__lte: Option<Vec<i32>>,
9023    memory__n: Option<Vec<i32>>,
9024    name: Option<Vec<String>>,
9025    name__ic: Option<Vec<String>>,
9026    name__ie: Option<Vec<String>>,
9027    name__iew: Option<Vec<String>>,
9028    name__ire: Option<Vec<String>>,
9029    name__isw: Option<Vec<String>>,
9030    name__n: Option<Vec<String>>,
9031    name__nic: Option<Vec<String>>,
9032    name__nie: Option<Vec<String>>,
9033    name__niew: Option<Vec<String>>,
9034    name__nire: Option<Vec<String>>,
9035    name__nisw: Option<Vec<String>>,
9036    name__nre: Option<Vec<String>>,
9037    name__re: Option<Vec<String>>,
9038    offset: Option<i32>,
9039    platform: Option<Vec<String>>,
9040    platform__isnull: Option<bool>,
9041    platform__n: Option<Vec<String>>,
9042    platform_id: Option<Vec<uuid::Uuid>>,
9043    platform_id__isnull: Option<bool>,
9044    platform_id__n: Option<Vec<uuid::Uuid>>,
9045    primary_ip4: Option<Vec<String>>,
9046    primary_ip6: Option<Vec<String>>,
9047    q: Option<&str>,
9048    role: Option<Vec<String>>,
9049    role__isnull: Option<bool>,
9050    role__n: Option<Vec<String>>,
9051    services: Option<Vec<String>>,
9052    services__isnull: Option<bool>,
9053    services__n: Option<Vec<String>>,
9054    software_image_files: Option<Vec<String>>,
9055    software_image_files__n: Option<Vec<String>>,
9056    software_version: Option<Vec<String>>,
9057    software_version__isnull: Option<bool>,
9058    software_version__n: Option<Vec<String>>,
9059    sort: Option<&str>,
9060    status: Option<Vec<String>>,
9061    status__n: Option<Vec<String>>,
9062    tags: Option<Vec<String>>,
9063    tags__isnull: Option<bool>,
9064    tags__n: Option<Vec<String>>,
9065    teams: Option<Vec<String>>,
9066    teams__isnull: Option<bool>,
9067    teams__n: Option<Vec<String>>,
9068    tenant: Option<Vec<String>>,
9069    tenant__isnull: Option<bool>,
9070    tenant__n: Option<Vec<String>>,
9071    tenant_group: Option<Vec<String>>,
9072    tenant_group__isnull: Option<bool>,
9073    tenant_group__n: Option<Vec<String>>,
9074    tenant_id: Option<Vec<uuid::Uuid>>,
9075    tenant_id__isnull: Option<bool>,
9076    tenant_id__n: Option<Vec<uuid::Uuid>>,
9077    vcpus: Option<Vec<i32>>,
9078    vcpus__gt: Option<Vec<i32>>,
9079    vcpus__gte: Option<Vec<i32>>,
9080    vcpus__isnull: Option<bool>,
9081    vcpus__lt: Option<Vec<i32>>,
9082    vcpus__lte: Option<Vec<i32>>,
9083    vcpus__n: Option<Vec<i32>>,
9084    vrfs: Option<Vec<String>>,
9085    vrfs__isnull: Option<bool>,
9086    vrfs__n: Option<Vec<String>>,
9087    depth: Option<i32>,
9088    exclude_m2m: Option<bool>,
9089) -> Result<crate::models::PaginatedVirtualMachineList, Error<VirtualizationVirtualMachinesListError>>
9090{
9091    let local_var_configuration = configuration;
9092
9093    let local_var_client = &local_var_configuration.client;
9094
9095    let local_var_uri_str = format!(
9096        "{}/virtualization/virtual-machines/",
9097        local_var_configuration.base_path
9098    );
9099    let mut local_var_req_builder =
9100        local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
9101
9102    if let Some(ref local_var_str) = cluster {
9103        local_var_req_builder = match "multi" {
9104            "multi" => local_var_req_builder.query(
9105                &local_var_str
9106                    .into_iter()
9107                    .map(|p| ("cluster".to_owned(), p.to_string()))
9108                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9109            ),
9110            _ => local_var_req_builder.query(&[(
9111                "cluster",
9112                &local_var_str
9113                    .into_iter()
9114                    .map(|p| p.to_string())
9115                    .collect::<Vec<String>>()
9116                    .join(",")
9117                    .to_string(),
9118            )]),
9119        };
9120    }
9121    if let Some(ref local_var_str) = cluster__n {
9122        local_var_req_builder = match "multi" {
9123            "multi" => local_var_req_builder.query(
9124                &local_var_str
9125                    .into_iter()
9126                    .map(|p| ("cluster__n".to_owned(), p.to_string()))
9127                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9128            ),
9129            _ => local_var_req_builder.query(&[(
9130                "cluster__n",
9131                &local_var_str
9132                    .into_iter()
9133                    .map(|p| p.to_string())
9134                    .collect::<Vec<String>>()
9135                    .join(",")
9136                    .to_string(),
9137            )]),
9138        };
9139    }
9140    if let Some(ref local_var_str) = cluster_group {
9141        local_var_req_builder = match "multi" {
9142            "multi" => local_var_req_builder.query(
9143                &local_var_str
9144                    .into_iter()
9145                    .map(|p| ("cluster_group".to_owned(), p.to_string()))
9146                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9147            ),
9148            _ => local_var_req_builder.query(&[(
9149                "cluster_group",
9150                &local_var_str
9151                    .into_iter()
9152                    .map(|p| p.to_string())
9153                    .collect::<Vec<String>>()
9154                    .join(",")
9155                    .to_string(),
9156            )]),
9157        };
9158    }
9159    if let Some(ref local_var_str) = cluster_group__isnull {
9160        local_var_req_builder =
9161            local_var_req_builder.query(&[("cluster_group__isnull", &local_var_str.to_string())]);
9162    }
9163    if let Some(ref local_var_str) = cluster_group__n {
9164        local_var_req_builder = match "multi" {
9165            "multi" => local_var_req_builder.query(
9166                &local_var_str
9167                    .into_iter()
9168                    .map(|p| ("cluster_group__n".to_owned(), p.to_string()))
9169                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9170            ),
9171            _ => local_var_req_builder.query(&[(
9172                "cluster_group__n",
9173                &local_var_str
9174                    .into_iter()
9175                    .map(|p| p.to_string())
9176                    .collect::<Vec<String>>()
9177                    .join(",")
9178                    .to_string(),
9179            )]),
9180        };
9181    }
9182    if let Some(ref local_var_str) = cluster_group_id {
9183        local_var_req_builder = match "multi" {
9184            "multi" => local_var_req_builder.query(
9185                &local_var_str
9186                    .into_iter()
9187                    .map(|p| ("cluster_group_id".to_owned(), p.to_string()))
9188                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9189            ),
9190            _ => local_var_req_builder.query(&[(
9191                "cluster_group_id",
9192                &local_var_str
9193                    .into_iter()
9194                    .map(|p| p.to_string())
9195                    .collect::<Vec<String>>()
9196                    .join(",")
9197                    .to_string(),
9198            )]),
9199        };
9200    }
9201    if let Some(ref local_var_str) = cluster_group_id__isnull {
9202        local_var_req_builder = local_var_req_builder
9203            .query(&[("cluster_group_id__isnull", &local_var_str.to_string())]);
9204    }
9205    if let Some(ref local_var_str) = cluster_group_id__n {
9206        local_var_req_builder = match "multi" {
9207            "multi" => local_var_req_builder.query(
9208                &local_var_str
9209                    .into_iter()
9210                    .map(|p| ("cluster_group_id__n".to_owned(), p.to_string()))
9211                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9212            ),
9213            _ => local_var_req_builder.query(&[(
9214                "cluster_group_id__n",
9215                &local_var_str
9216                    .into_iter()
9217                    .map(|p| p.to_string())
9218                    .collect::<Vec<String>>()
9219                    .join(",")
9220                    .to_string(),
9221            )]),
9222        };
9223    }
9224    if let Some(ref local_var_str) = cluster_id {
9225        local_var_req_builder = match "multi" {
9226            "multi" => local_var_req_builder.query(
9227                &local_var_str
9228                    .into_iter()
9229                    .map(|p| ("cluster_id".to_owned(), p.to_string()))
9230                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9231            ),
9232            _ => local_var_req_builder.query(&[(
9233                "cluster_id",
9234                &local_var_str
9235                    .into_iter()
9236                    .map(|p| p.to_string())
9237                    .collect::<Vec<String>>()
9238                    .join(",")
9239                    .to_string(),
9240            )]),
9241        };
9242    }
9243    if let Some(ref local_var_str) = cluster_id__n {
9244        local_var_req_builder = match "multi" {
9245            "multi" => local_var_req_builder.query(
9246                &local_var_str
9247                    .into_iter()
9248                    .map(|p| ("cluster_id__n".to_owned(), p.to_string()))
9249                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9250            ),
9251            _ => local_var_req_builder.query(&[(
9252                "cluster_id__n",
9253                &local_var_str
9254                    .into_iter()
9255                    .map(|p| p.to_string())
9256                    .collect::<Vec<String>>()
9257                    .join(",")
9258                    .to_string(),
9259            )]),
9260        };
9261    }
9262    if let Some(ref local_var_str) = cluster_type {
9263        local_var_req_builder = match "multi" {
9264            "multi" => local_var_req_builder.query(
9265                &local_var_str
9266                    .into_iter()
9267                    .map(|p| ("cluster_type".to_owned(), p.to_string()))
9268                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9269            ),
9270            _ => local_var_req_builder.query(&[(
9271                "cluster_type",
9272                &local_var_str
9273                    .into_iter()
9274                    .map(|p| p.to_string())
9275                    .collect::<Vec<String>>()
9276                    .join(",")
9277                    .to_string(),
9278            )]),
9279        };
9280    }
9281    if let Some(ref local_var_str) = cluster_type__n {
9282        local_var_req_builder = match "multi" {
9283            "multi" => local_var_req_builder.query(
9284                &local_var_str
9285                    .into_iter()
9286                    .map(|p| ("cluster_type__n".to_owned(), p.to_string()))
9287                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9288            ),
9289            _ => local_var_req_builder.query(&[(
9290                "cluster_type__n",
9291                &local_var_str
9292                    .into_iter()
9293                    .map(|p| p.to_string())
9294                    .collect::<Vec<String>>()
9295                    .join(",")
9296                    .to_string(),
9297            )]),
9298        };
9299    }
9300    if let Some(ref local_var_str) = cluster_type_id {
9301        local_var_req_builder = match "multi" {
9302            "multi" => local_var_req_builder.query(
9303                &local_var_str
9304                    .into_iter()
9305                    .map(|p| ("cluster_type_id".to_owned(), p.to_string()))
9306                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9307            ),
9308            _ => local_var_req_builder.query(&[(
9309                "cluster_type_id",
9310                &local_var_str
9311                    .into_iter()
9312                    .map(|p| p.to_string())
9313                    .collect::<Vec<String>>()
9314                    .join(",")
9315                    .to_string(),
9316            )]),
9317        };
9318    }
9319    if let Some(ref local_var_str) = cluster_type_id__n {
9320        local_var_req_builder = match "multi" {
9321            "multi" => local_var_req_builder.query(
9322                &local_var_str
9323                    .into_iter()
9324                    .map(|p| ("cluster_type_id__n".to_owned(), p.to_string()))
9325                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9326            ),
9327            _ => local_var_req_builder.query(&[(
9328                "cluster_type_id__n",
9329                &local_var_str
9330                    .into_iter()
9331                    .map(|p| p.to_string())
9332                    .collect::<Vec<String>>()
9333                    .join(",")
9334                    .to_string(),
9335            )]),
9336        };
9337    }
9338    if let Some(ref local_var_str) = comments {
9339        local_var_req_builder = match "multi" {
9340            "multi" => local_var_req_builder.query(
9341                &local_var_str
9342                    .into_iter()
9343                    .map(|p| ("comments".to_owned(), p.to_string()))
9344                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9345            ),
9346            _ => local_var_req_builder.query(&[(
9347                "comments",
9348                &local_var_str
9349                    .into_iter()
9350                    .map(|p| p.to_string())
9351                    .collect::<Vec<String>>()
9352                    .join(",")
9353                    .to_string(),
9354            )]),
9355        };
9356    }
9357    if let Some(ref local_var_str) = comments__ic {
9358        local_var_req_builder = match "multi" {
9359            "multi" => local_var_req_builder.query(
9360                &local_var_str
9361                    .into_iter()
9362                    .map(|p| ("comments__ic".to_owned(), p.to_string()))
9363                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9364            ),
9365            _ => local_var_req_builder.query(&[(
9366                "comments__ic",
9367                &local_var_str
9368                    .into_iter()
9369                    .map(|p| p.to_string())
9370                    .collect::<Vec<String>>()
9371                    .join(",")
9372                    .to_string(),
9373            )]),
9374        };
9375    }
9376    if let Some(ref local_var_str) = comments__ie {
9377        local_var_req_builder = match "multi" {
9378            "multi" => local_var_req_builder.query(
9379                &local_var_str
9380                    .into_iter()
9381                    .map(|p| ("comments__ie".to_owned(), p.to_string()))
9382                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9383            ),
9384            _ => local_var_req_builder.query(&[(
9385                "comments__ie",
9386                &local_var_str
9387                    .into_iter()
9388                    .map(|p| p.to_string())
9389                    .collect::<Vec<String>>()
9390                    .join(",")
9391                    .to_string(),
9392            )]),
9393        };
9394    }
9395    if let Some(ref local_var_str) = comments__iew {
9396        local_var_req_builder = match "multi" {
9397            "multi" => local_var_req_builder.query(
9398                &local_var_str
9399                    .into_iter()
9400                    .map(|p| ("comments__iew".to_owned(), p.to_string()))
9401                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9402            ),
9403            _ => local_var_req_builder.query(&[(
9404                "comments__iew",
9405                &local_var_str
9406                    .into_iter()
9407                    .map(|p| p.to_string())
9408                    .collect::<Vec<String>>()
9409                    .join(",")
9410                    .to_string(),
9411            )]),
9412        };
9413    }
9414    if let Some(ref local_var_str) = comments__ire {
9415        local_var_req_builder = match "multi" {
9416            "multi" => local_var_req_builder.query(
9417                &local_var_str
9418                    .into_iter()
9419                    .map(|p| ("comments__ire".to_owned(), p.to_string()))
9420                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9421            ),
9422            _ => local_var_req_builder.query(&[(
9423                "comments__ire",
9424                &local_var_str
9425                    .into_iter()
9426                    .map(|p| p.to_string())
9427                    .collect::<Vec<String>>()
9428                    .join(",")
9429                    .to_string(),
9430            )]),
9431        };
9432    }
9433    if let Some(ref local_var_str) = comments__isw {
9434        local_var_req_builder = match "multi" {
9435            "multi" => local_var_req_builder.query(
9436                &local_var_str
9437                    .into_iter()
9438                    .map(|p| ("comments__isw".to_owned(), p.to_string()))
9439                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9440            ),
9441            _ => local_var_req_builder.query(&[(
9442                "comments__isw",
9443                &local_var_str
9444                    .into_iter()
9445                    .map(|p| p.to_string())
9446                    .collect::<Vec<String>>()
9447                    .join(",")
9448                    .to_string(),
9449            )]),
9450        };
9451    }
9452    if let Some(ref local_var_str) = comments__n {
9453        local_var_req_builder = match "multi" {
9454            "multi" => local_var_req_builder.query(
9455                &local_var_str
9456                    .into_iter()
9457                    .map(|p| ("comments__n".to_owned(), p.to_string()))
9458                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9459            ),
9460            _ => local_var_req_builder.query(&[(
9461                "comments__n",
9462                &local_var_str
9463                    .into_iter()
9464                    .map(|p| p.to_string())
9465                    .collect::<Vec<String>>()
9466                    .join(",")
9467                    .to_string(),
9468            )]),
9469        };
9470    }
9471    if let Some(ref local_var_str) = comments__nic {
9472        local_var_req_builder = match "multi" {
9473            "multi" => local_var_req_builder.query(
9474                &local_var_str
9475                    .into_iter()
9476                    .map(|p| ("comments__nic".to_owned(), p.to_string()))
9477                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9478            ),
9479            _ => local_var_req_builder.query(&[(
9480                "comments__nic",
9481                &local_var_str
9482                    .into_iter()
9483                    .map(|p| p.to_string())
9484                    .collect::<Vec<String>>()
9485                    .join(",")
9486                    .to_string(),
9487            )]),
9488        };
9489    }
9490    if let Some(ref local_var_str) = comments__nie {
9491        local_var_req_builder = match "multi" {
9492            "multi" => local_var_req_builder.query(
9493                &local_var_str
9494                    .into_iter()
9495                    .map(|p| ("comments__nie".to_owned(), p.to_string()))
9496                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9497            ),
9498            _ => local_var_req_builder.query(&[(
9499                "comments__nie",
9500                &local_var_str
9501                    .into_iter()
9502                    .map(|p| p.to_string())
9503                    .collect::<Vec<String>>()
9504                    .join(",")
9505                    .to_string(),
9506            )]),
9507        };
9508    }
9509    if let Some(ref local_var_str) = comments__niew {
9510        local_var_req_builder = match "multi" {
9511            "multi" => local_var_req_builder.query(
9512                &local_var_str
9513                    .into_iter()
9514                    .map(|p| ("comments__niew".to_owned(), p.to_string()))
9515                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9516            ),
9517            _ => local_var_req_builder.query(&[(
9518                "comments__niew",
9519                &local_var_str
9520                    .into_iter()
9521                    .map(|p| p.to_string())
9522                    .collect::<Vec<String>>()
9523                    .join(",")
9524                    .to_string(),
9525            )]),
9526        };
9527    }
9528    if let Some(ref local_var_str) = comments__nire {
9529        local_var_req_builder = match "multi" {
9530            "multi" => local_var_req_builder.query(
9531                &local_var_str
9532                    .into_iter()
9533                    .map(|p| ("comments__nire".to_owned(), p.to_string()))
9534                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9535            ),
9536            _ => local_var_req_builder.query(&[(
9537                "comments__nire",
9538                &local_var_str
9539                    .into_iter()
9540                    .map(|p| p.to_string())
9541                    .collect::<Vec<String>>()
9542                    .join(",")
9543                    .to_string(),
9544            )]),
9545        };
9546    }
9547    if let Some(ref local_var_str) = comments__nisw {
9548        local_var_req_builder = match "multi" {
9549            "multi" => local_var_req_builder.query(
9550                &local_var_str
9551                    .into_iter()
9552                    .map(|p| ("comments__nisw".to_owned(), p.to_string()))
9553                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9554            ),
9555            _ => local_var_req_builder.query(&[(
9556                "comments__nisw",
9557                &local_var_str
9558                    .into_iter()
9559                    .map(|p| p.to_string())
9560                    .collect::<Vec<String>>()
9561                    .join(",")
9562                    .to_string(),
9563            )]),
9564        };
9565    }
9566    if let Some(ref local_var_str) = comments__nre {
9567        local_var_req_builder = match "multi" {
9568            "multi" => local_var_req_builder.query(
9569                &local_var_str
9570                    .into_iter()
9571                    .map(|p| ("comments__nre".to_owned(), p.to_string()))
9572                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9573            ),
9574            _ => local_var_req_builder.query(&[(
9575                "comments__nre",
9576                &local_var_str
9577                    .into_iter()
9578                    .map(|p| p.to_string())
9579                    .collect::<Vec<String>>()
9580                    .join(",")
9581                    .to_string(),
9582            )]),
9583        };
9584    }
9585    if let Some(ref local_var_str) = comments__re {
9586        local_var_req_builder = match "multi" {
9587            "multi" => local_var_req_builder.query(
9588                &local_var_str
9589                    .into_iter()
9590                    .map(|p| ("comments__re".to_owned(), p.to_string()))
9591                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9592            ),
9593            _ => local_var_req_builder.query(&[(
9594                "comments__re",
9595                &local_var_str
9596                    .into_iter()
9597                    .map(|p| p.to_string())
9598                    .collect::<Vec<String>>()
9599                    .join(",")
9600                    .to_string(),
9601            )]),
9602        };
9603    }
9604    if let Some(ref local_var_str) = contacts {
9605        local_var_req_builder = match "multi" {
9606            "multi" => local_var_req_builder.query(
9607                &local_var_str
9608                    .into_iter()
9609                    .map(|p| ("contacts".to_owned(), p.to_string()))
9610                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9611            ),
9612            _ => local_var_req_builder.query(&[(
9613                "contacts",
9614                &local_var_str
9615                    .into_iter()
9616                    .map(|p| p.to_string())
9617                    .collect::<Vec<String>>()
9618                    .join(",")
9619                    .to_string(),
9620            )]),
9621        };
9622    }
9623    if let Some(ref local_var_str) = contacts__isnull {
9624        local_var_req_builder =
9625            local_var_req_builder.query(&[("contacts__isnull", &local_var_str.to_string())]);
9626    }
9627    if let Some(ref local_var_str) = contacts__n {
9628        local_var_req_builder = match "multi" {
9629            "multi" => local_var_req_builder.query(
9630                &local_var_str
9631                    .into_iter()
9632                    .map(|p| ("contacts__n".to_owned(), p.to_string()))
9633                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9634            ),
9635            _ => local_var_req_builder.query(&[(
9636                "contacts__n",
9637                &local_var_str
9638                    .into_iter()
9639                    .map(|p| p.to_string())
9640                    .collect::<Vec<String>>()
9641                    .join(",")
9642                    .to_string(),
9643            )]),
9644        };
9645    }
9646    if let Some(ref local_var_str) = created {
9647        local_var_req_builder = match "multi" {
9648            "multi" => local_var_req_builder.query(
9649                &local_var_str
9650                    .into_iter()
9651                    .map(|p| ("created".to_owned(), p.to_string()))
9652                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9653            ),
9654            _ => local_var_req_builder.query(&[(
9655                "created",
9656                &local_var_str
9657                    .into_iter()
9658                    .map(|p| p.to_string())
9659                    .collect::<Vec<String>>()
9660                    .join(",")
9661                    .to_string(),
9662            )]),
9663        };
9664    }
9665    if let Some(ref local_var_str) = created__gt {
9666        local_var_req_builder = match "multi" {
9667            "multi" => local_var_req_builder.query(
9668                &local_var_str
9669                    .into_iter()
9670                    .map(|p| ("created__gt".to_owned(), p.to_string()))
9671                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9672            ),
9673            _ => local_var_req_builder.query(&[(
9674                "created__gt",
9675                &local_var_str
9676                    .into_iter()
9677                    .map(|p| p.to_string())
9678                    .collect::<Vec<String>>()
9679                    .join(",")
9680                    .to_string(),
9681            )]),
9682        };
9683    }
9684    if let Some(ref local_var_str) = created__gte {
9685        local_var_req_builder = match "multi" {
9686            "multi" => local_var_req_builder.query(
9687                &local_var_str
9688                    .into_iter()
9689                    .map(|p| ("created__gte".to_owned(), p.to_string()))
9690                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9691            ),
9692            _ => local_var_req_builder.query(&[(
9693                "created__gte",
9694                &local_var_str
9695                    .into_iter()
9696                    .map(|p| p.to_string())
9697                    .collect::<Vec<String>>()
9698                    .join(",")
9699                    .to_string(),
9700            )]),
9701        };
9702    }
9703    if let Some(ref local_var_str) = created__isnull {
9704        local_var_req_builder =
9705            local_var_req_builder.query(&[("created__isnull", &local_var_str.to_string())]);
9706    }
9707    if let Some(ref local_var_str) = created__lt {
9708        local_var_req_builder = match "multi" {
9709            "multi" => local_var_req_builder.query(
9710                &local_var_str
9711                    .into_iter()
9712                    .map(|p| ("created__lt".to_owned(), p.to_string()))
9713                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9714            ),
9715            _ => local_var_req_builder.query(&[(
9716                "created__lt",
9717                &local_var_str
9718                    .into_iter()
9719                    .map(|p| p.to_string())
9720                    .collect::<Vec<String>>()
9721                    .join(",")
9722                    .to_string(),
9723            )]),
9724        };
9725    }
9726    if let Some(ref local_var_str) = created__lte {
9727        local_var_req_builder = match "multi" {
9728            "multi" => local_var_req_builder.query(
9729                &local_var_str
9730                    .into_iter()
9731                    .map(|p| ("created__lte".to_owned(), p.to_string()))
9732                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9733            ),
9734            _ => local_var_req_builder.query(&[(
9735                "created__lte",
9736                &local_var_str
9737                    .into_iter()
9738                    .map(|p| p.to_string())
9739                    .collect::<Vec<String>>()
9740                    .join(",")
9741                    .to_string(),
9742            )]),
9743        };
9744    }
9745    if let Some(ref local_var_str) = created__n {
9746        local_var_req_builder = match "multi" {
9747            "multi" => local_var_req_builder.query(
9748                &local_var_str
9749                    .into_iter()
9750                    .map(|p| ("created__n".to_owned(), p.to_string()))
9751                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9752            ),
9753            _ => local_var_req_builder.query(&[(
9754                "created__n",
9755                &local_var_str
9756                    .into_iter()
9757                    .map(|p| p.to_string())
9758                    .collect::<Vec<String>>()
9759                    .join(",")
9760                    .to_string(),
9761            )]),
9762        };
9763    }
9764    if let Some(ref local_var_str) = disk {
9765        local_var_req_builder = match "multi" {
9766            "multi" => local_var_req_builder.query(
9767                &local_var_str
9768                    .into_iter()
9769                    .map(|p| ("disk".to_owned(), p.to_string()))
9770                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9771            ),
9772            _ => local_var_req_builder.query(&[(
9773                "disk",
9774                &local_var_str
9775                    .into_iter()
9776                    .map(|p| p.to_string())
9777                    .collect::<Vec<String>>()
9778                    .join(",")
9779                    .to_string(),
9780            )]),
9781        };
9782    }
9783    if let Some(ref local_var_str) = disk__gt {
9784        local_var_req_builder = match "multi" {
9785            "multi" => local_var_req_builder.query(
9786                &local_var_str
9787                    .into_iter()
9788                    .map(|p| ("disk__gt".to_owned(), p.to_string()))
9789                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9790            ),
9791            _ => local_var_req_builder.query(&[(
9792                "disk__gt",
9793                &local_var_str
9794                    .into_iter()
9795                    .map(|p| p.to_string())
9796                    .collect::<Vec<String>>()
9797                    .join(",")
9798                    .to_string(),
9799            )]),
9800        };
9801    }
9802    if let Some(ref local_var_str) = disk__gte {
9803        local_var_req_builder = match "multi" {
9804            "multi" => local_var_req_builder.query(
9805                &local_var_str
9806                    .into_iter()
9807                    .map(|p| ("disk__gte".to_owned(), p.to_string()))
9808                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9809            ),
9810            _ => local_var_req_builder.query(&[(
9811                "disk__gte",
9812                &local_var_str
9813                    .into_iter()
9814                    .map(|p| p.to_string())
9815                    .collect::<Vec<String>>()
9816                    .join(",")
9817                    .to_string(),
9818            )]),
9819        };
9820    }
9821    if let Some(ref local_var_str) = disk__isnull {
9822        local_var_req_builder =
9823            local_var_req_builder.query(&[("disk__isnull", &local_var_str.to_string())]);
9824    }
9825    if let Some(ref local_var_str) = disk__lt {
9826        local_var_req_builder = match "multi" {
9827            "multi" => local_var_req_builder.query(
9828                &local_var_str
9829                    .into_iter()
9830                    .map(|p| ("disk__lt".to_owned(), p.to_string()))
9831                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9832            ),
9833            _ => local_var_req_builder.query(&[(
9834                "disk__lt",
9835                &local_var_str
9836                    .into_iter()
9837                    .map(|p| p.to_string())
9838                    .collect::<Vec<String>>()
9839                    .join(",")
9840                    .to_string(),
9841            )]),
9842        };
9843    }
9844    if let Some(ref local_var_str) = disk__lte {
9845        local_var_req_builder = match "multi" {
9846            "multi" => local_var_req_builder.query(
9847                &local_var_str
9848                    .into_iter()
9849                    .map(|p| ("disk__lte".to_owned(), p.to_string()))
9850                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9851            ),
9852            _ => local_var_req_builder.query(&[(
9853                "disk__lte",
9854                &local_var_str
9855                    .into_iter()
9856                    .map(|p| p.to_string())
9857                    .collect::<Vec<String>>()
9858                    .join(",")
9859                    .to_string(),
9860            )]),
9861        };
9862    }
9863    if let Some(ref local_var_str) = disk__n {
9864        local_var_req_builder = match "multi" {
9865            "multi" => local_var_req_builder.query(
9866                &local_var_str
9867                    .into_iter()
9868                    .map(|p| ("disk__n".to_owned(), p.to_string()))
9869                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9870            ),
9871            _ => local_var_req_builder.query(&[(
9872                "disk__n",
9873                &local_var_str
9874                    .into_iter()
9875                    .map(|p| p.to_string())
9876                    .collect::<Vec<String>>()
9877                    .join(",")
9878                    .to_string(),
9879            )]),
9880        };
9881    }
9882    if let Some(ref local_var_str) = dynamic_groups {
9883        local_var_req_builder = match "multi" {
9884            "multi" => local_var_req_builder.query(
9885                &local_var_str
9886                    .into_iter()
9887                    .map(|p| ("dynamic_groups".to_owned(), p.to_string()))
9888                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9889            ),
9890            _ => local_var_req_builder.query(&[(
9891                "dynamic_groups",
9892                &local_var_str
9893                    .into_iter()
9894                    .map(|p| p.to_string())
9895                    .collect::<Vec<String>>()
9896                    .join(",")
9897                    .to_string(),
9898            )]),
9899        };
9900    }
9901    if let Some(ref local_var_str) = dynamic_groups__n {
9902        local_var_req_builder = match "multi" {
9903            "multi" => local_var_req_builder.query(
9904                &local_var_str
9905                    .into_iter()
9906                    .map(|p| ("dynamic_groups__n".to_owned(), p.to_string()))
9907                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9908            ),
9909            _ => local_var_req_builder.query(&[(
9910                "dynamic_groups__n",
9911                &local_var_str
9912                    .into_iter()
9913                    .map(|p| p.to_string())
9914                    .collect::<Vec<String>>()
9915                    .join(",")
9916                    .to_string(),
9917            )]),
9918        };
9919    }
9920    if let Some(ref local_var_str) = format {
9921        local_var_req_builder =
9922            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
9923    }
9924    if let Some(ref local_var_str) = has_interfaces {
9925        local_var_req_builder =
9926            local_var_req_builder.query(&[("has_interfaces", &local_var_str.to_string())]);
9927    }
9928    if let Some(ref local_var_str) = has_ip_addresses {
9929        local_var_req_builder =
9930            local_var_req_builder.query(&[("has_ip_addresses", &local_var_str.to_string())]);
9931    }
9932    if let Some(ref local_var_str) = has_primary_ip {
9933        local_var_req_builder =
9934            local_var_req_builder.query(&[("has_primary_ip", &local_var_str.to_string())]);
9935    }
9936    if let Some(ref local_var_str) = has_services {
9937        local_var_req_builder =
9938            local_var_req_builder.query(&[("has_services", &local_var_str.to_string())]);
9939    }
9940    if let Some(ref local_var_str) = has_software_image_files {
9941        local_var_req_builder = local_var_req_builder
9942            .query(&[("has_software_image_files", &local_var_str.to_string())]);
9943    }
9944    if let Some(ref local_var_str) = has_software_version {
9945        local_var_req_builder =
9946            local_var_req_builder.query(&[("has_software_version", &local_var_str.to_string())]);
9947    }
9948    if let Some(ref local_var_str) = id {
9949        local_var_req_builder = match "multi" {
9950            "multi" => local_var_req_builder.query(
9951                &local_var_str
9952                    .into_iter()
9953                    .map(|p| ("id".to_owned(), p.to_string()))
9954                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9955            ),
9956            _ => local_var_req_builder.query(&[(
9957                "id",
9958                &local_var_str
9959                    .into_iter()
9960                    .map(|p| p.to_string())
9961                    .collect::<Vec<String>>()
9962                    .join(",")
9963                    .to_string(),
9964            )]),
9965        };
9966    }
9967    if let Some(ref local_var_str) = id__n {
9968        local_var_req_builder = match "multi" {
9969            "multi" => local_var_req_builder.query(
9970                &local_var_str
9971                    .into_iter()
9972                    .map(|p| ("id__n".to_owned(), p.to_string()))
9973                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9974            ),
9975            _ => local_var_req_builder.query(&[(
9976                "id__n",
9977                &local_var_str
9978                    .into_iter()
9979                    .map(|p| p.to_string())
9980                    .collect::<Vec<String>>()
9981                    .join(",")
9982                    .to_string(),
9983            )]),
9984        };
9985    }
9986    if let Some(ref local_var_str) = interfaces {
9987        local_var_req_builder = match "multi" {
9988            "multi" => local_var_req_builder.query(
9989                &local_var_str
9990                    .into_iter()
9991                    .map(|p| ("interfaces".to_owned(), p.to_string()))
9992                    .collect::<Vec<(std::string::String, std::string::String)>>(),
9993            ),
9994            _ => local_var_req_builder.query(&[(
9995                "interfaces",
9996                &local_var_str
9997                    .into_iter()
9998                    .map(|p| p.to_string())
9999                    .collect::<Vec<String>>()
10000                    .join(",")
10001                    .to_string(),
10002            )]),
10003        };
10004    }
10005    if let Some(ref local_var_str) = interfaces__isnull {
10006        local_var_req_builder =
10007            local_var_req_builder.query(&[("interfaces__isnull", &local_var_str.to_string())]);
10008    }
10009    if let Some(ref local_var_str) = interfaces__n {
10010        local_var_req_builder = match "multi" {
10011            "multi" => local_var_req_builder.query(
10012                &local_var_str
10013                    .into_iter()
10014                    .map(|p| ("interfaces__n".to_owned(), p.to_string()))
10015                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10016            ),
10017            _ => local_var_req_builder.query(&[(
10018                "interfaces__n",
10019                &local_var_str
10020                    .into_iter()
10021                    .map(|p| p.to_string())
10022                    .collect::<Vec<String>>()
10023                    .join(",")
10024                    .to_string(),
10025            )]),
10026        };
10027    }
10028    if let Some(ref local_var_str) = ip_addresses {
10029        local_var_req_builder = match "multi" {
10030            "multi" => local_var_req_builder.query(
10031                &local_var_str
10032                    .into_iter()
10033                    .map(|p| ("ip_addresses".to_owned(), p.to_string()))
10034                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10035            ),
10036            _ => local_var_req_builder.query(&[(
10037                "ip_addresses",
10038                &local_var_str
10039                    .into_iter()
10040                    .map(|p| p.to_string())
10041                    .collect::<Vec<String>>()
10042                    .join(",")
10043                    .to_string(),
10044            )]),
10045        };
10046    }
10047    if let Some(ref local_var_str) = last_updated {
10048        local_var_req_builder = match "multi" {
10049            "multi" => local_var_req_builder.query(
10050                &local_var_str
10051                    .into_iter()
10052                    .map(|p| ("last_updated".to_owned(), p.to_string()))
10053                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10054            ),
10055            _ => local_var_req_builder.query(&[(
10056                "last_updated",
10057                &local_var_str
10058                    .into_iter()
10059                    .map(|p| p.to_string())
10060                    .collect::<Vec<String>>()
10061                    .join(",")
10062                    .to_string(),
10063            )]),
10064        };
10065    }
10066    if let Some(ref local_var_str) = last_updated__gt {
10067        local_var_req_builder = match "multi" {
10068            "multi" => local_var_req_builder.query(
10069                &local_var_str
10070                    .into_iter()
10071                    .map(|p| ("last_updated__gt".to_owned(), p.to_string()))
10072                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10073            ),
10074            _ => local_var_req_builder.query(&[(
10075                "last_updated__gt",
10076                &local_var_str
10077                    .into_iter()
10078                    .map(|p| p.to_string())
10079                    .collect::<Vec<String>>()
10080                    .join(",")
10081                    .to_string(),
10082            )]),
10083        };
10084    }
10085    if let Some(ref local_var_str) = last_updated__gte {
10086        local_var_req_builder = match "multi" {
10087            "multi" => local_var_req_builder.query(
10088                &local_var_str
10089                    .into_iter()
10090                    .map(|p| ("last_updated__gte".to_owned(), p.to_string()))
10091                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10092            ),
10093            _ => local_var_req_builder.query(&[(
10094                "last_updated__gte",
10095                &local_var_str
10096                    .into_iter()
10097                    .map(|p| p.to_string())
10098                    .collect::<Vec<String>>()
10099                    .join(",")
10100                    .to_string(),
10101            )]),
10102        };
10103    }
10104    if let Some(ref local_var_str) = last_updated__isnull {
10105        local_var_req_builder =
10106            local_var_req_builder.query(&[("last_updated__isnull", &local_var_str.to_string())]);
10107    }
10108    if let Some(ref local_var_str) = last_updated__lt {
10109        local_var_req_builder = match "multi" {
10110            "multi" => local_var_req_builder.query(
10111                &local_var_str
10112                    .into_iter()
10113                    .map(|p| ("last_updated__lt".to_owned(), p.to_string()))
10114                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10115            ),
10116            _ => local_var_req_builder.query(&[(
10117                "last_updated__lt",
10118                &local_var_str
10119                    .into_iter()
10120                    .map(|p| p.to_string())
10121                    .collect::<Vec<String>>()
10122                    .join(",")
10123                    .to_string(),
10124            )]),
10125        };
10126    }
10127    if let Some(ref local_var_str) = last_updated__lte {
10128        local_var_req_builder = match "multi" {
10129            "multi" => local_var_req_builder.query(
10130                &local_var_str
10131                    .into_iter()
10132                    .map(|p| ("last_updated__lte".to_owned(), p.to_string()))
10133                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10134            ),
10135            _ => local_var_req_builder.query(&[(
10136                "last_updated__lte",
10137                &local_var_str
10138                    .into_iter()
10139                    .map(|p| p.to_string())
10140                    .collect::<Vec<String>>()
10141                    .join(",")
10142                    .to_string(),
10143            )]),
10144        };
10145    }
10146    if let Some(ref local_var_str) = last_updated__n {
10147        local_var_req_builder = match "multi" {
10148            "multi" => local_var_req_builder.query(
10149                &local_var_str
10150                    .into_iter()
10151                    .map(|p| ("last_updated__n".to_owned(), p.to_string()))
10152                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10153            ),
10154            _ => local_var_req_builder.query(&[(
10155                "last_updated__n",
10156                &local_var_str
10157                    .into_iter()
10158                    .map(|p| p.to_string())
10159                    .collect::<Vec<String>>()
10160                    .join(",")
10161                    .to_string(),
10162            )]),
10163        };
10164    }
10165    if let Some(ref local_var_str) = limit {
10166        local_var_req_builder =
10167            local_var_req_builder.query(&[("limit", &local_var_str.to_string())]);
10168    }
10169    if let Some(ref local_var_str) = local_config_context_data {
10170        local_var_req_builder = local_var_req_builder
10171            .query(&[("local_config_context_data", &local_var_str.to_string())]);
10172    }
10173    if let Some(ref local_var_str) = local_config_context_schema {
10174        local_var_req_builder = match "multi" {
10175            "multi" => local_var_req_builder.query(
10176                &local_var_str
10177                    .into_iter()
10178                    .map(|p| ("local_config_context_schema".to_owned(), p.to_string()))
10179                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10180            ),
10181            _ => local_var_req_builder.query(&[(
10182                "local_config_context_schema",
10183                &local_var_str
10184                    .into_iter()
10185                    .map(|p| p.to_string())
10186                    .collect::<Vec<String>>()
10187                    .join(",")
10188                    .to_string(),
10189            )]),
10190        };
10191    }
10192    if let Some(ref local_var_str) = local_config_context_schema__isnull {
10193        local_var_req_builder = local_var_req_builder.query(&[(
10194            "local_config_context_schema__isnull",
10195            &local_var_str.to_string(),
10196        )]);
10197    }
10198    if let Some(ref local_var_str) = local_config_context_schema__n {
10199        local_var_req_builder = match "multi" {
10200            "multi" => local_var_req_builder.query(
10201                &local_var_str
10202                    .into_iter()
10203                    .map(|p| ("local_config_context_schema__n".to_owned(), p.to_string()))
10204                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10205            ),
10206            _ => local_var_req_builder.query(&[(
10207                "local_config_context_schema__n",
10208                &local_var_str
10209                    .into_iter()
10210                    .map(|p| p.to_string())
10211                    .collect::<Vec<String>>()
10212                    .join(",")
10213                    .to_string(),
10214            )]),
10215        };
10216    }
10217    if let Some(ref local_var_str) = local_config_context_schema_id {
10218        local_var_req_builder = match "multi" {
10219            "multi" => local_var_req_builder.query(
10220                &local_var_str
10221                    .into_iter()
10222                    .map(|p| ("local_config_context_schema_id".to_owned(), p.to_string()))
10223                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10224            ),
10225            _ => local_var_req_builder.query(&[(
10226                "local_config_context_schema_id",
10227                &local_var_str
10228                    .into_iter()
10229                    .map(|p| p.to_string())
10230                    .collect::<Vec<String>>()
10231                    .join(",")
10232                    .to_string(),
10233            )]),
10234        };
10235    }
10236    if let Some(ref local_var_str) = local_config_context_schema_id__isnull {
10237        local_var_req_builder = local_var_req_builder.query(&[(
10238            "local_config_context_schema_id__isnull",
10239            &local_var_str.to_string(),
10240        )]);
10241    }
10242    if let Some(ref local_var_str) = local_config_context_schema_id__n {
10243        local_var_req_builder = match "multi" {
10244            "multi" => local_var_req_builder.query(
10245                &local_var_str
10246                    .into_iter()
10247                    .map(|p| {
10248                        (
10249                            "local_config_context_schema_id__n".to_owned(),
10250                            p.to_string(),
10251                        )
10252                    })
10253                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10254            ),
10255            _ => local_var_req_builder.query(&[(
10256                "local_config_context_schema_id__n",
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) = location {
10267        local_var_req_builder = match "multi" {
10268            "multi" => local_var_req_builder.query(
10269                &local_var_str
10270                    .into_iter()
10271                    .map(|p| ("location".to_owned(), p.to_string()))
10272                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10273            ),
10274            _ => local_var_req_builder.query(&[(
10275                "location",
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) = location__isnull {
10286        local_var_req_builder =
10287            local_var_req_builder.query(&[("location__isnull", &local_var_str.to_string())]);
10288    }
10289    if let Some(ref local_var_str) = location__n {
10290        local_var_req_builder = match "multi" {
10291            "multi" => local_var_req_builder.query(
10292                &local_var_str
10293                    .into_iter()
10294                    .map(|p| ("location__n".to_owned(), p.to_string()))
10295                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10296            ),
10297            _ => local_var_req_builder.query(&[(
10298                "location__n",
10299                &local_var_str
10300                    .into_iter()
10301                    .map(|p| p.to_string())
10302                    .collect::<Vec<String>>()
10303                    .join(",")
10304                    .to_string(),
10305            )]),
10306        };
10307    }
10308    if let Some(ref local_var_str) = mac_address {
10309        local_var_req_builder = match "multi" {
10310            "multi" => local_var_req_builder.query(
10311                &local_var_str
10312                    .into_iter()
10313                    .map(|p| ("mac_address".to_owned(), p.to_string()))
10314                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10315            ),
10316            _ => local_var_req_builder.query(&[(
10317                "mac_address",
10318                &local_var_str
10319                    .into_iter()
10320                    .map(|p| p.to_string())
10321                    .collect::<Vec<String>>()
10322                    .join(",")
10323                    .to_string(),
10324            )]),
10325        };
10326    }
10327    if let Some(ref local_var_str) = mac_address__ic {
10328        local_var_req_builder = match "multi" {
10329            "multi" => local_var_req_builder.query(
10330                &local_var_str
10331                    .into_iter()
10332                    .map(|p| ("mac_address__ic".to_owned(), p.to_string()))
10333                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10334            ),
10335            _ => local_var_req_builder.query(&[(
10336                "mac_address__ic",
10337                &local_var_str
10338                    .into_iter()
10339                    .map(|p| p.to_string())
10340                    .collect::<Vec<String>>()
10341                    .join(",")
10342                    .to_string(),
10343            )]),
10344        };
10345    }
10346    if let Some(ref local_var_str) = mac_address__ie {
10347        local_var_req_builder = match "multi" {
10348            "multi" => local_var_req_builder.query(
10349                &local_var_str
10350                    .into_iter()
10351                    .map(|p| ("mac_address__ie".to_owned(), p.to_string()))
10352                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10353            ),
10354            _ => local_var_req_builder.query(&[(
10355                "mac_address__ie",
10356                &local_var_str
10357                    .into_iter()
10358                    .map(|p| p.to_string())
10359                    .collect::<Vec<String>>()
10360                    .join(",")
10361                    .to_string(),
10362            )]),
10363        };
10364    }
10365    if let Some(ref local_var_str) = mac_address__iew {
10366        local_var_req_builder = match "multi" {
10367            "multi" => local_var_req_builder.query(
10368                &local_var_str
10369                    .into_iter()
10370                    .map(|p| ("mac_address__iew".to_owned(), p.to_string()))
10371                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10372            ),
10373            _ => local_var_req_builder.query(&[(
10374                "mac_address__iew",
10375                &local_var_str
10376                    .into_iter()
10377                    .map(|p| p.to_string())
10378                    .collect::<Vec<String>>()
10379                    .join(",")
10380                    .to_string(),
10381            )]),
10382        };
10383    }
10384    if let Some(ref local_var_str) = mac_address__ire {
10385        local_var_req_builder = match "multi" {
10386            "multi" => local_var_req_builder.query(
10387                &local_var_str
10388                    .into_iter()
10389                    .map(|p| ("mac_address__ire".to_owned(), p.to_string()))
10390                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10391            ),
10392            _ => local_var_req_builder.query(&[(
10393                "mac_address__ire",
10394                &local_var_str
10395                    .into_iter()
10396                    .map(|p| p.to_string())
10397                    .collect::<Vec<String>>()
10398                    .join(",")
10399                    .to_string(),
10400            )]),
10401        };
10402    }
10403    if let Some(ref local_var_str) = mac_address__isw {
10404        local_var_req_builder = match "multi" {
10405            "multi" => local_var_req_builder.query(
10406                &local_var_str
10407                    .into_iter()
10408                    .map(|p| ("mac_address__isw".to_owned(), p.to_string()))
10409                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10410            ),
10411            _ => local_var_req_builder.query(&[(
10412                "mac_address__isw",
10413                &local_var_str
10414                    .into_iter()
10415                    .map(|p| p.to_string())
10416                    .collect::<Vec<String>>()
10417                    .join(",")
10418                    .to_string(),
10419            )]),
10420        };
10421    }
10422    if let Some(ref local_var_str) = mac_address__n {
10423        local_var_req_builder = match "multi" {
10424            "multi" => local_var_req_builder.query(
10425                &local_var_str
10426                    .into_iter()
10427                    .map(|p| ("mac_address__n".to_owned(), p.to_string()))
10428                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10429            ),
10430            _ => local_var_req_builder.query(&[(
10431                "mac_address__n",
10432                &local_var_str
10433                    .into_iter()
10434                    .map(|p| p.to_string())
10435                    .collect::<Vec<String>>()
10436                    .join(",")
10437                    .to_string(),
10438            )]),
10439        };
10440    }
10441    if let Some(ref local_var_str) = mac_address__nic {
10442        local_var_req_builder = match "multi" {
10443            "multi" => local_var_req_builder.query(
10444                &local_var_str
10445                    .into_iter()
10446                    .map(|p| ("mac_address__nic".to_owned(), p.to_string()))
10447                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10448            ),
10449            _ => local_var_req_builder.query(&[(
10450                "mac_address__nic",
10451                &local_var_str
10452                    .into_iter()
10453                    .map(|p| p.to_string())
10454                    .collect::<Vec<String>>()
10455                    .join(",")
10456                    .to_string(),
10457            )]),
10458        };
10459    }
10460    if let Some(ref local_var_str) = mac_address__nie {
10461        local_var_req_builder = match "multi" {
10462            "multi" => local_var_req_builder.query(
10463                &local_var_str
10464                    .into_iter()
10465                    .map(|p| ("mac_address__nie".to_owned(), p.to_string()))
10466                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10467            ),
10468            _ => local_var_req_builder.query(&[(
10469                "mac_address__nie",
10470                &local_var_str
10471                    .into_iter()
10472                    .map(|p| p.to_string())
10473                    .collect::<Vec<String>>()
10474                    .join(",")
10475                    .to_string(),
10476            )]),
10477        };
10478    }
10479    if let Some(ref local_var_str) = mac_address__niew {
10480        local_var_req_builder = match "multi" {
10481            "multi" => local_var_req_builder.query(
10482                &local_var_str
10483                    .into_iter()
10484                    .map(|p| ("mac_address__niew".to_owned(), p.to_string()))
10485                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10486            ),
10487            _ => local_var_req_builder.query(&[(
10488                "mac_address__niew",
10489                &local_var_str
10490                    .into_iter()
10491                    .map(|p| p.to_string())
10492                    .collect::<Vec<String>>()
10493                    .join(",")
10494                    .to_string(),
10495            )]),
10496        };
10497    }
10498    if let Some(ref local_var_str) = mac_address__nire {
10499        local_var_req_builder = match "multi" {
10500            "multi" => local_var_req_builder.query(
10501                &local_var_str
10502                    .into_iter()
10503                    .map(|p| ("mac_address__nire".to_owned(), p.to_string()))
10504                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10505            ),
10506            _ => local_var_req_builder.query(&[(
10507                "mac_address__nire",
10508                &local_var_str
10509                    .into_iter()
10510                    .map(|p| p.to_string())
10511                    .collect::<Vec<String>>()
10512                    .join(",")
10513                    .to_string(),
10514            )]),
10515        };
10516    }
10517    if let Some(ref local_var_str) = mac_address__nisw {
10518        local_var_req_builder = match "multi" {
10519            "multi" => local_var_req_builder.query(
10520                &local_var_str
10521                    .into_iter()
10522                    .map(|p| ("mac_address__nisw".to_owned(), p.to_string()))
10523                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10524            ),
10525            _ => local_var_req_builder.query(&[(
10526                "mac_address__nisw",
10527                &local_var_str
10528                    .into_iter()
10529                    .map(|p| p.to_string())
10530                    .collect::<Vec<String>>()
10531                    .join(",")
10532                    .to_string(),
10533            )]),
10534        };
10535    }
10536    if let Some(ref local_var_str) = mac_address__nre {
10537        local_var_req_builder = match "multi" {
10538            "multi" => local_var_req_builder.query(
10539                &local_var_str
10540                    .into_iter()
10541                    .map(|p| ("mac_address__nre".to_owned(), p.to_string()))
10542                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10543            ),
10544            _ => local_var_req_builder.query(&[(
10545                "mac_address__nre",
10546                &local_var_str
10547                    .into_iter()
10548                    .map(|p| p.to_string())
10549                    .collect::<Vec<String>>()
10550                    .join(",")
10551                    .to_string(),
10552            )]),
10553        };
10554    }
10555    if let Some(ref local_var_str) = mac_address__re {
10556        local_var_req_builder = match "multi" {
10557            "multi" => local_var_req_builder.query(
10558                &local_var_str
10559                    .into_iter()
10560                    .map(|p| ("mac_address__re".to_owned(), p.to_string()))
10561                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10562            ),
10563            _ => local_var_req_builder.query(&[(
10564                "mac_address__re",
10565                &local_var_str
10566                    .into_iter()
10567                    .map(|p| p.to_string())
10568                    .collect::<Vec<String>>()
10569                    .join(",")
10570                    .to_string(),
10571            )]),
10572        };
10573    }
10574    if let Some(ref local_var_str) = memory {
10575        local_var_req_builder = match "multi" {
10576            "multi" => local_var_req_builder.query(
10577                &local_var_str
10578                    .into_iter()
10579                    .map(|p| ("memory".to_owned(), p.to_string()))
10580                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10581            ),
10582            _ => local_var_req_builder.query(&[(
10583                "memory",
10584                &local_var_str
10585                    .into_iter()
10586                    .map(|p| p.to_string())
10587                    .collect::<Vec<String>>()
10588                    .join(",")
10589                    .to_string(),
10590            )]),
10591        };
10592    }
10593    if let Some(ref local_var_str) = memory__gt {
10594        local_var_req_builder = match "multi" {
10595            "multi" => local_var_req_builder.query(
10596                &local_var_str
10597                    .into_iter()
10598                    .map(|p| ("memory__gt".to_owned(), p.to_string()))
10599                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10600            ),
10601            _ => local_var_req_builder.query(&[(
10602                "memory__gt",
10603                &local_var_str
10604                    .into_iter()
10605                    .map(|p| p.to_string())
10606                    .collect::<Vec<String>>()
10607                    .join(",")
10608                    .to_string(),
10609            )]),
10610        };
10611    }
10612    if let Some(ref local_var_str) = memory__gte {
10613        local_var_req_builder = match "multi" {
10614            "multi" => local_var_req_builder.query(
10615                &local_var_str
10616                    .into_iter()
10617                    .map(|p| ("memory__gte".to_owned(), p.to_string()))
10618                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10619            ),
10620            _ => local_var_req_builder.query(&[(
10621                "memory__gte",
10622                &local_var_str
10623                    .into_iter()
10624                    .map(|p| p.to_string())
10625                    .collect::<Vec<String>>()
10626                    .join(",")
10627                    .to_string(),
10628            )]),
10629        };
10630    }
10631    if let Some(ref local_var_str) = memory__isnull {
10632        local_var_req_builder =
10633            local_var_req_builder.query(&[("memory__isnull", &local_var_str.to_string())]);
10634    }
10635    if let Some(ref local_var_str) = memory__lt {
10636        local_var_req_builder = match "multi" {
10637            "multi" => local_var_req_builder.query(
10638                &local_var_str
10639                    .into_iter()
10640                    .map(|p| ("memory__lt".to_owned(), p.to_string()))
10641                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10642            ),
10643            _ => local_var_req_builder.query(&[(
10644                "memory__lt",
10645                &local_var_str
10646                    .into_iter()
10647                    .map(|p| p.to_string())
10648                    .collect::<Vec<String>>()
10649                    .join(",")
10650                    .to_string(),
10651            )]),
10652        };
10653    }
10654    if let Some(ref local_var_str) = memory__lte {
10655        local_var_req_builder = match "multi" {
10656            "multi" => local_var_req_builder.query(
10657                &local_var_str
10658                    .into_iter()
10659                    .map(|p| ("memory__lte".to_owned(), p.to_string()))
10660                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10661            ),
10662            _ => local_var_req_builder.query(&[(
10663                "memory__lte",
10664                &local_var_str
10665                    .into_iter()
10666                    .map(|p| p.to_string())
10667                    .collect::<Vec<String>>()
10668                    .join(",")
10669                    .to_string(),
10670            )]),
10671        };
10672    }
10673    if let Some(ref local_var_str) = memory__n {
10674        local_var_req_builder = match "multi" {
10675            "multi" => local_var_req_builder.query(
10676                &local_var_str
10677                    .into_iter()
10678                    .map(|p| ("memory__n".to_owned(), p.to_string()))
10679                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10680            ),
10681            _ => local_var_req_builder.query(&[(
10682                "memory__n",
10683                &local_var_str
10684                    .into_iter()
10685                    .map(|p| p.to_string())
10686                    .collect::<Vec<String>>()
10687                    .join(",")
10688                    .to_string(),
10689            )]),
10690        };
10691    }
10692    if let Some(ref local_var_str) = name {
10693        local_var_req_builder = match "multi" {
10694            "multi" => local_var_req_builder.query(
10695                &local_var_str
10696                    .into_iter()
10697                    .map(|p| ("name".to_owned(), p.to_string()))
10698                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10699            ),
10700            _ => local_var_req_builder.query(&[(
10701                "name",
10702                &local_var_str
10703                    .into_iter()
10704                    .map(|p| p.to_string())
10705                    .collect::<Vec<String>>()
10706                    .join(",")
10707                    .to_string(),
10708            )]),
10709        };
10710    }
10711    if let Some(ref local_var_str) = name__ic {
10712        local_var_req_builder = match "multi" {
10713            "multi" => local_var_req_builder.query(
10714                &local_var_str
10715                    .into_iter()
10716                    .map(|p| ("name__ic".to_owned(), p.to_string()))
10717                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10718            ),
10719            _ => local_var_req_builder.query(&[(
10720                "name__ic",
10721                &local_var_str
10722                    .into_iter()
10723                    .map(|p| p.to_string())
10724                    .collect::<Vec<String>>()
10725                    .join(",")
10726                    .to_string(),
10727            )]),
10728        };
10729    }
10730    if let Some(ref local_var_str) = name__ie {
10731        local_var_req_builder = match "multi" {
10732            "multi" => local_var_req_builder.query(
10733                &local_var_str
10734                    .into_iter()
10735                    .map(|p| ("name__ie".to_owned(), p.to_string()))
10736                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10737            ),
10738            _ => local_var_req_builder.query(&[(
10739                "name__ie",
10740                &local_var_str
10741                    .into_iter()
10742                    .map(|p| p.to_string())
10743                    .collect::<Vec<String>>()
10744                    .join(",")
10745                    .to_string(),
10746            )]),
10747        };
10748    }
10749    if let Some(ref local_var_str) = name__iew {
10750        local_var_req_builder = match "multi" {
10751            "multi" => local_var_req_builder.query(
10752                &local_var_str
10753                    .into_iter()
10754                    .map(|p| ("name__iew".to_owned(), p.to_string()))
10755                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10756            ),
10757            _ => local_var_req_builder.query(&[(
10758                "name__iew",
10759                &local_var_str
10760                    .into_iter()
10761                    .map(|p| p.to_string())
10762                    .collect::<Vec<String>>()
10763                    .join(",")
10764                    .to_string(),
10765            )]),
10766        };
10767    }
10768    if let Some(ref local_var_str) = name__ire {
10769        local_var_req_builder = match "multi" {
10770            "multi" => local_var_req_builder.query(
10771                &local_var_str
10772                    .into_iter()
10773                    .map(|p| ("name__ire".to_owned(), p.to_string()))
10774                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10775            ),
10776            _ => local_var_req_builder.query(&[(
10777                "name__ire",
10778                &local_var_str
10779                    .into_iter()
10780                    .map(|p| p.to_string())
10781                    .collect::<Vec<String>>()
10782                    .join(",")
10783                    .to_string(),
10784            )]),
10785        };
10786    }
10787    if let Some(ref local_var_str) = name__isw {
10788        local_var_req_builder = match "multi" {
10789            "multi" => local_var_req_builder.query(
10790                &local_var_str
10791                    .into_iter()
10792                    .map(|p| ("name__isw".to_owned(), p.to_string()))
10793                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10794            ),
10795            _ => local_var_req_builder.query(&[(
10796                "name__isw",
10797                &local_var_str
10798                    .into_iter()
10799                    .map(|p| p.to_string())
10800                    .collect::<Vec<String>>()
10801                    .join(",")
10802                    .to_string(),
10803            )]),
10804        };
10805    }
10806    if let Some(ref local_var_str) = name__n {
10807        local_var_req_builder = match "multi" {
10808            "multi" => local_var_req_builder.query(
10809                &local_var_str
10810                    .into_iter()
10811                    .map(|p| ("name__n".to_owned(), p.to_string()))
10812                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10813            ),
10814            _ => local_var_req_builder.query(&[(
10815                "name__n",
10816                &local_var_str
10817                    .into_iter()
10818                    .map(|p| p.to_string())
10819                    .collect::<Vec<String>>()
10820                    .join(",")
10821                    .to_string(),
10822            )]),
10823        };
10824    }
10825    if let Some(ref local_var_str) = name__nic {
10826        local_var_req_builder = match "multi" {
10827            "multi" => local_var_req_builder.query(
10828                &local_var_str
10829                    .into_iter()
10830                    .map(|p| ("name__nic".to_owned(), p.to_string()))
10831                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10832            ),
10833            _ => local_var_req_builder.query(&[(
10834                "name__nic",
10835                &local_var_str
10836                    .into_iter()
10837                    .map(|p| p.to_string())
10838                    .collect::<Vec<String>>()
10839                    .join(",")
10840                    .to_string(),
10841            )]),
10842        };
10843    }
10844    if let Some(ref local_var_str) = name__nie {
10845        local_var_req_builder = match "multi" {
10846            "multi" => local_var_req_builder.query(
10847                &local_var_str
10848                    .into_iter()
10849                    .map(|p| ("name__nie".to_owned(), p.to_string()))
10850                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10851            ),
10852            _ => local_var_req_builder.query(&[(
10853                "name__nie",
10854                &local_var_str
10855                    .into_iter()
10856                    .map(|p| p.to_string())
10857                    .collect::<Vec<String>>()
10858                    .join(",")
10859                    .to_string(),
10860            )]),
10861        };
10862    }
10863    if let Some(ref local_var_str) = name__niew {
10864        local_var_req_builder = match "multi" {
10865            "multi" => local_var_req_builder.query(
10866                &local_var_str
10867                    .into_iter()
10868                    .map(|p| ("name__niew".to_owned(), p.to_string()))
10869                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10870            ),
10871            _ => local_var_req_builder.query(&[(
10872                "name__niew",
10873                &local_var_str
10874                    .into_iter()
10875                    .map(|p| p.to_string())
10876                    .collect::<Vec<String>>()
10877                    .join(",")
10878                    .to_string(),
10879            )]),
10880        };
10881    }
10882    if let Some(ref local_var_str) = name__nire {
10883        local_var_req_builder = match "multi" {
10884            "multi" => local_var_req_builder.query(
10885                &local_var_str
10886                    .into_iter()
10887                    .map(|p| ("name__nire".to_owned(), p.to_string()))
10888                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10889            ),
10890            _ => local_var_req_builder.query(&[(
10891                "name__nire",
10892                &local_var_str
10893                    .into_iter()
10894                    .map(|p| p.to_string())
10895                    .collect::<Vec<String>>()
10896                    .join(",")
10897                    .to_string(),
10898            )]),
10899        };
10900    }
10901    if let Some(ref local_var_str) = name__nisw {
10902        local_var_req_builder = match "multi" {
10903            "multi" => local_var_req_builder.query(
10904                &local_var_str
10905                    .into_iter()
10906                    .map(|p| ("name__nisw".to_owned(), p.to_string()))
10907                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10908            ),
10909            _ => local_var_req_builder.query(&[(
10910                "name__nisw",
10911                &local_var_str
10912                    .into_iter()
10913                    .map(|p| p.to_string())
10914                    .collect::<Vec<String>>()
10915                    .join(",")
10916                    .to_string(),
10917            )]),
10918        };
10919    }
10920    if let Some(ref local_var_str) = name__nre {
10921        local_var_req_builder = match "multi" {
10922            "multi" => local_var_req_builder.query(
10923                &local_var_str
10924                    .into_iter()
10925                    .map(|p| ("name__nre".to_owned(), p.to_string()))
10926                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10927            ),
10928            _ => local_var_req_builder.query(&[(
10929                "name__nre",
10930                &local_var_str
10931                    .into_iter()
10932                    .map(|p| p.to_string())
10933                    .collect::<Vec<String>>()
10934                    .join(",")
10935                    .to_string(),
10936            )]),
10937        };
10938    }
10939    if let Some(ref local_var_str) = name__re {
10940        local_var_req_builder = match "multi" {
10941            "multi" => local_var_req_builder.query(
10942                &local_var_str
10943                    .into_iter()
10944                    .map(|p| ("name__re".to_owned(), p.to_string()))
10945                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10946            ),
10947            _ => local_var_req_builder.query(&[(
10948                "name__re",
10949                &local_var_str
10950                    .into_iter()
10951                    .map(|p| p.to_string())
10952                    .collect::<Vec<String>>()
10953                    .join(",")
10954                    .to_string(),
10955            )]),
10956        };
10957    }
10958    if let Some(ref local_var_str) = offset {
10959        local_var_req_builder =
10960            local_var_req_builder.query(&[("offset", &local_var_str.to_string())]);
10961    }
10962    if let Some(ref local_var_str) = platform {
10963        local_var_req_builder = match "multi" {
10964            "multi" => local_var_req_builder.query(
10965                &local_var_str
10966                    .into_iter()
10967                    .map(|p| ("platform".to_owned(), p.to_string()))
10968                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10969            ),
10970            _ => local_var_req_builder.query(&[(
10971                "platform",
10972                &local_var_str
10973                    .into_iter()
10974                    .map(|p| p.to_string())
10975                    .collect::<Vec<String>>()
10976                    .join(",")
10977                    .to_string(),
10978            )]),
10979        };
10980    }
10981    if let Some(ref local_var_str) = platform__isnull {
10982        local_var_req_builder =
10983            local_var_req_builder.query(&[("platform__isnull", &local_var_str.to_string())]);
10984    }
10985    if let Some(ref local_var_str) = platform__n {
10986        local_var_req_builder = match "multi" {
10987            "multi" => local_var_req_builder.query(
10988                &local_var_str
10989                    .into_iter()
10990                    .map(|p| ("platform__n".to_owned(), p.to_string()))
10991                    .collect::<Vec<(std::string::String, std::string::String)>>(),
10992            ),
10993            _ => local_var_req_builder.query(&[(
10994                "platform__n",
10995                &local_var_str
10996                    .into_iter()
10997                    .map(|p| p.to_string())
10998                    .collect::<Vec<String>>()
10999                    .join(",")
11000                    .to_string(),
11001            )]),
11002        };
11003    }
11004    if let Some(ref local_var_str) = platform_id {
11005        local_var_req_builder = match "multi" {
11006            "multi" => local_var_req_builder.query(
11007                &local_var_str
11008                    .into_iter()
11009                    .map(|p| ("platform_id".to_owned(), p.to_string()))
11010                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11011            ),
11012            _ => local_var_req_builder.query(&[(
11013                "platform_id",
11014                &local_var_str
11015                    .into_iter()
11016                    .map(|p| p.to_string())
11017                    .collect::<Vec<String>>()
11018                    .join(",")
11019                    .to_string(),
11020            )]),
11021        };
11022    }
11023    if let Some(ref local_var_str) = platform_id__isnull {
11024        local_var_req_builder =
11025            local_var_req_builder.query(&[("platform_id__isnull", &local_var_str.to_string())]);
11026    }
11027    if let Some(ref local_var_str) = platform_id__n {
11028        local_var_req_builder = match "multi" {
11029            "multi" => local_var_req_builder.query(
11030                &local_var_str
11031                    .into_iter()
11032                    .map(|p| ("platform_id__n".to_owned(), p.to_string()))
11033                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11034            ),
11035            _ => local_var_req_builder.query(&[(
11036                "platform_id__n",
11037                &local_var_str
11038                    .into_iter()
11039                    .map(|p| p.to_string())
11040                    .collect::<Vec<String>>()
11041                    .join(",")
11042                    .to_string(),
11043            )]),
11044        };
11045    }
11046    if let Some(ref local_var_str) = primary_ip4 {
11047        local_var_req_builder = match "multi" {
11048            "multi" => local_var_req_builder.query(
11049                &local_var_str
11050                    .into_iter()
11051                    .map(|p| ("primary_ip4".to_owned(), p.to_string()))
11052                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11053            ),
11054            _ => local_var_req_builder.query(&[(
11055                "primary_ip4",
11056                &local_var_str
11057                    .into_iter()
11058                    .map(|p| p.to_string())
11059                    .collect::<Vec<String>>()
11060                    .join(",")
11061                    .to_string(),
11062            )]),
11063        };
11064    }
11065    if let Some(ref local_var_str) = primary_ip6 {
11066        local_var_req_builder = match "multi" {
11067            "multi" => local_var_req_builder.query(
11068                &local_var_str
11069                    .into_iter()
11070                    .map(|p| ("primary_ip6".to_owned(), p.to_string()))
11071                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11072            ),
11073            _ => local_var_req_builder.query(&[(
11074                "primary_ip6",
11075                &local_var_str
11076                    .into_iter()
11077                    .map(|p| p.to_string())
11078                    .collect::<Vec<String>>()
11079                    .join(",")
11080                    .to_string(),
11081            )]),
11082        };
11083    }
11084    if let Some(ref local_var_str) = q {
11085        local_var_req_builder = local_var_req_builder.query(&[("q", &local_var_str.to_string())]);
11086    }
11087    if let Some(ref local_var_str) = role {
11088        local_var_req_builder = match "multi" {
11089            "multi" => local_var_req_builder.query(
11090                &local_var_str
11091                    .into_iter()
11092                    .map(|p| ("role".to_owned(), p.to_string()))
11093                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11094            ),
11095            _ => local_var_req_builder.query(&[(
11096                "role",
11097                &local_var_str
11098                    .into_iter()
11099                    .map(|p| p.to_string())
11100                    .collect::<Vec<String>>()
11101                    .join(",")
11102                    .to_string(),
11103            )]),
11104        };
11105    }
11106    if let Some(ref local_var_str) = role__isnull {
11107        local_var_req_builder =
11108            local_var_req_builder.query(&[("role__isnull", &local_var_str.to_string())]);
11109    }
11110    if let Some(ref local_var_str) = role__n {
11111        local_var_req_builder = match "multi" {
11112            "multi" => local_var_req_builder.query(
11113                &local_var_str
11114                    .into_iter()
11115                    .map(|p| ("role__n".to_owned(), p.to_string()))
11116                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11117            ),
11118            _ => local_var_req_builder.query(&[(
11119                "role__n",
11120                &local_var_str
11121                    .into_iter()
11122                    .map(|p| p.to_string())
11123                    .collect::<Vec<String>>()
11124                    .join(",")
11125                    .to_string(),
11126            )]),
11127        };
11128    }
11129    if let Some(ref local_var_str) = services {
11130        local_var_req_builder = match "multi" {
11131            "multi" => local_var_req_builder.query(
11132                &local_var_str
11133                    .into_iter()
11134                    .map(|p| ("services".to_owned(), p.to_string()))
11135                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11136            ),
11137            _ => local_var_req_builder.query(&[(
11138                "services",
11139                &local_var_str
11140                    .into_iter()
11141                    .map(|p| p.to_string())
11142                    .collect::<Vec<String>>()
11143                    .join(",")
11144                    .to_string(),
11145            )]),
11146        };
11147    }
11148    if let Some(ref local_var_str) = services__isnull {
11149        local_var_req_builder =
11150            local_var_req_builder.query(&[("services__isnull", &local_var_str.to_string())]);
11151    }
11152    if let Some(ref local_var_str) = services__n {
11153        local_var_req_builder = match "multi" {
11154            "multi" => local_var_req_builder.query(
11155                &local_var_str
11156                    .into_iter()
11157                    .map(|p| ("services__n".to_owned(), p.to_string()))
11158                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11159            ),
11160            _ => local_var_req_builder.query(&[(
11161                "services__n",
11162                &local_var_str
11163                    .into_iter()
11164                    .map(|p| p.to_string())
11165                    .collect::<Vec<String>>()
11166                    .join(",")
11167                    .to_string(),
11168            )]),
11169        };
11170    }
11171    if let Some(ref local_var_str) = software_image_files {
11172        local_var_req_builder = match "multi" {
11173            "multi" => local_var_req_builder.query(
11174                &local_var_str
11175                    .into_iter()
11176                    .map(|p| ("software_image_files".to_owned(), p.to_string()))
11177                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11178            ),
11179            _ => local_var_req_builder.query(&[(
11180                "software_image_files",
11181                &local_var_str
11182                    .into_iter()
11183                    .map(|p| p.to_string())
11184                    .collect::<Vec<String>>()
11185                    .join(",")
11186                    .to_string(),
11187            )]),
11188        };
11189    }
11190    if let Some(ref local_var_str) = software_image_files__n {
11191        local_var_req_builder = match "multi" {
11192            "multi" => local_var_req_builder.query(
11193                &local_var_str
11194                    .into_iter()
11195                    .map(|p| ("software_image_files__n".to_owned(), p.to_string()))
11196                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11197            ),
11198            _ => local_var_req_builder.query(&[(
11199                "software_image_files__n",
11200                &local_var_str
11201                    .into_iter()
11202                    .map(|p| p.to_string())
11203                    .collect::<Vec<String>>()
11204                    .join(",")
11205                    .to_string(),
11206            )]),
11207        };
11208    }
11209    if let Some(ref local_var_str) = software_version {
11210        local_var_req_builder = match "multi" {
11211            "multi" => local_var_req_builder.query(
11212                &local_var_str
11213                    .into_iter()
11214                    .map(|p| ("software_version".to_owned(), p.to_string()))
11215                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11216            ),
11217            _ => local_var_req_builder.query(&[(
11218                "software_version",
11219                &local_var_str
11220                    .into_iter()
11221                    .map(|p| p.to_string())
11222                    .collect::<Vec<String>>()
11223                    .join(",")
11224                    .to_string(),
11225            )]),
11226        };
11227    }
11228    if let Some(ref local_var_str) = software_version__isnull {
11229        local_var_req_builder = local_var_req_builder
11230            .query(&[("software_version__isnull", &local_var_str.to_string())]);
11231    }
11232    if let Some(ref local_var_str) = software_version__n {
11233        local_var_req_builder = match "multi" {
11234            "multi" => local_var_req_builder.query(
11235                &local_var_str
11236                    .into_iter()
11237                    .map(|p| ("software_version__n".to_owned(), p.to_string()))
11238                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11239            ),
11240            _ => local_var_req_builder.query(&[(
11241                "software_version__n",
11242                &local_var_str
11243                    .into_iter()
11244                    .map(|p| p.to_string())
11245                    .collect::<Vec<String>>()
11246                    .join(",")
11247                    .to_string(),
11248            )]),
11249        };
11250    }
11251    if let Some(ref local_var_str) = sort {
11252        local_var_req_builder =
11253            local_var_req_builder.query(&[("sort", &local_var_str.to_string())]);
11254    }
11255    if let Some(ref local_var_str) = status {
11256        local_var_req_builder = match "multi" {
11257            "multi" => local_var_req_builder.query(
11258                &local_var_str
11259                    .into_iter()
11260                    .map(|p| ("status".to_owned(), p.to_string()))
11261                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11262            ),
11263            _ => local_var_req_builder.query(&[(
11264                "status",
11265                &local_var_str
11266                    .into_iter()
11267                    .map(|p| p.to_string())
11268                    .collect::<Vec<String>>()
11269                    .join(",")
11270                    .to_string(),
11271            )]),
11272        };
11273    }
11274    if let Some(ref local_var_str) = status__n {
11275        local_var_req_builder = match "multi" {
11276            "multi" => local_var_req_builder.query(
11277                &local_var_str
11278                    .into_iter()
11279                    .map(|p| ("status__n".to_owned(), p.to_string()))
11280                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11281            ),
11282            _ => local_var_req_builder.query(&[(
11283                "status__n",
11284                &local_var_str
11285                    .into_iter()
11286                    .map(|p| p.to_string())
11287                    .collect::<Vec<String>>()
11288                    .join(",")
11289                    .to_string(),
11290            )]),
11291        };
11292    }
11293    if let Some(ref local_var_str) = tags {
11294        local_var_req_builder = match "multi" {
11295            "multi" => local_var_req_builder.query(
11296                &local_var_str
11297                    .into_iter()
11298                    .map(|p| ("tags".to_owned(), p.to_string()))
11299                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11300            ),
11301            _ => local_var_req_builder.query(&[(
11302                "tags",
11303                &local_var_str
11304                    .into_iter()
11305                    .map(|p| p.to_string())
11306                    .collect::<Vec<String>>()
11307                    .join(",")
11308                    .to_string(),
11309            )]),
11310        };
11311    }
11312    if let Some(ref local_var_str) = tags__isnull {
11313        local_var_req_builder =
11314            local_var_req_builder.query(&[("tags__isnull", &local_var_str.to_string())]);
11315    }
11316    if let Some(ref local_var_str) = tags__n {
11317        local_var_req_builder = match "multi" {
11318            "multi" => local_var_req_builder.query(
11319                &local_var_str
11320                    .into_iter()
11321                    .map(|p| ("tags__n".to_owned(), p.to_string()))
11322                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11323            ),
11324            _ => local_var_req_builder.query(&[(
11325                "tags__n",
11326                &local_var_str
11327                    .into_iter()
11328                    .map(|p| p.to_string())
11329                    .collect::<Vec<String>>()
11330                    .join(",")
11331                    .to_string(),
11332            )]),
11333        };
11334    }
11335    if let Some(ref local_var_str) = teams {
11336        local_var_req_builder = match "multi" {
11337            "multi" => local_var_req_builder.query(
11338                &local_var_str
11339                    .into_iter()
11340                    .map(|p| ("teams".to_owned(), p.to_string()))
11341                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11342            ),
11343            _ => local_var_req_builder.query(&[(
11344                "teams",
11345                &local_var_str
11346                    .into_iter()
11347                    .map(|p| p.to_string())
11348                    .collect::<Vec<String>>()
11349                    .join(",")
11350                    .to_string(),
11351            )]),
11352        };
11353    }
11354    if let Some(ref local_var_str) = teams__isnull {
11355        local_var_req_builder =
11356            local_var_req_builder.query(&[("teams__isnull", &local_var_str.to_string())]);
11357    }
11358    if let Some(ref local_var_str) = teams__n {
11359        local_var_req_builder = match "multi" {
11360            "multi" => local_var_req_builder.query(
11361                &local_var_str
11362                    .into_iter()
11363                    .map(|p| ("teams__n".to_owned(), p.to_string()))
11364                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11365            ),
11366            _ => local_var_req_builder.query(&[(
11367                "teams__n",
11368                &local_var_str
11369                    .into_iter()
11370                    .map(|p| p.to_string())
11371                    .collect::<Vec<String>>()
11372                    .join(",")
11373                    .to_string(),
11374            )]),
11375        };
11376    }
11377    if let Some(ref local_var_str) = tenant {
11378        local_var_req_builder = match "multi" {
11379            "multi" => local_var_req_builder.query(
11380                &local_var_str
11381                    .into_iter()
11382                    .map(|p| ("tenant".to_owned(), p.to_string()))
11383                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11384            ),
11385            _ => local_var_req_builder.query(&[(
11386                "tenant",
11387                &local_var_str
11388                    .into_iter()
11389                    .map(|p| p.to_string())
11390                    .collect::<Vec<String>>()
11391                    .join(",")
11392                    .to_string(),
11393            )]),
11394        };
11395    }
11396    if let Some(ref local_var_str) = tenant__isnull {
11397        local_var_req_builder =
11398            local_var_req_builder.query(&[("tenant__isnull", &local_var_str.to_string())]);
11399    }
11400    if let Some(ref local_var_str) = tenant__n {
11401        local_var_req_builder = match "multi" {
11402            "multi" => local_var_req_builder.query(
11403                &local_var_str
11404                    .into_iter()
11405                    .map(|p| ("tenant__n".to_owned(), p.to_string()))
11406                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11407            ),
11408            _ => local_var_req_builder.query(&[(
11409                "tenant__n",
11410                &local_var_str
11411                    .into_iter()
11412                    .map(|p| p.to_string())
11413                    .collect::<Vec<String>>()
11414                    .join(",")
11415                    .to_string(),
11416            )]),
11417        };
11418    }
11419    if let Some(ref local_var_str) = tenant_group {
11420        local_var_req_builder = match "multi" {
11421            "multi" => local_var_req_builder.query(
11422                &local_var_str
11423                    .into_iter()
11424                    .map(|p| ("tenant_group".to_owned(), p.to_string()))
11425                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11426            ),
11427            _ => local_var_req_builder.query(&[(
11428                "tenant_group",
11429                &local_var_str
11430                    .into_iter()
11431                    .map(|p| p.to_string())
11432                    .collect::<Vec<String>>()
11433                    .join(",")
11434                    .to_string(),
11435            )]),
11436        };
11437    }
11438    if let Some(ref local_var_str) = tenant_group__isnull {
11439        local_var_req_builder =
11440            local_var_req_builder.query(&[("tenant_group__isnull", &local_var_str.to_string())]);
11441    }
11442    if let Some(ref local_var_str) = tenant_group__n {
11443        local_var_req_builder = match "multi" {
11444            "multi" => local_var_req_builder.query(
11445                &local_var_str
11446                    .into_iter()
11447                    .map(|p| ("tenant_group__n".to_owned(), p.to_string()))
11448                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11449            ),
11450            _ => local_var_req_builder.query(&[(
11451                "tenant_group__n",
11452                &local_var_str
11453                    .into_iter()
11454                    .map(|p| p.to_string())
11455                    .collect::<Vec<String>>()
11456                    .join(",")
11457                    .to_string(),
11458            )]),
11459        };
11460    }
11461    if let Some(ref local_var_str) = tenant_id {
11462        local_var_req_builder = match "multi" {
11463            "multi" => local_var_req_builder.query(
11464                &local_var_str
11465                    .into_iter()
11466                    .map(|p| ("tenant_id".to_owned(), p.to_string()))
11467                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11468            ),
11469            _ => local_var_req_builder.query(&[(
11470                "tenant_id",
11471                &local_var_str
11472                    .into_iter()
11473                    .map(|p| p.to_string())
11474                    .collect::<Vec<String>>()
11475                    .join(",")
11476                    .to_string(),
11477            )]),
11478        };
11479    }
11480    if let Some(ref local_var_str) = tenant_id__isnull {
11481        local_var_req_builder =
11482            local_var_req_builder.query(&[("tenant_id__isnull", &local_var_str.to_string())]);
11483    }
11484    if let Some(ref local_var_str) = tenant_id__n {
11485        local_var_req_builder = match "multi" {
11486            "multi" => local_var_req_builder.query(
11487                &local_var_str
11488                    .into_iter()
11489                    .map(|p| ("tenant_id__n".to_owned(), p.to_string()))
11490                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11491            ),
11492            _ => local_var_req_builder.query(&[(
11493                "tenant_id__n",
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) = vcpus {
11504        local_var_req_builder = match "multi" {
11505            "multi" => local_var_req_builder.query(
11506                &local_var_str
11507                    .into_iter()
11508                    .map(|p| ("vcpus".to_owned(), p.to_string()))
11509                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11510            ),
11511            _ => local_var_req_builder.query(&[(
11512                "vcpus",
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) = vcpus__gt {
11523        local_var_req_builder = match "multi" {
11524            "multi" => local_var_req_builder.query(
11525                &local_var_str
11526                    .into_iter()
11527                    .map(|p| ("vcpus__gt".to_owned(), p.to_string()))
11528                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11529            ),
11530            _ => local_var_req_builder.query(&[(
11531                "vcpus__gt",
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) = vcpus__gte {
11542        local_var_req_builder = match "multi" {
11543            "multi" => local_var_req_builder.query(
11544                &local_var_str
11545                    .into_iter()
11546                    .map(|p| ("vcpus__gte".to_owned(), p.to_string()))
11547                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11548            ),
11549            _ => local_var_req_builder.query(&[(
11550                "vcpus__gte",
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) = vcpus__isnull {
11561        local_var_req_builder =
11562            local_var_req_builder.query(&[("vcpus__isnull", &local_var_str.to_string())]);
11563    }
11564    if let Some(ref local_var_str) = vcpus__lt {
11565        local_var_req_builder = match "multi" {
11566            "multi" => local_var_req_builder.query(
11567                &local_var_str
11568                    .into_iter()
11569                    .map(|p| ("vcpus__lt".to_owned(), p.to_string()))
11570                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11571            ),
11572            _ => local_var_req_builder.query(&[(
11573                "vcpus__lt",
11574                &local_var_str
11575                    .into_iter()
11576                    .map(|p| p.to_string())
11577                    .collect::<Vec<String>>()
11578                    .join(",")
11579                    .to_string(),
11580            )]),
11581        };
11582    }
11583    if let Some(ref local_var_str) = vcpus__lte {
11584        local_var_req_builder = match "multi" {
11585            "multi" => local_var_req_builder.query(
11586                &local_var_str
11587                    .into_iter()
11588                    .map(|p| ("vcpus__lte".to_owned(), p.to_string()))
11589                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11590            ),
11591            _ => local_var_req_builder.query(&[(
11592                "vcpus__lte",
11593                &local_var_str
11594                    .into_iter()
11595                    .map(|p| p.to_string())
11596                    .collect::<Vec<String>>()
11597                    .join(",")
11598                    .to_string(),
11599            )]),
11600        };
11601    }
11602    if let Some(ref local_var_str) = vcpus__n {
11603        local_var_req_builder = match "multi" {
11604            "multi" => local_var_req_builder.query(
11605                &local_var_str
11606                    .into_iter()
11607                    .map(|p| ("vcpus__n".to_owned(), p.to_string()))
11608                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11609            ),
11610            _ => local_var_req_builder.query(&[(
11611                "vcpus__n",
11612                &local_var_str
11613                    .into_iter()
11614                    .map(|p| p.to_string())
11615                    .collect::<Vec<String>>()
11616                    .join(",")
11617                    .to_string(),
11618            )]),
11619        };
11620    }
11621    if let Some(ref local_var_str) = vrfs {
11622        local_var_req_builder = match "multi" {
11623            "multi" => local_var_req_builder.query(
11624                &local_var_str
11625                    .into_iter()
11626                    .map(|p| ("vrfs".to_owned(), p.to_string()))
11627                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11628            ),
11629            _ => local_var_req_builder.query(&[(
11630                "vrfs",
11631                &local_var_str
11632                    .into_iter()
11633                    .map(|p| p.to_string())
11634                    .collect::<Vec<String>>()
11635                    .join(",")
11636                    .to_string(),
11637            )]),
11638        };
11639    }
11640    if let Some(ref local_var_str) = vrfs__isnull {
11641        local_var_req_builder =
11642            local_var_req_builder.query(&[("vrfs__isnull", &local_var_str.to_string())]);
11643    }
11644    if let Some(ref local_var_str) = vrfs__n {
11645        local_var_req_builder = match "multi" {
11646            "multi" => local_var_req_builder.query(
11647                &local_var_str
11648                    .into_iter()
11649                    .map(|p| ("vrfs__n".to_owned(), p.to_string()))
11650                    .collect::<Vec<(std::string::String, std::string::String)>>(),
11651            ),
11652            _ => local_var_req_builder.query(&[(
11653                "vrfs__n",
11654                &local_var_str
11655                    .into_iter()
11656                    .map(|p| p.to_string())
11657                    .collect::<Vec<String>>()
11658                    .join(",")
11659                    .to_string(),
11660            )]),
11661        };
11662    }
11663    if let Some(ref local_var_str) = depth {
11664        local_var_req_builder =
11665            local_var_req_builder.query(&[("depth", &local_var_str.to_string())]);
11666    }
11667    if let Some(ref local_var_str) = exclude_m2m {
11668        local_var_req_builder =
11669            local_var_req_builder.query(&[("exclude_m2m", &local_var_str.to_string())]);
11670    }
11671    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
11672        local_var_req_builder =
11673            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
11674    }
11675    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
11676        let local_var_key = local_var_apikey.key.clone();
11677        let local_var_value = match local_var_apikey.prefix {
11678            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
11679            None => local_var_key,
11680        };
11681        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
11682    };
11683
11684    let local_var_req = local_var_req_builder.build()?;
11685    let local_var_resp = local_var_client.execute(local_var_req).await?;
11686
11687    let local_var_status = local_var_resp.status();
11688    let local_var_content = local_var_resp.text().await?;
11689
11690    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
11691        serde_json::from_str(&local_var_content).map_err(Error::from)
11692    } else {
11693        let local_var_entity: Option<VirtualizationVirtualMachinesListError> =
11694            serde_json::from_str(&local_var_content).ok();
11695        let local_var_error = ResponseContent {
11696            status: local_var_status,
11697            content: local_var_content,
11698            entity: local_var_entity,
11699        };
11700        Err(Error::ResponseError(local_var_error))
11701    }
11702}
11703
11704/// API methods for returning or creating notes on an object.
11705pub async fn virtualization_virtual_machines_notes_create(
11706    configuration: &configuration::Configuration,
11707    id: &str,
11708    note_input_request: crate::models::NoteInputRequest,
11709    format: Option<&str>,
11710) -> Result<crate::models::Note, Error<VirtualizationVirtualMachinesNotesCreateError>> {
11711    let local_var_configuration = configuration;
11712
11713    let local_var_client = &local_var_configuration.client;
11714
11715    let local_var_uri_str = format!(
11716        "{}/virtualization/virtual-machines/{id}/notes/",
11717        local_var_configuration.base_path,
11718        id = crate::apis::urlencode(id)
11719    );
11720    let mut local_var_req_builder =
11721        local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
11722
11723    if let Some(ref local_var_str) = format {
11724        local_var_req_builder =
11725            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
11726    }
11727    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
11728        local_var_req_builder =
11729            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
11730    }
11731    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
11732        let local_var_key = local_var_apikey.key.clone();
11733        let local_var_value = match local_var_apikey.prefix {
11734            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
11735            None => local_var_key,
11736        };
11737        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
11738    };
11739    local_var_req_builder = local_var_req_builder.json(&note_input_request);
11740
11741    let local_var_req = local_var_req_builder.build()?;
11742    let local_var_resp = local_var_client.execute(local_var_req).await?;
11743
11744    let local_var_status = local_var_resp.status();
11745    let local_var_content = local_var_resp.text().await?;
11746
11747    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
11748        serde_json::from_str(&local_var_content).map_err(Error::from)
11749    } else {
11750        let local_var_entity: Option<VirtualizationVirtualMachinesNotesCreateError> =
11751            serde_json::from_str(&local_var_content).ok();
11752        let local_var_error = ResponseContent {
11753            status: local_var_status,
11754            content: local_var_content,
11755            entity: local_var_entity,
11756        };
11757        Err(Error::ResponseError(local_var_error))
11758    }
11759}
11760
11761/// API methods for returning or creating notes on an object.
11762pub async fn virtualization_virtual_machines_notes_list(
11763    configuration: &configuration::Configuration,
11764    id: &str,
11765    format: Option<&str>,
11766    limit: Option<i32>,
11767    offset: Option<i32>,
11768    depth: Option<i32>,
11769    exclude_m2m: Option<bool>,
11770) -> Result<crate::models::PaginatedNoteList, Error<VirtualizationVirtualMachinesNotesListError>> {
11771    let local_var_configuration = configuration;
11772
11773    let local_var_client = &local_var_configuration.client;
11774
11775    let local_var_uri_str = format!(
11776        "{}/virtualization/virtual-machines/{id}/notes/",
11777        local_var_configuration.base_path,
11778        id = crate::apis::urlencode(id)
11779    );
11780    let mut local_var_req_builder =
11781        local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
11782
11783    if let Some(ref local_var_str) = format {
11784        local_var_req_builder =
11785            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
11786    }
11787    if let Some(ref local_var_str) = limit {
11788        local_var_req_builder =
11789            local_var_req_builder.query(&[("limit", &local_var_str.to_string())]);
11790    }
11791    if let Some(ref local_var_str) = offset {
11792        local_var_req_builder =
11793            local_var_req_builder.query(&[("offset", &local_var_str.to_string())]);
11794    }
11795    if let Some(ref local_var_str) = depth {
11796        local_var_req_builder =
11797            local_var_req_builder.query(&[("depth", &local_var_str.to_string())]);
11798    }
11799    if let Some(ref local_var_str) = exclude_m2m {
11800        local_var_req_builder =
11801            local_var_req_builder.query(&[("exclude_m2m", &local_var_str.to_string())]);
11802    }
11803    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
11804        local_var_req_builder =
11805            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
11806    }
11807    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
11808        let local_var_key = local_var_apikey.key.clone();
11809        let local_var_value = match local_var_apikey.prefix {
11810            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
11811            None => local_var_key,
11812        };
11813        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
11814    };
11815
11816    let local_var_req = local_var_req_builder.build()?;
11817    let local_var_resp = local_var_client.execute(local_var_req).await?;
11818
11819    let local_var_status = local_var_resp.status();
11820    let local_var_content = local_var_resp.text().await?;
11821
11822    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
11823        serde_json::from_str(&local_var_content).map_err(Error::from)
11824    } else {
11825        let local_var_entity: Option<VirtualizationVirtualMachinesNotesListError> =
11826            serde_json::from_str(&local_var_content).ok();
11827        let local_var_error = ResponseContent {
11828            status: local_var_status,
11829            content: local_var_content,
11830            entity: local_var_entity,
11831        };
11832        Err(Error::ResponseError(local_var_error))
11833    }
11834}
11835
11836/// Partial update a virtual machine object.
11837pub async fn virtualization_virtual_machines_partial_update(
11838    configuration: &configuration::Configuration,
11839    id: &str,
11840    format: Option<&str>,
11841    patched_virtual_machine_request: Option<crate::models::PatchedVirtualMachineRequest>,
11842) -> Result<crate::models::VirtualMachine, Error<VirtualizationVirtualMachinesPartialUpdateError>> {
11843    let local_var_configuration = configuration;
11844
11845    let local_var_client = &local_var_configuration.client;
11846
11847    let local_var_uri_str = format!(
11848        "{}/virtualization/virtual-machines/{id}/",
11849        local_var_configuration.base_path,
11850        id = crate::apis::urlencode(id)
11851    );
11852    let mut local_var_req_builder =
11853        local_var_client.request(reqwest::Method::PATCH, local_var_uri_str.as_str());
11854
11855    if let Some(ref local_var_str) = format {
11856        local_var_req_builder =
11857            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
11858    }
11859    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
11860        local_var_req_builder =
11861            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
11862    }
11863    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
11864        let local_var_key = local_var_apikey.key.clone();
11865        let local_var_value = match local_var_apikey.prefix {
11866            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
11867            None => local_var_key,
11868        };
11869        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
11870    };
11871    local_var_req_builder = local_var_req_builder.json(&patched_virtual_machine_request);
11872
11873    let local_var_req = local_var_req_builder.build()?;
11874    let local_var_resp = local_var_client.execute(local_var_req).await?;
11875
11876    let local_var_status = local_var_resp.status();
11877    let local_var_content = local_var_resp.text().await?;
11878
11879    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
11880        serde_json::from_str(&local_var_content).map_err(Error::from)
11881    } else {
11882        let local_var_entity: Option<VirtualizationVirtualMachinesPartialUpdateError> =
11883            serde_json::from_str(&local_var_content).ok();
11884        let local_var_error = ResponseContent {
11885            status: local_var_status,
11886            content: local_var_content,
11887            entity: local_var_entity,
11888        };
11889        Err(Error::ResponseError(local_var_error))
11890    }
11891}
11892
11893/// Retrieve a virtual machine object.
11894pub async fn virtualization_virtual_machines_retrieve(
11895    configuration: &configuration::Configuration,
11896    id: &str,
11897    format: Option<&str>,
11898    depth: Option<i32>,
11899    exclude_m2m: Option<bool>,
11900) -> Result<crate::models::VirtualMachine, Error<VirtualizationVirtualMachinesRetrieveError>> {
11901    let local_var_configuration = configuration;
11902
11903    let local_var_client = &local_var_configuration.client;
11904
11905    let local_var_uri_str = format!(
11906        "{}/virtualization/virtual-machines/{id}/",
11907        local_var_configuration.base_path,
11908        id = crate::apis::urlencode(id)
11909    );
11910    let mut local_var_req_builder =
11911        local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
11912
11913    if let Some(ref local_var_str) = format {
11914        local_var_req_builder =
11915            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
11916    }
11917    if let Some(ref local_var_str) = depth {
11918        local_var_req_builder =
11919            local_var_req_builder.query(&[("depth", &local_var_str.to_string())]);
11920    }
11921    if let Some(ref local_var_str) = exclude_m2m {
11922        local_var_req_builder =
11923            local_var_req_builder.query(&[("exclude_m2m", &local_var_str.to_string())]);
11924    }
11925    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
11926        local_var_req_builder =
11927            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
11928    }
11929    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
11930        let local_var_key = local_var_apikey.key.clone();
11931        let local_var_value = match local_var_apikey.prefix {
11932            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
11933            None => local_var_key,
11934        };
11935        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
11936    };
11937
11938    let local_var_req = local_var_req_builder.build()?;
11939    let local_var_resp = local_var_client.execute(local_var_req).await?;
11940
11941    let local_var_status = local_var_resp.status();
11942    let local_var_content = local_var_resp.text().await?;
11943
11944    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
11945        serde_json::from_str(&local_var_content).map_err(Error::from)
11946    } else {
11947        let local_var_entity: Option<VirtualizationVirtualMachinesRetrieveError> =
11948            serde_json::from_str(&local_var_content).ok();
11949        let local_var_error = ResponseContent {
11950            status: local_var_status,
11951            content: local_var_content,
11952            entity: local_var_entity,
11953        };
11954        Err(Error::ResponseError(local_var_error))
11955    }
11956}
11957
11958/// Update a virtual machine object.
11959pub async fn virtualization_virtual_machines_update(
11960    configuration: &configuration::Configuration,
11961    id: &str,
11962    virtual_machine_request: crate::models::VirtualMachineRequest,
11963    format: Option<&str>,
11964) -> Result<crate::models::VirtualMachine, Error<VirtualizationVirtualMachinesUpdateError>> {
11965    let local_var_configuration = configuration;
11966
11967    let local_var_client = &local_var_configuration.client;
11968
11969    let local_var_uri_str = format!(
11970        "{}/virtualization/virtual-machines/{id}/",
11971        local_var_configuration.base_path,
11972        id = crate::apis::urlencode(id)
11973    );
11974    let mut local_var_req_builder =
11975        local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());
11976
11977    if let Some(ref local_var_str) = format {
11978        local_var_req_builder =
11979            local_var_req_builder.query(&[("format", &local_var_str.to_string())]);
11980    }
11981    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
11982        local_var_req_builder =
11983            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
11984    }
11985    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
11986        let local_var_key = local_var_apikey.key.clone();
11987        let local_var_value = match local_var_apikey.prefix {
11988            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
11989            None => local_var_key,
11990        };
11991        local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
11992    };
11993    local_var_req_builder = local_var_req_builder.json(&virtual_machine_request);
11994
11995    let local_var_req = local_var_req_builder.build()?;
11996    let local_var_resp = local_var_client.execute(local_var_req).await?;
11997
11998    let local_var_status = local_var_resp.status();
11999    let local_var_content = local_var_resp.text().await?;
12000
12001    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
12002        serde_json::from_str(&local_var_content).map_err(Error::from)
12003    } else {
12004        let local_var_entity: Option<VirtualizationVirtualMachinesUpdateError> =
12005            serde_json::from_str(&local_var_content).ok();
12006        let local_var_error = ResponseContent {
12007            status: local_var_status,
12008            content: local_var_content,
12009            entity: local_var_entity,
12010        };
12011        Err(Error::ResponseError(local_var_error))
12012    }
12013}